распаковка неизвестного сериализованного формата с переменной длиной

Вы понятия не имеете, сколько нужно читать, поэтому чтение всего файла сразу даст вам наилучшие результаты по скорости.

{
   my $file = do { local $/; <> };

   $file =~ s/^.{8}//s
      or die("Bad data");

   while (length($file)) {
      $file =~ s/^([^\0]*)\0[^\0]*\0[^\0]*\0([^\0]*)\0//
         or die("Bad data");

      my $user_id = $1;
      my @items = split(/\n/, $2, -1);
      ...
   }
}

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

{
   my $buf = '';
   my $not_eof = 1;

   my $reader = sub {
      $not_eof &&= read(\*ARGV, $buf, 1024*1024, length($buf));
      die($!) if !defined($not_eof);
      return $not_eof;
   };

   while ($buf !~ s/^.{8}//s) {
      $reader->()
         or die("Bad data");
   }      

   while (length($buf) || $reader->()) {
      my $user_id;
      my @items;
      while (1) {
         if ($buf =~ s/^([^\0]*)\0[^\0]*\0[^\0]*\0([^\0]*)\0//) {
            $user_id = $1;
            @items = split(/\n/, $2, -1);
            last;
         }

         $reader->()
            or die("Bad data");
      }

      ...
   }
}

Вот два способа уменьшить количество жестко закодированных особенностей, основанных на описании данных; один читает эти нулевые байты (затем возвращается к новым строкам), другой unpacks строк с нулевыми значениями.

Задайте для $/ variable нулевой байт и прочитайте первые 4 (четыре) таких «линии». Там вы получаете свой идентификатор пользователя, а затем последняя прочитанная «строка» — это количество следующих за ним элементов. Восстановите $/ на новую строку и прочитайте этот список, используя обычный readline (он же <>). Повторите, если этот шаблон действительно повторяется.

use warnings;
use strict;
use feature 'say';

my $file = shift or die "Usage: $0 file\n";  # a_file_with_nuls.txt    
open my $fh, '<', $file or die "Can't open $file: $!"; 

my ($user_id, $num_items);
while (not eof $fh) {    
    READ_BY_NUL: { 
        my $num_of_nul_lines = 4;
        local $/ = "\x00"; 
        my $line;
        for my $i (1..$num_of_nul_lines) { 
            $line = readline $fh;
            chop $line;
            if ($i == 2) {
                $user_id = $line;
            }
        }   
        $num_items = $line;  # last nul-terminated "line"
    }        
    say "Got: user-id = |$user_id|, and number-of-items = |$num_items|";    

    my @items;
    for (1..$num_items) {
        my $line = readline $fh;
        chomp $line;
        push @items, $line;
    }    
    say for @items;
};

Поскольку $/ задается с помощью local в блоке READ_BY_NUL, его предыдущее значение восстанавливается из блокировать.

Вывод соответствует ожиданиям, но, пожалуйста, добавьте проверки. Кроме того, можно представить ошибки, при которых имело бы смысл восстанавливаться (например, фактическое количество элементов меньше заданного числа).

Все дело в while с ручной проверкой (и завершением) с использованием eof, исходя из предположения, что шаблон four-nuls + number-of-lines действительно повторяется (немного неясно из вопроса).

Я тестирую файл, созданный

perl -wE'say "toss\x00user-id\x00this-too\x003\x00item-1\nitem2\nitem 3"' 
    > a_file_with_nuls.txt

который затем добавляется несколько раз, чтобы дать нам что-то для этого цикла while.

Наконец, сделайте это чтение <:raw в системах, которым это нужно, и unpack по мере необходимости. Смотри ниже.

Как указано в вопросе, (некоторые?) данные являются двоичными, поэтому то, что читается выше, должно быть upack-ed. Это также означает, что могут возникнуть проблемы с чтением нулевых байтов — как эти данные были записаны в первую очередь? Незаполненные части этих полей с фиксированной шириной могут быть заполнены точно нулевыми значениями.

Другой вариант — просто прочитать строки и распаковать первую (а затем unpack одну строку каждый раз после того, как будет прочитано заданное количество строк, указанное как «элементы»).

open my $fh, '<:raw', $file or die "Can't open $file: $!"; 

my @items;
my $block_lines = 1;

while (my $line = <$fh>) { 
    chomp $line;
    if ( $. % $block_lines == 0 ) {
        my ($uid, $num_items) = unpack "x8 A7x x13 i3x", $line;
        say "User-id: $uid, read $num_items lines for items";
        $block_lines += 1 + $num_items;
    }   
    else {
        push @items, $line;
    }
}
say for @items;

Здесь количество пропущенных байтов (x8 и x13) включает ноль.

Это предполагает, что количество «элементов» (строк) для чтения в каждом «блоке» может быть разным, и складывает их по ходу (плюс строка с нулевыми значениями для общего количества запущенных $block_lines), чтобы можно было проверить, когда это снова на строке с нулями ($. % $block_lines == 0)

Он делает несколько других (разумных) предположений для вещей, которые не указаны. Это было проверено лишь слегка, с некоторыми выдуманными данными.