static int use_usb_info;
static int use_num_info;
-static void set_str(char *to, const char *from, size_t count)
-{
- size_t i, j, len;
-
- /* strip trailing whitespace */
- len = strnlen(from, count);
- while (len && isspace(from[len-1]))
- len--;
-
- /* strip leading whitespace */
- i = 0;
- while (isspace(from[i]) && (i < len))
- i++;
-
- j = 0;
- while (i < len) {
- /* substitute multiple whitespace */
- if (isspace(from[i])) {
- while (isspace(from[i]))
- i++;
- to[j++] = '_';
- }
- /* Replace '/' with '.' */
- if (from[i] == '/') {
- to[j++] = '.';
- i++;
- continue;
- }
- /* skip non-printable chars */
- if (!isalnum(from[i]) && !ispunct(from[i])) {
- i++;
- continue;
- }
- to[j++] = from[i++];
- }
- to[j] = '\0';
-}
-
static void set_usb_iftype(char *to, int if_class_num, size_t len)
{
char *type = "generic";
case 0x0a: /* CDC-Data */
case 0x0b: /* Chip/Smart Card */
case 0x0d: /* Content Security */
- case 0x0e: /* Video */
+ case 0x0e:
+ type = "video";
+ break;
case 0xdc: /* Diagnostic Device */
case 0xe0: /* Wireless Controller */
case 0xf2: /* Application-specific */
type = "floppy";
break;
case 1: /* RBC devices */
+ type = "rbc";
+ break;
case 6: /* Transparent SPC-2 devices */
- type = "disk";
+ type = "scsi";
break;
default:
break;
return 1;
}
- if_class = udev_device_get_attr_value(dev_interface, "bInterfaceClass");
+ if_class = udev_device_get_sysattr_value(dev_interface, "bInterfaceClass");
if (!if_class) {
info(udev, "%s: cannot get bInterfaceClass attribute\n",
udev_device_get_sysname(dev));
}
if_class_num = strtoul(if_class, NULL, 16);
if (if_class_num == 8) {
- if_subclass = udev_device_get_attr_value(dev_interface, "bInterfaceSubClass");
+ if_subclass = udev_device_get_sysattr_value(dev_interface, "bInterfaceSubClass");
if (if_subclass != NULL)
protocol = set_usb_mass_storage_ifsubtype(type_str, if_subclass, sizeof(type_str)-1);
} else {
}
/* Generic SPC-2 device */
- scsi_vendor = udev_device_get_attr_value(dev_scsi, "vendor");
+ scsi_vendor = udev_device_get_sysattr_value(dev_scsi, "vendor");
if (!scsi_vendor) {
info(udev, "%s: cannot get SCSI vendor attribute\n",
udev_device_get_sysname(dev_scsi));
goto fallback;
}
- set_str(vendor_str, scsi_vendor, sizeof(vendor_str)-1);
+ udev_util_replace_whitespace(scsi_vendor, vendor_str, sizeof(vendor_str)-1);
+ udev_util_replace_chars(vendor_str, NULL);
- scsi_model = udev_device_get_attr_value(dev_scsi, "model");
+ scsi_model = udev_device_get_sysattr_value(dev_scsi, "model");
if (!scsi_model) {
info(udev, "%s: cannot get SCSI model attribute\n",
udev_device_get_sysname(dev_scsi));
goto fallback;
}
- set_str(model_str, scsi_model, sizeof(model_str)-1);
+ udev_util_replace_whitespace(scsi_model, model_str, sizeof(model_str)-1);
+ udev_util_replace_chars(model_str, NULL);
- scsi_type = udev_device_get_attr_value(dev_scsi, "type");
+ scsi_type = udev_device_get_sysattr_value(dev_scsi, "type");
if (!scsi_type) {
info(udev, "%s: cannot get SCSI type attribute\n",
udev_device_get_sysname(dev_scsi));
}
set_scsi_type(type_str, scsi_type, sizeof(type_str)-1);
- scsi_rev = udev_device_get_attr_value(dev_scsi, "rev");
+ scsi_rev = udev_device_get_sysattr_value(dev_scsi, "rev");
if (!scsi_rev) {
info(udev, "%s: cannot get SCSI revision attribute\n",
udev_device_get_sysname(dev_scsi));
goto fallback;
}
- set_str(revision_str, scsi_rev, sizeof(revision_str)-1);
+ udev_util_replace_whitespace(scsi_rev, revision_str, sizeof(revision_str)-1);
+ udev_util_replace_chars(revision_str, NULL);
/*
* some broken devices have the same identifiers
const char *usb_vendor = NULL;
if (!use_num_info)
- usb_vendor = udev_device_get_attr_value(dev_usb, "manufacturer");
+ usb_vendor = udev_device_get_sysattr_value(dev_usb, "manufacturer");
if (!usb_vendor)
- usb_vendor = udev_device_get_attr_value(dev_usb, "idVendor");
+ usb_vendor = udev_device_get_sysattr_value(dev_usb, "idVendor");
if (!usb_vendor) {
info(udev, "No USB vendor information available\n");
return 1;
}
- set_str(vendor_str, usb_vendor, sizeof(vendor_str)-1);
+ udev_util_replace_whitespace(usb_vendor, vendor_str, sizeof(vendor_str)-1);
+ udev_util_replace_chars(vendor_str, NULL);
}
if (model_str[0] == '\0') {
const char *usb_model = NULL;
if (!use_num_info)
- usb_model = udev_device_get_attr_value(dev_usb, "product");
+ usb_model = udev_device_get_sysattr_value(dev_usb, "product");
if (!usb_model)
- usb_model = udev_device_get_attr_value(dev_usb, "idProduct");
+ usb_model = udev_device_get_sysattr_value(dev_usb, "idProduct");
if (!usb_model) {
dbg(udev, "No USB model information available\n");
return 1;
}
- set_str(model_str, usb_model, sizeof(model_str)-1);
+ udev_util_replace_whitespace(usb_model, model_str, sizeof(model_str)-1);
+ udev_util_replace_chars(model_str, NULL);
}
if (revision_str[0] == '\0') {
const char *usb_rev;
- usb_rev = udev_device_get_attr_value(dev_usb, "bcdDevice");
- if (usb_rev)
- set_str(revision_str, usb_rev, sizeof(revision_str)-1);
+ usb_rev = udev_device_get_sysattr_value(dev_usb, "bcdDevice");
+ if (usb_rev) {
+ udev_util_replace_whitespace(usb_rev, revision_str, sizeof(revision_str)-1);
+ udev_util_replace_chars(revision_str, NULL);
+ }
}
if (serial_str[0] == '\0') {
const char *usb_serial;
- usb_serial = udev_device_get_attr_value(dev_usb, "serial");
- if (usb_serial)
- set_str(serial_str, usb_serial, sizeof(serial_str)-1);
+ usb_serial = udev_device_get_sysattr_value(dev_usb, "serial");
+ if (usb_serial) {
+ udev_util_replace_whitespace(usb_serial, serial_str, sizeof(serial_str)-1);
+ udev_util_replace_chars(serial_str, NULL);
+ }
}
return 0;
}
{}
};
struct udev *udev;
- struct udev_device *dev;
+ struct udev_device *dev = NULL;
char syspath[UTIL_PATH_SIZE];
const char *devpath;
static int export;
~ianmdlvl / elogind.git / blobdiff