/ dev / hidraw: permissões de leitura

Question

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

Estou vendo coisas sobre as regras do udev e vi isso na net, mas o mundo do udev é como uma terra estrangeira para mim, e se houver algum tipo de solução mais simples onde eu simplesmente me adiciono a um grupo que seria dandy ...

(visualização do Ubuntu 13.10)

Sinta-se à vontade para repetir a pergunta - não estou muito interessada no que exatamente 'hidraw' vai abaixo.

EDITAR:

H'okay, então, apenas mais algumas informações para esclarecer a questão: Eu literalmente percorri o código que chamava o método POSIX open() e obtive o errno para permissões insuficientes. A execução de cat no arquivo como um usuário normal resulta em um erro de permissões insuficiente, enquanto a execução em su resulta em uma operação cat bem-sucedida (embora sem sentido).

EDITAR EDIT:

A pedido, estou fornecendo o código relevante com a chamada POSIX. É da biblioteca HIDAPI pelo Signal11 (função hid_open_path ). Eu confio que este código está correto, já que aparentemente tem sido usado há algum tempo. Eu adicionei um comentário localizado onde a leitura relevante de errno 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;
}

    

Answer 1

Eu desisti de correr por aí tentando descobrir alguns outros meios de fazer isso do que as regras do udev, e em vez disso apenas aprendi um pouco sobre o udev e escrevi uma regra de flippin '. A linha a seguir foi colocada em um arquivo .rules (denominei o meu 99-hidraw-permissions.rules ) localizado em /etc/udev/rules.d .

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

Basicamente isso designa todos os dispositivos que saem do subsistema hidraw no kernel para o grupo plugdev e define as permissões para r / w r / w r (para root [o proprietário padrão], plugdev e todos os outros respectivamente). Com eu adicionado ao grupo plugdev, tudo é maravilhoso.

Não exatamente como o cérebro se derretendo como eu esperava. As regras do Udev, na verdade, parecem bem diretas ... Quero dizer, elas parecem que podem ridicularizar se você está lidando com IDs de produtos individuais e outras coisas, mas elas parecem muito dóceis para o que fazem. / p>     

Answer 2

To understand something... start being knowing of it.

Ok, primeiro de tudo, vamos ver o que hidraw significa e o que é composto por:

• hid (Dispositivo de Interface Humana): Um dispositivo de interface humana ou HID é um tipo de dispositivo de computador que interage diretamente e, na maioria das vezes, recebe dados de humanos e pode fornecer resultados para humanos. _{wikipedia fonte}
• raw: Isso é feito como bruto , mas no ambiente do 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 significa character special ? Os arquivos especiais de caractere ou os dispositivos de caractere referem-se a dispositivos por meio dos quais o sistema transmite dados de um caractere por vez, por exemplo, getchar . _{novamente a Wikipedia é nossa amiga} O mesmo segue o c no início do ls -l command.

What do I need to do to have read permissions on /dev/hidraw*?

Então, como isso resolve sua pergunta? Para acessar o /dev/hidraw* , você deve usar a implementação C para ler / gravar neste arquivo. Mas, se o que você quer é informação sobre os HIDs conectados, você deve procurar em /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

Tenha em conta 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.

I'm seeing stuff about udev rules and saw this on the net, but the world of udev is like a foreign land to me

A menos que você esteja desenvolvendo um novo driver / dispositivo, você não deve jogar muito em torno de udev , você pode ter seu cérebro permanentemente danificado.