/ dev / hidraw: permisos de lectura

¿Qué debo hacer para tener permisos de lectura en / dev / hidraw *?

Estoy viendo cosas sobre las reglas de udev y vi esto en la red, pero el mundo de udev es como una tierra extranjera para mí, y si hay algún tipo de solución más simple donde me agregue a un grupo que sería genial ...

(Vista previa de Ubuntu 13.10)

Siéntase libre de volver a plantear la pregunta: no estoy demasiado interesado en qué es exactamente lo que 'hidraw' tiene.

EDITAR:

Bien, entonces, solo un poco más de información para aclarar el problema: literalmente revisé el código que llamaba al open()método POSIX , y obtuve los errnopermisos insuficientes. Ejecutar caten el archivo como un usuario normal da como resultado un error de permisos insuficiente, mientras que ejecuta bajo suresultados en una catoperación exitosa (aunque sin sentido) .

EDITAR EDITAR:

A petición, proporciono el código relevante con la llamada POSIX. Es de la biblioteca HIDAPI de Signal11 (función hid_open_path). Confío en que este código sea correcto, ya que aparentemente ha estado en uso durante bastante tiempo. Agregué un comentario donde se realizó la errnolectura relevante en GDB.

hid_device *dev = NULL;

hid_init();

dev = new_hid_device();

if (kernel_version == 0) {
    struct utsname name;
    int major, minor, release;
    int ret;
    uname(&name);
    ret = sscanf(name.release, "%d.%d.%d", &major, &minor, &release);
    if (ret == 3) {
        kernel_version = major << 16 | minor << 8 | release;
        //printf("Kernel Version: %d\n", kernel_version);
    }
    else {
        printf("Couldn't sscanf() version string %s\n", name.release);
    }
}

/* OPEN HERE */
dev->device_handle = open(path, O_RDWR);

// errno at this location is 13: insufficient permissions

/* If we have a good handle, return it. */
if (dev->device_handle > 0) {

    /* Get the report descriptor */
    int res, desc_size = 0;
    struct hidraw_report_descriptor rpt_desc;

    memset(&rpt_desc, 0x0, sizeof(rpt_desc));

    /* Get Report Descriptor Size */
    res = ioctl(dev->device_handle, HIDIOCGRDESCSIZE, &desc_size);
    if (res < 0)
        perror("HIDIOCGRDESCSIZE");


    /* Get Report Descriptor */
    rpt_desc.size = desc_size;
    res = ioctl(dev->device_handle, HIDIOCGRDESC, &rpt_desc);
    if (res < 0) {
        perror("HIDIOCGRDESC");
    } else {
        /* Determine if this device uses numbered reports. */
        dev->uses_numbered_reports =
            uses_numbered_reports(rpt_desc.value,
                                  rpt_desc.size);
    }

    return dev;
}
else {
    /* Unable to open any devices. */
    free(dev);
    return NULL;
}

Dejé de correr tratando de encontrar alguna otra forma de hacerlo que no sean las reglas de udev, y en su lugar, aprendí un poco sobre udev y escribí una regla de flippin '. La siguiente línea se colocó en un .rulesarchivo (yo llamé el mío 99-hidraw-permissions.rules) ubicado debajo /etc/udev/rules.d.

KERNEL=="hidraw*", SUBSYSTEM=="hidraw", MODE="0664", GROUP="plugdev"

Básicamente, esto asigna todos los dispositivos que salen del subsistema hidraw en el kernel al grupo plugdevy establece los permisos en r / wr / wr (para root [el propietario predeterminado], plugdev y todos los demás, respectivamente). Con mi mismo agregado al grupo plugdev, todo es excelente.

No se derritió tanto como esperaba. Las reglas de Udev en realidad parecen bastante sencillas ... Quiero decir, parece que pueden volverse ridículas si se trata de identificaciones de productos individuales y otras cosas, pero parecen bastante mansas por lo que hacen.

Para entender algo ... empieza a saberlo.

Ok, antes que nada, veamos qué hidrawsignifica y de qué se compone:

• hid (Dispositivo de interfaz humana): un dispositivo de interfaz humana o HID es un tipo de dispositivo informático que interactúa directamente con los humanos y, con mayor frecuencia, recibe información de los humanos y puede entregar salida a los humanos. _{fuente wikipedia}
• crudo: Esto se entiende como crudo , pero en el ambiente Linux también significa directo.

De esto podemos inferir que hidrawes un método crudo / directo para acceder al hid . Ahora veamos qué piensan nuestros sistemas sobre esto:

$ ls -l /dev/hidraw*
crw------- 1 root root 251, 0 Aug  3  2013 /dev/hidraw0
crw------- 1 root root 251, 1 Aug  3  2013 /dev/hidraw1
crw------- 1 root root 251, 2 Aug  3  2013 /dev/hidraw2
$ file /dev/hidraw*
/dev/hidraw0: character special 
/dev/hidraw1: character special 
/dev/hidraw2: character special

Entonces, ¿qué character specialsignifica? Los archivos especiales de caracteres o dispositivos de caracteres se relacionan con dispositivos a través de los cuales el sistema transmite datos un carácter a la vez, por ejemplo getchar. _{de nuevo Wikipedia es nuestro amigo.} Lo mismo sigue cal inicio del ls -lcomando.

¿Qué debo hacer para tener permisos de lectura en / dev / hidraw *?

Entonces, ¿cómo resuelve esto tu pregunta? Para acceder al /dev/hidraw*debe usar la implementación C para leer / escribir en este archivo. Pero, si lo que desea es información sobre los HID conectados, debe buscarla /sys/class/hidraw/hidraw*/. Ejemplo:

$ cat /sys/class/hidraw/hidraw2/device/uevent
DRIVER=hid-generic
HID_ID=0003:000015D9:00000A4C
HID_NAME= USB OPTICAL MOUSE
HID_PHYS=usb-0000:00:1d.1-2/input0
HID_UNIQ=
MODALIAS=hid:b0003g0001v000015D9p00000A4C

Tenga en cuenta que solo el núcleo tiene acceso directo en la mayoría de los casos a los dispositivos, y solo debe usar las llamadas proporcionadas en el espacio de usuario para comunicarse con estos dispositivos.

Veo cosas sobre las reglas de udev y vi esto en la red, pero el mundo de udev es como una tierra extranjera para mí.

A menos que esté desarrollando un nuevo controlador / dispositivo con el que no debería jugar demasiado udev, puede sufrir daños permanentes en su cerebro.