Como colocar uma máscara de bit em / dev / zero para obter bytes diferentes de zero?

Como colocar uma máscara de bits /dev/zeropara poder ter uma fonte não apenas para 0x00, mas também para qualquer byte entre 0x01 e 0xFF?

O bashcódigo a seguir está definido para trabalhar com o byte sendo representado em binário . No entanto, você pode alterá-lo facilmente para lidar com ocatal , decimal ou hexadecimal , simplesmente alterando o valor da raiz r de 2 para 8, 10ou 16respectivamente, e configurando de b=acordo.

r=2; b=01111110
printf -vo '\\%o' "$(($r#$b))"; </dev/zero tr '\0' "$o"

EDIT - Ele lida com toda a gama de valores de bytes: hex 00 - FF (quando escrevi 00-7F abaixo, estava considerando apenas caracteres UTF-8 de byte único).

Se, por exemplo, você quiser apenas 4 bytes (caracteres no intervalo hex 00-7F somente UTF-8 'ASCII') , poderá inseri- lo na cabeça :... | head -c4

Saída (4 caracteres):

~~~~

Para ver a saída no formato de 8 bits, coloque-a em xxd(ou em qualquer outro despejo de bytes 1 e 0 *):
por exemplo. b=10000000e tubulação para:... | head -c4 | xxd -b

0000000: 10000000 10000000 10000000 10000000                    ....

Você não pode fazer isso facilmente.

Você pode escrever seu próprio módulo do kernel, fornecendo esse dispositivo. Eu não recomendo isso.

Você pode escrever um pequeno programa C escrevendo um fluxo infinito dos mesmos bytes em algum pipe (ou on stdout) ou FIFO.

Você pode usar tr (1) para ler /dev/zeroe traduzir cada 0 byte para outra coisa.

Você pode usar talvez sim (1) , pelo menos se puder pagar por novas linhas (ou então introduzi-lo em tr -d '\n'...)

Bem, se você literalmente deseja conseguir isso, pode usar um gancho LD_PRELOAD . A idéia básica é reescrever uma função da biblioteca C e usá-la em vez da normal.

Aqui está um exemplo simples em que substituímos a função read () para XOR o buffer de saída com 0x42.

#define _GNU_SOURCE
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <dlfcn.h> 
#include <unistd.h>

static int dev_zero_fd = -1;

int open64(const char *pathname, int flags)
{
    static int (*true_open64)(const char*, int) = NULL;
    if (true_open64 == NULL) {
        if ((true_open64 = dlsym(RTLD_NEXT, "open64")) == NULL) {
            perror("dlsym");
            return -1;
        }        
    }
    int ret = true_open64(pathname, flags);
    if (strcmp(pathname, "/dev/zero") == 0) {
        dev_zero_fd = ret;
    }
    return ret;
}


ssize_t read(int fd, void *buf, size_t count)
{
    static ssize_t (*true_read)(int, void*, size_t) = NULL;
    if (true_read == NULL) {
        if ((true_read = dlsym(RTLD_NEXT, "read")) == NULL) {
            perror("dlsym");
            return -1;
        }        
    }    

    if (fd == dev_zero_fd) {
        int i;
        ssize_t ret = true_read(fd, buf, count);    
        for (i = 0; i < ret; i++) {
            *((char*)buf + i) ^= 0x42;
        }
        return ret;
    }

    return true_read(fd, buf, count);    
}

Uma implementação ingênua XOR 0x42 em todos os arquivos que lemos, o que teria conseqüências indesejáveis. Para resolver esse problema, eu também instalei a função open () , fazendo com que ela buscasse o descritor de arquivo associado a / dev / zero. Então, apenas executamos o XOR em nossa função read () se fd == dev_zero_fd.

Uso:

$ gcc hook.c -ldl -shared -o hook.so
$ LD_PRELOAD=$(pwd)/hook.so bash #this spawns a hooked shell
$ cat /dev/zero
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

Em termos de velocidade, o mais rápido que encontrei foi:

$ PERLIO=:unix perl -e '$s="\1" x 65536; for(;;){print $s}' | pv -a > /dev/null
[4.02GiB/s]

Para comparação:

$ tr '\0' '\1' < /dev/zero | pv -a > /dev/null
[ 765MiB/s]
$ busybox tr '\0' '\1' < /dev/zero | pv -a > /dev/null
[ 399MiB/s]

$ yes $'\1' | tr -d '\n' | pv -a > /dev/null
[26.7MiB/s]

$ dash -c 'while:; faça eco -n "\ 1"; feito '| pv -a> / dev / null
[225KiB / s]

$ bash -c 'while:; faça eco -ne "\ 1"; feito '| pv -a> / dev / null
[180KiB / s]

$ < /dev/zero pv -a > /dev/null
[5.56GiB/s]
$ cat /dev/zero | pv -a > /dev/null
[2.82GiB/s]

É meio inútil tentar usar bitmask / x ou zero bytes, não é? Pegar um byte e xorzerá-lo é um no-op.

Basta criar um loop com os bytes desejados e colocá-lo atrás de um pipe ou pipe nomeado. Ele se comportará da mesma forma que um dispositivo de caractere (não desperdiçará ciclos de CPU quando ocioso):

mkfifo pipe
while : ; do echo -n "a"; done > pipe &

E se você quiser super otimizá-lo, pode usar o código C abaixo:

#include <stdio.h>
#include <string.h>

int main(int argc, char **argv) { 
  char c = argc == 1+1 ? argv[1][0] : 'y';

  char buff[BUFSIZ];
  memset(buff, c, BUFSIZ);

  for(;;){ 
    write(1, buff, sizeof(buff)); 
  }
}

compilar e executar

$ CFLAGS=-O3 make loop
./loop "$the_byte_you_want" > pipe

Teste de performance:

./loop 1 | pv -a >/dev/null 

2,1 GB / s na minha máquina (até um pouco mais rápido que cat /dev/zero | pv -a >/dev/null)

Leia zeros, traduza cada zero para o seu padrão!

Lemos zero bytes de /dev/zeroe usamos trpara aplicar uma máscara de bit a cada um dos bytes, traduzindo cada byte de zero:

$ </dev/zero tr '\000' '\176' | head -c 10
~~~~~~~~~~$

Octal 176 é o código ascii de ~, então obtemos 10 ~. (O $final da saída indica no meu shell que não havia final de linha - pode parecer diferente para você)

Então, vamos criar 0xFFbytes: Hex 0xFFé octal 0377. O zero à esquerda é deixado de fora para a trlinha de comando; No final, hexdumpé usado para tornar a saída legível.

$ </dev/zero tr '\000' '\377' | head -c 10 | hexdump
0000000 ffff ffff ffff ffff ffff               
000000a

Você precisa usar os códigos octais dos caracteres aqui, em vez do hexadecimal. Portanto, é o intervalo de\000 até octal \377(o mesmo que 0xFF).
Use ascii -xe ascii -opara obter uma tabela dos caracteres com números de índice hexadecimal ou octal.
(Para uma tabela com decimal e hexadecimal, apenas ascii).

Bem rápido

Ele roda bastante rápido, comparado ao uso de zeros: cat /dev/zeroé apenas quatro vezes mais rápido, enquanto pode fazer perfeito uso do buffer IO, quetr não pode.

$ </dev/zero tr '\000' '\176' | pv -a >/dev/null
[ 913MB/s]

$ </dev/zero cat | pv -a >/dev/null        
[4.37GB/s]

Depende do que você deseja fazer com os dados e de quão flexível você deseja usá-los.

Na pior das hipóteses, se você precisar de velocidade, poderá fazer o mesmo que o / dev / zero e apenas compilar o / dev / one, / dev / two, .. / dev / fourtytwo .. e assim por diante.

Na maioria dos casos, deve ser melhor criar os dados diretamente onde são necessários, portanto, dentro de um programa / script como uma constante. Com mais informações, as pessoas poderiam ajudá-lo melhor.

Infinte printf loop

Substitua \u00com o byte desejado.

while true ; do printf "\u00" ; done | yourapp

Código C ++:

#include<cstdio>

int main(){
 char out=Byte;
 while(true)
 fwrite(&out,sizeof(out),1,stdout);
}

Compilar: substitua Bytepelo valor desejado.

g++ -O3 -o bin file.cpp -D Byte=0x01

Usar

./bin | yourapp