2 # Copyright (c) 2017 University of Cambridge.
3 # See the file NOTICE for conditions of use and distribution.
6 # This variables should be set by the building process
7 my $spool = 'SPOOL_DIRECTORY'; # may be overridden later
8 my $exim = 'BIN_DIRECTORY/exim';
10 # Need to set this dynamically during build, but it's not used right now anyway.
11 my $charset = 'ISO-8859-1';
13 # use 'exipick --help' to view documentation for this program.
14 # Documentation also viewable online at
15 # http://www.exim.org/eximwiki/ToolExipickManPage
18 BEGIN { pop @INC if $INC[-1] eq '.' };
21 my($p_name) = $0 =~ m|/?([^/]+)$|;
22 my $p_version = "20100323.0";
23 my $p_usage = "Usage: $p_name [--help|--version] (see --help for details)";
25 Copyright (c) 2003-2010 John Jetmore <jj33\@pobox.com>
27 This program is free software; you can redistribute it and/or modify
28 it under the terms of the GNU General Public License as published by
29 the Free Software Foundation; either version 2 of the License, or
30 (at your option) any later version.
32 This program is distributed in the hope that it will be useful,
33 but WITHOUT ANY WARRANTY; without even the implied warranty of
34 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
35 GNU General Public License for more details.
37 You should have received a copy of the GNU General Public License
38 along with this program; if not, write to the Free Software
39 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
41 ext_usage(); # before we do anything else, check for --help
43 $| = 1; # unbuffer STDOUT
45 Getopt::Long::Configure("bundling_override");
47 'spool=s' => \$G::spool, # exim spool dir
48 'C|Config=s' => \$G::config, # use alternative Exim configuration file
49 'input-dir=s' => \$G::input_dir, # name of the "input" dir
50 'finput' => \$G::finput, # same as "--input-dir Finput"
51 'bp' => \$G::mailq_bp, # List the queue (noop - default)
52 'bpa' => \$G::mailq_bpa, # ... with generated address as well
53 'bpc' => \$G::mailq_bpc, # ... but just show a count of messages
54 'bpr' => \$G::mailq_bpr, # ... do not sort
55 'bpra' => \$G::mailq_bpra, # ... with generated addresses, unsorted
56 'bpru' => \$G::mailq_bpru, # ... only undelivered addresses, unsorted
57 'bpu' => \$G::mailq_bpu, # ... only undelivered addresses
58 'and' => \$G::and, # 'and' the criteria (default)
59 'or' => \$G::or, # 'or' the criteria
60 'f=s' => \$G::qgrep_f, # from regexp
61 'r=s' => \$G::qgrep_r, # recipient regexp
62 's=s' => \$G::qgrep_s, # match against size field
63 'y=s' => \$G::qgrep_y, # message younger than (secs)
64 'o=s' => \$G::qgrep_o, # message older than (secs)
65 'z' => \$G::qgrep_z, # frozen only
66 'x' => \$G::qgrep_x, # non-frozen only
67 'c' => \$G::qgrep_c, # display match count
68 'l' => \$G::qgrep_l, # long format (default)
69 'i' => \$G::qgrep_i, # message ids only
70 'b' => \$G::qgrep_b, # brief format
71 'size' => \$G::size_only, # sum the size of the matching msgs
72 'not' => \$G::negate, # flip every test
73 'R|reverse' => \$G::reverse, # reverse output (-R is qgrep option)
74 'sort=s' => \@G::sort, # allow you to choose variables to sort by
75 'freeze=s' => \$G::freeze, # freeze data in this file
76 'thaw=s' => \$G::thaw, # thaw data from this file
77 'unsorted' => \$G::unsorted, # unsorted, regardless of output format
78 'random' => \$G::random, # (poorly) randomize evaluation order
79 'flatq' => \$G::flatq, # brief format
80 'caseful' => \$G::caseful, # in '=' criteria, respect case
81 'caseless' => \$G::caseless, # ...ignore case (default)
82 'charset=s' => \$charset, # charset for $bh and $h variables
83 'show-vars=s' => \$G::show_vars, # display the contents of these vars
84 'just-vars' => \$G::just_vars, # only display vars, no other info
85 'show-rules' => \$G::show_rules, # display compiled match rules
86 'show-tests' => \$G::show_tests # display tests as applied to each message
89 # if both freeze and thaw specified, only thaw as it is less destructive
90 $G::freeze = undef if ($G::freeze && $G::thaw);
91 freeze_start() if ($G::freeze);
92 thaw_start() if ($G::thaw);
94 # massage sort options (make '$var,Var:' be 'var','var')
95 for (my $i = scalar(@G::sort)-1; $i >= 0; $i--) {
96 $G::sort[$i] = lc($G::sort[$i]);
97 $G::sort[$i] =~ s/[\$:\s]//g;
98 if ((my @vars = split(/,/, $G::sort[$i])) > 1) {
99 $G::sort[$i] = $vars[0]; shift(@vars); # replace current slot w/ first var
100 splice(@G::sort, $i+1, 0, @vars); # add other vars after current pos
103 push(@G::sort, "message_exim_id") if (@G::sort);
104 die "empty value provided to --sort not allowed, exiting\n"
105 if (grep /^\s*$/, @G::sort);
107 # massage the qgrep options into standard criteria
108 push(@ARGV, "\$sender_address =~ /$G::qgrep_f/") if ($G::qgrep_f);
109 push(@ARGV, "\$recipients =~ /$G::qgrep_r/") if ($G::qgrep_r);
110 push(@ARGV, "\$shown_message_size eq $G::qgrep_s") if ($G::qgrep_s);
111 push(@ARGV, "\$message_age < $G::qgrep_y") if ($G::qgrep_y);
112 push(@ARGV, "\$message_age > $G::qgrep_o") if ($G::qgrep_o);
113 push(@ARGV, "\$deliver_freeze") if ($G::qgrep_z);
114 push(@ARGV, "!\$deliver_freeze") if ($G::qgrep_x);
116 $G::mailq_bp = $G::mailq_bp; # shut up -w
117 $G::and = $G::and; # shut up -w
118 $G::msg_ids = {}; # short circuit when crit is only MID
119 $G::caseless = $G::caseful ? 0 : 1; # nocase by default, case if both
120 @G::recipients_crit = (); # holds per-recip criteria
121 $spool = defined $G::spool ? $G::spool
122 : do { chomp($_ = `$exim @{[defined $G::config ? "-C $G::config" : '']} -n -bP spool_directory`)
124 my $input_dir = $G::input_dir || ($G::finput ? "Finput" : "input");
125 my $count_only = 1 if ($G::mailq_bpc || $G::qgrep_c);
126 my $unsorted = 1 if ($G::mailq_bpr || $G::mailq_bpra ||
127 $G::mailq_bpru || $G::unsorted);
128 my $msg = $G::thaw ? thaw_message_list()
129 : get_all_msgs($spool, $input_dir, $unsorted,
130 $G::reverse, $G::random);
131 die "Problem accessing thaw file\n" if ($G::thaw && !$msg);
132 my $crit = process_criteria(\@ARGV);
133 my $e = Exim::SpoolFile->new();
134 my $tcount = 0 if ($count_only); # holds count of all messages
135 my $mcount = 0 if ($count_only); # holds count of matching messages
136 my $total_size = 0 if ($G::size_only);
137 $e->set_undelivered_only(1) if ($G::mailq_bpru || $G::mailq_bpu);
138 $e->set_show_generated(1) if ($G::mailq_bpra || $G::mailq_bpa);
139 $e->output_long() if ($G::qgrep_l);
140 $e->output_idonly() if ($G::qgrep_i);
141 $e->output_brief() if ($G::qgrep_b);
142 $e->output_flatq() if ($G::flatq);
143 $e->output_vars_only() if ($G::just_vars && $G::show_vars);
144 $e->set_show_vars($G::show_vars) if ($G::show_vars);
145 $e->set_spool($spool, $input_dir);
148 foreach my $m (@$msg) {
149 next if (scalar(keys(%$G::msg_ids)) && !$G::or
150 && !$G::msg_ids->{$m->{message}});
152 my $data = thaw_data();
153 if (!$e->restore_state($data)) {
154 warn "Couldn't thaw $data->{_message}: ".$e->error()."\n";
158 if (!$e->parse_message($m->{message}, $m->{path})) {
159 warn "Couldn't parse $m->{message}: ".$e->error()."\n";
166 foreach my $c (@G::recipients_crit) { # handle each_recip* vars
167 foreach my $addr (split(/, /, $e->get_var($c->{var}))) {
168 my %t = ( 'cmp' => $c->{cmp}, 'var' => $c->{var} );
169 $t{cmp} =~ s/"?\$var"?/'$addr'/;
170 push(@local_crit, \%t);
173 if ($G::show_tests) { print $e->get_var('message_exim_id'), "\n"; }
175 foreach my $c (@$crit, @local_crit) {
176 my $var = $e->get_var($c->{var});
177 my $ret = eval($c->{cmp});
178 if ($G::show_tests) {
179 printf " %25s = '%s'\n %25s => $ret\n",$c->{var},$var,$c->{cmp},$ret;
182 print STDERR "Error in eval '$c->{cmp}': $@\n";
186 if ($G::or) { last CRITERIA; }
187 else { next CRITERIA; }
189 if ($G::or) { next CRITERIA; }
194 # skip this message if any criteria were supplied and it didn't match
195 next MSG if ((scalar(@$crit) || scalar(@local_crit)) && !$match);
197 if ($count_only || $G::size_only) {
199 $total_size += $e->get_var('message_size');
202 # if we are defining criteria to sort on, save the message here. If
203 # we don't save here and do the sort later, we have a chicken/egg
205 push(@G::to_print, { vars => {}, output => "" });
206 foreach my $var (@G::sort) {
207 # save any values we want to sort on. I don't like doing the internal
208 # struct access here, but calling get_var a bunch can be _slow_ =(
209 $G::sort_type{$var} ||= '<=>';
210 $G::to_print[-1]{vars}{$var} = $e->{_vars}{$var};
211 $G::sort_type{$var} = 'cmp' if ($G::to_print[-1]{vars}{$var} =~ /\D/);
213 $G::to_print[-1]{output} = $e->format_message();
215 print $e->format_message();
220 freeze_data($e->get_state());
221 push(@G::frozen_msgs, $m);
226 msg_sort(\@G::to_print, \@G::sort, $G::reverse);
227 foreach my $msg (@G::to_print) {
228 print $msg->{output};
233 print "$mcount matches out of $tcount messages" .
234 ($G::size_only ? " ($total_size)" : "") . "\n";
235 } elsif ($G::mailq_bpc) {
236 print "$mcount" . ($G::size_only ? " ($total_size)" : "") . "\n";
237 } elsif ($G::size_only) {
238 print "$total_size\n";
242 freeze_message_list(\@G::frozen_msgs);
250 # sender_address_domain,shown_message_size
257 foreach my $v (@G::sort) {
258 push(@pieces, "\$a->{vars}{\"$v\"} $G::sort_type{$v} \$b->{vars}{\"$v\"}");
260 my $sort_str = join(" || ", @pieces);
262 @$msgs = sort { eval $sort_str } (@$msgs);
263 @$msgs = reverse(@$msgs) if ($reverse);
273 # FREEZE FILE FORMAT:
279 # message_list_bytes <- 10 bytes, zero-packed, plus \n
282 eval("use Storable");
283 die "Storable module not found: $@\n" if ($@);
284 open(O, ">$G::freeze") || die "Can't open freeze file $G::freeze: $!\n";
285 $G::freeze_handle = \*O;
289 close($G::freeze_handle);
293 eval("use Storable");
294 die "Storable module not found: $@\n" if ($@);
295 open(I, "<$G::thaw") || die "Can't open freeze file $G::thaw: $!\n";
296 $G::freeze_handle = \*I;
300 close($G::freeze_handle);
304 my $h = Storable::freeze($_[0]);
305 print $G::freeze_handle length($h)+1, "\n$h\n";
308 sub freeze_message_list {
309 my $h = Storable::freeze($_[0]);
310 my $l = length($h) + 1;
311 printf $G::freeze_handle "EOM\n$l\n$h\n%010d\n", $l+11+length($l)+1;
314 sub thaw_message_list {
315 my $orig_pos = tell($G::freeze_handle);
316 seek($G::freeze_handle, -11, 2);
317 chomp(my $bytes = <$G::freeze_handle>);
318 seek($G::freeze_handle, $bytes * -1, 2);
319 my $obj = thaw_data();
320 seek($G::freeze_handle, 0, $orig_pos);
326 chomp(my $bytes = <$G::freeze_handle>);
327 return(undef) if (!$bytes || $bytes eq 'EOM');
328 my $read = read(I, $obj, $bytes);
329 die "Format error in thaw file (expected $bytes bytes, got $read)\n"
330 if ($bytes != $read);
332 return(Storable::thaw($obj));
335 sub process_criteria {
341 foreach my $t ('@') { s/$t/\\$t/g; }
342 if (/^(.*?)\s+(<=|>=|==|!=|<|>)\s+(.*)$/) {
343 #print STDERR "found as integer\n";
344 my $v = $1; my $o = $2; my $n = $3;
345 if ($n =~ /^(-?[\d\.]+)M$/) { $n = $1 * 1024 * 1024; }
346 elsif ($n =~ /^(-?[\d\.]+)K$/) { $n = $1 * 1024; }
347 elsif ($n =~ /^(-?[\d\.]+)B?$/) { $n = $1; }
348 elsif ($n =~ /^(-?[\d\.]+)d$/) { $n = $1 * 60 * 60 * 24; }
349 elsif ($n =~ /^(-?[\d\.]+)h$/) { $n = $1 * 60 * 60; }
350 elsif ($n =~ /^(-?[\d\.]+)m$/) { $n = $1 * 60; }
351 elsif ($n =~ /^(-?[\d\.]+)s?$/) { $n = $1; }
353 print STDERR "Expression $_ did not parse: numeric comparison with ",
358 push(@c, { var => lc($v), cmp => "(\$var $o $n)" });
359 } elsif (/^(.*?)\s+(=~|!~)\s+(.*)$/) {
360 #print STDERR "found as string regexp\n";
361 push(@c, { var => lc($1), cmp => "(\"\$var\" $2 $3)" });
362 } elsif (/^(.*?)\s+=\s+(.*)$/) {
363 #print STDERR "found as bare string regexp\n";
364 my $case = $G::caseful ? '' : 'i';
365 push(@c, { var => lc($1), cmp => "(\"\$var\" =~ /$2/$case)" });
366 # quote special characters in perl text string
367 #foreach my $t ('@') { $c[-1]{cmp} =~ s/$t/\\$t/g; }
368 } elsif (/^(.*?)\s+(eq|ne)\s+(.*)$/) {
369 #print STDERR "found as string cmp\n";
370 my $var = lc($1); my $op = $2; my $val = $3;
371 $val =~ s|^(['"])(.*)\1$|$2|;
372 push(@c, { var => $var, cmp => "(\"\$var\" $op \"$val\")" });
373 if (($var eq 'message_id' || $var eq 'message_exim_id') && $op eq "eq") {
374 #print STDERR "short circuit @c[-1]->{cmp} $val\n";
375 $G::msg_ids->{$val} = 1;
377 #foreach my $t ('@') { $c[-1]{cmp} =~ s/$t/\\$t/g; }
378 } elsif (/^(\S+)$/) {
379 #print STDERR "found as boolean\n";
380 push(@c, { var => lc($1), cmp => "(\$var)" });
382 print STDERR "Expression $_ did not parse\n";
386 # assign the results of the cmp test here (handle "!" negation)
387 # also handle global --not negation
388 if ($c[-1]{var} =~ s|^!||) {
389 $c[-1]{cmp} .= $G::negate ? " ? 1 : 0" : " ? 0 : 1";
391 $c[-1]{cmp} .= $G::negate ? " ? 0 : 1" : " ? 1 : 0";
393 # support the each_* pseudo variables. Steal the criteria off of the
394 # queue for special processing later
395 if ($c[-1]{var} =~ /^each_(recipients(_(un)?del)?)$/) {
397 push(@G::recipients_crit,pop(@c));
398 $G::recipients_crit[-1]{var} = $var; # remove each_ from the variable
404 if ($G::show_rules) { foreach (@c) { print "$_->{var}\t$_->{cmp}\n"; } }
412 my $u = shift; # don't sort
413 my $r = shift; # right before returning, reverse order
414 my $o = shift; # if true, randomize list order before returning
417 if ($i =~ m|^/|) { $d = $i; } else { $d = $d . '/' . $i; }
419 opendir(D, "$d") || die "Couldn't opendir $d: $!\n";
420 foreach my $e (grep !/^\./, readdir(D)) {
421 if ($e =~ /^[a-zA-Z0-9]$/) {
422 opendir(DD, "$d/$e") || next;
423 foreach my $f (grep !/^\./, readdir(DD)) {
424 push(@m, { message => $1, path => "$d/$e" }) if ($f =~ /^(.{16})-H$/);
427 } elsif ($e =~ /^(.{16})-H$/) {
428 push(@m, { message => $1, path => $d });
435 # loop twice to pretend we're doing a good job of mixing things up
436 for (my $i = 0; $i < 2 * $c; $i++) {
437 my $rand = int(rand($c));
438 ($m[$i % $c],$m[$rand]) = ($m[$rand],$m[$i % $c]);
441 @m = sort { $a->{message} cmp $b->{message} } @m;
443 @m = reverse(@m) if ($r);
450 package Exim::SpoolFile;
452 # versions 4.61 and higher will not need these variables anymore, but they
453 # are left for handling legacy installs
454 $Exim::SpoolFile::ACL_C_MAX_LEGACY = 10;
455 #$Exim::SpoolFile::ACL_M_MAX _LEGACY= 10;
460 bless($self, $class);
462 $self->{_spool_dir} = '';
463 $self->{_input_path} = '';
464 $self->{_undelivered_only} = 0;
465 $self->{_show_generated} = 0;
466 $self->{_output_long} = 1;
467 $self->{_output_idonly} = 0;
468 $self->{_output_brief} = 0;
469 $self->{_output_flatq} = 0;
470 $self->{_output_vars_only} = 0;
471 $self->{_show_vars} = [];
480 $self->{_output_long} = 1;
481 $self->{_output_idonly} = 0;
482 $self->{_output_brief} = 0;
483 $self->{_output_flatq} = 0;
484 $self->{_output_vars_only} = 0;
490 $self->{_output_long} = 0;
491 $self->{_output_idonly} = 1;
492 $self->{_output_brief} = 0;
493 $self->{_output_flatq} = 0;
494 $self->{_output_vars_only} = 0;
500 $self->{_output_long} = 0;
501 $self->{_output_idonly} = 0;
502 $self->{_output_brief} = 1;
503 $self->{_output_flatq} = 0;
504 $self->{_output_vars_only} = 0;
510 $self->{_output_long} = 0;
511 $self->{_output_idonly} = 0;
512 $self->{_output_brief} = 0;
513 $self->{_output_flatq} = 1;
514 $self->{_output_vars_only} = 0;
517 sub output_vars_only {
520 $self->{_output_long} = 0;
521 $self->{_output_idonly} = 0;
522 $self->{_output_brief} = 0;
523 $self->{_output_flatq} = 0;
524 $self->{_output_vars_only} = 1;
531 foreach my $v (split(/\s*,\s*/, $s)) {
532 push(@{$self->{_show_vars}}, $v);
536 sub set_show_generated {
538 $self->{_show_generated} = shift;
541 sub set_undelivered_only {
543 $self->{_undelivered_only} = shift;
548 return $self->{_error};
553 $self->{_error} = shift;
560 $self->{_error} = '';
561 $self->{_delivered} = 0;
562 $self->{_message} = '';
565 $self->{_vars_raw} = {};
567 $self->{_numrecips} = 0;
568 $self->{_udel_tree} = {};
569 $self->{_del_tree} = {};
570 $self->{_recips} = {};
579 $self->{_message} = shift || return(0);
580 $self->{_path} = shift; # optional path to message
581 return(0) if (!$self->{_input_path});
582 if (!$self->{_path} && !$self->_find_path()) {
583 # assume the message was delivered from under us and ignore
584 $self->{_delivered} = 1;
587 $self->_parse_header() || return(0);
592 # take the output of get_state() and set up a message internally like
593 # parse_message (except from a saved data struct, not by parsing the
599 return(1) if ($h->{_delivered});
601 $self->{_message} = $h->{_message} || return(0);
602 return(0) if (!$self->{_input_path});
604 $self->{_path} = $h->{_path};
605 $self->{_vars} = $h->{_vars};
606 $self->{_numrecips} = $h->{_numrecips};
607 $self->{_udel_tree} = $h->{_udel_tree};
608 $self->{_del_tree} = $h->{_del_tree};
609 $self->{_recips} = $h->{_recips};
611 $self->{_vars}{message_age} = time() - $self->{_vars}{received_time};
615 # This returns the state data for a specific message in a format that can
616 # be later frozen back in to regain state
618 # after calling this function, this specific state is not expect to be
619 # reused. That's because we're returning direct references to specific
620 # internal structures. We're also modifying the structure ourselves
621 # by deleting certain internal message variables.
624 my $h = {}; # this is the hash ref we'll be returning.
626 $h->{_delivered} = $self->{_delivered};
627 $h->{_message} = $self->{_message};
628 $h->{_path} = $self->{_path};
629 $h->{_vars} = $self->{_vars};
630 $h->{_numrecips} = $self->{_numrecips};
631 $h->{_udel_tree} = $self->{_udel_tree};
632 $h->{_del_tree} = $self->{_del_tree};
633 $h->{_recips} = $self->{_recips};
635 # delete some internal variables that we will rebuild later if needed
636 delete($h->{_vars}{message_body});
637 delete($h->{_vars}{message_age});
642 # keep this sub as a feature if we ever break this module out, but do away
643 # with its use in exipick (pass it in from caller instead)
647 return(0) if (!$self->{_message});
648 return(0) if (!$self->{_input_path});
650 # test split spool first on the theory that people concerned about
651 # performance will have split spool set =).
652 foreach my $f (substr($self->{_message}, 5, 1).'/', '') {
653 if (-f "$self->{_input_path}/$f$self->{_message}-H") {
654 $self->{_path} = "$self->{_input_path}}/$f";
663 $self->{_spool_dir} = shift;
664 $self->{_input_path} = shift;
665 if ($self->{_input_path} !~ m|^/|) {
666 $self->{_input_path} = $self->{_spool_dir} . '/' . $self->{_input_path};
670 sub get_matching_vars {
676 foreach my $v (keys %{$self->{_vars}}) { push(@r, $v) if ($v =~ /$e/); }
683 # accepts a variable with or without leading '$' or trailing ':'
686 my $var = lc(shift); $var =~ s/^\$//; $var =~ s/:$//;
688 if ($var eq 'message_body' && !defined($self->{_vars}{message_body})) {
690 } elsif ($var =~ s|^([rb]?h)(eader)?_|${1}eader_| &&
691 exists($self->{_vars}{$var}) && !defined($self->{_vars}{$var}))
693 if ((my $type = $1) eq 'rh') {
694 $self->{_vars}{$var} = join('', @{$self->{_vars_raw}{$var}{vals}});
696 # both bh_ and h_ build their strings from rh_. Do common work here
697 my $rh = $var; $rh =~ s|^b?|r|;
698 my $comma = 1 if ($self->{_vars_raw}{$rh}{type} =~ /^[BCFRST]$/);
699 foreach (@{$self->{_vars_raw}{$rh}{vals}}) {
700 my $x = $_; # editing $_ here would change the original, which is bad
703 if ($comma) { chomp($x); $self->{_vars}{$var} .= "$x,\n"; }
704 else { $self->{_vars}{$var} .= $x; }
706 $self->{_vars}{$var} =~ s|[\s\n]*$||;
707 $self->{_vars}{$var} =~ s|,$|| if ($comma);
708 # ok, that's the preprocessing, not do specific processing for h type
710 $self->{_vars}{$var} = $self->_decode_2047($self->{_vars}{$var});
712 $self->{_vars}{$var} =
713 $self->_decode_2047($self->{_vars}{$var}, $charset);
717 elsif ($var eq 'received_count' && !defined($self->{_vars}{received_count}))
719 $self->{_vars}{received_count} =
720 scalar(@{$self->{_vars_raw}{rheader_received}{vals}});
722 elsif ($var eq 'message_headers' && !defined($self->{_vars}{message_headers}))
724 $self->{_vars}{$var} =
725 $self->_decode_2047($self->{_vars}{message_headers_raw}, $charset);
726 chomp($self->{_vars}{$var});
728 elsif ($var eq 'reply_address' && !defined($self->{_vars}{reply_address}))
730 $self->{_vars}{reply_address} = exists($self->{_vars}{"header_reply-to"})
731 ? $self->get_var("header_reply-to") : $self->get_var("header_from");
734 #chomp($self->{_vars}{$var}); # I think this was only for headers, obsolete
735 return $self->{_vars}{$var};
740 my $s = shift; # string to decode
741 my $c = shift; # target charset. If empty, just decode, don't convert
742 my $t = ''; # the translated string
743 my $e = 0; # set to true if we get an error in here anywhere
745 return($s) if ($s !~ /=\?/); # don't even bother to look if there's no sign
748 foreach my $mw (split(/(=\?[^\?]{3,}\?[BQ]\?[^\?]{1,74}\?=)/i, $s)) {
750 if ($mw =~ /=\?([^\?]{3,})\?([BQ])\?([^\?]{1,74})\?=/i) {
751 push(@p, { data => $3, encoding => uc($2), charset => uc($1),
753 if ($p[-1]{encoding} eq 'Q') {
754 my @ow = split('', $p[-1]{data});
756 for (my $i = 0; $i < @ow; $i++) {
757 if ($ow[$i] eq '_') { push(@nw, ' '); }
758 elsif ($ow[$i] eq '=') {
759 if (scalar(@ow) - ($i+1) < 2) { # ran out of characters
761 } elsif ($ow[$i+1] !~ /[\dA-F]/i || $ow[$i+2] !~ /[\dA-F]/i) {
764 #push(@nw, chr('0x'.$ow[$i+1].$ow[$i+2]));
765 push(@nw, pack("C", hex($ow[$i+1].$ow[$i+2])));
769 elsif ($ow[$i] =~ /\s/) { # whitespace is illegal
773 else { push(@nw, $ow[$i]); }
775 $p[-1]{data} = join('', @nw);
776 } elsif ($p[-1]{encoding} eq 'B') {
777 my $x = $p[-1]{data};
778 $x =~ tr#A-Za-z0-9+/##cd;
780 $x =~ tr#A-Za-z0-9+/# -_#;
782 while ($x =~ s/(.{1,60})//s) {
783 $r .= unpack("u", chr(32 + int(length($1)*3/4)) . $1);
788 push(@p, { data => $mw, is_mime => 0,
789 is_ws => ($mw =~ m|^[\s\n]+|sm) ? 1 : 0 });
793 for (my $i = 0; $i < @p; $i++) {
794 # mark entities we want to skip (whitespace between consecutive mimewords)
795 if ($p[$i]{is_mime} && $p[$i+1]{is_ws} && $p[$i+2]{is_mime}) {
799 # if word is a mimeword and we have access to Encode and charset was
800 # specified, try to convert text
801 # XXX _cannot_ get consistent conversion results in perl, can't get them
802 # to return same conversions that exim performs. Until I can figure this
803 # out, don't attempt any conversions (header_ will return same value as
805 #if ($c && $p[$i]{is_mime} && $self->_try_load('Encode')) {
806 # # XXX not sure how to catch errors here
807 # Encode::from_to($p[$i]{data}, $p[$i]{charset}, $c);
810 # replace binary zeros w/ '?' in decoded text
811 if ($p[$i]{is_mime}) { $p[$i]{data} =~ s|\x00|?|g; }
817 return(join('', map { $_->{data} } grep { !$_->{skip} } @p));
821 # This isn't a class func but I'm tired
832 my $f = $self->{_path} . '/' . $self->{_message} . '-D';
833 $self->{_vars}{message_body} = ""; # define var so we only come here once
835 open(I, "<$f") || return($self->_error("Couldn't open $f: $!"));
837 return(0) if ($self->{_message}.'-D' ne $_);
839 $self->{_vars}{message_body} = join('', <I>);
841 $self->{_vars}{message_body} =~ s/\n/ /g;
842 $self->{_vars}{message_body} =~ s/\000/ /g;
848 my $f = $self->{_path} . '/' . $self->{_message} . '-H';
849 $self->{_vars}{header_path} = $f;
850 $self->{_vars}{data_path} = $self->{_path} . '/' . $self->{_message} . '-D';
852 if (!open(I, "<$f")) {
853 # assume message went away and silently ignore
854 $self->{_delivered} = 1;
858 # There are a few numeric variables that should explicitly be set to
859 # zero if they aren't found in the header. Technically an empty value
860 # works just as well, but might as well be pedantic
861 $self->{_vars}{body_zerocount} = 0;
862 $self->{_vars}{host_lookup_deferred} = 0;
863 $self->{_vars}{host_lookup_failed} = 0;
864 $self->{_vars}{tls_certificate_verified} = 0;
867 return(0) if ($self->{_message}.'-H' ne $_);
868 $self->{_vars}{message_id} = $self->{_message};
869 $self->{_vars}{message_exim_id} = $self->{_message};
873 return(0) if (!/^(.+)\s(\-?\d+)\s(\-?\d+)$/);
874 $self->{_vars}{originator_login} = $1;
875 $self->{_vars}{originator_uid} = $2;
876 $self->{_vars}{originator_gid} = $3;
880 return(0) if (!/^<(.*)>$/);
881 $self->{_vars}{sender_address} = $1;
882 $self->{_vars}{sender_address_domain} = $1;
883 $self->{_vars}{sender_address_local_part} = $1;
884 $self->{_vars}{sender_address_domain} =~ s/^.*\@//;
885 $self->{_vars}{sender_address_local_part} =~ s/^(.*)\@.*$/$1/;
889 return(0) if (!/^(\d+)\s(\d+)$/);
890 $self->{_vars}{received_time} = $1;
891 $self->{_vars}{warning_count} = $2;
892 $self->{_vars}{message_age} = time() - $self->{_vars}{received_time};
896 if (/^(-\S+)\s*(.*$)/) {
899 if ($tag eq '-acl') {
901 return(0) if ($arg !~ /^(\d+)\s(\d+)$/);
902 if ($1 < $Exim::SpoolFile::ACL_C_MAX_LEGACY) {
905 $t = "acl_m" . ($1 - $Exim::SpoolFile::ACL_C_MAX_LEGACY);
907 read(I, $self->{_vars}{$t}, $2+1) || return(0);
908 chomp($self->{_vars}{$t});
909 } elsif ($tag eq '-aclc') {
910 #return(0) if ($arg !~ /^(\d+)\s(\d+)$/);
911 return(0) if ($arg !~ /^(\S+)\s(\d+)$/);
913 read(I, $self->{_vars}{$t}, $2+1) || return(0);
914 chomp($self->{_vars}{$t});
915 } elsif ($tag eq '-aclm') {
916 #return(0) if ($arg !~ /^(\d+)\s(\d+)$/);
917 return(0) if ($arg !~ /^(\S+)\s(\d+)$/);
919 read(I, $self->{_vars}{$t}, $2+1) || return(0);
920 chomp($self->{_vars}{$t});
921 } elsif ($tag eq '-local') {
922 $self->{_vars}{sender_local} = 1;
923 } elsif ($tag eq '-localerror') {
924 $self->{_vars}{local_error_message} = 1;
925 } elsif ($tag eq '-local_scan') {
926 $self->{_vars}{local_scan_data} = $arg;
927 } elsif ($tag eq '-spam_score_int') {
928 $self->{_vars}{spam_score_int} = $arg;
929 $self->{_vars}{spam_score} = $arg / 10;
930 } elsif ($tag eq '-bmi_verdicts') {
931 $self->{_vars}{bmi_verdicts} = $arg;
932 } elsif ($tag eq '-host_lookup_deferred') {
933 $self->{_vars}{host_lookup_deferred} = 1;
934 } elsif ($tag eq '-host_lookup_failed') {
935 $self->{_vars}{host_lookup_failed} = 1;
936 } elsif ($tag eq '-body_linecount') {
937 $self->{_vars}{body_linecount} = $arg;
938 } elsif ($tag eq '-max_received_linelength') {
939 $self->{_vars}{max_received_linelength} = $arg;
940 } elsif ($tag eq '-body_zerocount') {
941 $self->{_vars}{body_zerocount} = $arg;
942 } elsif ($tag eq '-frozen') {
943 $self->{_vars}{deliver_freeze} = 1;
944 $self->{_vars}{deliver_frozen_at} = $arg;
945 } elsif ($tag eq '-allow_unqualified_recipient') {
946 $self->{_vars}{allow_unqualified_recipient} = 1;
947 } elsif ($tag eq '-allow_unqualified_sender') {
948 $self->{_vars}{allow_unqualified_sender} = 1;
949 } elsif ($tag eq '-deliver_firsttime') {
950 $self->{_vars}{deliver_firsttime} = 1;
951 $self->{_vars}{first_delivery} = 1;
952 } elsif ($tag eq '-manual_thaw') {
953 $self->{_vars}{deliver_manual_thaw} = 1;
954 $self->{_vars}{manually_thawed} = 1;
955 } elsif ($tag eq '-auth_id') {
956 $self->{_vars}{authenticated_id} = $arg;
957 } elsif ($tag eq '-auth_sender') {
958 $self->{_vars}{authenticated_sender} = $arg;
959 } elsif ($tag eq '-sender_set_untrusted') {
960 $self->{_vars}{sender_set_untrusted} = 1;
961 } elsif ($tag eq '-tls_certificate_verified') {
962 $self->{_vars}{tls_certificate_verified} = 1;
963 } elsif ($tag eq '-tls_cipher') {
964 $self->{_vars}{tls_cipher} = $arg;
965 } elsif ($tag eq '-tls_peerdn') {
966 $self->{_vars}{tls_peerdn} = $arg;
967 } elsif ($tag eq '-tls_sni') {
968 $self->{_vars}{tls_sni} = $arg;
969 } elsif ($tag eq '-host_address') {
970 $self->{_vars}{sender_host_port} = $self->_get_host_and_port(\$arg);
971 $self->{_vars}{sender_host_address} = $arg;
972 } elsif ($tag eq '-interface_address') {
973 $self->{_vars}{received_port} =
974 $self->{_vars}{interface_port} = $self->_get_host_and_port(\$arg);
975 $self->{_vars}{received_ip_address} =
976 $self->{_vars}{interface_address} = $arg;
977 } elsif ($tag eq '-active_hostname') {
978 $self->{_vars}{smtp_active_hostname} = $arg;
979 } elsif ($tag eq '-host_auth') {
980 $self->{_vars}{sender_host_authenticated} = $arg;
981 } elsif ($tag eq '-host_name') {
982 $self->{_vars}{sender_host_name} = $arg;
983 } elsif ($tag eq '-helo_name') {
984 $self->{_vars}{sender_helo_name} = $arg;
985 } elsif ($tag eq '-ident') {
986 $self->{_vars}{sender_ident} = $arg;
987 } elsif ($tag eq '-received_protocol') {
988 $self->{_vars}{received_protocol} = $arg;
989 } elsif ($tag eq '-N') {
990 $self->{_vars}{dont_deliver} = 1;
992 # unrecognized tag, save it for reference
993 $self->{$tag} = $arg;
1000 # when we drop out of the while loop, we have the first line of the
1001 # delivered tree in $_
1005 } elsif ($_ =~ s/^[YN][YN]\s+//) {
1006 $self->{_del_tree}{$_} = 1;
1011 } while ($_ !~ /^\d+$/);
1013 $self->{_numrecips} = $_;
1014 $self->{_vars}{recipients_count} = $self->{_numrecips};
1015 for (my $i = 0; $i < $self->{_numrecips}; $i++) {
1017 return(0) if (/^$/);
1019 if (/^(.*)\s\d+,(\d+),\d+$/) {
1020 #print STDERR "exim3 type (untested): $_\n";
1021 $self->{_recips}{$1} = { pno => $2 };
1023 } elsif (/^(.*)\s(\d+)$/) {
1024 #print STDERR "exim4 original type (untested): $_\n";
1025 $self->{_recips}{$1} = { pno => $2 };
1027 } elsif (/^(.*)\s(.*)\s(\d+),(\d+)#1$/) {
1028 #print STDERR "exim4 new type #1 (untested): $_\n";
1029 return($self->_error("incorrect format: $_")) if (length($2) != $3);
1030 $self->{_recips}{$1} = { pno => $4, errors_to => $2 };
1032 } elsif (/^(\S*)\s(\S*)\s(\d+),(\d+)\s(\S*)\s(\d+),(-?\d+)#3$/) {
1033 #print STDERR "exim4 new type #3 DSN (untested): $_\n";
1034 return($self->_error("incorrect format: $_"))
1035 if ((length($2) != $3) || (length($5) != $6));
1036 $self->{_recips}{$1} = { pno => $7, errors_to => $5 };
1038 } elsif (/^.*#(\d+)$/) {
1039 #print STDERR "exim4 #$1 style (unimplemented): $_\n";
1040 $self->_error("exim4 #$1 style (unimplemented): $_");
1042 #print STDERR "default type: $_\n";
1043 $self->{_recips}{$_} = {};
1046 $self->{_udel_tree}{$addr} = 1 if (!$self->{_del_tree}{$addr});
1048 $self->{_vars}{recipients} = join(', ', keys(%{$self->{_recips}}));
1049 $self->{_vars}{recipients_del} = join(', ', keys(%{$self->{_del_tree}}));
1050 $self->{_vars}{recipients_undel} = join(', ', keys(%{$self->{_udel_tree}}));
1051 $self->{_vars}{recipients_undel_count} = scalar(keys(%{$self->{_udel_tree}}));
1052 $self->{_vars}{recipients_del_count} = 0;
1053 foreach my $r (keys %{$self->{_del_tree}}) {
1054 next if (!$self->{_recips}{$r});
1055 $self->{_vars}{recipients_del_count}++;
1060 return(0) if (!/^$/);
1062 # start reading headers
1063 while (read(I, $_, 3) == 3) {
1065 return(0) if (!length($t));
1066 while ($t =~ /^\d$/) {
1072 $t = getc(I); # strip the space out of the file
1073 return(0) if (read(I, $_, $hdr_bytes) != $hdr_bytes);
1074 if ($hdr_flag ne '*') {
1075 $self->{_vars}{message_linecount} += (tr/\n//);
1076 $self->{_vars}{message_size} += $hdr_bytes;
1079 # mark (rb)?header_ vars as existing and store raw value. They'll be
1080 # processed further in get_var() if needed
1081 my($v,$d) = split(/:/, $_, 2);
1082 $v = "header_" . lc($v);
1083 $self->{_vars}{$v} = $self->{_vars}{"b$v"} = $self->{_vars}{"r$v"} = undef;
1084 push(@{$self->{_vars_raw}{"r$v"}{vals}}, $d);
1085 $self->{_vars_raw}{"r$v"}{type} = $hdr_flag;
1086 $self->{_vars}{message_headers_raw} .= $_;
1090 $self->{_vars}{message_body_size} =
1091 (stat($self->{_path}.'/'.$self->{_message}.'-D'))[7] - 19;
1092 if ($self->{_vars}{message_body_size} < 0) {
1093 $self->{_vars}{message_size} = 0;
1094 $self->{_vars}{message_body_missing} = 1;
1096 $self->{_vars}{message_size} += $self->{_vars}{message_body_size} + 1;
1099 $self->{_vars}{message_linecount} += $self->{_vars}{body_linecount};
1101 my $i = $self->{_vars}{message_size};
1102 if ($i == 0) { $i = ""; }
1103 elsif ($i < 1024) { $i = sprintf("%d", $i); }
1104 elsif ($i < 10240) { $i = sprintf("%.1fK", $i / 1024); }
1105 elsif ($i < 1048576) { $i = sprintf("%dK", ($i+512)/1024); }
1106 elsif ($i < 10485760) { $i = sprintf("%.1fM", $i/1048576); }
1107 else { $i = sprintf("%dM", ($i + 524288)/1048576); }
1108 $self->{_vars}{shown_message_size} = $i;
1113 # mimic exim's host_extract_port function - receive a ref to a scalar,
1114 # strip it of port, return port
1115 sub _get_host_and_port {
1117 my $host = shift; # scalar ref, be careful
1119 if ($$host =~ /^\[([^\]]+)\](?:\:(\d+))?$/) {
1122 } elsif ($$host =~ /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(?:\.(\d+))?$/) {
1125 } elsif ($$host =~ /^([\d\:]+)(?:\.(\d+))?$/) {
1133 # honoring all formatting preferences, return a scalar variable of the
1134 # information for the single message matching what exim -bp would show.
1135 # We can print later if we want.
1136 sub format_message {
1139 return if ($self->{_delivered});
1141 # define any vars we want to print out for this message. The requests
1142 # can be regexps, and the defined vars can change for each message, so we
1143 # have to build this list for each message
1145 if (@{$self->{_show_vars}}) {
1147 foreach my $e (@{$self->{_show_vars}}) {
1148 foreach my $v ($self->get_matching_vars($e)) {
1149 next if ($t{$v}); $t{$v}++; push(@vars, $v);
1154 if ($self->{_output_idonly}) {
1155 $o .= $self->{_message};
1156 foreach my $v (@vars) { $o .= " $v='" . $self->get_var($v) . "'"; }
1159 } elsif ($self->{_output_vars_only}) {
1160 foreach my $v (@vars) { $o .= $self->get_var($v) . "\n"; }
1164 if ($self->{_output_long} || $self->{_output_flatq}) {
1165 my $i = int($self->{_vars}{message_age} / 60);
1167 $i = int(($i+30)/60);
1168 if ($i > 72) { $o .= sprintf "%2dd ", int(($i+12)/24); }
1169 else { $o .= sprintf "%2dh ", $i; }
1170 } else { $o .= sprintf "%2dm ", $i; }
1172 if ($self->{_output_flatq} && @vars) {
1173 $o .= join(';', map { "$_='".$self->get_var($_)."'" } (@vars)
1176 $o .= sprintf "%5s", $self->{_vars}{shown_message_size};
1180 $o .= "$self->{_message} ";
1181 $o .= "From: " if ($self->{_output_brief});
1182 $o .= "<$self->{_vars}{sender_address}>";
1184 if ($self->{_output_long}) {
1185 $o .= " ($self->{_vars}{originator_login})"
1186 if ($self->{_vars}{sender_set_untrusted});
1188 # XXX exim contains code here to print spool format errors
1189 $o .= " *** frozen ***" if ($self->{_vars}{deliver_freeze});
1192 foreach my $v (@vars) {
1193 $o .= sprintf " %25s = '%s'\n", $v, $self->get_var($v);
1196 foreach my $r (keys %{$self->{_recips}}) {
1197 next if ($self->{_del_tree}{$r} && $self->{_undelivered_only});
1198 $o .= sprintf " %s %s\n", $self->{_del_tree}{$r} ? "D" : " ", $r;
1200 if ($self->{_show_generated}) {
1201 foreach my $r (keys %{$self->{_del_tree}}) {
1202 next if ($self->{_recips}{$r});
1203 $o .= sprintf " +D %s\n", $r;
1206 } elsif ($self->{_output_brief}) {
1208 foreach my $r (keys %{$self->{_recips}}) {
1209 next if ($self->{_del_tree}{$r});
1212 $o .= " To: " . join(';', @r);
1213 if (scalar(@vars)) {
1214 $o .= " Vars: ".join(';',map { "$_='".$self->get_var($_)."'" } (@vars));
1216 } elsif ($self->{_output_flatq}) {
1217 $o .= " *** frozen ***" if ($self->{_vars}{deliver_freeze});
1219 foreach my $r (keys %{$self->{_recips}}) {
1220 next if ($self->{_del_tree}{$r});
1223 $o .= " " . join(' ', @r);
1232 my $fh = shift || \*STDOUT;
1233 return if ($self->{_delivered});
1235 print $fh $self->format_message();
1241 foreach my $k (sort keys %$self) {
1242 my $r = ref($self->{$k});
1243 if ($r eq 'ARRAY') {
1244 printf "%20s <<EOM\n", $k;
1245 print @{$self->{$k}}, "EOM\n";
1246 } elsif ($r eq 'HASH') {
1247 printf "%20s <<EOM\n", $k;
1248 foreach (sort keys %{$self->{$k}}) {
1249 printf "%20s %s\n", $_, $self->{$k}{$_};
1253 printf "%20s %s\n", $k, $self->{$k};
1261 if ($ARGV[0] =~ /^--help$/i) {
1263 $ENV{PATH} .= ":" unless $ENV{PATH} eq "";
1264 $ENV{PATH} = "$ENV{PATH}$Config::Config{'installscript'}";
1265 #exec("perldoc", "-F", "-U", $0) || exit 1;
1266 $< = $> = 1 if ($> == 0 || $< == 0);
1267 exec("perldoc", $0) || exit 1;
1269 %Config::Config = ();
1270 } elsif ($ARGV[0] =~ /^--version$/i) {
1271 print "$p_name version $p_version\n\n$p_cp\n";
1283 exipick - selectively display messages from an Exim queue
1287 exipick [<options>] [<criterion> [<criterion> ...]]
1291 exipick is a tool to display messages in an Exim queue. It is very similar to exiqgrep and is, in fact, a drop in replacement for exiqgrep. exipick allows you to select messages to be displayed using any piece of data stored in an Exim spool file. Matching messages can be displayed in a variety of formats.
1295 Delete every frozen message from queue:
1296 exipick -zi | xargs exim -Mrm
1298 Show only messages which have not yet been virus scanned:
1299 exipick '$received_protocol ne virus-scanned'
1301 Run the queue in a semi-random order:
1302 exipick -i --random | xargs exim -M
1304 Show the count and total size of all messages which either originated from localhost or have a received protocol of 'local':
1305 exipick --or --size --bpc \
1306 '$sender_host_address eq 127.0.0.1' \
1307 '$received_protocol eq local'
1309 Display all messages received on the MSA port, ordered first by the sender's email domain and then by the size of the emails:
1310 exipick --sort sender_address_domain,message_size \
1311 '$received_port == 587'
1313 Display only messages whose every recipient is in the example.com domain, also listing the IP address of the sending host:
1314 exipick --show-vars sender_host_address \
1315 '$each_recipients = example.com'
1317 Same as above, but show values for all defined variables starting with sender_ and the number of recipients:
1318 exipick --show-vars ^sender_,recipients_count \
1319 '$each_recipients = example.com'
1327 Display messages matching all criteria (default)
1331 Display messages in brief format (exiqgrep)
1335 Display messages in standard mailq format (default)
1339 Same as -bp, show generated addresses also (exim)
1343 Show a count of matching messages (exim)
1347 Same as '-bp --unsorted' (exim)
1351 Same as '-bpa --unsorted' (exim)
1355 Same as '-bpu --unsorted' (exim)
1359 Same as -bp, but only show undelivered messages (exim)
1361 =item -C | --config <config>
1363 Use <config> to determine the proper spool directory. (See C<--spool>
1364 or C<--input> for alternative ways to specify the directories to operate on.)
1368 Show a count of matching messages (exiqgrep)
1372 Make operators involving '=' honor case
1376 Override the default local character set for $header_ decoding
1380 Same as '$sender_address =~ /<regexp>/' (exiqgrep). Note that this preserves the default case sensitivity of exiqgrep's interface.
1384 Same as '--input-dir Finput'. 'Finput' is where exim copies frozen messages when compiled with SUPPORT_MOVE_FROZEN_MESSAGES.
1388 Use a single-line output format
1390 =item --freeze <cache file>
1392 Save queue information in an quickly retrievable format
1400 Display only the message IDs (exiqgrep)
1402 =item --input-dir <inputname>
1404 Set the name of the directory under the spool directory. By default this is "input". If this starts with '/', the value of --spool is ignored. See also --finput.
1408 Same as -bp (exiqgrep)
1416 Same as '$message_age > <seconds>' (exiqgrep)
1420 Display messages matching any criteria
1424 Same as --reverse (exiqgrep)
1428 Same as '$recipients =~ /<regexp>/' (exiqgrep). Note that this preserves the default case sensitivity of exiqgrep's interface.
1432 Display messages in random order
1436 Display messages in reverse order
1440 Same as '$shown_message_size eq <string>' (exiqgrep)
1442 =item --spool <path>
1444 Set the path to the exim spool to use. This value will have the argument to --input or 'input' appended, or be ignored if --input is a full path. If not specified, exipick uses the value from C<exim [-C config] -n -bP spool_directory>, and if this call fails, the F</opt/exim/spool> from build time (F<Local/Makefile>) is used. See also --config.
1448 Show the internal representation of each criterion specified
1452 Show the result of each criterion on each message
1454 =item --show-vars <variable>[,<variable>...]
1456 Show the value for <variable> for each displayed message. <variable> will be a regular expression if it begins with a circumflex.
1460 Show the total bytes used by each displayed message
1462 =item --thaw <cache file>
1464 Read queue information cached from a previous --freeze run
1466 =item --sort <variable>[,<variable>...]
1468 Display matching messages sorted according to <variable>
1472 Do not apply any sorting to output
1476 Display the version of this command
1480 Same as '!$deliver_freeze' (exiqgrep)
1484 Same as '$message_age < <seconds>' (exiqgrep)
1488 Same as '$deliver_freeze' (exiqgrep)
1494 Exipick decides which messages to display by applying a test against each message. The rules take the general form of 'VARIABLE OPERATOR VALUE'. For example, '$message_age > 60'. When exipick is deciding which messages to display, it checks the $message_age variable for each message. If a message's age is greater than 60, the message will be displayed. If the message's age is 60 or less seconds, it will not be displayed.
1496 Multiple criteria can be used. The order they are specified does not matter. By default all criteria must evaluate to true for a message to be displayed. If the --or option is used, a message is displayed as long as any of the criteria evaluate to true.
1498 See the VARIABLES and OPERATORS sections below for more details
1506 Boolean variables are checked simply by being true or false. There is no real operator except negation. Examples of valid boolean tests:
1512 Valid comparisons are <, <=, >, >=, ==, and !=. Numbers can be integers or floats. Any number in a test suffixed with d, h, m, s, M, K, or B will be multiplied by 86400, 3600, 60, 1, 1048576, 1024, or 1 respectively. Examples of valid numeric tests:
1513 '$message_age >= 3d'
1514 '$local_interface == 587'
1515 '$message_size < 30K'
1519 The string operators are =, eq, ne, =~, and !~. With the exception of '=', the operators all match the functionality of the like-named perl operators. eq and ne match a string exactly. !~, =~, and = apply a perl regular expression to a string. The '=' operator behaves just like =~ but you are not required to place // around the regular expression. Examples of valid string tests:
1520 '$received_protocol eq esmtp'
1521 '$sender_address = example.com'
1522 '$each_recipients =~ /^a[a-z]{2,3}@example.com$/'
1526 There are many ways to negate tests, each having a reason for existing. Many tests can be negated using native operators. For instance, >1 is the opposite of <=1 and eq and ne are opposites. In addition, each individual test can be negated by adding a ! at the beginning of the test. For instance, '!$acl_m1 =~ /^DENY$/' is the same as '$acl_m1 !~ /^DENY$/'. Finally, every test can be specified by using the command line argument --not. This is functionally equivalent to adding a ! to the beginning of every test.
1532 With a few exceptions the available variables match Exim's internal expansion variables in both name and exact contents. There are a few notable additions and format deviations which are noted below. Although a brief explanation is offered below, Exim's spec.txt should be consulted for full details. It is important to remember that not every variable will be defined for every message. For example, $sender_host_port is not defined for messages not received from a remote host.
1534 Internally, all variables are represented as strings, meaning any operator will work on any variable. This means that '$sender_host_name > 4' is a legal criterion, even if it does not produce meaningful results. Variables in the list below are marked with a 'type' to help in choosing which types of operators make sense to use.
1537 B - Boolean variables
1538 S - String variables
1539 N - Numeric variables
1540 . - Standard variable matching Exim's content definition
1541 # - Standard variable, contents differ from Exim's definition
1542 + - Non-standard variable
1546 =item S . $acl_c0-$acl_c9, $acl_m0-$acl_m9
1548 User definable variables.
1550 =item B + $allow_unqualified_recipient
1552 TRUE if unqualified recipient addresses are permitted in header lines.
1554 =item B + $allow_unqualified_sender
1556 TRUE if unqualified sender addresses are permitted in header lines.
1558 =item S . $authenticated_id
1560 Optional saved information from authenticators, or the login name of the calling process for locally submitted messages.
1562 =item S . $authenticated_sender
1564 The value of AUTH= param for smtp messages, or a generated value from the calling processes login and qualify domain for locally submitted messages.
1566 =item S . $bheader_*, $bh_*
1568 Value of the header(s) with the same name with any RFC2047 words decoded if present. See section 11.5 of Exim's spec.txt for full details.
1570 =item S + $bmi_verdicts
1572 The verdict string provided by a Brightmail content scan
1574 =item N . $body_linecount
1576 The number of lines in the message's body.
1578 =item N . $body_zerocount
1580 The number of binary zero bytes in the message's body.
1582 =item S + $data_path
1584 The path to the body file's location in the filesystem.
1586 =item B + $deliver_freeze
1588 TRUE if the message is currently frozen.
1590 =item N + $deliver_frozen_at
1592 The epoch time at which message was frozen.
1594 =item B + $dont_deliver
1596 TRUE if, under normal circumstances, Exim will not try to deliver the message.
1598 =item S + $each_recipients
1600 This is a pseudo variable which allows you to apply a test against each address in $recipients individually. Whereas '$recipients =~ /@aol.com/' will match if any recipient address contains aol.com, '$each_recipients =~ /@aol.com$/' will only be true if every recipient matches that pattern. Note that this obeys --and or --or being set. Using it with --or is very similar to just matching against $recipients, but with the added benefit of being able to use anchors at the beginning and end of each recipient address.
1602 =item S + $each_recipients_del
1604 Like $each_recipients, but for $recipients_del
1606 =item S + $each_recipients_undel
1608 Like $each_recipients, but for $recipients_undel
1610 =item B . $first_delivery
1612 TRUE if the message has never been deferred.
1614 =item S . $header_*, $h_*
1616 This will always match the contents of the corresponding $bheader_* variable currently (the same behaviour Exim displays when iconv is not installed).
1618 =item S + $header_path
1620 The path to the header file's location in the filesystem.
1622 =item B . $host_lookup_deferred
1624 TRUE if there was an attempt to look up the host's name from its IP address, but an error occurred that during the attempt.
1626 =item B . $host_lookup_failed
1628 TRUE if there was an attempt to look up the host's name from its IP address, but the attempt returned a negative result.
1630 =item B + $local_error_message
1632 TRUE if the message is a locally-generated error message.
1634 =item S . $local_scan_data
1636 The text returned by the local_scan() function when a message is received.
1638 =item B . $manually_thawed
1640 TRUE when the message has been manually thawed.
1642 =item N . $max_received_linelength
1644 The number of bytes in the longest line that was received as part of the message, not counting line termination characters.
1646 =item N . $message_age
1648 The number of seconds since the message was received.
1650 =item S # $message_body
1652 The message's body. Unlike Exim's variable of the same name, this variable contains the entire message body. Newlines and nulls are replaced by spaces.
1654 =item B + $message_body_missing
1656 TRUE is a message's spool data file (-D file) is missing or unreadable.
1658 =item N . $message_body_size
1660 The size of the body in bytes.
1662 =item S . $message_exim_id, $message_id
1664 The unique message id that is used by Exim to identify the message. $message_id is deprecated as of Exim 4.53.
1666 =item S . $message_headers
1668 A concatenation of all the header lines except for lines added by routers or transports. RFC2047 decoding is performed
1670 =item S . $message_headers_raw
1672 A concatenation of all the header lines except for lines added by routers or transports. No decoding or translation is performed.
1674 =item N . $message_linecount
1676 The number of lines in the entire message (body and headers).
1678 =item N . $message_size
1680 The size of the message in bytes.
1682 =item N . $originator_gid
1684 The group id under which the process that called Exim was running as when the message was received.
1686 =item S + $originator_login
1688 The login of the process which called Exim.
1690 =item N . $originator_uid
1692 The user id under which the process that called Exim was running as when the message was received.
1694 =item S . $received_ip_address, $interface_address
1696 The address of the local IP interface for network-originated messages. $interface_address is deprecated as of Exim 4.64
1698 =item N . $received_port, $interface_port
1700 The local port number if network-originated messages. $interface_port is deprecated as of Exim 4.64
1702 =item N . $received_count
1704 The number of Received: header lines in the message.
1706 =item S . $received_protocol
1708 The name of the protocol by which the message was received.
1710 =item N . $received_time
1712 The epoch time at which the message was received.
1714 =item S # $recipients
1716 The list of envelope recipients for a message. Unlike Exim's version, this variable always contains every recipient of the message. The recipients are separated by a comma and a space. See also $each_recipients.
1718 =item N . $recipients_count
1720 The number of envelope recipients for the message.
1722 =item S + $recipients_del
1724 The list of delivered envelope recipients for a message. This non-standard variable is in the same format as $recipients and contains the list of already-delivered recipients including any generated addresses. See also $each_recipients_del.
1726 =item N + $recipients_del_count
1728 The number of envelope recipients for the message which have already been delivered. Note that this is the count of original recipients to which the message has been delivered. It does not include generated addresses so it is possible that this number will be less than the number of addresses in the $recipients_del string.
1730 =item S + $recipients_undel
1732 The list of undelivered envelope recipients for a message. This non-standard variable is in the same format as $recipients and contains the list of undelivered recipients. See also $each_recipients_undel.
1734 =item N + $recipients_undel_count
1736 The number of envelope recipients for the message which have not yet been delivered.
1738 =item S . $reply_address
1740 The contents of the Reply-To: header line if one exists and it is not empty, or otherwise the contents of the From: header line.
1742 =item S . $rheader_*, $rh_*
1744 The value of the message's header(s) with the same name. See section 11.5 of Exim's spec.txt for full description.
1746 =item S . $sender_address
1748 The sender's address that was received in the message's envelope. For bounce messages, the value of this variable is the empty string.
1750 =item S . $sender_address_domain
1752 The domain part of $sender_address.
1754 =item S . $sender_address_local_part
1756 The local part of $sender_address.
1758 =item S . $sender_helo_name
1760 The HELO or EHLO value supplied for smtp or bsmtp messages.
1762 =item S . $sender_host_address
1764 The remote host's IP address.
1766 =item S . $sender_host_authenticated
1768 The name of the authenticator driver which successfully authenticated the client from which the message was received.
1770 =item S . $sender_host_name
1772 The remote host's name as obtained by looking up its IP address.
1774 =item N . $sender_host_port
1776 The port number that was used on the remote host for network-originated messages.
1778 =item S . $sender_ident
1780 The identification received in response to an RFC 1413 request for remote messages, the login name of the user that called Exim for locally generated messages.
1782 =item B + $sender_local
1784 TRUE if the message was locally generated.
1786 =item B + $sender_set_untrusted
1788 TRUE if the envelope sender of this message was set by an untrusted local caller.
1790 =item S + $shown_message_size
1792 This non-standard variable contains the formatted size string. That is, for a message whose $message_size is 66566 bytes, $shown_message_size is 65K.
1794 =item S . $smtp_active_hostname
1796 The value of the active host name when the message was received, as specified by the "smtp_active_hostname" option.
1798 =item S . $spam_score
1800 The spam score of the message, for example '3.4' or '30.5'. (Requires exiscan or WITH_CONTENT_SCAN)
1802 =item S . $spam_score_int
1804 The spam score of the message, multiplied by ten, as an integer value. For instance '34' or '305'. (Requires exiscan or WITH_CONTENT_SCAN)
1806 =item B . $tls_certificate_verified
1808 TRUE if a TLS certificate was verified when the message was received.
1810 =item S . $tls_cipher
1812 The cipher suite that was negotiated for encrypted SMTP connections.
1814 =item S . $tls_peerdn
1816 The value of the Distinguished Name of the certificate if Exim is configured to request one
1820 The value of the Server Name Indication TLS extension sent by a client, if one was sent.
1822 =item N + $warning_count
1824 The number of delay warnings which have been sent for this message.
1832 =item EMAIL: proj-exipick@jetmore.net
1834 =item HOME: jetmore.org/john/code/#exipick