← Back to branch summary

~ubuntu-branches/ubuntu/karmic/pcsc-lite/karmic-updates

« back to all changes in this revision

Viewing changes to src/winscard_svc.c

  • Committer: Bazaar Package Importer
  • Author(s): Ludovic Rousseau
  • Date: 2006-10-14 00:35:01 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20061014003501-thwa8ydzqnapajn1
Tags: 1.3.2-3
http://bugs.debian.org/392357
* urgency high to correct a RC bug
* debian/pcscd.init: really commit a local patch that should already be in
  1.3.2-2.  Closes: #392357 "fails to stop; postinst goes into infinite
  loop"

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/winscard_svc.c
6
6
 *  Damien Sauveron <damien.sauveron@labri.fr>
7
7
 *  Ludovic Rousseau <ludovic.rousseau@free.fr>
8
8
 *
9
 
 * $Id: winscard_svc.c 1998 2006-04-11 09:06:50Z rousseau $
 
9
 * $Id: winscard_svc.c 2128 2006-08-08 15:05:57Z rousseau $
10
10
 */
11
11
 
12
12
/**
91
91
        {
92
92
                SYS_CloseFile(psContext[i].dwClientID);
93
93
                psContext[i].dwClientID = 0; 
 
94
                Log2(PCSC_LOG_CRITICAL, "No more context available (max: %d)",
 
95
                        PCSCLITE_MAX_APPLICATIONS_CONTEXTS);
94
96
                return SCARD_F_INTERNAL_ERROR;
95
97
        }
96
98
        
100
102
        {
101
103
                SYS_CloseFile(psContext[i].dwClientID);
102
104
                psContext[i].dwClientID = 0; 
 
105
                Log1(PCSC_LOG_CRITICAL, "SYS_ThreadCreate failed");
103
106
                return SCARD_E_NO_MEMORY;
104
107
        }
105
108
 
152
155
                                 * Command must be found
153
156
                                 */
154
157
                                MSGFunctionDemarshall(&msgStruct, dwContextIndex);
155
 
                                rv = SHMMessageSend(&msgStruct, psContext[dwContextIndex].dwClientID,
156
 
                                                    PCSCLITE_SERVER_ATTEMPTS);
 
158
 
 
159
                                /* the SCARD_TRANSMIT_EXTENDED anwser is already sent by
 
160
                                 * MSGFunctionDemarshall */
 
161
                                if (msgStruct.command != SCARD_TRANSMIT_EXTENDED)
 
162
                                        rv = SHMMessageSend(&msgStruct, sizeof(msgStruct),
 
163
                                                psContext[dwContextIndex].dwClientID,
 
164
                                                PCSCLITE_SERVER_ATTEMPTS);
157
165
                        }
158
166
                        else
159
167
                                /* pcsc-lite client/server protocol version */
176
184
                                        veStr->rv = SCARD_S_SUCCESS;
177
185
 
178
186
                                        /* send back the response */
179
 
                                        rv = SHMMessageSend(&msgStruct,
 
187
                                        rv = SHMMessageSend(&msgStruct, sizeof(msgStruct),
180
188
                                                psContext[dwContextIndex].dwClientID,
181
189
                                            PCSCLITE_SERVER_ATTEMPTS);
182
190
                                }
363
371
                        gsStr->pbAttr, gsStr->cbAttrLen);
364
372
                break;
365
373
 
 
374
        case SCARD_TRANSMIT_EXTENDED:
 
375
                {
 
376
                        transmit_struct_extended *treStr;
 
377
                        unsigned char pbSendBuffer[MAX_BUFFER_SIZE_EXTENDED];
 
378
                        unsigned char pbRecvBuffer[MAX_BUFFER_SIZE_EXTENDED];
 
379
 
 
380
                        treStr = ((transmit_struct_extended *) msgStruct->data);
 
381
                        rv = MSGCheckHandleAssociation(treStr->hCard, dwContextIndex);
 
382
                        if (rv != 0) return rv;
 
383
 
 
384
                        /* on more block to read? */
 
385
                        if (treStr->size > PCSCLITE_MAX_MESSAGE_SIZE)
 
386
                        {
 
387
                                /* copy the first APDU part */
 
388
                                memcpy(pbSendBuffer, treStr->data,
 
389
                                        PCSCLITE_MAX_MESSAGE_SIZE-sizeof(*treStr));
 
390
 
 
391
                                /* receive the second block */
 
392
                                rv = SHMMessageReceive(
 
393
                                        pbSendBuffer+PCSCLITE_MAX_MESSAGE_SIZE-sizeof(*treStr),
 
394
                                        treStr->size - PCSCLITE_MAX_MESSAGE_SIZE,
 
395
                                        psContext[dwContextIndex].dwClientID,
 
396
                                        PCSCLITE_SERVER_ATTEMPTS);
 
397
                                if (rv)
 
398
                                        Log1(PCSC_LOG_CRITICAL, "reception failed");
 
399
                        }
 
400
                        else
 
401
                                memcpy(pbSendBuffer, treStr->data, treStr->cbSendLength);
 
402
 
 
403
                        treStr->rv = SCardTransmit(treStr->hCard, &treStr->pioSendPci,
 
404
                                pbSendBuffer, treStr->cbSendLength,
 
405
                                &treStr->pioRecvPci, pbRecvBuffer,
 
406
                                &treStr->pcbRecvLength);
 
407
 
 
408
                        treStr->size = sizeof(*treStr) + treStr->pcbRecvLength;
 
409
                        if (treStr->size > PCSCLITE_MAX_MESSAGE_SIZE)
 
410
                        {
 
411
                                /* two blocks */
 
412
                                memcpy(treStr->data, pbRecvBuffer, PCSCLITE_MAX_MESSAGE_SIZE
 
413
                                        - sizeof(*treStr));
 
414
 
 
415
                                rv = SHMMessageSend(msgStruct, sizeof(*msgStruct),
 
416
                                        psContext[dwContextIndex].dwClientID,
 
417
                                        PCSCLITE_SERVER_ATTEMPTS);
 
418
                                if (rv)
 
419
                                        Log1(PCSC_LOG_CRITICAL, "transmission failed");
 
420
 
 
421
                                rv = SHMMessageSend(pbRecvBuffer + PCSCLITE_MAX_MESSAGE_SIZE
 
422
                                        - sizeof(*treStr),
 
423
                                        treStr->size - PCSCLITE_MAX_MESSAGE_SIZE, 
 
424
                                        psContext[dwContextIndex].dwClientID,
 
425
                                        PCSCLITE_SERVER_ATTEMPTS);
 
426
                                if (rv)
 
427
                                        Log1(PCSC_LOG_CRITICAL, "transmission failed");
 
428
                        }
 
429
                        else
 
430
                        {
 
431
                                /* one block only */
 
432
                                memcpy(treStr->data, pbRecvBuffer, treStr->pcbRecvLength);
 
433
 
 
434
                                rv = SHMMessageSend(msgStruct, sizeof(*msgStruct),
 
435
                                        psContext[dwContextIndex].dwClientID,
 
436
                                        PCSCLITE_SERVER_ATTEMPTS);
 
437
                                if (rv)
 
438
                                        Log1(PCSC_LOG_CRITICAL, "transmission failed");
 
439
                        }
 
440
                }
 
441
                break;
 
442
 
366
443
        default:
 
444
                Log2(PCSC_LOG_CRITICAL, "Unknown command: %d", msgStruct->command);
367
445
                return -1;
368
446
        }
369
447