Come posso mettere una maschera di bit su / dev / zero in modo da poter ottenere byte diversi da zero?

Come posso mettere una maschera di bit in /dev/zeromodo da poter avere una sorgente non solo per 0x00 ma anche per qualsiasi byte compreso tra 0x01 e 0xFF?

Il seguente bashcodice è impostato per funzionare con il byte rappresentato in binario . Tuttavia, puoi facilmente cambiarlo per gestire l' ocatale , il decimale o l' esagono semplicemente cambiando il valore radix r di 2 in 8, 10o 16rispettivamente e impostando di b=conseguenza.

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

EDIT - Gestisce l' intera gamma di valori byte: hex 00 - FF (quando ho scritto 00-7F sotto, stavo considerando solo caratteri UTF-8 a byte singolo).

Se, ad esempio, vuoi solo 4 byte (caratteri nell'intervallo 00-7F esadecimale solo ASC1-UTF-8) , puoi inserirlo nella testa :... | head -c4

Uscita (4 caratteri):

~~~~

Per vedere l'output in formato 8 bit, esegui il pipe xxd(o qualsiasi altro dump di byte 1 e 0 *):
ad es. b=10000000e tubazioni per:... | head -c4 | xxd -b

0000000: 10000000 10000000 10000000 10000000                    ....

Non puoi farlo facilmente.

Si potrebbe prendere in considerazione la possibilità di scrivere il proprio modulo del kernel fornendo tale dispositivo. Non lo consiglio.

Potresti scrivere un piccolo programma C scrivendo un flusso infinito di stessi byte su una pipe (o su stdout) o FIFO.

Puoi usare tr (1) per leggere /dev/zeroe tradurre ogni 0 byte in qualcos'altro.

Potresti usare forse yes (1) , almeno se puoi permetterti di avere newline (oppure inoltralo in tr -d '\n'...)

Bene, se vuoi letteralmente raggiungere questo obiettivo, puoi usare un hook LD_PRELOAD . L'idea di base è di riscrivere una funzione dalla libreria C e usarla al posto di quella normale.

Ecco un semplice esempio in cui sovrascriviamo la funzione read () per XOR il buffer di output con 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);    
}

Un'implementazione ingenua avrebbe XOR 0x42 su ogni file che leggiamo, il che avrebbe conseguenze indesiderate. Per risolvere questo problema, ho anche agganciato la funzione open () , facendogli recuperare il descrittore di file associato a / dev / zero. Quindi eseguiamo XOR solo sulla nostra funzione 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

In termini di velocità, il più veloce che ho trovato è stato:

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

Per confronto:

$ 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 'mentre:; do echo -n "\ 1"; fatto "| pv -a> / dev / null
[225 KiB / s]

$ bash -c 'mentre:; do echo -ne "\ 1"; fatto "| pv -a> / dev / null
[180 KiB / s]

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

È un po 'inutile provare e maschera di bit / xo zero byte, non è vero? Prendere un byte e xorinserirlo con zero è un no-op.

Basta creare un loop che ti dia i byte desiderati e metterlo dietro una pipe o una pipe denominata. Si comporterà praticamente come un dispositivo a caratteri (non sprecherà i cicli della CPU quando è inattivo):

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

E se desideri ottimizzarlo in modo ottimale, puoi utilizzare il codice C di seguito:

#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)); 
  }
}

compilare ed eseguire

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

Test della prestazione:

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

2.1GB / s sulla mia macchina (anche leggermente più veloce di cat /dev/zero | pv -a >/dev/null)

Leggi gli zeri, traduci ogni zero nel tuo schema!

Leggiamo zero byte da /dev/zeroe utilizziamo trper applicare una maschera di bit a ciascuno dei byte traducendo ogni zero byte:

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

L'ottobre 176 è il codice ascii di ~, quindi ne otteniamo 10 ~. (La $fine dell'output indica nella mia shell che non c'era fine della linea - potrebbe avere un aspetto diverso per te)

Quindi, creiamo 0xFFbyte: esadecimale 0xFFè ottale 0377. Lo zero iniziale viene lasciato fuori per la trriga di comando; Alla fine, hexdumpviene utilizzato per rendere leggibile l'output.

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

È necessario utilizzare i codici ottali dei caratteri qui, anziché esadecimali. Quindi è la gamma da \000a ottale \377(uguale a 0xFF).
Utilizzare ascii -xe ascii -oper ottenere una tabella dei caratteri con numeri di indice esadecimali o ottali.
(Per una tabella con decimale ed esadecimale, solo ascii).

Abbastanza veloce

Funziona abbastanza velocemente, rispetto al solo utilizzo degli zeri: cat /dev/zeroè solo quattro volte più veloce, mentre può fare un uso perfetto del buffering IO, che trnon può.

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

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

Dipende da cosa vuoi fare con i dati e da quanto flessibile vuoi usarli.

Nel peggiore dei casi, se hai bisogno di velocità, potresti fare lo stesso di / dev / zero, e semplicemente compilare / dev / one, / dev / two, .. / dev / fourtytwo .. e così via.

Nella maggior parte dei casi dovrebbe essere meglio creare i dati direttamente dove sono necessari, quindi all'interno di un programma / script come costante. Con più informazioni le persone potrebbero aiutarti meglio.

Loop di stampa infinito

Sostituire \u00con il byte desiderato.

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

Codice C ++:

#include<cstdio>

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

Compila: riposiziona Bytecon il valore desiderato.

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

Uso

./bin | yourapp