/ dev / hidraw: autorizzazioni di lettura

Cosa devo fare per avere i permessi di lettura su / dev / hidraw *?

Sto vedendo cose sulle regole di udev e ho visto questo in rete, ma il mondo di udev è come una terra straniera per me, e se c'è una sorta di soluzione più semplice in cui mi aggiungo a un gruppo che sarebbe dandy ...

(Anteprima Ubuntu 13.10)

Sentiti libero di rimettere in discussione la domanda: non sono troppo entusiasta di ciò che "hidraw" è esattamente sotto.

MODIFICARE:

Bene, quindi, solo qualche informazione in più per chiarire il problema: ho letteralmente sfogliato il codice che chiamava il open()metodo POSIX e ho ottenuto le errnoautorizzazioni insufficienti. L'esecuzione catsul file come utente normale comporta un errore di autorizzazione insufficiente, mentre l'esecuzione in esecuzione sucomporta un'operazione riuscita (sebbene senza senso) cat.

MODIFICA MODIFICA:

Su richiesta, sto fornendo il codice pertinente con chiamata POSIX. Viene dalla libreria HIDAPI di Signal11 (funzione hid_open_path). Confido che questo codice sia corretto, poiché è apparentemente in uso da un po 'di tempo ormai. Ho aggiunto un commento in cui errnosi è svolta la lettura pertinente in 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;
}

Ho rinunciato a correre cercando di capire qualche altro modo di farlo rispetto alle regole di udev, e invece ho appena imparato un po 'di udev e ho scritto una regola di flippin. La seguente riga è stata inserita in un .rulesfile (che ho chiamato mio 99-hidraw-permissions.rules) situato sotto /etc/udev/rules.d.

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

Fondamentalmente questo assegna tutti i dispositivi che escono dal sottosistema hidraw nel kernel al gruppo plugdeve imposta i permessi su r / wr / wr (rispettivamente per root [il proprietario predefinito], plugdev e tutti gli altri). Con me stesso aggiunto al gruppo plugdev, tutto è dandy.

Non abbastanza scioglimento del cervello come mi aspettavo. Udev regole in realtà sembrano abbastanza semplice ... Voglio dire, loro li sembrano in grado di ottenere ridicolo se hai a che fare con gli ID dei singoli prodotti e quant'altro, ma sembrano dannatamente domare per quello che fanno.

Per capire qualcosa ... inizia a conoscerlo.

Ok, prima di tutto, vediamo cosa hidrawsignifica e cosa è composto:

• hid (Human Interface Device): un dispositivo di interfaccia umano o HID è un tipo di dispositivo informatico che interagisce direttamente con, e molto spesso prende input dagli umani, e può fornire output agli umani. _{fonte Wikipedia}
• raw: Questo è inteso come rozzo , ma nell'ambiente Linux significa anche diretto.

Da ciò possiamo dedurre che hidrawè un metodo grezzo / diretto per accedere al nascondiglio . Ora vediamo cosa ne pensano i nostri sistemi:

$ 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

Quindi, cosa character specialsignifica? I file speciali di carattere o i dispositivi di carattere si riferiscono a dispositivi attraverso i quali il sistema trasmette i dati un carattere alla volta, ad esempio getchar. _{di nuovo Wikipedia è nostra amica} Lo stesso segue call'inizio del ls -lcomando.

Cosa devo fare per avere i permessi di lettura su / dev / hidraw *?

Quindi, come questo risolve la tua domanda? Per accedere a /dev/hidraw*è necessario utilizzare l'implementazione C per leggere / scrivere in questo file. Ma, se ciò che vuoi sono informazioni sugli HID collegati, dovresti cercare /sys/class/hidraw/hidraw*/. Esempio:

$ 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

Prendi in considerazione che solo il kernel ha accesso diretto nella maggior parte dei casi ai dispositivi e dovresti usare solo le chiamate fornite nello spazio utente per comunicare con questi dispositivi.

Sto vedendo cose sulle regole di udev e ho visto questo in rete, ma il mondo di udev è come una terra straniera per me

A meno che tu non stia sviluppando un nuovo driver / dispositivo su cui non dovresti giocare troppo udev, puoi danneggiare permanentemente il tuo cervello.