Бинарный grep для Linux?

Ответ 1

Вход с одним лайнером

Вот более короткая версия с одним слоем:

% perl -ln0e 'print tell' < inputfile

И вот немного длинный однострочный:

% perl -e '($/,$\) = ("\0","\n"); print tell while <STDIN>' < inputfile

Способ подключения этих двух однострочных устройств состоит в том, чтобы скомпилировать первую программу:

% perl -MO=Deparse,-p -ln0e 'print tell'
BEGIN { $/ = "\000"; $\ = "\n"; }
LINE: while (defined(($_ = <ARGV>))) {
    chomp($_);
    print(tell);
}

Запрограммированный вход

Если вы хотите поместить это в файл вместо вызова из командной строки, это будет несколько более явная версия:

#!/usr/bin/env perl

use English qw[ -no_match_vars ];

$RS  = "\0";    # input  separator for readline, chomp
$ORS = "\n";    # output separator for print

while (<STDIN>) {
    print tell();
}

И есть очень длинная версия:

#!/usr/bin/env perl

use strict;
use autodie;  # for perl5.10 or better
use warnings qw[ FATAL all  ];

use IO::Handle;

IO::Handle->input_record_separator("\0");
IO::Handle->output_record_separator("\n");

binmode(STDIN);   # just in case

while (my $null_terminated = readline(STDIN)) {
    # this just *past* the null we just read:
    my $seek_offset = tell(STDIN);
    print STDOUT $seek_offset;  

}

close(STDIN);
close(STDOUT);

Выход с одним лайнером

BTW, чтобы создать тестовый входной файл, я не использовал ваш большой, длинный Python script; Я просто использовал этот простой однострочный Perl:

% perl -e 'print 0.0.0.0.2.4.6.8.0.1.3.0.5.20' > inputfile

Вы обнаружите, что Perl часто заканчивается в 2-3 раза короче, чем Python, чтобы выполнять ту же работу. И вам не нужно идти на компромисс по ясности; что может быть проще, чем однострочный выше?

Запрограммированный выход

Я знаю, я знаю. Если вы уже не знаете язык, это может быть яснее:

#!/usr/bin/env perl
@values = (
    0,  0,  0,  0,  2,
    4,  6,  8,  0,  1,
    3,  0,  5, 20,
);
print pack("C*", @values);

хотя это тоже работает:

print chr for @values;

как и

print map { chr } @values;

Хотя для тех, кто любит все, все строгие и осторожные и все, это может быть больше того, что вы увидите:

#!/usr/bin/env perl

use strict;
use warnings qw[ FATAL all ];
use autodie;

binmode(STDOUT);

my @octet_list = (
    0,  0,  0,  0,  2,
    4,  6,  8,  0,  1,
    3,  0,  5, 20,
);

my $binary = pack("C*", @octet_list);
print STDOUT $binary;

close(STDOUT); 

TMTOWTDI

Perl поддерживает несколько способов сделать что-то, чтобы вы могли выбрать тот, который вам больше всего нравится. Если бы это было что-то, что я планировал проверить в качестве школьного или рабочего проекта, я бы выбрал более длинные, более тщательные версии - или, по крайней мере, поместил комментарий в оболочку script, если бы я использовал однострочные.

Вы можете найти документацию для Perl в своей собственной системе. Просто введите

% man perl
% man perlrun
% man perlvar
% man perlfunc

и т.д. в командной строке. Если вы хотите получить симпатичные версии в Интернете вместо этого, получите manpages для perl, perlrun, perlvar и perlfunc из http://perldoc.perl.org.

Ответ 2

Кажется, это работает для меня:

grep --only-matching --byte-offset --binary --text --perl-regexp "<\x-hex pattern>" <file>

Краткая форма:

grep -obUaP "<\x-hex pattern>" <file>

Пример:

grep -obUaP "\x01\x02" /bin/grep

Вывод (Cygwin двоичный файл):

153: <\x01\x02>
33210: <\x01\x02>
53453: <\x01\x02>

Таким образом, вы можете снова выполнить эту операцию, чтобы извлечь смещения. Но не забудьте снова использовать двоичный режим.

Ответ 3

Кто-то, похоже, был так же расстроен и написал свой собственный инструмент для этого (или, по крайней мере, что-то подобное): bgrep.

Ответ 4

Программа bbe - это sed -образный редактор для двоичных файлов. См. документация.

Пример с bbe:

bbe -b "/\x00\x00\xCC\x00\x00\x00/:17" -s -e "F d" -e "p h" -e "A \n" mydata.bin

11:x00 x00 xcc x00 x00 x00 xcd x00 x00 x00 xce

Объяснение

-b search pattern between //. each 2 byte begin with \x (hexa notation).
   -b works like this /pattern/:length (in byte) after matched pattern
-s similar to 'grep -o' suppress unmatched output 
-e similar to 'sed -e' give commands
-e 'F d' display offsets before each result here: '11:'
-e 'p h' print results in hexadecimal notation
-e 'A \n' append end-of-line to each result

Вы также можете передать его в sed, чтобы получить более чистый результат:

bbe -b "/\x00\x00\xCC\x00\x00\x00/:17" -s -e "F d" -e "p h" -e "A \n" mydata.bin | sed -e 's/x//g'

11:00 00 cc 00 00 00 cd 00 00 00 ce

Ваше решение с Perl из вашего EDIT3 дает мне "недостаток памяти", ошибка с большими файлами.

То же самое происходит с bgrep.

Единственным недостатком bbe является то, что я не знаю, как печатать контекст, предшествующий сопоставленному шаблону.

Ответ 5

Один из способов решения вашей непосредственной проблемы с использованием только grep - создать файл, содержащий один нулевой байт. После этого grep -abo -f null_byte_file target_file выдаст следующий результат.

0:
1:
2:
3:
8:
11:

Это, конечно, каждое смещение байта в соответствии с запросом "-b", за которым следует нулевой байт по запросу "-o"

Я буду первым защищать perl, но в этом случае нет необходимости вводить расширенную семью.

Ответ 6

Как насчет grep -a? Не уверен, как он работает на действительно двоичных файлах, но он хорошо работает в текстовых файлах, которые ОС считает двоичными.