Sıfır dışında bayt alabilmem için / dev / zero üzerine nasıl biraz maske koyabilirim?

/dev/zeroSadece 0x00 için değil, aynı zamanda 0x01 ve 0xFF arasındaki herhangi bir bayt için de bir kaynağa sahip olabilmem için nasıl bir bit maskesi takabilirim?

Aşağıdaki bashkod ikili olarak temsil edilen bayt ile çalışacak şekilde ayarlanmıştır . Ancak kolayca işlemek için bunu değiştirebilirsiniz ocatal , ondalık veya onaltılık basitçe değiştirerek radix r değerini 2 etmek 8, 10ya da 16sırasıyla ve ayar b=buna göre.

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

DÜZENLEME - Tüm bayt değerleri aralığını işler : hex 00 - FF (aşağıda 00-7F yazdığımda, yalnızca tek bayt UTF-8 karakterleri düşünüyordum).

Örneğin, yalnızca 4 bayt istiyorsanız (UTF-8 'ASCII' okunur altıgen 00-7F aralığında karakter) , içine boru bunu yapabilirsiniz kafa :... | head -c4

Çıktı (4 karakter):

~~~~

Çıkışı 8 bit biçiminde görmek için xxd(veya diğer 1'ler ve 0'ların bayt dökümü *) içine boru bağlayın:
örn. b=10000000ve boru tesisatı:... | head -c4 | xxd -b

0000000: 10000000 10000000 10000000 10000000                    ....

Bunu kolayca yapamazsın.

Böyle bir cihaz sağlayan kendi çekirdek modülünüzü yazmayı düşünebilirsiniz. Bunu tavsiye etmiyorum.

Bazı pipo (veya üzerinde stdout) veya FIFO üzerine aynı baytlardan oluşan sonsuz bir akım yazarak küçük bir C programı yazabilirsiniz .

Sen kullanabilirsiniz tr (1) okuma /dev/zerove başka seyler her 0 bayt çevirmek.

Belki de evet (1) kullanabilirsiniz , en azından yeni satırlara sahip olmayı göze alabiliyorsanız (ya da başka bir yere tr -d '\n'...)

Eğer buysa, tam anlamıyla bunu başarmak istiyorum, bir kullanabilirsiniz LD_PRELOAD kanca . Temel fikir, bir işlevi C kütüphanesinden yeniden yazmak ve normal işlev yerine kullanmaktır.

Burada, 0x42 ile çıktı arabelleğini XOR yapmak için read () işlevini geçersiz kıldığımız basit bir örnek .

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

Saf bir uygulama, okuduğumuz her dosyada XOR 0x42 olur ve bu da istenmeyen sonuçlara yol açar. Bu sorunu çözmek için, open () işlevini de bağladım ve / dev / zero ile ilişkili dosya tanımlayıcısını getirdim . Ardından, XOR komutunu yalnızca read () işlevimizde yaparız fd == dev_zero_fd.

Kullanımı:

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

Hız açısından, bulduğum en hızlı şey:

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

Karşılaştırma için:

$ 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 'ise:; echo -n "\ 1" yapın; bitti '| pv -a> / dev / null
[225 KB / sn]

$ bash -c 'ise:; echo -ne "\ 1" yapın; bitti '| pv -a> / dev / null
[180 KB / sn]

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

Denemek ve sıfır bayt / x veya sıfır bayt denemek anlamsız, değil mi? Bayt almak ve xorsıfırla doldurmak bir işlem değildir.

İstediğiniz baytları veren bir döngü oluşturun ve bir piponun veya adlandırılmış bir borunun arkasına koyun. Bir karakter cihazıyla hemen hemen aynı davranacaktır (boşta iken CPU döngülerini boşa harcamaz):

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

Ve süper optimize etmek istiyorsanız, aşağıdaki C kodunu kullanabilirsiniz:

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

derle ve çalıştır

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

Performans testi:

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

Makinemde 2,1GB / s (biraz daha hızlı cat /dev/zero | pv -a >/dev/null)

Sıfırları okuyun, her sıfırı deseninize çevirin!

Sıfır baytı okur /dev/zerove trher bir sıfır baytı çevirerek her bir bayta bit maskesi uygulamak için kullanırız :

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

Octal 176 ascii kodudur ~, bu yüzden 10 elde ederiz ~. ( $Çıktının sonunda kabuğumda satır sonu olmadığını gösterir - sizin için farklı görünebilir)

Şimdi 0xFFbayt oluşturalım : Hex 0xFFsekizli 0377. Baştaki sıfır trkomut satırı için dışarıda bırakılır ; Sonunda, hexdumpçıkışı okunabilir hale getirmek için kullanılır.

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

Onaltılı yerine, karakterlerin sekizlik kodlarını kullanmanız gerekir. Yani gelen aralık var \000sekizlik biçime \377(aynı 0xFF). Onaltılık veya sekizli dizin numaralarına sahip karakterlerin bir tablosunu almak için ve
tuşlarını kullanın . (Ondalık ve onaltılık bir tablo için, sadece ).ascii -xascii -o
ascii

Oldukça hızlı

Sadece sıfırları kullanmaya kıyasla oldukça hızlı çalışır: cat /dev/zerosadece dört kat daha hızlıdır, IO tamponlamasını mükemmel bir şekilde kullanabilir tr.

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

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

Verilerle ne yapmak istediğinize ve bunları ne kadar esnek kullanmak istediğinize bağlıdır.

En kötü durumda hıza ihtiyacınız varsa, / dev / zero ile aynı şeyi yapabilir ve / dev / one, / dev / two, .. / dev / fourtytwo .. ve benzeri aygıtları derleyebilirsiniz.

Çoğu durumda, verileri doğrudan gerektiği yerde oluşturmak daha iyi olmalıdır, bu nedenle bir programın / komut dosyasının içinde sabit olarak. Daha fazla bilgi ile insanlar size daha iyi yardımcı olabilir.

Infinte printf döngüsü

İstediğiniz \u00bayt ile değiştirin.

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

C ++ kodu:

#include<cstdio>

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

Derleme: reeplace Byteistediğiniz değeri ile.

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

kullanım

./bin | yourapp