/ dev / hidraw: permissões de leitura

O que preciso fazer para ter permissões de leitura em / dev / hidraw *?

Estou vendo coisas sobre as regras do udev e vi isso na rede, mas o mundo do udev é como uma terra estrangeira para mim, e se houver algum tipo de solução mais simples, eu apenas me adicionarei a um grupo que seria dândi ...

(Visualização do Ubuntu 13.10)

Sinta-se à vontade para refazer a pergunta - não estou muito interessado no que exatamente 'hidraw' significa.

EDITAR:

Tudo bem, então, apenas mais algumas informações para esclarecer o problema: eu literalmente repassei o código que chamava o open()método POSIX e obtive as errnopermissões insuficientes. A execução catno arquivo como um usuário normal resulta em um erro de permissão insuficiente, enquanto a execução em suresultados resulta em uma catoperação bem-sucedida (embora sem sentido) .

EDIT EDIT:

A pedido, estou fornecendo o código relevante com a chamada POSIX. É da biblioteca HIDAPI da Signal11 (função hid_open_path). Confio que esse código esteja correto, pois aparentemente já está em uso há algum tempo. Adicionei um comentário localizado onde a errnoleitura relevante ocorreu no 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;
}

Desisti de tentar descobrir outros meios de fazê-lo além das regras do udev. Em vez disso, apenas aprendi um pouco sobre o udev e escrevi uma regra de flippin '. A seguinte linha foi colocada em um .rulesarquivo (denominei meu 99-hidraw-permissions.rules) localizado em /etc/udev/rules.d.

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

Basicamente, isso atribui todos os dispositivos que saem do subsistema hidraw no kernel ao grupo plugdeve define as permissões para r / wr / wr (para root [o proprietário padrão], plugdev e todos os outros, respectivamente). Eu mesmo adicionado ao grupo plugdev, está tudo bem.

Não é tão derretido como eu esperava. Udev governa realmente parecem bastante simples ... Quer dizer, parece que eles podem obter ridículo se você está lidando com IDs de produtos individuais e outros enfeites, mas eles parecem muito muito domar por aquilo que fazem.

Para entender alguma coisa ... comece a conhecê-la.

Ok, antes de tudo, vamos ver o que hidrawsignifica e o que é composto:

• hid (Dispositivo de interface humana): Um dispositivo de interface humana ou HID é um tipo de dispositivo de computador que interage diretamente com, e geralmente recebe entrada de seres humanos, e pode fornecer saída para seres humanos. _{fonte wikipedia}
• Bruto: isso significa bruto , mas no ambiente Linux também significa direto.

A partir disso, podemos inferir que hidrawé um método bruto / direto para acessar o hid . Agora vamos ver o que nossos sistemas pensam sobre isso:

$ 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

Então, o que character specialsignifica? Arquivos especiais de caracteres ou dispositivos de caracteres referem-se a dispositivos através dos quais o sistema transmite dados, um caractere de cada vez, por exemplo getchar. _{novamente Wikipedia é nosso amigo} O mesmo segue o cno início do ls -lcomando.

O que preciso fazer para ter permissões de leitura em / dev / hidraw *?

Então, como isso resolve sua pergunta? Para acessar, /dev/hidraw*você deve usar a implementação C para ler / gravar neste arquivo. Mas, se você deseja informações sobre os HIDs conectados, consulte /sys/class/hidraw/hidraw*/. Exemplo:

$ 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

Leve em consideração que apenas o kernel tem acesso direto na maioria dos casos aos dispositivos, e você só deve usar as chamadas fornecidas no espaço do usuário para se comunicar com esses dispositivos.

Estou vendo coisas sobre as regras do udev e vi isso na rede, mas o mundo do udev é como uma terra estrangeira para mim

A menos que você esteja desenvolvendo um novo driver / dispositivo para o qual não deve brincar muito udev, pode danificar permanentemente o cérebro.