1 /*
2 * USB device properties and persistent device path
3 *
4 * Copyright (c) 2005 SUSE Linux Products GmbH, Germany
5 * Author: Hannes Reinecke <hare@suse.de>
6 *
7 * Copyright (C) 2005-2011 Kay Sievers <kay@vrfy.org>
8 *
9 * This program is free software: you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation, either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <unistd.h>
27 #include <string.h>
28 #include <ctype.h>
29 #include <fcntl.h>
30 #include <errno.h>
31
32 #include "udev.h"
33
set_usb_iftype(char * to,int if_class_num,size_t len)34 static void set_usb_iftype(char *to, int if_class_num, size_t len) {
35 const char *type = "generic";
36
37 switch (if_class_num) {
38 case 1:
39 type = "audio";
40 break;
41 case 2: /* CDC-Control */
42 break;
43 case 3:
44 type = "hid";
45 break;
46 case 5: /* Physical */
47 break;
48 case 6:
49 type = "media";
50 break;
51 case 7:
52 type = "printer";
53 break;
54 case 8:
55 type = "storage";
56 break;
57 case 9:
58 type = "hub";
59 break;
60 case 0x0a: /* CDC-Data */
61 break;
62 case 0x0b: /* Chip/Smart Card */
63 break;
64 case 0x0d: /* Content Security */
65 break;
66 case 0x0e:
67 type = "video";
68 break;
69 case 0xdc: /* Diagnostic Device */
70 break;
71 case 0xe0: /* Wireless Controller */
72 break;
73 case 0xfe: /* Application-specific */
74 break;
75 case 0xff: /* Vendor-specific */
76 break;
77 default:
78 break;
79 }
80 strncpy(to, type, len);
81 to[len-1] = '\0';
82 }
83
set_usb_mass_storage_ifsubtype(char * to,const char * from,size_t len)84 static int set_usb_mass_storage_ifsubtype(char *to, const char *from, size_t len) {
85 int type_num = 0;
86 char *eptr;
87 const char *type = "generic";
88
89 type_num = strtoul(from, &eptr, 0);
90 if (eptr != from) {
91 switch (type_num) {
92 case 1: /* RBC devices */
93 type = "rbc";
94 break;
95 case 2:
96 type = "atapi";
97 break;
98 case 3:
99 type = "tape";
100 break;
101 case 4: /* UFI */
102 type = "floppy";
103 break;
104 case 6: /* Transparent SPC-2 devices */
105 type = "scsi";
106 break;
107 default:
108 break;
109 }
110 }
111 strscpy(to, len, type);
112 return type_num;
113 }
114
set_scsi_type(char * to,const char * from,size_t len)115 static void set_scsi_type(char *to, const char *from, size_t len) {
116 int type_num;
117 char *eptr;
118 const char *type = "generic";
119
120 type_num = strtoul(from, &eptr, 0);
121 if (eptr != from) {
122 switch (type_num) {
123 case 0:
124 case 0xe:
125 type = "disk";
126 break;
127 case 1:
128 type = "tape";
129 break;
130 case 4:
131 case 7:
132 case 0xf:
133 type = "optical";
134 break;
135 case 5:
136 type = "cd";
137 break;
138 default:
139 break;
140 }
141 }
142 strscpy(to, len, type);
143 }
144
145 #define USB_DT_DEVICE 0x01
146 #define USB_DT_INTERFACE 0x04
147
dev_if_packed_info(struct udev_device * dev,char * ifs_str,size_t len)148 static int dev_if_packed_info(struct udev_device *dev, char *ifs_str, size_t len) {
149 _cleanup_free_ char *filename = NULL;
150 _cleanup_close_ int fd = -1;
151 ssize_t size;
152 unsigned char buf[18 + 65535];
153 size_t pos = 0;
154 unsigned strpos = 0;
155 struct usb_interface_descriptor {
156 uint8_t bLength;
157 uint8_t bDescriptorType;
158 uint8_t bInterfaceNumber;
159 uint8_t bAlternateSetting;
160 uint8_t bNumEndpoints;
161 uint8_t bInterfaceClass;
162 uint8_t bInterfaceSubClass;
163 uint8_t bInterfaceProtocol;
164 uint8_t iInterface;
165 } _packed_;
166
167 if (asprintf(&filename, "%s/descriptors", udev_device_get_syspath(dev)) < 0)
168 return log_oom();
169
170 fd = open(filename, O_RDONLY|O_CLOEXEC);
171 if (fd < 0)
172 return log_debug_errno(errno, "Error opening USB device 'descriptors' file: %m");
173
174 size = read(fd, buf, sizeof(buf));
175 if (size < 18 || size == sizeof(buf))
176 return -EIO;
177
178 ifs_str[0] = '\0';
179 while (pos + sizeof(struct usb_interface_descriptor) < (size_t) size &&
180 strpos + 7 < len - 2) {
181
182 struct usb_interface_descriptor *desc;
183 char if_str[8];
184
185 desc = (struct usb_interface_descriptor *) &buf[pos];
186 if (desc->bLength < 3)
187 break;
188 pos += desc->bLength;
189
190 if (desc->bDescriptorType != USB_DT_INTERFACE)
191 continue;
192
193 if (snprintf(if_str, 8, ":%02x%02x%02x",
194 desc->bInterfaceClass,
195 desc->bInterfaceSubClass,
196 desc->bInterfaceProtocol) != 7)
197 continue;
198
199 if (strstr(ifs_str, if_str) != NULL)
200 continue;
201
202 memcpy(&ifs_str[strpos], if_str, 8),
203 strpos += 7;
204 }
205
206 if (strpos > 0) {
207 ifs_str[strpos++] = ':';
208 ifs_str[strpos++] = '\0';
209 }
210
211 return 0;
212 }
213
214 /*
215 * A unique USB identification is generated like this:
216 *
217 * 1.) Get the USB device type from InterfaceClass and InterfaceSubClass
218 * 2.) If the device type is 'Mass-Storage/SPC-2' or 'Mass-Storage/RBC',
219 * use the SCSI vendor and model as USB-Vendor and USB-model.
220 * 3.) Otherwise, use the USB manufacturer and product as
221 * USB-Vendor and USB-model. Any non-printable characters
222 * in those strings will be skipped; a slash '/' will be converted
223 * into a full stop '.'.
224 * 4.) If that fails, too, we will use idVendor and idProduct
225 * as USB-Vendor and USB-model.
226 * 5.) The USB identification is the USB-vendor and USB-model
227 * string concatenated with an underscore '_'.
228 * 6.) If the device supplies a serial number, this number
229 * is concatenated with the identification with an underscore '_'.
230 */
builtin_usb_id(struct udev_device * dev,int argc,char * argv[],bool test)231 static int builtin_usb_id(struct udev_device *dev, int argc, char *argv[], bool test) {
232 char vendor_str[64] = "";
233 char vendor_str_enc[256];
234 const char *vendor_id;
235 char model_str[64] = "";
236 char model_str_enc[256];
237 const char *product_id;
238 char serial_str[UTIL_NAME_SIZE] = "";
239 char packed_if_str[UTIL_NAME_SIZE] = "";
240 char revision_str[64] = "";
241 char type_str[64] = "";
242 char instance_str[64] = "";
243 const char *ifnum = NULL;
244 const char *driver = NULL;
245 char serial[256];
246
247 struct udev_device *dev_interface = NULL;
248 struct udev_device *dev_usb = NULL;
249 const char *if_class, *if_subclass;
250 int if_class_num;
251 int protocol = 0;
252 size_t l;
253 char *s;
254
255 /* shortcut, if we are called directly for a "usb_device" type */
256 if (udev_device_get_devtype(dev) != NULL && streq(udev_device_get_devtype(dev), "usb_device")) {
257 dev_if_packed_info(dev, packed_if_str, sizeof(packed_if_str));
258 dev_usb = dev;
259 goto fallback;
260 }
261
262 /* usb interface directory */
263 dev_interface = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_interface");
264 if (dev_interface == NULL) {
265 log_debug("unable to access usb_interface device of '%s'",
266 udev_device_get_syspath(dev));
267 return EXIT_FAILURE;
268 }
269
270 ifnum = udev_device_get_sysattr_value(dev_interface, "bInterfaceNumber");
271 driver = udev_device_get_sysattr_value(dev_interface, "driver");
272
273 if_class = udev_device_get_sysattr_value(dev_interface, "bInterfaceClass");
274 if (!if_class) {
275 log_debug("%s: cannot get bInterfaceClass attribute",
276 udev_device_get_sysname(dev));
277 return EXIT_FAILURE;
278 }
279
280 if_class_num = strtoul(if_class, NULL, 16);
281 if (if_class_num == 8) {
282 /* mass storage */
283 if_subclass = udev_device_get_sysattr_value(dev_interface, "bInterfaceSubClass");
284 if (if_subclass != NULL)
285 protocol = set_usb_mass_storage_ifsubtype(type_str, if_subclass, sizeof(type_str)-1);
286 } else {
287 set_usb_iftype(type_str, if_class_num, sizeof(type_str)-1);
288 }
289
290 log_debug("%s: if_class %d protocol %d",
291 udev_device_get_syspath(dev_interface), if_class_num, protocol);
292
293 /* usb device directory */
294 dev_usb = udev_device_get_parent_with_subsystem_devtype(dev_interface, "usb", "usb_device");
295 if (!dev_usb) {
296 log_debug("unable to find parent 'usb' device of '%s'",
297 udev_device_get_syspath(dev));
298 return EXIT_FAILURE;
299 }
300
301 /* all interfaces of the device in a single string */
302 dev_if_packed_info(dev_usb, packed_if_str, sizeof(packed_if_str));
303
304 /* mass storage : SCSI or ATAPI */
305 if (protocol == 6 || protocol == 2) {
306 struct udev_device *dev_scsi;
307 const char *scsi_model, *scsi_vendor, *scsi_type, *scsi_rev;
308 int host, bus, target, lun;
309
310 /* get scsi device */
311 dev_scsi = udev_device_get_parent_with_subsystem_devtype(dev, "scsi", "scsi_device");
312 if (dev_scsi == NULL) {
313 log_debug("unable to find parent 'scsi' device of '%s'",
314 udev_device_get_syspath(dev));
315 goto fallback;
316 }
317 if (sscanf(udev_device_get_sysname(dev_scsi), "%d:%d:%d:%d", &host, &bus, &target, &lun) != 4) {
318 log_debug("invalid scsi device '%s'", udev_device_get_sysname(dev_scsi));
319 goto fallback;
320 }
321
322 /* Generic SPC-2 device */
323 scsi_vendor = udev_device_get_sysattr_value(dev_scsi, "vendor");
324 if (!scsi_vendor) {
325 log_debug("%s: cannot get SCSI vendor attribute",
326 udev_device_get_sysname(dev_scsi));
327 goto fallback;
328 }
329 udev_util_encode_string(scsi_vendor, vendor_str_enc, sizeof(vendor_str_enc));
330 util_replace_whitespace(scsi_vendor, vendor_str, sizeof(vendor_str)-1);
331 util_replace_chars(vendor_str, NULL);
332
333 scsi_model = udev_device_get_sysattr_value(dev_scsi, "model");
334 if (!scsi_model) {
335 log_debug("%s: cannot get SCSI model attribute",
336 udev_device_get_sysname(dev_scsi));
337 goto fallback;
338 }
339 udev_util_encode_string(scsi_model, model_str_enc, sizeof(model_str_enc));
340 util_replace_whitespace(scsi_model, model_str, sizeof(model_str)-1);
341 util_replace_chars(model_str, NULL);
342
343 scsi_type = udev_device_get_sysattr_value(dev_scsi, "type");
344 if (!scsi_type) {
345 log_debug("%s: cannot get SCSI type attribute",
346 udev_device_get_sysname(dev_scsi));
347 goto fallback;
348 }
349 set_scsi_type(type_str, scsi_type, sizeof(type_str)-1);
350
351 scsi_rev = udev_device_get_sysattr_value(dev_scsi, "rev");
352 if (!scsi_rev) {
353 log_debug("%s: cannot get SCSI revision attribute",
354 udev_device_get_sysname(dev_scsi));
355 goto fallback;
356 }
357 util_replace_whitespace(scsi_rev, revision_str, sizeof(revision_str)-1);
358 util_replace_chars(revision_str, NULL);
359
360 /*
361 * some broken devices have the same identifiers
362 * for all luns, export the target:lun number
363 */
364 sprintf(instance_str, "%d:%d", target, lun);
365 }
366
367 fallback:
368 vendor_id = udev_device_get_sysattr_value(dev_usb, "idVendor");
369 product_id = udev_device_get_sysattr_value(dev_usb, "idProduct");
370
371 /* fallback to USB vendor & device */
372 if (vendor_str[0] == '\0') {
373 const char *usb_vendor = NULL;
374
375 usb_vendor = udev_device_get_sysattr_value(dev_usb, "manufacturer");
376 if (!usb_vendor)
377 usb_vendor = vendor_id;
378 if (!usb_vendor) {
379 log_debug("No USB vendor information available");
380 return EXIT_FAILURE;
381 }
382 udev_util_encode_string(usb_vendor, vendor_str_enc, sizeof(vendor_str_enc));
383 util_replace_whitespace(usb_vendor, vendor_str, sizeof(vendor_str)-1);
384 util_replace_chars(vendor_str, NULL);
385 }
386
387 if (model_str[0] == '\0') {
388 const char *usb_model = NULL;
389
390 usb_model = udev_device_get_sysattr_value(dev_usb, "product");
391 if (!usb_model)
392 usb_model = product_id;
393 if (!usb_model)
394 return EXIT_FAILURE;
395 udev_util_encode_string(usb_model, model_str_enc, sizeof(model_str_enc));
396 util_replace_whitespace(usb_model, model_str, sizeof(model_str)-1);
397 util_replace_chars(model_str, NULL);
398 }
399
400 if (revision_str[0] == '\0') {
401 const char *usb_rev;
402
403 usb_rev = udev_device_get_sysattr_value(dev_usb, "bcdDevice");
404 if (usb_rev) {
405 util_replace_whitespace(usb_rev, revision_str, sizeof(revision_str)-1);
406 util_replace_chars(revision_str, NULL);
407 }
408 }
409
410 if (serial_str[0] == '\0') {
411 const char *usb_serial;
412
413 usb_serial = udev_device_get_sysattr_value(dev_usb, "serial");
414 if (usb_serial) {
415 const unsigned char *p;
416
417 /* http://msdn.microsoft.com/en-us/library/windows/hardware/gg487321.aspx */
418 for (p = (unsigned char *)usb_serial; *p != '\0'; p++)
419 if (*p < 0x20 || *p > 0x7f || *p == ',') {
420 usb_serial = NULL;
421 break;
422 }
423 }
424
425 if (usb_serial) {
426 util_replace_whitespace(usb_serial, serial_str, sizeof(serial_str)-1);
427 util_replace_chars(serial_str, NULL);
428 }
429 }
430
431 s = serial;
432 l = strpcpyl(&s, sizeof(serial), vendor_str, "_", model_str, NULL);
433 if (!isempty(serial_str))
434 l = strpcpyl(&s, l, "_", serial_str, NULL);
435
436 if (!isempty(instance_str))
437 strpcpyl(&s, l, "-", instance_str, NULL);
438
439 udev_builtin_add_property(dev, test, "ID_VENDOR", vendor_str);
440 udev_builtin_add_property(dev, test, "ID_VENDOR_ENC", vendor_str_enc);
441 udev_builtin_add_property(dev, test, "ID_VENDOR_ID", vendor_id);
442 udev_builtin_add_property(dev, test, "ID_MODEL", model_str);
443 udev_builtin_add_property(dev, test, "ID_MODEL_ENC", model_str_enc);
444 udev_builtin_add_property(dev, test, "ID_MODEL_ID", product_id);
445 udev_builtin_add_property(dev, test, "ID_REVISION", revision_str);
446 udev_builtin_add_property(dev, test, "ID_SERIAL", serial);
447 if (!isempty(serial_str))
448 udev_builtin_add_property(dev, test, "ID_SERIAL_SHORT", serial_str);
449 if (!isempty(type_str))
450 udev_builtin_add_property(dev, test, "ID_TYPE", type_str);
451 if (!isempty(instance_str))
452 udev_builtin_add_property(dev, test, "ID_INSTANCE", instance_str);
453 udev_builtin_add_property(dev, test, "ID_BUS", "usb");
454 if (!isempty(packed_if_str))
455 udev_builtin_add_property(dev, test, "ID_USB_INTERFACES", packed_if_str);
456 if (ifnum != NULL)
457 udev_builtin_add_property(dev, test, "ID_USB_INTERFACE_NUM", ifnum);
458 if (driver != NULL)
459 udev_builtin_add_property(dev, test, "ID_USB_DRIVER", driver);
460 return EXIT_SUCCESS;
461 }
462
463 const struct udev_builtin udev_builtin_usb_id = {
464 .name = "usb_id",
465 .cmd = builtin_usb_id,
466 .help = "USB device properties",
467 .run_once = true,
468 };
469