« back to all changes in this revision
Viewing changes to pcsc-lite/src/winscard.c
- browse files at revision 4
- compare with another revision
- download diff
- download tarball
- view history from revision 4
- Committer: Bazaar Package Importer
- Author(s): Ludovic Rousseau
- Date: 2005-11-27 18:04:59 UTC
- mfrom: (1.2.2 upstream)
- Revision ID: james.westby@ubuntu.com-20051127180459-qrex2gzpq9d8jexd
Tags: 1.2.9-beta9-1
* New upstream version
* debian/compat: change from 3 to 4
* debian/compat: change from 3 to 4
- files added:
- AUTHORS
- doc
- doc/example
- etc
- m4
- src
- src/PCSC
- src/utils
- win32
- files removed:
- libmusclecard/AUTHORS
- pcsc-lite
- pcsc-lite/doc
- pcsc-lite/doc/example
- pcsc-lite/etc
- pcsc-lite/m4
- pcsc-lite/src
- pcsc-lite/src/PCSC
- pcsc-lite/src/utils
- pcsc-lite/win32
- files modified:
- debian/changelog
added
removed
pcsc-lite/src/winscard.c
1
/*
2
* This handles smartcard reader communications.
3
* This is the heart of the M$ smartcard API.
4
*
5
* MUSCLE SmartCard Development ( http://www.linuxnet.com )
6
*
7
* Copyright (C) 1999-2004
8
* David Corcoran <corcoran@linuxnet.com>
9
* Ludovic Rousseau <ludovic.rousseau@free.fr>
10
*
11
* $Id: winscard.c,v 1.51 2005/03/01 09:22:52 rousseau Exp $
12
*/
13
14
#include "config.h"
15
#include <stdlib.h>
16
#include <sys/time.h>
17
#include <string.h>
18
19
#include "pcsclite.h"
20
#include "winscard.h"
21
#include "ifdhandler.h"
22
#include "debuglog.h"
23
#include "readerfactory.h"
24
#include "prothandler.h"
25
#include "ifdwrapper.h"
26
#include "atrhandler.h"
27
#include "configfile.h"
28
#include "sys_generic.h"
29
#include "eventhandler.h"
30
31
#define SCARD_PROTOCOL_ANY_OLD 0x1000 /* used for backward compatibility */
32
33
/*
34
* Some defines for context stack
35
*/
36
#define SCARD_LAST_CONTEXT 1
37
#define SCARD_NO_CONTEXT 0
38
#define SCARD_EXCLUSIVE_CONTEXT -1
39
#define SCARD_NO_LOCK 0
40
41
SCARD_IO_REQUEST g_rgSCardT0Pci = { SCARD_PROTOCOL_T0, 8 };
42
SCARD_IO_REQUEST g_rgSCardT1Pci = { SCARD_PROTOCOL_T1, 8 };
43
SCARD_IO_REQUEST g_rgSCardRawPci = { SCARD_PROTOCOL_RAW, 8 };
44
45
LONG SCardEstablishContext(DWORD dwScope, LPCVOID pvReserved1,
46
LPCVOID pvReserved2, LPSCARDCONTEXT phContext)
47
{
48
/*
49
* Check for NULL pointer
50
*/
51
if (phContext == 0)
52
return SCARD_E_INVALID_PARAMETER;
53
54
if (dwScope != SCARD_SCOPE_USER && dwScope != SCARD_SCOPE_TERMINAL &&
55
dwScope != SCARD_SCOPE_SYSTEM && dwScope != SCARD_SCOPE_GLOBAL)
56
{
57
58
*phContext = 0;
59
return SCARD_E_INVALID_VALUE;
60
}
61
62
/*
63
* Unique identifier for this server so that it can uniquely be
64
* identified by clients and distinguished from others
65
*/
66
67
*phContext = (PCSCLITE_SVC_IDENTITY + SYS_RandomInt(1, 65535));
68
69
Log2(PCSC_LOG_DEBUG, "Establishing Context: %d", *phContext);
70
71
return SCARD_S_SUCCESS;
72
}
73
74
LONG SCardReleaseContext(SCARDCONTEXT hContext)
75
{
76
/*
77
* Nothing to do here RPC layer will handle this
78
*/
79
80
Log2(PCSC_LOG_DEBUG, "Releasing Context: %d", hContext);
81
82
return SCARD_S_SUCCESS;
83
}
84
85
LONG SCardSetTimeout(SCARDCONTEXT hContext, DWORD dwTimeout)
86
{
87
/*
88
* This is only used at the client side of an RPC call but just in
89
* case someone calls it here
90
*/
91
92
return SCARD_E_UNSUPPORTED_FEATURE;
93
}
94
95
LONG SCardConnect(SCARDCONTEXT hContext, LPCTSTR szReader,
96
DWORD dwShareMode, DWORD dwPreferredProtocols, LPSCARDHANDLE phCard,
97
LPDWORD pdwActiveProtocol)
98
{
99
LONG rv;
100
PREADER_CONTEXT rContext = NULL;
101
DWORD dwStatus;
102
103
/*
104
* Check for NULL parameters
105
*/
106
if (szReader == 0 || phCard == 0 || pdwActiveProtocol == 0)
107
return SCARD_E_INVALID_PARAMETER;
108
else
109
*phCard = 0;
110
111
if (!(dwPreferredProtocols & SCARD_PROTOCOL_T0) &&
112
!(dwPreferredProtocols & SCARD_PROTOCOL_T1) &&
113
!(dwPreferredProtocols & SCARD_PROTOCOL_RAW) &&
114
!(dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD))
115
return SCARD_E_PROTO_MISMATCH;
116
117
if (dwShareMode != SCARD_SHARE_EXCLUSIVE &&
118
dwShareMode != SCARD_SHARE_SHARED &&
119
dwShareMode != SCARD_SHARE_DIRECT)
120
return SCARD_E_INVALID_VALUE;
121
122
Log3(PCSC_LOG_DEBUG, "Attempting Connect to %s using protocol: %d",
123
szReader, dwPreferredProtocols);
124
125
rv = RFReaderInfo((LPTSTR) szReader, &rContext);
126
127
if (rv != SCARD_S_SUCCESS)
128
{
129
Log2(PCSC_LOG_ERROR, "Reader %s Not Found", szReader);
130
return rv;
131
}
132
133
/*
134
* Make sure the reader is working properly
135
*/
136
rv = RFCheckReaderStatus(rContext);
137
if (rv != SCARD_S_SUCCESS)
138
return rv;
139
140
/*******************************************
141
*
142
* This section checks for simple errors
143
*
144
*******************************************/
145
146
/*
147
* Connect if not exclusive mode
148
*/
149
if (rContext->dwContexts == SCARD_EXCLUSIVE_CONTEXT)
150
{
151
Log1(PCSC_LOG_ERROR, "Error Reader Exclusive");
152
return SCARD_E_SHARING_VIOLATION;
153
}
154
155
/*******************************************
156
*
157
* This section tries to determine the
158
* presence of a card or not
159
*
160
*******************************************/
161
dwStatus = rContext->readerState->readerState;
162
163
if (dwShareMode != SCARD_SHARE_DIRECT)
164
{
165
if (!(dwStatus & SCARD_PRESENT))
166
{
167
Log1(PCSC_LOG_ERROR, "Card Not Inserted");
168
return SCARD_E_NO_SMARTCARD;
169
}
170
}
171
172
/*******************************************
173
*
174
* This section tries to decode the ATR
175
* and set up which protocol to use
176
*
177
*******************************************/
178
if (dwPreferredProtocols & SCARD_PROTOCOL_RAW)
179
rContext->readerState->cardProtocol = SCARD_PROTOCOL_RAW;
180
else
181
{
182
if (dwShareMode != SCARD_SHARE_DIRECT)
183
{
184
/* the protocol is not yet set (no PPS yet) */
185
if (SCARD_PROTOCOL_UNSET == rContext->readerState->cardProtocol)
186
{
187
UCHAR ucAvailable, ucDefault;
188
int ret;
189
190
ucDefault = PHGetDefaultProtocol(rContext->readerState->cardAtr,
191
rContext->readerState->cardAtrLength);
192
ucAvailable =
193
PHGetAvailableProtocols(rContext->readerState->cardAtr,
194
rContext->readerState->cardAtrLength);
195
196
/*
197
* If it is set to ANY let it do any of the protocols
198
*/
199
if (dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD)
200
dwPreferredProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
201
202
ret = PHSetProtocol(rContext, dwPreferredProtocols,
203
ucAvailable, ucDefault);
204
205
/* keep cardProtocol = SCARD_PROTOCOL_UNSET in case of error */
206
if (SET_PROTOCOL_PPS_FAILED == ret)
207
return SCARD_W_UNRESPONSIVE_CARD;
208
209
if (SET_PROTOCOL_WRONG_ARGUMENT == ret)
210
return SCARD_E_PROTO_MISMATCH;
211
212
/* use negociated protocol */
213
rContext->readerState->cardProtocol = ret;
214
}
215
else
216
{
217
if (! (dwPreferredProtocols & rContext->readerState->cardProtocol))
218
return SCARD_E_PROTO_MISMATCH;
219
}
220
}
221
}
222
223
*pdwActiveProtocol = rContext->readerState->cardProtocol;
224
225
if ((*pdwActiveProtocol != SCARD_PROTOCOL_T0)
226
&& (*pdwActiveProtocol != SCARD_PROTOCOL_T1))
227
Log2(PCSC_LOG_ERROR, "Active Protocol: unknown %d",
228
*pdwActiveProtocol);
229
else
230
Log2(PCSC_LOG_DEBUG, "Active Protocol: T=%d",
231
(*pdwActiveProtocol == SCARD_PROTOCOL_T0) ? 0 : 1);
232
233
/*
234
* Prepare the SCARDHANDLE identity
235
*/
236
*phCard = RFCreateReaderHandle(rContext);
237
238
Log2(PCSC_LOG_DEBUG, "hCard Identity: %x", *phCard);
239
240
/*******************************************
241
*
242
* This section tries to set up the
243
* exclusivity modes. -1 is exclusive
244
*
245
*******************************************/
246
247
if (dwShareMode == SCARD_SHARE_EXCLUSIVE)
248
{
249
if (rContext->dwContexts == SCARD_NO_CONTEXT)
250
{
251
rContext->dwContexts = SCARD_EXCLUSIVE_CONTEXT;
252
RFLockSharing(*phCard);
253
}
254
else
255
{
256
RFDestroyReaderHandle(*phCard);
257
*phCard = 0;
258
return SCARD_E_SHARING_VIOLATION;
259
}
260
}
261
else
262
{
263
/*
264
* Add a connection to the context stack
265
*/
266
rContext->dwContexts += 1;
267
}
268
269
/*
270
* Add this handle to the handle list
271
*/
272
rv = RFAddReaderHandle(rContext, *phCard);
273
274
if (rv != SCARD_S_SUCCESS)
275
{
276
/*
277
* Clean up - there is no more room
278
*/
279
RFDestroyReaderHandle(*phCard);
280
if (rContext->dwContexts == SCARD_EXCLUSIVE_CONTEXT)
281
rContext->dwContexts = SCARD_NO_CONTEXT;
282
else
283
if (rContext->dwContexts > SCARD_NO_CONTEXT)
284
rContext->dwContexts -= 1;
285
286
*phCard = 0;
287
return SCARD_F_INTERNAL_ERROR;
288
}
289
290
/*
291
* Allow the status thread to convey information
292
*/
293
SYS_USleep(PCSCLITE_STATUS_POLL_RATE + 10);
294
295
return SCARD_S_SUCCESS;
296
}
297
298
LONG SCardReconnect(SCARDHANDLE hCard, DWORD dwShareMode,
299
DWORD dwPreferredProtocols, DWORD dwInitialization,
300
LPDWORD pdwActiveProtocol)
301
{
302
LONG rv;
303
PREADER_CONTEXT rContext = NULL;
304
305
Log1(PCSC_LOG_DEBUG, "Attempting reconnect to token.");
306
307
if (hCard == 0)
308
return SCARD_E_INVALID_HANDLE;
309
310
if (dwInitialization != SCARD_LEAVE_CARD &&
311
dwInitialization != SCARD_RESET_CARD &&
312
dwInitialization != SCARD_UNPOWER_CARD)
313
return SCARD_E_INVALID_VALUE;
314
315
if (dwShareMode != SCARD_SHARE_SHARED &&
316
dwShareMode != SCARD_SHARE_EXCLUSIVE &&
317
dwShareMode != SCARD_SHARE_DIRECT)
318
return SCARD_E_INVALID_VALUE;
319
320
if (!(dwPreferredProtocols & SCARD_PROTOCOL_T0) &&
321
!(dwPreferredProtocols & SCARD_PROTOCOL_T1) &&
322
!(dwPreferredProtocols & SCARD_PROTOCOL_RAW) &&
323
!(dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD))
324
return SCARD_E_PROTO_MISMATCH;
325
326
if (pdwActiveProtocol == 0)
327
return SCARD_E_INVALID_PARAMETER;
328
329
rv = RFReaderInfoById(hCard, &rContext);
330
if (rv != SCARD_S_SUCCESS)
331
return rv;
332
333
/*
334
* Make sure the reader is working properly
335
*/
336
rv = RFCheckReaderStatus(rContext);
337
if (rv != SCARD_S_SUCCESS)
338
return rv;
339
340
rv = RFFindReaderHandle(hCard);
341
if (rv != SCARD_S_SUCCESS)
342
return rv;
343
344
/*
345
* Make sure no one has a lock on this reader
346
*/
347
if ((rv = RFCheckSharing(hCard)) != SCARD_S_SUCCESS)
348
return rv;
349
350
/*
351
* Handle the dwInitialization
352
*/
353
if ((dwInitialization != SCARD_LEAVE_CARD)
354
&& (dwInitialization != SCARD_UNPOWER_CARD)
355
&& (dwInitialization != SCARD_RESET_CARD))
356
return SCARD_E_INVALID_VALUE;
357
358
/*
359
* RFUnblockReader( rContext ); FIX - this doesn't work
360
*/
361
362
if (dwInitialization == SCARD_RESET_CARD ||
363
dwInitialization == SCARD_UNPOWER_CARD)
364
{
365
/*
366
* Currently pcsc-lite keeps the card powered constantly
367
*/
368
if (SCARD_RESET_CARD == dwInitialization)
369
rv = IFDPowerICC(rContext, IFD_RESET,
370
rContext->readerState->cardAtr,
371
&rContext->readerState->cardAtrLength);
372
else
373
{
374
rv = IFDPowerICC(rContext, IFD_POWER_DOWN,
375
rContext->readerState->cardAtr,
376
&rContext->readerState->cardAtrLength);
377
rv = IFDPowerICC(rContext, IFD_POWER_UP,
378
rContext->readerState->cardAtr,
379
&rContext->readerState->cardAtrLength);
380
}
381
382
/* the protocol is unset after a power on */
383
rContext->readerState->cardProtocol = SCARD_PROTOCOL_UNSET;
384
385
/*
386
* Notify the card has been reset
387
* Not doing this could result in deadlock
388
*/
389
rv = RFCheckReaderEventState(rContext, hCard);
390
switch(rv)
391
{
392
/* avoid deadlock */
393
case SCARD_W_RESET_CARD:
394
break;
395
396
case SCARD_W_REMOVED_CARD:
397
Log1(PCSC_LOG_ERROR, "card removed");
398
return SCARD_W_REMOVED_CARD;
399
400
/* invalid EventStatus */
401
case SCARD_E_INVALID_VALUE:
402
Log1(PCSC_LOG_ERROR, "invalid EventStatus");
403
return SCARD_F_INTERNAL_ERROR;
404
405
/* invalid hCard, but hCard was widely used some lines above :( */
406
case SCARD_E_INVALID_HANDLE:
407
Log1(PCSC_LOG_ERROR, "invalid handle");
408
return SCARD_F_INTERNAL_ERROR;
409
410
case SCARD_S_SUCCESS:
411
/*
412
* Notify the card has been reset
413
*/
414
RFSetReaderEventState(rContext, SCARD_RESET);
415
416
/*
417
* Set up the status bit masks on dwStatus
418
*/
419
if (rv == SCARD_S_SUCCESS)
420
{
421
rContext->readerState->readerState |= SCARD_PRESENT;
422
rContext->readerState->readerState &= ~SCARD_ABSENT;
423
rContext->readerState->readerState |= SCARD_POWERED;
424
rContext->readerState->readerState |= SCARD_NEGOTIABLE;
425
rContext->readerState->readerState &= ~SCARD_SPECIFIC;
426
rContext->readerState->readerState &= ~SCARD_SWALLOWED;
427
rContext->readerState->readerState &= ~SCARD_UNKNOWN;
428
}
429
else
430
{
431
rContext->readerState->readerState |= SCARD_PRESENT;
432
rContext->readerState->readerState &= ~SCARD_ABSENT;
433
rContext->readerState->readerState |= SCARD_SWALLOWED;
434
rContext->readerState->readerState &= ~SCARD_POWERED;
435
rContext->readerState->readerState &= ~SCARD_NEGOTIABLE;
436
rContext->readerState->readerState &= ~SCARD_SPECIFIC;
437
rContext->readerState->readerState &= ~SCARD_UNKNOWN;
438
rContext->readerState->cardAtrLength = 0;
439
}
440
441
if (rContext->readerState->cardAtrLength > 0)
442
{
443
Log1(PCSC_LOG_DEBUG, "Reset complete.");
444
LogXxd(PCSC_LOG_DEBUG, "Card ATR: ",
445
rContext->readerState->cardAtr,
446
rContext->readerState->cardAtrLength);
447
}
448
else
449
{
450
DWORD dwStatus, dwAtrLen;
451
UCHAR ucAtr[MAX_ATR_SIZE];
452
453
Log1(PCSC_LOG_ERROR, "Error resetting card.");
454
IFDStatusICC(rContext, &dwStatus, ucAtr, &dwAtrLen);
455
if (dwStatus & SCARD_PRESENT)
456
return SCARD_W_UNRESPONSIVE_CARD;
457
else
458
return SCARD_E_NO_SMARTCARD;
459
}
460
break;
461
462
default:
463
Log2(PCSC_LOG_ERROR,
464
"invalid retcode from RFCheckReaderEventState (%X)", rv);
465
return SCARD_F_INTERNAL_ERROR;
466
break;
467
}
468
469
}
470
else
471
if (dwInitialization == SCARD_LEAVE_CARD)
472
{
473
/*
474
* Do nothing
475
*/
476
}
477
478
/*******************************************
479
*
480
* This section tries to decode the ATR
481
* and set up which protocol to use
482
*
483
*******************************************/
484
if (dwPreferredProtocols & SCARD_PROTOCOL_RAW)
485
rContext->readerState->cardProtocol = SCARD_PROTOCOL_RAW;
486
else
487
{
488
if (dwShareMode != SCARD_SHARE_DIRECT)
489
{
490
/* the protocol is not yet set (no PPS yet) */
491
if (SCARD_PROTOCOL_UNSET == rContext->readerState->cardProtocol)
492
{
493
UCHAR ucAvailable, ucDefault;
494
int ret;
495
496
ucDefault = PHGetDefaultProtocol(rContext->readerState->cardAtr,
497
rContext->readerState->cardAtrLength);
498
ucAvailable =
499
PHGetAvailableProtocols(rContext->readerState->cardAtr,
500
rContext->readerState->cardAtrLength);
501
502
/* If it is set to ANY let it do any of the protocols */
503
if (dwPreferredProtocols & SCARD_PROTOCOL_ANY_OLD)
504
dwPreferredProtocols = SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1;
505
506
ret = PHSetProtocol(rContext, dwPreferredProtocols,
507
ucAvailable, ucDefault);
508
509
/* keep cardProtocol = SCARD_PROTOCOL_UNSET in case of error */
510
if (SET_PROTOCOL_PPS_FAILED == ret)
511
return SCARD_W_UNRESPONSIVE_CARD;
512
513
if (SET_PROTOCOL_WRONG_ARGUMENT == ret)
514
return SCARD_E_PROTO_MISMATCH;
515
516
/* use negociated protocol */
517
rContext->readerState->cardProtocol = ret;
518
}
519
else
520
{
521
if (! (dwPreferredProtocols & rContext->readerState->cardProtocol))
522
return SCARD_E_PROTO_MISMATCH;
523
}
524
}
525
}
526
527
*pdwActiveProtocol = rContext->readerState->cardProtocol;
528
529
if (dwShareMode == SCARD_SHARE_EXCLUSIVE)
530
{
531
if (rContext->dwContexts == SCARD_EXCLUSIVE_CONTEXT)
532
{
533
/*
534
* Do nothing - we are already exclusive
535
*/
536
} else
537
{
538
if (rContext->dwContexts == SCARD_LAST_CONTEXT)
539
{
540
rContext->dwContexts = SCARD_EXCLUSIVE_CONTEXT;
541
RFLockSharing(hCard);
542
} else
543
{
544
return SCARD_E_SHARING_VIOLATION;
545
}
546
}
547
} else if (dwShareMode == SCARD_SHARE_SHARED)
548
{
549
if (rContext->dwContexts != SCARD_EXCLUSIVE_CONTEXT)
550
{
551
/*
552
* Do nothing - in sharing mode already
553
*/
554
} else
555
{
556
/*
557
* We are in exclusive mode but want to share now
558
*/
559
RFUnlockSharing(hCard);
560
rContext->dwContexts = SCARD_LAST_CONTEXT;
561
}
562
} else if (dwShareMode == SCARD_SHARE_DIRECT)
563
{
564
if (rContext->dwContexts != SCARD_EXCLUSIVE_CONTEXT)
565
{
566
/*
567
* Do nothing - in sharing mode already
568
*/
569
} else
570
{
571
/*
572
* We are in exclusive mode but want to share now
573
*/
574
RFUnlockSharing(hCard);
575
rContext->dwContexts = SCARD_LAST_CONTEXT;
576
}
577
} else
578
return SCARD_E_INVALID_VALUE;
579
580
/*
581
* Clear a previous event to the application
582
*/
583
RFClearReaderEventState(rContext, hCard);
584
585
/*
586
* Allow the status thread to convey information
587
*/
588
SYS_USleep(PCSCLITE_STATUS_POLL_RATE + 10);
589
590
return SCARD_S_SUCCESS;
591
}
592
593
LONG SCardDisconnect(SCARDHANDLE hCard, DWORD dwDisposition)
594
{
595
LONG rv;
596
PREADER_CONTEXT rContext = NULL;
597
598
if (hCard == 0)
599
return SCARD_E_INVALID_HANDLE;
600
601
rv = RFReaderInfoById(hCard, &rContext);
602
if (rv != SCARD_S_SUCCESS)
603
return rv;
604
605
rv = RFFindReaderHandle(hCard);
606
if (rv != SCARD_S_SUCCESS)
607
return rv;
608
609
if ((dwDisposition != SCARD_LEAVE_CARD)
610
&& (dwDisposition != SCARD_UNPOWER_CARD)
611
&& (dwDisposition != SCARD_RESET_CARD)
612
&& (dwDisposition != SCARD_EJECT_CARD))
613
return SCARD_E_INVALID_VALUE;
614
615
/*
616
* Unlock any blocks on this context
617
*/
618
RFUnlockSharing(hCard);
619
620
Log2(PCSC_LOG_DEBUG, "Active Contexts: %d", rContext->dwContexts);
621
622
if (dwDisposition == SCARD_RESET_CARD ||
623
dwDisposition == SCARD_UNPOWER_CARD)
624
{
625
/*
626
* Currently pcsc-lite keeps the card powered constantly
627
*/
628
if (SCARD_RESET_CARD == dwDisposition)
629
rv = IFDPowerICC(rContext, IFD_RESET,
630
rContext->readerState->cardAtr,
631
&rContext->readerState->cardAtrLength);
632
else
633
{
634
rv = IFDPowerICC(rContext, IFD_POWER_DOWN,
635
rContext->readerState->cardAtr,
636
&rContext->readerState->cardAtrLength);
637
rv = IFDPowerICC(rContext, IFD_POWER_UP,
638
rContext->readerState->cardAtr,
639
&rContext->readerState->cardAtrLength);
640
}
641
642
/* the protocol is unset after a power on */
643
rContext->readerState->cardProtocol = SCARD_PROTOCOL_UNSET;
644
645
/*
646
* Notify the card has been reset
647
*/
648
RFSetReaderEventState(rContext, SCARD_RESET);
649
650
/*
651
* Set up the status bit masks on dwStatus
652
*/
653
if (rv == SCARD_S_SUCCESS)
654
{
655
rContext->readerState->readerState |= SCARD_PRESENT;
656
rContext->readerState->readerState &= ~SCARD_ABSENT;
657
rContext->readerState->readerState |= SCARD_POWERED;
658
rContext->readerState->readerState |= SCARD_NEGOTIABLE;
659
rContext->readerState->readerState &= ~SCARD_SPECIFIC;
660
rContext->readerState->readerState &= ~SCARD_SWALLOWED;
661
rContext->readerState->readerState &= ~SCARD_UNKNOWN;
662
}
663
else
664
{
665
if (rContext->readerState->readerState & SCARD_ABSENT)
666
rContext->readerState->readerState &= ~SCARD_PRESENT;
667
else
668
rContext->readerState->readerState |= SCARD_PRESENT;
669
/* SCARD_ABSENT flag is already set */
670
rContext->readerState->readerState |= SCARD_SWALLOWED;
671
rContext->readerState->readerState &= ~SCARD_POWERED;
672
rContext->readerState->readerState &= ~SCARD_NEGOTIABLE;
673
rContext->readerState->readerState &= ~SCARD_SPECIFIC;
674
rContext->readerState->readerState &= ~SCARD_UNKNOWN;
675
rContext->readerState->cardAtrLength = 0;
676
}
677
678
if (rContext->readerState->cardAtrLength > 0)
679
Log1(PCSC_LOG_DEBUG, "Reset complete.");
680
else
681
Log1(PCSC_LOG_ERROR, "Error resetting card.");
682
683
}
684
else if (dwDisposition == SCARD_EJECT_CARD)
685
{
686
UCHAR controlBuffer[5];
687
UCHAR receiveBuffer[MAX_BUFFER_SIZE];
688
DWORD receiveLength;
689
690
/*
691
* Set up the CTBCS command for Eject ICC
692
*/
693
controlBuffer[0] = 0x20;
694
controlBuffer[1] = 0x15;
695
controlBuffer[2] = (rContext->dwSlot & 0x0000FFFF) + 1;
696
controlBuffer[3] = 0x00;
697
controlBuffer[4] = 0x00;
698
receiveLength = 2;
699
rv = IFDControl_v2(rContext, controlBuffer, 5, receiveBuffer,
700
&receiveLength);
701
702
if (rv == SCARD_S_SUCCESS)
703
{
704
if (receiveLength == 2 && receiveBuffer[0] == 0x90)
705
{
706
Log1(PCSC_LOG_DEBUG, "Card ejected successfully.");
707
/*
708
* Successful
709
*/
710
}
711
else
712
Log1(PCSC_LOG_ERROR, "Error ejecting card.");
713
}
714
else
715
Log1(PCSC_LOG_ERROR, "Error ejecting card.");
716
717
}
718
else if (dwDisposition == SCARD_LEAVE_CARD)
719
{
720
/*
721
* Do nothing
722
*/
723
}
724
725
/*
726
* Remove and destroy this handle
727
*/
728
RFRemoveReaderHandle(rContext, hCard);
729
RFDestroyReaderHandle(hCard);
730
731
/*
732
* For exclusive connection reset it to no connections
733
*/
734
if (rContext->dwContexts == SCARD_EXCLUSIVE_CONTEXT)
735
{
736
rContext->dwContexts = SCARD_NO_CONTEXT;
737
return SCARD_S_SUCCESS;
738
}
739
740
/*
741
* Remove a connection from the context stack
742
*/
743
rContext->dwContexts -= 1;
744
745
if (rContext->dwContexts < 0)
746
rContext->dwContexts = 0;
747
748
/*
749
* Allow the status thread to convey information
750
*/
751
SYS_USleep(PCSCLITE_STATUS_POLL_RATE + 10);
752
753
return SCARD_S_SUCCESS;
754
}
755
756
LONG SCardBeginTransaction(SCARDHANDLE hCard)
757
{
758
LONG rv;
759
PREADER_CONTEXT rContext;
760
761
if (hCard == 0)
762
return SCARD_E_INVALID_HANDLE;
763
764
rv = RFReaderInfoById(hCard, &rContext);
765
766
/*
767
* Cannot find the hCard in this context
768
*/
769
if (rv != SCARD_S_SUCCESS)
770
return rv;
771
772
/*
773
* Make sure the reader is working properly
774
*/
775
rv = RFCheckReaderStatus(rContext);
776
if (rv != SCARD_S_SUCCESS)
777
return rv;
778
779
rv = RFFindReaderHandle(hCard);
780
if (rv != SCARD_S_SUCCESS)
781
return rv;
782
783
/*
784
* Make sure some event has not occurred
785
*/
786
if ((rv = RFCheckReaderEventState(rContext, hCard)) != SCARD_S_SUCCESS)
787
return rv;
788
789
rv = RFLockSharing(hCard);
790
791
Log2(PCSC_LOG_DEBUG, "Status: %d.", rv);
792
793
return rv;
794
}
795
796
LONG SCardEndTransaction(SCARDHANDLE hCard, DWORD dwDisposition)
797
{
798
LONG rv;
799
PREADER_CONTEXT rContext = NULL;
800
801
/*
802
* Ignoring dwDisposition for now
803
*/
804
if (hCard == 0)
805
return SCARD_E_INVALID_HANDLE;
806
807
if ((dwDisposition != SCARD_LEAVE_CARD)
808
&& (dwDisposition != SCARD_UNPOWER_CARD)
809
&& (dwDisposition != SCARD_RESET_CARD)
810
&& (dwDisposition != SCARD_EJECT_CARD))
811
return SCARD_E_INVALID_VALUE;
812
813
rv = RFReaderInfoById(hCard, &rContext);
814
815
/*
816
* Cannot find the hCard in this context
817
*/
818
if (rv != SCARD_S_SUCCESS)
819
return rv;
820
821
rv = RFFindReaderHandle(hCard);
822
if (rv != SCARD_S_SUCCESS)
823
return rv;
824
825
/*
826
* Make sure some event has not occurred
827
*/
828
if ((rv = RFCheckReaderEventState(rContext, hCard)) != SCARD_S_SUCCESS)
829
return rv;
830
831
if (dwDisposition == SCARD_RESET_CARD ||
832
dwDisposition == SCARD_UNPOWER_CARD)
833
{
834
/*
835
* Currently pcsc-lite keeps the card always powered
836
*/
837
if (SCARD_RESET_CARD == dwDisposition)
838
rv = IFDPowerICC(rContext, IFD_RESET,
839
rContext->readerState->cardAtr,
840
&rContext->readerState->cardAtrLength);
841
else
842
{
843
rv = IFDPowerICC(rContext, IFD_POWER_DOWN,
844
rContext->readerState->cardAtr,
845
&rContext->readerState->cardAtrLength);
846
rv = IFDPowerICC(rContext, IFD_POWER_UP,
847
rContext->readerState->cardAtr,
848
&rContext->readerState->cardAtrLength);
849
}
850
851
/* the protocol is unset after a power on */
852
rContext->readerState->cardProtocol = SCARD_PROTOCOL_UNSET;
853
854
/*
855
* Notify the card has been reset
856
*/
857
RFSetReaderEventState(rContext, SCARD_RESET);
858
859
/*
860
* Set up the status bit masks on dwStatus
861
*/
862
if (rv == SCARD_S_SUCCESS)
863
{
864
rContext->readerState->readerState |= SCARD_PRESENT;
865
rContext->readerState->readerState &= ~SCARD_ABSENT;
866
rContext->readerState->readerState |= SCARD_POWERED;
867
rContext->readerState->readerState |= SCARD_NEGOTIABLE;
868
rContext->readerState->readerState &= ~SCARD_SPECIFIC;
869
rContext->readerState->readerState &= ~SCARD_SWALLOWED;
870
rContext->readerState->readerState &= ~SCARD_UNKNOWN;
871
}
872
else
873
{
874
if (rContext->readerState->readerState & SCARD_ABSENT)
875
rContext->readerState->readerState &= ~SCARD_PRESENT;
876
else
877
rContext->readerState->readerState |= SCARD_PRESENT;
878
/* SCARD_ABSENT flag is already set */
879
rContext->readerState->readerState |= SCARD_SWALLOWED;
880
rContext->readerState->readerState &= ~SCARD_POWERED;
881
rContext->readerState->readerState &= ~SCARD_NEGOTIABLE;
882
rContext->readerState->readerState &= ~SCARD_SPECIFIC;
883
rContext->readerState->readerState &= ~SCARD_UNKNOWN;
884
rContext->readerState->cardAtrLength = 0;
885
}
886
887
if (rContext->readerState->cardAtrLength > 0)
888
Log1(PCSC_LOG_DEBUG, "Reset complete.");
889
else
890
Log1(PCSC_LOG_ERROR, "Error resetting card.");
891
892
}
893
else if (dwDisposition == SCARD_EJECT_CARD)
894
{
895
UCHAR controlBuffer[5];
896
UCHAR receiveBuffer[MAX_BUFFER_SIZE];
897
DWORD receiveLength;
898
899
/*
900
* Set up the CTBCS command for Eject ICC
901
*/
902
controlBuffer[0] = 0x20;
903
controlBuffer[1] = 0x15;
904
controlBuffer[2] = (rContext->dwSlot & 0x0000FFFF) + 1;
905
controlBuffer[3] = 0x00;
906
controlBuffer[4] = 0x00;
907
receiveLength = 2;
908
rv = IFDControl_v2(rContext, controlBuffer, 5, receiveBuffer,
909
&receiveLength);
910
911
if (rv == SCARD_S_SUCCESS)
912
{
913
if (receiveLength == 2 && receiveBuffer[0] == 0x90)
914
{
915
Log1(PCSC_LOG_DEBUG, "Card ejected successfully.");
916
/*
917
* Successful
918
*/
919
}
920
else
921
Log1(PCSC_LOG_ERROR, "Error ejecting card.");
922
}
923
else
924
Log1(PCSC_LOG_ERROR, "Error ejecting card.");
925
926
}
927
else if (dwDisposition == SCARD_LEAVE_CARD)
928
{
929
/*
930
* Do nothing
931
*/
932
}
933
934
/*
935
* Unlock any blocks on this context
936
*/
937
RFUnlockSharing(hCard);
938
939
Log2(PCSC_LOG_DEBUG, "Status: %d.", rv);
940
941
return rv;
942
}
943
944
LONG SCardCancelTransaction(SCARDHANDLE hCard)
945
{
946
LONG rv;
947
PREADER_CONTEXT rContext = NULL;
948
949
/*
950
* Ignoring dwDisposition for now
951
*/
952
if (hCard == 0)
953
return SCARD_E_INVALID_HANDLE;
954
955
rv = RFReaderInfoById(hCard, &rContext);
956
957
/*
958
* Cannot find the hCard in this context
959
*/
960
if (rv != SCARD_S_SUCCESS)
961
return rv;
962
963
rv = RFFindReaderHandle(hCard);
964
if (rv != SCARD_S_SUCCESS)
965
return rv;
966
967
/*
968
* Make sure some event has not occurred
969
*/
970
if ((rv = RFCheckReaderEventState(rContext, hCard)) != SCARD_S_SUCCESS)
971
return rv;
972
973
rv = RFUnlockSharing(hCard);
974
975
Log2(PCSC_LOG_DEBUG, "Status: %d.", rv);
976
977
return rv;
978
}
979
980
LONG SCardStatus(SCARDHANDLE hCard, LPTSTR mszReaderNames,
981
LPDWORD pcchReaderLen, LPDWORD pdwState,
982
LPDWORD pdwProtocol, LPBYTE pbAtr, LPDWORD pcbAtrLen)
983
{
984
LONG rv;
985
PREADER_CONTEXT rContext = NULL;
986
987
rv = RFReaderInfoById(hCard, &rContext);
988
989
/*
990
* Cannot find the hCard in this context
991
*/
992
if (rv != SCARD_S_SUCCESS)
993
return rv;
994
995
if (strlen(rContext->lpcReader) > MAX_BUFFER_SIZE
996
|| rContext->readerState->cardAtrLength > MAX_ATR_SIZE
997
|| rContext->readerState->cardAtrLength < 0)
998
return SCARD_F_INTERNAL_ERROR;
999
1000
/*
1001
* This is a client side function however the server maintains the
1002
* list of events between applications so it must be passed through to
1003
* obtain this event if it has occurred
1004
*/
1005
1006
/*
1007
* Make sure some event has not occurred
1008
*/
1009
if ((rv = RFCheckReaderEventState(rContext, hCard)) != SCARD_S_SUCCESS)
1010
return rv;
1011
1012
/*
1013
* Make sure the reader is working properly
1014
*/
1015
rv = RFCheckReaderStatus(rContext);
1016
if (rv != SCARD_S_SUCCESS)
1017
return rv;
1018
1019
if (mszReaderNames)
1020
{ /* want reader name */
1021
if (pcchReaderLen)
1022
{ /* & present reader name length */
1023
if (*pcchReaderLen >= strlen(rContext->lpcReader))
1024
{ /* & enough room */
1025
*pcchReaderLen = strlen(rContext->lpcReader);
1026
strncpy(mszReaderNames, rContext->lpcReader, MAX_READERNAME);
1027
}
1028
else
1029
{ /* may report only reader name len */
1030
*pcchReaderLen = strlen(rContext->lpcReader);
1031
rv = SCARD_E_INSUFFICIENT_BUFFER;
1032
}
1033
}
1034
else
1035
{ /* present buf & no buflen */
1036
return SCARD_E_INVALID_PARAMETER;
1037
}
1038
}
1039
else
1040
{
1041
if (pcchReaderLen)
1042
{ /* want reader len only */
1043
*pcchReaderLen = strlen(rContext->lpcReader);
1044
}
1045
else
1046
{
1047
/* nothing todo */
1048
}
1049
}
1050
1051
if (pdwState)
1052
*pdwState = rContext->readerState->readerState;
1053
1054
if (pdwProtocol)
1055
*pdwProtocol = rContext->readerState->cardProtocol;
1056
1057
if (pbAtr)
1058
{ /* want ATR */
1059
if (pcbAtrLen)
1060
{ /* & present ATR length */
1061
if (*pcbAtrLen >= rContext->readerState->cardAtrLength)
1062
{ /* & enough room */
1063
*pcbAtrLen = rContext->readerState->cardAtrLength;
1064
memcpy(pbAtr, rContext->readerState->cardAtr,
1065
rContext->readerState->cardAtrLength);
1066
}
1067
else
1068
{ /* may report only ATR len */
1069
*pcbAtrLen = rContext->readerState->cardAtrLength;
1070
rv = SCARD_E_INSUFFICIENT_BUFFER;
1071
}
1072
}
1073
else
1074
{ /* present buf & no buflen */
1075
return SCARD_E_INVALID_PARAMETER;
1076
}
1077
}
1078
else
1079
{
1080
if (pcbAtrLen)
1081
{ /* want ATR len only */
1082
*pcbAtrLen = rContext->readerState->cardAtrLength;
1083
}
1084
else
1085
{
1086
/* nothing todo */
1087
}
1088
}
1089
1090
return rv;
1091
}
1092
1093
LONG SCardGetStatusChange(SCARDCONTEXT hContext, DWORD dwTimeout,
1094
LPSCARD_READERSTATE_A rgReaderStates, DWORD cReaders)
1095
{
1096
/*
1097
* Client side function
1098
*/
1099
return SCARD_S_SUCCESS;
1100
}
1101
1102
LONG SCardControl(SCARDHANDLE hCard, DWORD dwControlCode,
1103
LPCVOID pbSendBuffer, DWORD cbSendLength,
1104
LPVOID pbRecvBuffer, DWORD cbRecvLength, LPDWORD lpBytesReturned)
1105
{
1106
LONG rv;
1107
PREADER_CONTEXT rContext = NULL;
1108
1109
/* 0 bytes returned by default */
1110
*lpBytesReturned = 0;
1111
1112
if (0 == hCard)
1113
return SCARD_E_INVALID_HANDLE;
1114
1115
/*
1116
* Make sure no one has a lock on this reader
1117
*/
1118
if ((rv = RFCheckSharing(hCard)) != SCARD_S_SUCCESS)
1119
return rv;
1120
1121
rv = RFReaderInfoById(hCard, &rContext);
1122
if (rv != SCARD_S_SUCCESS)
1123
return rv;
1124
1125
if (IFD_HVERSION_2_0 == rContext->dwVersion)
1126
if (NULL == pbSendBuffer || 0 == cbSendLength)
1127
return SCARD_E_INVALID_PARAMETER;
1128
1129
/*
1130
* Make sure the reader is working properly
1131
*/
1132
rv = RFCheckReaderStatus(rContext);
1133
if (rv != SCARD_S_SUCCESS)
1134
return rv;
1135
1136
rv = RFFindReaderHandle(hCard);
1137
if (rv != SCARD_S_SUCCESS)
1138
return rv;
1139
1140
/*
1141
* Make sure some event has not occurred
1142
*/
1143
if ((rv = RFCheckReaderEventState(rContext, hCard)) != SCARD_S_SUCCESS)
1144
return rv;
1145
1146
if (cbSendLength > MAX_BUFFER_SIZE)
1147
return SCARD_E_INSUFFICIENT_BUFFER;
1148
1149
if (IFD_HVERSION_2_0 == rContext->dwVersion)
1150
{
1151
/* we must wrap a API 3.0 client in an API 2.0 driver */
1152
*lpBytesReturned = cbRecvLength;
1153
return IFDControl_v2(rContext, (PUCHAR)pbSendBuffer,
1154
cbSendLength, pbRecvBuffer, lpBytesReturned);
1155
}
1156
else
1157
if (IFD_HVERSION_3_0 == rContext->dwVersion)
1158
return IFDControl(rContext, dwControlCode, pbSendBuffer,
1159
cbSendLength, pbRecvBuffer, cbRecvLength, lpBytesReturned);
1160
else
1161
return SCARD_E_UNSUPPORTED_FEATURE;
1162
}
1163
1164
LONG SCardGetAttrib(SCARDHANDLE hCard, DWORD dwAttrId,
1165
LPBYTE pbAttr, LPDWORD pcbAttrLen)
1166
{
1167
LONG rv;
1168
PREADER_CONTEXT rContext = NULL;
1169
1170
if (0 == hCard)
1171
return SCARD_E_INVALID_HANDLE;
1172
1173
/*
1174
* Make sure no one has a lock on this reader
1175
*/
1176
if ((rv = RFCheckSharing(hCard)) != SCARD_S_SUCCESS)
1177
return rv;
1178
1179
rv = RFReaderInfoById(hCard, &rContext);
1180
if (rv != SCARD_S_SUCCESS)
1181
return rv;
1182
1183
/*
1184
* Make sure the reader is working properly
1185
*/
1186
rv = RFCheckReaderStatus(rContext);
1187
if (rv != SCARD_S_SUCCESS)
1188
return rv;
1189
1190
rv = RFFindReaderHandle(hCard);
1191
if (rv != SCARD_S_SUCCESS)
1192
return rv;
1193
1194
/*
1195
* Make sure some event has not occurred
1196
*/
1197
if ((rv = RFCheckReaderEventState(rContext, hCard)) != SCARD_S_SUCCESS)
1198
return rv;
1199
1200
rv = IFDGetCapabilities(rContext, dwAttrId, pcbAttrLen, pbAttr);
1201
if (rv == IFD_SUCCESS)
1202
return SCARD_S_SUCCESS;
1203
else
1204
return SCARD_E_NOT_TRANSACTED;
1205
}
1206
1207
LONG SCardSetAttrib(SCARDHANDLE hCard, DWORD dwAttrId,
1208
LPCBYTE pbAttr, DWORD cbAttrLen)
1209
{
1210
LONG rv;
1211
PREADER_CONTEXT rContext = NULL;
1212
1213
if (0 == hCard)
1214
return SCARD_E_INVALID_HANDLE;
1215
1216
/*
1217
* Make sure no one has a lock on this reader
1218
*/
1219
if ((rv = RFCheckSharing(hCard)) != SCARD_S_SUCCESS)
1220
return rv;
1221
1222
rv = RFReaderInfoById(hCard, &rContext);
1223
if (rv != SCARD_S_SUCCESS)
1224
return rv;
1225
1226
/*
1227
* Make sure the reader is working properly
1228
*/
1229
rv = RFCheckReaderStatus(rContext);
1230
if (rv != SCARD_S_SUCCESS)
1231
return rv;
1232
1233
rv = RFFindReaderHandle(hCard);
1234
if (rv != SCARD_S_SUCCESS)
1235
return rv;
1236
1237
/*
1238
* Make sure some event has not occurred
1239
*/
1240
if ((rv = RFCheckReaderEventState(rContext, hCard)) != SCARD_S_SUCCESS)
1241
return rv;
1242
1243
rv = IFDSetCapabilities(rContext, dwAttrId, cbAttrLen, (PUCHAR)pbAttr);
1244
if (rv == IFD_SUCCESS)
1245
return SCARD_S_SUCCESS;
1246
else
1247
return SCARD_E_NOT_TRANSACTED;
1248
}
1249
1250
LONG SCardTransmit(SCARDHANDLE hCard, LPCSCARD_IO_REQUEST pioSendPci,
1251
LPCBYTE pbSendBuffer, DWORD cbSendLength,
1252
LPSCARD_IO_REQUEST pioRecvPci, LPBYTE pbRecvBuffer,
1253
LPDWORD pcbRecvLength)
1254
{
1255
LONG rv;
1256
PREADER_CONTEXT rContext = NULL;
1257
SCARD_IO_HEADER sSendPci, sRecvPci;
1258
DWORD dwRxLength, tempRxLength;
1259
1260
if (pcbRecvLength == 0)
1261
return SCARD_E_INVALID_PARAMETER;
1262
1263
dwRxLength = *pcbRecvLength;
1264
*pcbRecvLength = 0;
1265
1266
if (hCard == 0)
1267
return SCARD_E_INVALID_HANDLE;
1268
1269
if (pbSendBuffer == NULL || pbRecvBuffer == NULL || pioSendPci == NULL)
1270
return SCARD_E_INVALID_PARAMETER;
1271
1272
/*
1273
* Must at least send a 4 bytes APDU
1274
*/
1275
if (cbSendLength < 4)
1276
return SCARD_E_INVALID_PARAMETER;
1277
1278
/*
1279
* Must at least have 2 status words even for SCardControl
1280
*/
1281
if (dwRxLength < 2)
1282
return SCARD_E_INSUFFICIENT_BUFFER;
1283
1284
/*
1285
* Make sure no one has a lock on this reader
1286
*/
1287
if ((rv = RFCheckSharing(hCard)) != SCARD_S_SUCCESS)
1288
return rv;
1289
1290
rv = RFReaderInfoById(hCard, &rContext);
1291
if (rv != SCARD_S_SUCCESS)
1292
return rv;
1293
1294
/*
1295
* Make sure the reader is working properly
1296
*/
1297
rv = RFCheckReaderStatus(rContext);
1298
if (rv != SCARD_S_SUCCESS)
1299
return rv;
1300
1301
rv = RFFindReaderHandle(hCard);
1302
if (rv != SCARD_S_SUCCESS)
1303
return rv;
1304
1305
/*
1306
* Make sure some event has not occurred
1307
*/
1308
if ((rv = RFCheckReaderEventState(rContext, hCard)) != SCARD_S_SUCCESS)
1309
return rv;
1310
1311
/*
1312
* Check for some common errors
1313
*/
1314
if (pioSendPci->dwProtocol != SCARD_PROTOCOL_RAW)
1315
{
1316
if (rContext->readerState->readerState & SCARD_ABSENT)
1317
{
1318
return SCARD_E_NO_SMARTCARD;
1319
}
1320
}
1321
1322
if (pioSendPci->dwProtocol != SCARD_PROTOCOL_RAW)
1323
{
1324
if (pioSendPci->dwProtocol != SCARD_PROTOCOL_ANY_OLD)
1325
{
1326
if (pioSendPci->dwProtocol != rContext->readerState->cardProtocol)
1327
{
1328
return SCARD_E_PROTO_MISMATCH;
1329
}
1330
}
1331
}
1332
1333
if (cbSendLength > MAX_BUFFER_SIZE)
1334
{
1335
return SCARD_E_INSUFFICIENT_BUFFER;
1336
}
1337
1338
/*
1339
* Removed - a user may allocate a larger buffer if ( dwRxLength >
1340
* MAX_BUFFER_SIZE ) { return SCARD_E_INSUFFICIENT_BUFFER; }
1341
*/
1342
1343
/*
1344
* Quick fix: PC/SC starts at 1 for bit masking but the IFD_Handler
1345
* just wants 0 or 1
1346
*/
1347
1348
if (pioSendPci->dwProtocol == SCARD_PROTOCOL_T0)
1349
{
1350
sSendPci.Protocol = 0;
1351
} else if (pioSendPci->dwProtocol == SCARD_PROTOCOL_T1)
1352
{
1353
sSendPci.Protocol = 1;
1354
} else if (pioSendPci->dwProtocol == SCARD_PROTOCOL_RAW)
1355
{
1356
/*
1357
* This is temporary ......
1358
*/
1359
sSendPci.Protocol = SCARD_PROTOCOL_RAW;
1360
} else if (pioSendPci->dwProtocol == SCARD_PROTOCOL_ANY_OLD)
1361
{
1362
/* Fix by Amira (Athena) */
1363
unsigned long i;
1364
unsigned long prot = rContext->readerState->cardProtocol;
1365
1366
for (i = 0 ; prot != 1 ; i++)
1367
prot >>= 1;
1368
1369
sSendPci.Protocol = i;
1370
}
1371
1372
sSendPci.Length = pioSendPci->cbPciLength;
1373
1374
/* the protocol number is decoded a few lines above */
1375
Log2(PCSC_LOG_DEBUG, "Send Protocol: T=%d", sSendPci.Protocol);
1376
1377
tempRxLength = dwRxLength;
1378
1379
if (pioSendPci->dwProtocol == SCARD_PROTOCOL_RAW)
1380
{
1381
rv = IFDControl_v2(rContext, (PUCHAR) pbSendBuffer, cbSendLength,
1382
pbRecvBuffer, &dwRxLength);
1383
} else
1384
{
1385
rv = IFDTransmit(rContext, sSendPci, (PUCHAR) pbSendBuffer,
1386
cbSendLength, pbRecvBuffer, &dwRxLength, &sRecvPci);
1387
}
1388
1389
if (pioRecvPci)
1390
{
1391
pioRecvPci->dwProtocol = sRecvPci.Protocol;
1392
pioRecvPci->cbPciLength = sRecvPci.Length;
1393
}
1394
1395
/*
1396
* Check for any errors that might have occurred
1397
*/
1398
1399
if (rv != SCARD_S_SUCCESS)
1400
{
1401
*pcbRecvLength = 0;
1402
Log2(PCSC_LOG_ERROR, "Card not transacted: %ld", rv);
1403
return SCARD_E_NOT_TRANSACTED;
1404
}
1405
1406
/*
1407
* Available is less than received
1408
*/
1409
if (tempRxLength < dwRxLength)
1410
{
1411
*pcbRecvLength = 0;
1412
return SCARD_E_INSUFFICIENT_BUFFER;
1413
}
1414
1415
if (dwRxLength > MAX_BUFFER_SIZE)
1416
{
1417
*pcbRecvLength = 0;
1418
return SCARD_E_INSUFFICIENT_BUFFER;
1419
}
1420
1421
/*
1422
* Successful return
1423
*/
1424
*pcbRecvLength = dwRxLength;
1425
return SCARD_S_SUCCESS;
1426
}
1427
1428
LONG SCardListReaders(SCARDCONTEXT hContext, LPCTSTR mszGroups,
1429
LPTSTR mszReaders, LPDWORD pcchReaders)
1430
{
1431
/*
1432
* Client side function
1433
*/
1434
return SCARD_S_SUCCESS;
1435
}
1436
1437
LONG SCardCancel(SCARDCONTEXT hContext)
1438
{
1439
/*
1440
* Client side function
1441
*/
1442
return SCARD_S_SUCCESS;
1443
}
1444
Loggerhead is a web-based interface for Breezy
Version: 2.0.1