46 #include <sys/types.h>
72 #define BUS_DEVICE_STRSIZE 10+1+10+1+10+1
74 #define READER_ABSENT 0
75 #define READER_PRESENT 1
76 #define READER_FAILED 2
81 extern char Add_Interface_In_Name;
82 extern char Add_Serial_In_Name;
87 pthread_mutex_t usbNotifierMutex;
89 static pthread_t usbNotifyThread;
90 static int driverSize = -1;
91 static char AraKiriHotPlug = FALSE;
92 static int rescan_pipe[] = { -1, -1 };
93 extern int HPForceReaderPolling;
96 #define IFD_GENERATE_HOTPLUG 1
101 static struct _driverTracker
104 unsigned int productID;
111 } *driverTracker = NULL;
112 #define DRIVER_TRACKER_SIZE_STEP 8
117 static struct _readerTracker
120 char bus_device[BUS_DEVICE_STRSIZE];
124 static LONG HPAddHotPluggable(
struct libusb_device *dev,
125 struct libusb_device_descriptor desc,
126 const char bus_device[],
127 const struct libusb_interface *idesc,
128 struct _driverTracker *driver,
129 struct _driverTracker *classdriver);
130 static LONG HPRemoveHotPluggable(
int reader_index);
132 static LONG HPReadBundleValues(
void)
136 struct dirent *currFP = NULL;
137 char fullPath[FILENAME_MAX];
138 char fullLibPath[FILENAME_MAX];
141 hpDir = opendir(PCSCLITE_HP_DROPDIR);
145 Log1(PCSC_LOG_ERROR,
"Cannot open PC/SC drivers directory: " PCSCLITE_HP_DROPDIR);
146 Log1(PCSC_LOG_ERROR,
"Disabling USB support for pcscd.");
151 driverTracker = calloc(DRIVER_TRACKER_SIZE_STEP,
sizeof(*driverTracker));
152 if (NULL == driverTracker)
154 Log1(PCSC_LOG_CRITICAL,
"Not enough memory");
157 driverSize = DRIVER_TRACKER_SIZE_STEP;
159 #define GET_KEY(key, values) \
160 rv = LTPBundleFindValueWithKey(&plist, key, values); \
163 Log2(PCSC_LOG_ERROR, "Value/Key not defined for " key " in %s", \
168 while ((currFP = readdir(hpDir)) != 0)
170 if (strstr(currFP->d_name,
".bundle") != 0)
174 list_t *manuIDs, *productIDs, *readerNames;
183 snprintf(fullPath,
sizeof(fullPath),
"%s/%s/Contents/Info.plist",
184 PCSCLITE_HP_DROPDIR, currFP->d_name);
185 fullPath[
sizeof(fullPath) - 1] =
'\0';
187 rv = bundleParse(fullPath, &plist);
192 GET_KEY(PCSCLITE_HP_LIBRKEY_NAME, &values)
193 libraryPath = list_get_at(values, 0);
194 (void)snprintf(fullLibPath,
sizeof(fullLibPath),
195 "%s/%s/Contents/%s/%s",
196 PCSCLITE_HP_DROPDIR, currFP->d_name, PCSC_ARCH,
198 fullLibPath[
sizeof(fullLibPath) - 1] =
'\0';
201 GET_KEY(PCSCLITE_HP_CPCTKEY_NAME, &values)
202 ifdCapabilities = strtol(list_get_at(values, 0), NULL, 16);
204 GET_KEY(PCSCLITE_HP_MANUKEY_NAME, &manuIDs)
205 GET_KEY(PCSCLITE_HP_PRODKEY_NAME, &productIDs)
206 GET_KEY(PCSCLITE_HP_NAMEKEY_NAME, &readerNames)
209 rv = LTPBundleFindValueWithKey(&plist, PCSCLITE_HP_CFBUNDLE_NAME,
214 CFBundleName = strdup(list_get_at(values, 0));
217 for (alias=0; alias<list_size(manuIDs); alias++)
222 value = list_get_at(manuIDs, alias);
223 driverTracker[listCount].manuID = strtol(value, NULL, 16);
225 value = list_get_at(productIDs, alias);
226 driverTracker[listCount].productID = strtol(value, NULL, 16);
228 driverTracker[listCount].readerName = strdup(list_get_at(readerNames, alias));
231 driverTracker[listCount].bundleName = strdup(currFP->d_name);
232 driverTracker[listCount].libraryPath = strdup(fullLibPath);
233 driverTracker[listCount].ifdCapabilities = ifdCapabilities;
234 driverTracker[listCount].CFBundleName = CFBundleName;
237 Log2(PCSC_LOG_INFO,
"Found driver for: %s",
238 driverTracker[listCount].readerName);
241 if (listCount >= driverSize)
246 driverSize += DRIVER_TRACKER_SIZE_STEP;
249 "Increase driverTracker to %d entries", driverSize);
251 void* tmp = realloc(driverTracker,
252 driverSize *
sizeof(*driverTracker));
256 Log1(PCSC_LOG_CRITICAL,
"Not enough memory");
264 for (i=driverSize-DRIVER_TRACKER_SIZE_STEP; i<driverSize; i++)
266 driverTracker[i].manuID = 0;
267 driverTracker[i].productID = 0;
268 driverTracker[i].bundleName = NULL;
269 driverTracker[i].libraryPath = NULL;
270 driverTracker[i].readerName = NULL;
271 driverTracker[i].ifdCapabilities = 0;
272 driverTracker[i].CFBundleName = NULL;
276 bundleRelease(&plist);
280 driverSize = listCount;
285 Log1(PCSC_LOG_INFO,
"No bundle files in pcsc drivers directory: " PCSCLITE_HP_DROPDIR);
286 Log1(PCSC_LOG_INFO,
"Disabling USB support for pcscd");
290 Log2(PCSC_LOG_INFO,
"Found drivers for %d readers", listCount);
296 static struct _driverTracker *get_driver(
unsigned int idVendor,
297 unsigned int idProduct,
struct _driverTracker **classdriver)
300 static struct _driverTracker *driver;
304 "Looking for a driver for VID: 0x%04X, PID: 0x%04X",
305 idVendor, idProduct);
311 for (i=0; i<driverSize; i++)
313 if (driverTracker[i].libraryPath != NULL &&
314 idVendor == driverTracker[i].manuID &&
315 idProduct == driverTracker[i].productID)
317 if ((driverTracker[i].CFBundleName != NULL)
318 && (0 == strcmp(driverTracker[i].CFBundleName,
"CCIDCLASSDRIVER")))
319 *classdriver = &driverTracker[i];
322 driver = &driverTracker[i];
334 static void HPRescanUsbBus(
void)
337 char bus_device[BUS_DEVICE_STRSIZE];
338 libusb_device **devs, *dev;
343 readerTracker[i].status = READER_ABSENT;
345 cnt = libusb_get_device_list(ctx, &devs);
348 Log2(PCSC_LOG_CRITICAL,
"libusb_get_device_list() failed: %s",
349 libusb_error_name(cnt));
355 while ((dev = devs[cnt++]) != NULL)
357 struct libusb_device_descriptor desc;
358 struct libusb_config_descriptor *config_desc;
359 uint8_t bus_number = libusb_get_bus_number(dev);
360 uint8_t device_address = libusb_get_device_address(dev);
361 struct _driverTracker *driver, *classdriver;
364 int r = libusb_get_device_descriptor(dev, &desc);
368 "failed to get device descriptor for %d/%d: %s",
369 bus_number, device_address, libusb_error_name(r));
373 r = libusb_get_active_config_descriptor(dev, &config_desc);
376 Log4(PCSC_LOG_ERROR,
"failed to get device config for %d/%d: %s",
377 bus_number, device_address, libusb_error_name(r));
381 driver = get_driver(desc.idVendor, desc.idProduct, &classdriver);
386 Log3(PCSC_LOG_DEBUG,
"%d/%d is not a supported smart card reader",
387 bus_number, device_address);
389 libusb_free_config_descriptor(config_desc);
394 Log3(PCSC_LOG_DEBUG,
"Found matching USB device: %d:%d",
395 bus_number, device_address);
398 for (interface = 0;
interface < config_desc->bNumInterfaces;
404 snprintf(bus_device, BUS_DEVICE_STRSIZE,
"%d:%d:%d",
405 bus_number, device_address, interface);
406 bus_device[BUS_DEVICE_STRSIZE - 1] =
'\0';
412 if (strncmp(readerTracker[j].bus_device,
413 bus_device, BUS_DEVICE_STRSIZE) == 0)
416 readerTracker[j].status = READER_PRESENT;
419 Log2(PCSC_LOG_DEBUG,
"Refresh USB device: %s",
428 HPAddHotPluggable(dev, desc, bus_device,
429 &config_desc->interface[interface], driver, classdriver);
432 libusb_free_config_descriptor(config_desc);
440 if ((readerTracker[i].status == READER_ABSENT) &&
441 (readerTracker[i].fullName != NULL))
442 HPRemoveHotPluggable(i);
449 for (i=0; i<driverSize; i++)
452 free(driverTracker[i].bundleName);
453 free(driverTracker[i].libraryPath);
454 free(driverTracker[i].readerName);
455 free(driverTracker[i].CFBundleName);
459 Log1(PCSC_LOG_INFO,
"Hotplug stopped");
460 pthread_exit(&retval);
464 libusb_free_device_list(devs, 1);
467 static void * HPEstablishUSBNotifications(
int pipefd[2])
473 r = libusb_init(ctx);
476 Log2(PCSC_LOG_CRITICAL,
"libusb_init failed: %s", libusb_error_name(r));
478 kill(getpid(), SIGTERM);
486 if (write(pipefd[1], &c, 1) == -1)
488 Log2(PCSC_LOG_ERROR,
"write: %s", strerror(errno));
494 for (i=0; i<driverSize; i++)
495 if (driverTracker[i].libraryPath)
496 if ((driverTracker[i].ifdCapabilities & IFD_GENERATE_HOTPLUG) == 0)
499 "Driver %s does not support IFD_GENERATE_HOTPLUG. Using active polling instead.",
500 driverTracker[i].bundleName);
501 if (HPForceReaderPolling < 1)
502 HPForceReaderPolling = 1;
506 if (HPForceReaderPolling)
509 "Polling forced every %d second(s)", HPForceReaderPolling);
515 while (!AraKiriHotPlug)
526 if (pipe(rescan_pipe) == -1)
528 Log2(PCSC_LOG_ERROR,
"pipe: %s", strerror(errno));
531 while (read(rescan_pipe[0], &dummy,
sizeof(dummy)) > 0)
533 Log1(PCSC_LOG_INFO,
"Reload serial configuration");
536 RFReCheckReaderConf();
538 Log1(PCSC_LOG_INFO,
"End reload serial configuration");
540 close(rescan_pipe[0]);
547 LONG HPSearchHotPluggables(
void)
553 readerTracker[i].status = READER_ABSENT;
554 readerTracker[i].bus_device[0] =
'\0';
555 readerTracker[i].fullName = NULL;
558 if (HPReadBundleValues() > 0)
563 if (pipe(pipefd) == -1)
565 Log2(PCSC_LOG_ERROR,
"pipe: %s", strerror(errno));
569 ThreadCreate(&usbNotifyThread, THREAD_ATTR_DETACHED,
570 (PCSCLITE_THREAD_FUNCTION( )) HPEstablishUSBNotifications, pipefd);
573 if (read(pipefd[0], &c, 1) == -1)
575 Log2(PCSC_LOG_ERROR,
"read: %s", strerror(errno));
587 LONG HPStopHotPluggables(
void)
589 AraKiriHotPlug = TRUE;
590 if (rescan_pipe[1] >= 0)
592 close(rescan_pipe[1]);
599 static LONG HPAddHotPluggable(
struct libusb_device *dev,
600 struct libusb_device_descriptor desc,
601 const char bus_device[],
602 const struct libusb_interface *idesc,
603 struct _driverTracker *driver,
604 struct _driverTracker *classdriver)
607 uint8_t iInterface = 0;
608 uint8_t iSerialNumber = 0;
609 char deviceName[MAX_DEVICENAME];
611 Log2(PCSC_LOG_INFO,
"Adding USB device: %s", bus_device);
613 snprintf(deviceName,
sizeof(deviceName),
"usb:%04x/%04x:libusb-1.0:%s",
614 desc.idVendor, desc.idProduct, bus_device);
616 deviceName[
sizeof(deviceName) -1] =
'\0';
618 pthread_mutex_lock(&usbNotifierMutex);
623 if (readerTracker[i].fullName == NULL)
630 "Not enough reader entries. Already found %d readers", i);
631 pthread_mutex_unlock(&usbNotifierMutex);
635 strncpy(readerTracker[i].bus_device, bus_device,
636 sizeof(readerTracker[i].bus_device));
637 readerTracker[i].bus_device[
sizeof(readerTracker[i].bus_device) - 1] =
'\0';
638 readerTracker[i].fullName = NULL;
640 if (Add_Interface_In_Name && idesc->num_altsetting > 0)
641 iInterface = idesc->altsetting[0].iInterface;
643 if (Add_Serial_In_Name)
644 iSerialNumber = desc.iSerialNumber;
646 if (iSerialNumber != 0 || iInterface != 0)
648 libusb_device_handle *device;
651 ret = libusb_open(dev, &device);
654 Log2(PCSC_LOG_ERROR,
"libusb_open failed: %s",
655 libusb_error_name(ret));
659 unsigned char interfaceName[MAX_READERNAME];
660 unsigned char serialNumber[MAX_READERNAME];
661 char fullname[MAX_READERNAME * 3];
663 int ret_interface = 0;
668 ret_interface = libusb_get_string_descriptor_ascii(device,
669 iInterface, interfaceName,
sizeof interfaceName);
670 if (ret_interface < 0)
673 "libusb_get_string_descriptor_ascii failed: %s",
674 libusb_error_name(ret_interface));
680 ret_serial = libusb_get_string_descriptor_ascii(device,
681 iSerialNumber, serialNumber,
sizeof serialNumber);
685 "libusb_get_string_descriptor_ascii failed: %s",
686 libusb_error_name(ret_serial));
690 libusb_close(device);
692 if (ret_interface > 0 && ret_serial > 0)
694 snprintf(fullname,
sizeof(fullname),
"%s [%s] (%s)",
695 driver->readerName, interfaceName, serialNumber);
699 if (ret_interface > 0)
701 snprintf(fullname,
sizeof(fullname),
"%s [%s]",
702 driver->readerName, interfaceName);
708 snprintf(fullname,
sizeof(fullname),
"%s (%s)",
709 driver->readerName, serialNumber);
714 if (fullname[0] !=
'\0')
715 readerTracker[i].fullName = strdup(fullname);
719 if (readerTracker[i].fullName == NULL)
720 readerTracker[i].fullName = strdup(driver->readerName);
723 ret = RFAddReader(readerTracker[i].fullName, PCSCLITE_HP_BASE_PORT + i,
724 driver->libraryPath, deviceName);
726 readerTracker[i].status = READER_PRESENT;
729 Log2(PCSC_LOG_ERROR,
"Failed adding USB device: %s",
732 if (classdriver && driver != classdriver)
735 ret = RFAddReader(readerTracker[i].fullName,
736 PCSCLITE_HP_BASE_PORT + i,
737 classdriver->libraryPath, deviceName);
740 Log2(PCSC_LOG_ERROR,
"Failed adding USB device: %s",
742 readerTracker[i].status = READER_FAILED;
746 readerTracker[i].status = READER_FAILED;
749 if (READER_FAILED == readerTracker[i].status)
750 (void)CheckForOpenCT();
752 pthread_mutex_unlock(&usbNotifierMutex);
757 static LONG HPRemoveHotPluggable(
int reader_index)
759 pthread_mutex_lock(&usbNotifierMutex);
761 Log3(PCSC_LOG_INFO,
"Removing USB device[%d]: %s", reader_index,
762 readerTracker[reader_index].bus_device);
764 RFRemoveReader(readerTracker[reader_index].fullName,
765 PCSCLITE_HP_BASE_PORT + reader_index, REMOVE_READER_FLAG_REMOVED);
766 free(readerTracker[reader_index].fullName);
767 readerTracker[reader_index].status = READER_ABSENT;
768 readerTracker[reader_index].bus_device[0] =
'\0';
769 readerTracker[reader_index].fullName = NULL;
771 pthread_mutex_unlock(&usbNotifierMutex);
779 ULONG HPRegisterForHotplugEvents(
void)
781 (void)pthread_mutex_init(&usbNotifierMutex, NULL);
785 void HPReCheckSerialReaders(
void)
788 if (rescan_pipe[1] >= 0)
791 if (write(rescan_pipe[1], &dummy,
sizeof(dummy)) == -1)
792 Log2(PCSC_LOG_ERROR,
"write: %s", strerror(errno));
#define SCARD_E_UNKNOWN_READER
The specified reader name is not recognized.
#define SCARD_S_SUCCESS
No error was encountered.
This provides a search API for hot pluggble devices.
Reads lexical config files and updates database.
This keeps a list of defines for pcsc-lite.
#define PCSCLITE_MAX_READERS_CONTEXTS
Maximum readers context (a slot is count as a reader)
This keeps track of a list of currently available reader structures.
This handles abstract system level calls.
int SYS_Sleep(int)
Makes the current process sleep for some seconds.
This defines some structures and #defines to be used over the transport layer.
This keeps a list of Windows(R) types.