39#if defined(HAVE_LIBUDEV) && defined(USE_USB)
58#ifndef TEMP_FAILURE_RETRY
59#define TEMP_FAILURE_RETRY(expression) \
61 ({ long int __result; \
62 do __result = (long int) (expression); \
63 while (__result == -1L && errno == EINTR); \
72extern char Add_Interface_In_Name;
73extern char Add_Serial_In_Name;
75static pthread_t usbNotifyThread;
76static int driverSize = -1;
77static struct udev *Udev;
83static struct _driverTracker
86 unsigned int productID;
92} *driverTracker = NULL;
93#define DRIVER_TRACKER_SIZE_STEP 10
97#define DRIVER_TRACKER_INITIAL_SIZE 200
102static struct _readerTracker
110static LONG HPReadBundleValues(
void)
114 struct dirent *currFP = NULL;
115 char fullPath[FILENAME_MAX];
116 char fullLibPath[FILENAME_MAX];
119 hpDir = opendir(PCSCLITE_HP_DROPDIR);
123 Log1(PCSC_LOG_ERROR,
"Cannot open PC/SC drivers directory: " PCSCLITE_HP_DROPDIR);
124 Log1(PCSC_LOG_ERROR,
"Disabling USB support for pcscd.");
129 driverSize = DRIVER_TRACKER_INITIAL_SIZE;
130 driverTracker = calloc(driverSize,
sizeof(*driverTracker));
131 if (NULL == driverTracker)
133 Log1(PCSC_LOG_CRITICAL,
"Not enough memory");
134 (void)closedir(hpDir);
138#define GET_KEY(key, values) \
139 rv = LTPBundleFindValueWithKey(&plist, key, values); \
142 Log2(PCSC_LOG_ERROR, "Value/Key not defined for " key " in %s", \
147 while ((currFP = readdir(hpDir)) != 0)
149 if (strstr(currFP->d_name,
".bundle") != 0)
153 list_t *manuIDs, *productIDs, *readerNames;
161 (void)snprintf(fullPath,
sizeof(fullPath),
"%s/%s/Contents/Info.plist",
162 PCSCLITE_HP_DROPDIR, currFP->d_name);
163 fullPath[
sizeof(fullPath) - 1] =
'\0';
165 rv = bundleParse(fullPath, &plist);
170 GET_KEY(PCSCLITE_HP_LIBRKEY_NAME, &values)
171 libraryPath = list_get_at(values, 0);
172 (void)snprintf(fullLibPath,
sizeof(fullLibPath),
173 "%s/%s/Contents/%s/%s",
174 PCSCLITE_HP_DROPDIR, currFP->d_name, PCSC_ARCH,
176 fullLibPath[
sizeof(fullLibPath) - 1] =
'\0';
178 GET_KEY(PCSCLITE_HP_MANUKEY_NAME, &manuIDs)
179 GET_KEY(PCSCLITE_HP_PRODKEY_NAME, &productIDs)
180 GET_KEY(PCSCLITE_HP_NAMEKEY_NAME, &readerNames)
182 if ((list_size(manuIDs) != list_size(productIDs))
183 || (list_size(manuIDs) != list_size(readerNames)))
185 Log2(PCSC_LOG_CRITICAL,
"Error parsing %s", fullPath);
186 (void)closedir(hpDir);
191 rv = LTPBundleFindValueWithKey(&plist, PCSCLITE_HP_CFBUNDLE_NAME,
196 CFBundleName = strdup(list_get_at(values, 0));
199 for (alias=0; alias<list_size(manuIDs); alias++)
204 value = list_get_at(manuIDs, alias);
205 driverTracker[listCount].manuID = strtol(value, NULL, 16);
207 value = list_get_at(productIDs, alias);
208 driverTracker[listCount].productID = strtol(value, NULL, 16);
210 driverTracker[listCount].readerName = strdup(list_get_at(readerNames, alias));
213 driverTracker[listCount].bundleName = strdup(currFP->d_name);
214 driverTracker[listCount].libraryPath = strdup(fullLibPath);
215 driverTracker[listCount].CFBundleName = CFBundleName;
218 Log2(PCSC_LOG_INFO,
"Found driver for: %s",
219 driverTracker[listCount].readerName);
222 if (listCount >= driverSize)
227 driverSize += DRIVER_TRACKER_SIZE_STEP;
230 "Increase driverTracker to %d entries", driverSize);
233 void* tmp = realloc(driverTracker,
234 driverSize *
sizeof(*driverTracker));
239 Log1(PCSC_LOG_CRITICAL,
"Not enough memory");
241 (void)closedir(hpDir);
247 for (i=driverSize-DRIVER_TRACKER_SIZE_STEP; i<driverSize; i++)
249 driverTracker[i].manuID = 0;
250 driverTracker[i].productID = 0;
251 driverTracker[i].bundleName = NULL;
252 driverTracker[i].libraryPath = NULL;
253 driverTracker[i].readerName = NULL;
254 driverTracker[i].CFBundleName = NULL;
258 bundleRelease(&plist);
262 driverSize = listCount;
263 (void)closedir(hpDir);
266 Log2(PCSC_LOG_INFO,
"Found drivers for %d readers", listCount);
273 static struct _driverTracker *get_driver(
struct udev_device *dev,
274 const char *devpath,
struct _driverTracker **classdriver)
277 unsigned int idVendor, idProduct;
278 static struct _driverTracker *driver;
281 str = udev_device_get_sysattr_value(dev,
"idVendor");
284 Log1(PCSC_LOG_ERROR,
"udev_device_get_sysattr_value() failed");
287 idVendor = strtol(str, NULL, 16);
289 str = udev_device_get_sysattr_value(dev,
"idProduct");
292 Log1(PCSC_LOG_ERROR,
"udev_device_get_sysattr_value() failed");
295 idProduct = strtol(str, NULL, 16);
301 "Looking for a driver for VID: 0x%04X, PID: 0x%04X, path: %s",
302 idVendor, idProduct, devpath);
307 for (i=0; i<driverSize; i++)
309 if (driverTracker[i].libraryPath != NULL &&
310 idVendor == driverTracker[i].manuID &&
311 idProduct == driverTracker[i].productID)
313 if ((driverTracker[i].CFBundleName != NULL)
314 && (0 == strcmp(driverTracker[i].CFBundleName,
"CCIDCLASSDRIVER")))
315 *classdriver = &driverTracker[i];
318 driver = &driverTracker[i];
331static void HPRemoveDevice(
struct udev_device *dev)
335 struct udev_device *parent;
343 parent = udev_device_get_parent_with_subsystem_devtype(dev,
"usb",
348 devpath = udev_device_get_devnode(parent);
352 Log1(PCSC_LOG_ERROR,
"udev_device_get_devnode() failed");
356 sysname = udev_device_get_sysname(dev);
359 Log1(PCSC_LOG_ERROR,
"udev_device_get_sysname() failed");
365 if (readerTracker[i].fullName && !strcmp(sysname, readerTracker[i].sysname))
367 Log4(PCSC_LOG_INFO,
"Removing USB device[%d]: %s at %s", i,
368 readerTracker[i].fullName, readerTracker[i].devpath);
370 RFRemoveReader(readerTracker[i].fullName, PCSCLITE_HP_BASE_PORT + i, REMOVE_READER_FLAG_REMOVED);
372 free(readerTracker[i].devpath);
373 readerTracker[i].devpath = NULL;
374 free(readerTracker[i].fullName);
375 readerTracker[i].fullName = NULL;
376 free(readerTracker[i].sysname);
377 readerTracker[i].sysname = NULL;
384static void HPAddDevice(
struct udev_device *dev)
387 char *deviceName = NULL;
388 char *fullname = NULL;
389 struct _driverTracker *driver, *classdriver;
390 const char *sSerialNumber = NULL, *sInterfaceName = NULL;
391 const char *sInterfaceNumber;
393 int bInterfaceNumber;
395 struct udev_device *parent;
403 parent = udev_device_get_parent_with_subsystem_devtype(dev,
"usb",
408 devpath = udev_device_get_devnode(parent);
412 Log1(PCSC_LOG_ERROR,
"udev_device_get_devnode() failed");
416 driver = get_driver(parent, devpath, &classdriver);
421 Log2(PCSC_LOG_DEBUG,
"%s is not a supported smart card reader",
427 sysname = udev_device_get_sysname(dev);
430 Log1(PCSC_LOG_ERROR,
"udev_device_get_sysname() failed");
437 if (readerTracker[index].fullName && !strcmp(sysname, readerTracker[index].sysname))
441 Log2(PCSC_LOG_INFO,
"Adding USB device: %s", driver->readerName);
443 sInterfaceNumber = udev_device_get_sysattr_value(dev,
"bInterfaceNumber");
444 if (sInterfaceNumber)
445 bInterfaceNumber = atoi(sInterfaceNumber);
447 bInterfaceNumber = 0;
449 a = asprintf(&deviceName,
"usb:%04x/%04x:libudev:%d:%s",
450 driver->manuID, driver->productID, bInterfaceNumber, devpath);
453 Log1(PCSC_LOG_ERROR,
"asprintf() failed");
460 if (NULL == readerTracker[index].fullName)
467 "Not enough reader entries. Already found %d readers", index);
471 if (Add_Interface_In_Name)
472 sInterfaceName = udev_device_get_sysattr_value(dev,
"interface");
474 if (Add_Serial_In_Name)
475 sSerialNumber = udev_device_get_sysattr_value(parent,
"serial");
478 fullname = strdup(driver->readerName);
485 char *tmpInterfaceName = strdup(sInterfaceName);
488 for (
size_t i=0; i<strlen(tmpInterfaceName); i++)
490 if (! isascii(tmpInterfaceName[i]))
491 tmpInterfaceName[i] =
'.';
495 a = asprintf(&result,
"%s [%s]", fullname, tmpInterfaceName);
498 Log1(PCSC_LOG_ERROR,
"asprintf() failed");
499 free(tmpInterfaceName);
504 free(tmpInterfaceName);
513 if (!sInterfaceName || NULL == strstr(sInterfaceName, sSerialNumber))
518 a = asprintf(&result,
"%s (%s)", fullname, sSerialNumber);
521 Log1(PCSC_LOG_ERROR,
"asprintf() failed");
530 readerTracker[index].fullName = strdup(fullname);
531 readerTracker[index].devpath = strdup(devpath);
532 readerTracker[index].sysname = strdup(sysname);
534 ret = RFAddReader(fullname, PCSCLITE_HP_BASE_PORT + index,
535 driver->libraryPath, deviceName);
538 Log2(PCSC_LOG_ERROR,
"Failed adding USB device: %s",
541 if (classdriver && driver != classdriver)
544 ret = RFAddReader(fullname, PCSCLITE_HP_BASE_PORT + index,
545 classdriver->libraryPath, deviceName);
548 Log2(PCSC_LOG_ERROR,
"Failed adding USB device: %s",
550 (void)CheckForOpenCT();
555 (void)CheckForOpenCT();
562 free(readerTracker[index].devpath);
563 readerTracker[index].devpath = NULL;
564 free(readerTracker[index].fullName);
565 readerTracker[index].fullName = NULL;
566 free(readerTracker[index].sysname);
567 readerTracker[index].sysname = NULL;
576static void HPScanUSB(
struct udev *udev)
578 struct udev_enumerate *enumerate;
579 struct udev_list_entry *devices, *dev_list_entry;
582 enumerate = udev_enumerate_new(udev);
583 udev_enumerate_add_match_subsystem(enumerate,
"usb");
584 udev_enumerate_scan_devices(enumerate);
585 devices = udev_enumerate_get_list_entry(enumerate);
588 udev_list_entry_foreach(dev_list_entry, devices)
590 struct udev_device *dev;
595 devpath = udev_list_entry_get_name(dev_list_entry);
596 dev = udev_device_new_from_syspath(udev, devpath);
599 Log2(PCSC_LOG_DEBUG,
"Found matching USB device: %s", devpath);
604 udev_device_unref(dev);
608 udev_enumerate_unref(enumerate);
612static void * HPEstablishUSBNotifications(
void *arg)
614 struct udev_monitor *udev_monitor = arg;
619 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
620 pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
623 fd = udev_monitor_get_fd(udev_monitor);
626 Log2(PCSC_LOG_ERROR,
"udev_monitor_get_fd() error: %d", fd);
635 struct udev_device *dev;
640 pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
643 r = TEMP_FAILURE_RETRY(poll(&pfd, 1, -1));
646 Log2(PCSC_LOG_ERROR,
"select(): %s", strerror(errno));
650 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
652 dev = udev_monitor_receive_device(udev_monitor);
655 const char *action = udev_device_get_action(dev);
659 if (!strcmp(
"remove", action))
661 Log1(PCSC_LOG_INFO,
"USB Device removed");
665 if (!strcmp(
"add", action))
667 Log1(PCSC_LOG_INFO,
"USB Device add");
673 udev_device_unref(dev);
684LONG HPSearchHotPluggables(
void)
690 readerTracker[i].devpath = NULL;
691 readerTracker[i].fullName = NULL;
692 readerTracker[i].sysname = NULL;
695 return HPReadBundleValues();
702LONG HPStopHotPluggables(
void)
712 pthread_cancel(usbNotifyThread);
713 pthread_join(usbNotifyThread, NULL);
715 for (i=0; i<driverSize; i++)
718 free(driverTracker[i].bundleName);
719 free(driverTracker[i].libraryPath);
720 free(driverTracker[i].readerName);
729 Log1(PCSC_LOG_INFO,
"Hotplug stopped");
737ULONG HPRegisterForHotplugEvents(
void)
739 struct udev_monitor *udev_monitor;
744 Log1(PCSC_LOG_INFO,
"No bundle files in pcsc drivers directory: "
745 PCSCLITE_HP_DROPDIR);
746 Log1(PCSC_LOG_INFO,
"Disabling USB support for pcscd");
754 Log1(PCSC_LOG_ERROR,
"udev_new() failed");
758 udev_monitor = udev_monitor_new_from_netlink(Udev,
"udev");
759 if (NULL == udev_monitor)
761 Log1(PCSC_LOG_ERROR,
"udev_monitor_new_from_netlink() error");
766 r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor,
"usb",
770 Log2(PCSC_LOG_ERROR,
"udev_monitor_filter_add_match_subsystem_devtype() error: %d\n", r);
774 r = udev_monitor_enable_receiving(udev_monitor);
777 Log2(PCSC_LOG_ERROR,
"udev_monitor_enable_receiving() error: %d\n", r);
784 if (ThreadCreate(&usbNotifyThread, 0,
785 (PCSCLITE_THREAD_FUNCTION( )) HPEstablishUSBNotifications, udev_monitor))
787 Log1(PCSC_LOG_ERROR,
"ThreadCreate() failed");
795void HPReCheckSerialReaders(
void)
799 Log0(PCSC_LOG_ERROR);
#define SCARD_F_INTERNAL_ERROR
An internal consistency check failed.
#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.
#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.