user-tools/stdfilt

   1 #!/usr/bin/env perl
   2
   3 use Data::Dumper;
   4 use Getopt::Long qw/:config no_ignore_case bundling no_getopt_compat/;
   5 use Fcntl qw/F_GETFL F_SETFL O_NONBLOCK/;
   6 use POSIX;
   7 use Pod::Usage;
   8
   9
  10 $Filters = {
  11         'out' => [],
  12         'err' => [],
  13 };
  14 @savedARGV = @ARGV;
  15
  16
  17 sub process_args
  18 {
  19         @ARGV = @savedARGV;
  20         pop @{$Filters->{'out'}} while scalar @{$Filters->{'out'}};
  21         pop @{$Filters->{'err'}} while scalar @{$Filters->{'err'}};
  22         return GetOptions(
  23                 'F|filter-file=s@' => sub { process_filter_file($_[1]); },
  24                 'o|po|pass-stdout=s@' => sub { push @{$Filters->{'out'}}, {'pass'=>1, 'pattern'=>$_[1]}; },
  25                 'e|pe|pass-stderr=s@' => sub { push @{$Filters->{'err'}}, {'pass'=>1, 'pattern'=>$_[1]}; },
  26                 'O|fo|filter-stdout=s@' => sub { push @{$Filters->{'out'}}, {'pass'=>0, 'pattern'=>$_[1]}; },
  27                 'E|fe|filter-stderr=s@' => sub { push @{$Filters->{'err'}}, {'pass'=>0, 'pattern'=>$_[1]}; },
  28                 'p|pass=s@' =>   sub { push @{$Filters->{$_}}, {'pass'=>1, 'pattern'=>$_[1]} for ('out', 'err'); },
  29                 'f|filter=s@' => sub { push @{$Filters->{$_}}, {'pass'=>0, 'pattern'=>$_[1]} for ('out', 'err'); },
  30         );
  31 }
  32
  33
  34 process_args or pod2usage(-exitval=>2, -verbose=>99);
  35
  36 if(not @ARGV)
  37 {
  38         pod2usage(-exitval=>2, -verbose=>99);
  39 }
  40
  41
  42 sub process_filter_file
  43 {
  44         my $filepath = shift;
  45         open my $fh, '<', $filepath or die "$filepath: $!\n";
  46         my @channels = ('out', 'err');
  47         while(<$fh>)
  48         {
  49                 chomp;
  50                 s/^\s*//;
  51                 next if /^(#|$)/;
  52                 if(/^\[std(out|err)\]$/)
  53                 {
  54                         @channels = ($1);
  55                         next;
  56                 }
  57                 if(/^\[\*\]$/)
  58                 {
  59                         @channels = ('out', 'err');
  60                         next;
  61                 }
  62                 my $pass = 0;
  63                 $pass = 1 if s/^!\s*//;
  64                 my $pattern = $_;
  65                 push @{$Filters->{$_}}, {'pass'=>$pass, 'pattern'=>$pattern} for @channels;
  66         }
  67         close $fh;
  68 }
  69
  70
  71 sub filter_pass
  72 {
  73         my $line = shift;
  74         my $filters = shift;
  75         my $pass = 1;
  76
  77         for my $filt (@$filters)
  78         {
  79                 if($line =~ $filt->{'pattern'})
  80                 {
  81                         $pass = $filt->{'pass'};
  82                 }
  83         }
  84         return $pass;
  85 }
  86
  87 sub process_line
  88 {
  89         my $line = shift;
  90         my $stream = shift;
  91         print {$stream->{'write_fh'}} $line if filter_pass $line, $stream->{'filter'};
  92 }
  93
  94 sub process_stream
  95 {
  96         my $stream = shift;
  97         while(1)
  98         {
  99                 my $nl = index $stream->{'buf'}, "\n";
 100                 last if $nl == -1;
 101                 $nl++;
 102
 103                 my $line = substr $stream->{'buf'}, 0, $nl;
 104                 process_line $line, $stream;
 105
 106                 $stream->{'buf'} = substr $stream->{'buf'}, $nl;
 107         }
 108 }
 109
 110
 111
 112 pipe($stdout_r, $stdout_w) or die "$0: pipe: $!\n";
 113 pipe($stderr_r, $stderr_w) or die "$0: pipe: $!\n";
 114
 115
 116 my $child_pid = fork // die "$0: fork: $!\n";
 117
 118 if($child_pid == 0)
 119 {
 120         open STDOUT, '>&', $stdout_w or die "$0: replace stdout: $!\n";
 121         open STDERR, '>&', $stderr_w or die "$0: replace stderr: $!\n";
 122         select STDERR; $|++;
 123         select STDOUT; $|++;
 124
 125         exec {$ARGV[0]} @ARGV;
 126         my ($errno, $errstr) = (int $!, $!);
 127         warn "$0: ${ARGV[0]}: $errstr\n";
 128         exit 125+$errno;
 129 }
 130
 131
 132 my $child_status = undef;
 133 close STDIN;
 134 close $stdout_w;
 135 close $stderr_w;
 136 fcntl($stdout_r, F_SETFL, fcntl($stdout_r, F_GETFL, 0) | O_NONBLOCK);
 137 fcntl($stderr_r, F_SETFL, fcntl($stderr_r, F_GETFL, 0) | O_NONBLOCK);
 138 select STDERR; $|++;
 139 select STDOUT; $|++;
 140
 141
 142 $pipe = {
 143         'out' => {
 144                 'fh' => $stdout_r,
 145                 'write_fh' => \*STDOUT,
 146                 'fd' => fileno $stdout_r,
 147                 'buf' => '',
 148                 'filter' => $Filters->{'out'},
 149         },
 150         'err' => {
 151                 'fh' => $stderr_r,
 152                 'write_fh' => \*STDERR,
 153                 'fd' => fileno $stderr_r,
 154                 'buf' => '',
 155                 'filter' => $Filters->{'err'},
 156         },
 157 };
 158
 159
 160 $SIG{'HUP'} = sub { $do_reload = 1; };
 161
 162
 163 while(1)
 164 {
 165         $fds = '';
 166         for my $n ('out', 'err')
 167         {
 168                 vec($fds, $pipe->{$n}->{'fd'}, 1) = 1 if defined $pipe->{$n}->{'fh'};
 169         }
 170         last if $fds eq '';
 171
 172         $! = 0;
 173         select($fds, undef, undef, undef);
 174         my $errno = int $!;
 175
 176         if($do_reload)
 177         {
 178                 $do_reload = 0;
 179                 process_args;
 180         }
 181
 182         next if $errno;
 183
 184         for my $n ('out', 'err')
 185         {
 186                 if(vec($fds, $pipe->{$n}->{'fd'}, 1) == 1)
 187                 {
 188                         my $bytes = sysread $pipe->{$n}->{'fh'}, $pipe->{$n}->{'buf'}, 1024, length $pipe->{$n}->{'buf'};
 189                         if($bytes)
 190                         {
 191                                 process_stream($pipe->{$n});
 192                         }
 193                         else
 194                         {
 195                                 # this stream is closed.
 196                                 undef $pipe->{$n}->{'fh'};
 197                                 # process last unterminated line (if any)
 198                                 process_line($pipe->{$n}->{'buf'}, $pipe->{$n}) if length $pipe->{$n}->{'buf'};
 199                         }
 200                 }
 201         }
 202 }
 203
 204 waitpid($child_pid, 0);
 205 $child_status = $?;
 206 $exit_status = WEXITSTATUS($child_status);
 207 $exit_status = 128 + WTERMSIG($child_status) if WIFSIGNALED($child_status);
 208 exit $exit_status;
 209
 210
 211 __END__
 212
 213 =pod
 214
 215 =head1 NAME
 216
 217 stdfilt - Run a command but filter its STDOUT and STDERR
 218
 219 =head1 SYNOPSIS
 220
 221 stdfilt [I<OPTIONS>] [--] I<COMMAND> [I<ARGS>]
 222
 223 =head1 OPTIONS
 224
 225 =over 4
 226
 227 =item -F, --filter-file I<FILE>
 228
 229 =item -o, -po, --pass-stdout I<PATTERN>
 230
 231 =item -e, -pe, --pass-stderr I<PATTERN>
 232
 233 =item -p, --pass I<PATTERN>
 234
 235 =item -O, -fo, --filter-stdout I<PATTERN>
 236
 237 =item -E, -fe, --filter-stderr I<PATTERN>
 238
 239 =item -f, --filter I<PATTERN>
 240
 241 =back
 242
 243 =head1 DESCRIPTION
 244
 245 Run I<COMMAND> and match each of its output lines (both stdout and stderr separately) against
 246 the given perl-compatible regexp (see perlre(1)) patterns.
 247
 248 =head1 FILTER FILE FORMAT
 249
 250 Empty and comment lines (starting with C<#> hashmark) are ignored as well as leading whitespace.
 251 Each line is either a filter pattern,
 252 or the literal string C<[stdout]>, C<[stderr]>, or C<[*]>,
 253 which indicates which standard fd will be filtered through the subsequent patterns.
 254 If not indicated, C<[*]> (all fd) is implied.
 255
 256 A pattern may start with an C<!> exclamation mark, in which case, the lines matching it,
 257 will be passed, not filtered.
 258
 259 =head1 SIGNALS
 260
 261 HUP - re-read filter files given at command line
 262
 263 =head1 SEE ALSO
 264
 265 grep(1), stdbuf(1), logwall(8), perlre(1)
 266
 267 =cut
 268
 269 EOF