2 # $Cambridge: exim/src/src/exipick.src,v 1.15 2010/01/04 18:16:54 jetmore Exp $
4 # This variable should be set by the building process to Exim's spool directory.
5 my $spool = 'SPOOL_DIRECTORY';
6 # Need to set this dynamically during build, but it's not used right now anyway.
7 my $charset = 'ISO-8859-1';
9 # use 'exipick --help' to view documentation for this program.
10 # Documentation also viewable online at
11 # http://www.exim.org/eximwiki/ToolExipickManPage
16 my($p_name) = $0 =~ m|/?([^/]+)$|;
17 my $p_version = "20100104.1";
18 my $p_usage = "Usage: $p_name [--help|--version] (see --help for details)";
20 Copyright (c) 2003-2010 John Jetmore <jj33\@pobox.com>
22 This program is free software; you can redistribute it and/or modify
23 it under the terms of the GNU General Public License as published by
24 the Free Software Foundation; either version 2 of the License, or
25 (at your option) any later version.
27 This program is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 GNU General Public License for more details.
32 You should have received a copy of the GNU General Public License
33 along with this program; if not, write to the Free Software
34 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
36 ext_usage(); # before we do anything else, check for --help
38 $| = 1; # unbuffer STDOUT
40 Getopt::Long::Configure("bundling_override");
42 'spool=s' => \$G::spool, # exim spool dir
43 'bp' => \$G::mailq_bp, # List the queue (noop - default)
44 'bpa' => \$G::mailq_bpa, # ... with generated address as well
45 'bpc' => \$G::mailq_bpc, # ... but just show a count of messages
46 'bpr' => \$G::mailq_bpr, # ... do not sort
47 'bpra' => \$G::mailq_bpra, # ... with generated addresses, unsorted
48 'bpru' => \$G::mailq_bpru, # ... only undelivered addresses, unsorted
49 'bpu' => \$G::mailq_bpu, # ... only undelivered addresses
50 'and' => \$G::and, # 'and' the criteria (default)
51 'or' => \$G::or, # 'or' the criteria
52 'f=s' => \$G::qgrep_f, # from regexp
53 'r=s' => \$G::qgrep_r, # recipient regexp
54 's=s' => \$G::qgrep_s, # match against size field
55 'y=s' => \$G::qgrep_y, # message younger than (secs)
56 'o=s' => \$G::qgrep_o, # message older than (secs)
57 'z' => \$G::qgrep_z, # frozen only
58 'x' => \$G::qgrep_x, # non-frozen only
59 'c' => \$G::qgrep_c, # display match count
60 'l' => \$G::qgrep_l, # long format (default)
61 'i' => \$G::qgrep_i, # message ids only
62 'b' => \$G::qgrep_b, # brief format
63 'size' => \$G::size_only, # sum the size of the matching msgs
64 'not' => \$G::negate, # flip every test
65 'R|reverse' => \$G::reverse, # reverse output (-R is qgrep option)
66 'sort=s' => \@G::sort, # allow you to choose variables to sort by
67 'freeze=s' => \$G::freeze, # freeze data in this file
68 'thaw=s' => \$G::thaw, # thaw data from this file
69 'unsorted' => \$G::unsorted, # unsorted, regardless of output format
70 'random' => \$G::random, # (poorly) randomize evaluation order
71 'flatq' => \$G::flatq, # brief format
72 'caseful' => \$G::caseful, # in '=' criteria, respect case
73 'caseless' => \$G::caseless, # ...ignore case (default)
74 'charset=s' => \$charset, # charset for $bh and $h variables
75 'show-vars=s' => \$G::show_vars, # display the contents of these vars
76 'just-vars' => \$G::just_vars, # only display vars, no other info
77 'show-rules' => \$G::show_rules, # display compiled match rules
78 'show-tests' => \$G::show_tests # display tests as applied to each message
81 # if both freeze and thaw specified, only thaw as it is less desctructive
82 $G::freeze = undef if ($G::freeze && $G::thaw);
83 freeze_start() if ($G::freeze);
84 thaw_start() if ($G::thaw);
86 # massage sort options (make '$var,Var:' be 'var','var')
87 for (my $i = scalar(@G::sort)-1; $i >= 0; $i--) {
88 $G::sort[$i] = lc($G::sort[$i]);
89 $G::sort[$i] =~ s/[\$:\s]//g;
90 if ((my @vars = split(/,/, $G::sort[$i])) > 1) {
91 $G::sort[$i] = $vars[0]; shift(@vars); # replace current slot w/ first var
92 splice(@G::sort, $i+1, 0, @vars); # add other vars after current pos
95 push(@G::sort, "message_exim_id") if (@G::sort);
96 die "empty value provided to --sort not allowed, exiting\n"
97 if (grep /^\s*$/, @G::sort);
99 # massage the qgrep options into standard criteria
100 push(@ARGV, "\$sender_address =~ /$G::qgrep_f/") if ($G::qgrep_f);
101 push(@ARGV, "\$recipients =~ /$G::qgrep_r/") if ($G::qgrep_r);
102 push(@ARGV, "\$shown_message_size eq $G::qgrep_s") if ($G::qgrep_s);
103 push(@ARGV, "\$message_age < $G::qgrep_y") if ($G::qgrep_y);
104 push(@ARGV, "\$message_age > $G::qgrep_o") if ($G::qgrep_o);
105 push(@ARGV, "\$deliver_freeze") if ($G::qgrep_z);
106 push(@ARGV, "!\$deliver_freeze") if ($G::qgrep_x);
108 $G::mailq_bp = $G::mailq_bp; # shut up -w
109 $G::and = $G::and; # shut up -w
110 $G::msg_ids = {}; # short circuit when crit is only MID
111 $G::caseless = $G::caseful ? 0 : 1; # nocase by default, case if both
112 @G::recipients_crit = (); # holds per-recip criteria
113 $spool = $G::spool if ($G::spool);
114 my $count_only = 1 if ($G::mailq_bpc || $G::qgrep_c);
115 my $unsorted = 1 if ($G::mailq_bpr || $G::mailq_bpra ||
116 $G::mailq_bpru || $G::unsorted);
117 my $msg = $G::thaw ? thaw_message_list()
118 : get_all_msgs($spool, $unsorted,
119 $G::reverse, $G::random);
120 die "Problem accessing thaw file\n" if ($G::thaw && !$msg);
121 my $crit = process_criteria(\@ARGV);
122 my $e = Exim::SpoolFile->new();
123 my $tcount = 0 if ($count_only); # holds count of all messages
124 my $mcount = 0 if ($count_only); # holds count of matching messages
125 my $total_size = 0 if ($G::size_only);
126 $e->set_undelivered_only(1) if ($G::mailq_bpru || $G::mailq_bpu);
127 $e->set_show_generated(1) if ($G::mailq_bpra || $G::mailq_bpa);
128 $e->output_long() if ($G::qgrep_l);
129 $e->output_idonly() if ($G::qgrep_i);
130 $e->output_brief() if ($G::qgrep_b);
131 $e->output_flatq() if ($G::flatq);
132 $e->output_vars_only() if ($G::just_vars && $G::show_vars);
133 $e->set_show_vars($G::show_vars) if ($G::show_vars);
134 $e->set_spool($spool);
137 foreach my $m (@$msg) {
138 next if (scalar(keys(%$G::msg_ids)) && !$G::or
139 && !$G::msg_ids->{$m->{message}});
141 my $data = thaw_data();
142 if (!$e->restore_state($data)) {
143 warn "Couldn't thaw $data->{_message}: ".$e->error()."\n";
147 if (!$e->parse_message($m->{message}, $m->{path})) {
148 warn "Couldn't parse $m->{message}: ".$e->error()."\n";
155 foreach my $c (@G::recipients_crit) { # handle each_recip* vars
156 foreach my $addr (split(/, /, $e->get_var($c->{var}))) {
157 my %t = ( 'cmp' => $c->{cmp}, 'var' => $c->{var} );
158 $t{cmp} =~ s/"?\$var"?/'$addr'/;
159 push(@local_crit, \%t);
162 if ($G::show_tests) { print $e->get_var('message_exim_id'), "\n"; }
164 foreach my $c (@$crit, @local_crit) {
165 my $var = $e->get_var($c->{var});
166 my $ret = eval($c->{cmp});
167 if ($G::show_tests) {
168 printf " %25s = '%s'\n %25s => $ret\n",$c->{var},$var,$c->{cmp},$ret;
171 print STDERR "Error in eval '$c->{cmp}': $@\n";
175 if ($G::or) { last CRITERIA; }
176 else { next CRITERIA; }
178 if ($G::or) { next CRITERIA; }
183 # skip this message if any criteria were supplied and it didn't match
184 next MSG if ((scalar(@$crit) || scalar(@local_crit)) && !$match);
186 if ($count_only || $G::size_only) {
188 $total_size += $e->get_var('message_size');
191 # if we are defining criteria to sort on, save the message here. If
192 # we don't save here and do the sort later, we have a chicken/egg
194 push(@G::to_print, { vars => {}, output => "" });
195 foreach my $var (@G::sort) {
196 # save any values we want to sort on. I don't like doing the internal
197 # struct access here, but calling get_var a bunch can be _slow_ =(
198 $G::sort_type{$var} ||= '<=>';
199 $G::to_print[-1]{vars}{$var} = $e->{_vars}{$var};
200 $G::sort_type{$var} = 'cmp' if ($G::to_print[-1]{vars}{$var} =~ /\D/);
202 $G::to_print[-1]{output} = $e->format_message();
204 print $e->format_message();
209 freeze_data($e->get_state());
210 push(@G::frozen_msgs, $m);
215 msg_sort(\@G::to_print, \@G::sort, $G::reverse);
216 foreach my $msg (@G::to_print) {
217 print $msg->{output};
222 print "$mcount matches out of $tcount messages" .
223 ($G::size_only ? " ($total_size)" : "") . "\n";
224 } elsif ($G::mailq_bpc) {
225 print "$mcount" . ($G::size_only ? " ($total_size)" : "") . "\n";
226 } elsif ($G::size_only) {
227 print "$total_size\n";
231 freeze_message_list(\@G::frozen_msgs);
239 # sender_address_domain,shown_message_size
246 foreach my $v (@G::sort) {
247 push(@pieces, "\$a->{vars}{\"$v\"} $G::sort_type{$v} \$b->{vars}{\"$v\"}");
249 my $sort_str = join(" || ", @pieces);
251 @$msgs = sort { eval $sort_str } (@$msgs);
252 @$msgs = reverse(@$msgs) if ($reverse);
262 # FREEZE FILE FORMAT:
268 # message_list_bytes <- 10 bytes, zero-packed, plus \n
271 eval("use Storable");
272 die "Storable module not found: $@\n" if ($@);
273 open(O, ">$G::freeze") || die "Can't open freeze file $G::freeze: $!\n";
274 $G::freeze_handle = \*O;
278 close($G::freeze_handle);
282 eval("use Storable");
283 die "Storable module not found: $@\n" if ($@);
284 open(I, "<$G::thaw") || die "Can't open freeze file $G::thaw: $!\n";
285 $G::freeze_handle = \*I;
289 close($G::freeze_handle);
293 my $h = Storable::freeze($_[0]);
294 print $G::freeze_handle length($h)+1, "\n$h\n";
297 sub freeze_message_list {
298 my $h = Storable::freeze($_[0]);
299 my $l = length($h) + 1;
300 printf $G::freeze_handle "EOM\n$l\n$h\n%010d\n", $l+11+length($l)+1;
303 sub thaw_message_list {
304 my $orig_pos = tell($G::freeze_handle);
305 seek($G::freeze_handle, -11, 2);
306 chomp(my $bytes = <$G::freeze_handle>);
307 seek($G::freeze_handle, $bytes * -1, 2);
308 my $obj = thaw_data();
309 seek($G::freeze_handle, 0, $orig_pos);
315 chomp(my $bytes = <$G::freeze_handle>);
316 return(undef) if (!$bytes || $bytes eq 'EOM');
317 my $read = read(I, $obj, $bytes);
318 die "Format error in thaw file (expected $bytes bytes, got $read)\n"
319 if ($bytes != $read);
321 return(Storable::thaw($obj));
324 sub process_criteria {
330 foreach my $t ('@') { s/$t/\\$t/g; }
331 if (/^(.*?)\s+(<=|>=|==|!=|<|>)\s+(.*)$/) {
332 #print STDERR "found as integer\n";
333 my $v = $1; my $o = $2; my $n = $3;
334 if ($n =~ /^(-?[\d\.]+)M$/) { $n = $1 * 1024 * 1024; }
335 elsif ($n =~ /^(-?[\d\.]+)K$/) { $n = $1 * 1024; }
336 elsif ($n =~ /^(-?[\d\.]+)B?$/) { $n = $1; }
337 elsif ($n =~ /^(-?[\d\.]+)d$/) { $n = $1 * 60 * 60 * 24; }
338 elsif ($n =~ /^(-?[\d\.]+)h$/) { $n = $1 * 60 * 60; }
339 elsif ($n =~ /^(-?[\d\.]+)m$/) { $n = $1 * 60; }
340 elsif ($n =~ /^(-?[\d\.]+)s?$/) { $n = $1; }
342 print STDERR "Expression $_ did not parse: numeric comparison with ",
347 push(@c, { var => lc($v), cmp => "(\$var $o $n)" });
348 } elsif (/^(.*?)\s+(=~|!~)\s+(.*)$/) {
349 #print STDERR "found as string regexp\n";
350 push(@c, { var => lc($1), cmp => "(\"\$var\" $2 $3)" });
351 } elsif (/^(.*?)\s+=\s+(.*)$/) {
352 #print STDERR "found as bare string regexp\n";
353 my $case = $G::caseful ? '' : 'i';
354 push(@c, { var => lc($1), cmp => "(\"\$var\" =~ /$2/$case)" });
355 # quote special characters in perl text string
356 #foreach my $t ('@') { $c[-1]{cmp} =~ s/$t/\\$t/g; }
357 } elsif (/^(.*?)\s+(eq|ne)\s+(.*)$/) {
358 #print STDERR "found as string cmp\n";
359 my $var = lc($1); my $op = $2; my $val = $3;
360 $val =~ s|^(['"])(.*)\1$|$2|;
361 push(@c, { var => $var, cmp => "(\"\$var\" $op \"$val\")" });
362 if (($var eq 'message_id' || $var eq 'message_exim_id') && $op eq "eq") {
363 #print STDERR "short circuit @c[-1]->{cmp} $val\n";
364 $G::msg_ids->{$val} = 1;
366 #foreach my $t ('@') { $c[-1]{cmp} =~ s/$t/\\$t/g; }
367 } elsif (/^(\S+)$/) {
368 #print STDERR "found as boolean\n";
369 push(@c, { var => lc($1), cmp => "(\$var)" });
371 print STDERR "Expression $_ did not parse\n";
375 # assign the results of the cmp test here (handle "!" negation)
376 # also handle global --not negation
377 if ($c[-1]{var} =~ s|^!||) {
378 $c[-1]{cmp} .= $G::negate ? " ? 1 : 0" : " ? 0 : 1";
380 $c[-1]{cmp} .= $G::negate ? " ? 0 : 1" : " ? 1 : 0";
382 # support the each_* psuedo variables. Steal the criteria off of the
383 # queue for special processing later
384 if ($c[-1]{var} =~ /^each_(recipients(_(un)?del)?)$/) {
386 push(@G::recipients_crit,pop(@c));
387 $G::recipients_crit[-1]{var} = $var; # remove each_ from the variable
393 if ($G::show_rules) { foreach (@c) { print "$_->{var}\t$_->{cmp}\n"; } }
399 my $d = shift() . '/input';
400 my $u = shift; # don't sort
401 my $r = shift; # right before returning, reverse order
402 my $o = shift; # if true, randomize list order before returning
405 opendir(D, "$d") || die "Couldn't opendir $d: $!\n";
406 foreach my $e (grep !/^\./, readdir(D)) {
407 if ($e =~ /^[a-zA-Z0-9]$/) {
408 opendir(DD, "$d/$e") || next;
409 foreach my $f (grep !/^\./, readdir(DD)) {
410 push(@m, { message => $1, path => "$d/$e" }) if ($f =~ /^(.{16})-H$/);
413 } elsif ($e =~ /^(.{16})-H$/) {
414 push(@m, { message => $1, path => $d });
421 # loop twice to pretend we're doing a good job of mixing things up
422 for (my $i = 0; $i < 2 * $c; $i++) {
423 my $rand = int(rand($c));
424 ($m[$i % $c],$m[$rand]) = ($m[$rand],$m[$i % $c]);
427 @m = sort { $a->{message} cmp $b->{message} } @m;
429 @m = reverse(@m) if ($r);
436 package Exim::SpoolFile;
438 # versions 4.61 and higher will not need these variables anymore, but they
439 # are left for handling legacy installs
440 $Exim::SpoolFile::ACL_C_MAX_LEGACY = 10;
441 #$Exim::SpoolFile::ACL_M_MAX _LEGACY= 10;
446 bless($self, $class);
448 $self->{_spool_dir} = '';
449 $self->{_undelivered_only} = 0;
450 $self->{_show_generated} = 0;
451 $self->{_output_long} = 1;
452 $self->{_output_idonly} = 0;
453 $self->{_output_brief} = 0;
454 $self->{_output_flatq} = 0;
455 $self->{_output_vars_only} = 0;
456 $self->{_show_vars} = [];
465 $self->{_output_long} = 1;
466 $self->{_output_idonly} = 0;
467 $self->{_output_brief} = 0;
468 $self->{_output_flatq} = 0;
469 $self->{_output_vars_only} = 0;
475 $self->{_output_long} = 0;
476 $self->{_output_idonly} = 1;
477 $self->{_output_brief} = 0;
478 $self->{_output_flatq} = 0;
479 $self->{_output_vars_only} = 0;
485 $self->{_output_long} = 0;
486 $self->{_output_idonly} = 0;
487 $self->{_output_brief} = 1;
488 $self->{_output_flatq} = 0;
489 $self->{_output_vars_only} = 0;
495 $self->{_output_long} = 0;
496 $self->{_output_idonly} = 0;
497 $self->{_output_brief} = 0;
498 $self->{_output_flatq} = 1;
499 $self->{_output_vars_only} = 0;
502 sub output_vars_only {
505 $self->{_output_long} = 0;
506 $self->{_output_idonly} = 0;
507 $self->{_output_brief} = 0;
508 $self->{_output_flatq} = 0;
509 $self->{_output_vars_only} = 1;
516 foreach my $v (split(/\s*,\s*/, $s)) {
517 push(@{$self->{_show_vars}}, $v);
521 sub set_show_generated {
523 $self->{_show_generated} = shift;
526 sub set_undelivered_only {
528 $self->{_undelivered_only} = shift;
533 return $self->{_error};
538 $self->{_error} = shift;
545 $self->{_error} = '';
546 $self->{_delivered} = 0;
547 $self->{_message} = '';
550 $self->{_vars_raw} = {};
552 $self->{_numrecips} = 0;
553 $self->{_udel_tree} = {};
554 $self->{_del_tree} = {};
555 $self->{_recips} = {};
564 $self->{_message} = shift || return(0);
565 $self->{_path} = shift; # optional path to message
566 return(0) if (!$self->{_spool_dir});
567 if (!$self->{_path} && !$self->_find_path()) {
568 # assume the message was delivered from under us and ignore
569 $self->{_delivered} = 1;
572 $self->_parse_header() || return(0);
577 # take the output of get_state() and set up a message internally like
578 # parse_message (except from a saved data struct, not by parsing the
584 return(1) if ($h->{_delivered});
586 $self->{_message} = $h->{_message} || return(0);
587 return(0) if (!$self->{_spool_dir});
589 $self->{_path} = $h->{_path};
590 $self->{_vars} = $h->{_vars};
591 $self->{_numrecips} = $h->{_numrecips};
592 $self->{_udel_tree} = $h->{_udel_tree};
593 $self->{_del_tree} = $h->{_del_tree};
594 $self->{_recips} = $h->{_recips};
596 $self->{_vars}{message_age} = time() - $self->{_vars}{received_time};
600 # This returns the state data for a specific message in a format that can
601 # be later frozen back in to regain state
603 # after calling this function, this specific state is not expect to be
604 # reused. That's because we're returning direct references to specific
605 # internal structures. We're also modifying the structure ourselves
606 # by deleting certain internal message variables.
609 my $h = {}; # this is the hash ref we'll be returning.
611 $h->{_delivered} = $self->{_delivered};
612 $h->{_message} = $self->{_message};
613 $h->{_path} = $self->{_path};
614 $h->{_vars} = $self->{_vars};
615 $h->{_numrecips} = $self->{_numrecips};
616 $h->{_udel_tree} = $self->{_udel_tree};
617 $h->{_del_tree} = $self->{_del_tree};
618 $h->{_recips} = $self->{_recips};
620 # delete some internal variables that we will rebuild later if needed
621 delete($h->{_vars}{message_body});
622 delete($h->{_vars}{message_age});
627 # keep this sub as a feature if we ever break this module out, but do away
628 # with its use in exipick (pass it in from caller instead)
632 return(0) if (!$self->{_message});
633 return(0) if (!$self->{_spool_dir});
635 # test split spool first on the theory that people concerned about
636 # performance will have split spool set =).
637 foreach my $f (substr($self->{_message}, 5, 1).'/', '') {
638 if (-f "$self->{_spool_dir}/input/$f$self->{_message}-H") {
639 $self->{_path} = $self->{_spool_dir} . "/input/$f";
648 $self->{_spool_dir} = shift;
651 sub get_matching_vars {
657 foreach my $v (keys %{$self->{_vars}}) { push(@r, $v) if ($v =~ /$e/); }
664 # accepts a variable with or without leading '$' or trailing ':'
667 my $var = lc(shift); $var =~ s/^\$//; $var =~ s/:$//;
669 if ($var eq 'message_body' && !defined($self->{_vars}{message_body})) {
671 } elsif ($var =~ s|^([rb]?h)(eader)?_|${1}eader_| &&
672 exists($self->{_vars}{$var}) && !defined($self->{_vars}{$var}))
674 if ((my $type = $1) eq 'rh') {
675 $self->{_vars}{$var} = join('', @{$self->{_vars_raw}{$var}{vals}});
677 # both bh_ and h_ build their strings from rh_. Do common work here
678 my $rh = $var; $rh =~ s|^b?|r|;
679 my $comma = 1 if ($self->{_vars_raw}{$rh}{type} =~ /^[BCFRST]$/);
680 foreach (@{$self->{_vars_raw}{$rh}{vals}}) {
681 my $x = $_; # editing $_ here would change the original, which is bad
684 if ($comma) { chomp($x); $self->{_vars}{$var} .= "$x,\n"; }
685 else { $self->{_vars}{$var} .= $x; }
687 $self->{_vars}{$var} =~ s|[\s\n]*$||;
688 $self->{_vars}{$var} =~ s|,$|| if ($comma);
689 # ok, that's the preprocessing, not do specific processing for h type
691 $self->{_vars}{$var} = $self->_decode_2047($self->{_vars}{$var});
693 $self->{_vars}{$var} =
694 $self->_decode_2047($self->{_vars}{$var}, $charset);
698 elsif ($var eq 'received_count' && !defined($self->{_vars}{received_count}))
700 $self->{_vars}{received_count} =
701 scalar(@{$self->{_vars_raw}{rheader_received}{vals}});
703 elsif ($var eq 'message_headers' && !defined($self->{_vars}{message_headers}))
705 $self->{_vars}{$var} =
706 $self->_decode_2047($self->{_vars}{message_headers_raw}, $charset);
707 chomp($self->{_vars}{$var});
709 elsif ($var eq 'reply_address' && !defined($self->{_vars}{reply_address}))
711 $self->{_vars}{reply_address} = exists($self->{_vars}{"header_reply-to"})
712 ? $self->get_var("header_reply-to") : $self->get_var("header_from");
715 #chomp($self->{_vars}{$var}); # I think this was only for headers, obsolete
716 return $self->{_vars}{$var};
721 my $s = shift; # string to decode
722 my $c = shift; # target charset. If empty, just decode, don't convert
723 my $t = ''; # the translated string
724 my $e = 0; # set to true if we get an error in here anywhere
726 return($s) if ($s !~ /=\?/); # don't even bother to look if there's no sign
729 foreach my $mw (split(/(=\?[^\?]{3,}\?[BQ]\?[^\?]{1,74}\?=)/i, $s)) {
731 if ($mw =~ /=\?([^\?]{3,})\?([BQ])\?([^\?]{1,74})\?=/i) {
732 push(@p, { data => $3, encoding => uc($2), charset => uc($1),
734 if ($p[-1]{encoding} eq 'Q') {
735 my @ow = split('', $p[-1]{data});
737 for (my $i = 0; $i < @ow; $i++) {
738 if ($ow[$i] eq '_') { push(@nw, ' '); }
739 elsif ($ow[$i] eq '=') {
740 if (scalar(@ow) - ($i+1) < 2) { # ran out of characters
742 } elsif ($ow[$i+1] !~ /[\dA-F]/i || $ow[$i+2] !~ /[\dA-F]/i) {
745 #push(@nw, chr('0x'.$ow[$i+1].$ow[$i+2]));
746 push(@nw, pack("C", hex($ow[$i+1].$ow[$i+2])));
750 elsif ($ow[$i] =~ /\s/) { # whitspace is illegal
754 else { push(@nw, $ow[$i]); }
756 $p[-1]{data} = join('', @nw);
757 } elsif ($p[-1]{encoding} eq 'B') {
758 my $x = $p[-1]{data};
759 $x =~ tr#A-Za-z0-9+/##cd;
761 $x =~ tr#A-Za-z0-9+/# -_#;
763 while ($x =~ s/(.{1,60})//s) {
764 $r .= unpack("u", chr(32 + int(length($1)*3/4)) . $1);
769 push(@p, { data => $mw, is_mime => 0,
770 is_ws => ($mw =~ m|^[\s\n]+|sm) ? 1 : 0 });
774 for (my $i = 0; $i < @p; $i++) {
775 # mark entities we want to skip (whitespace between consecutive mimewords)
776 if ($p[$i]{is_mime} && $p[$i+1]{is_ws} && $p[$i+2]{is_mime}) {
780 # if word is a mimeword and we have access to Encode and charset was
781 # specified, try to convert text
782 # XXX _cannot_ get consistent conversion results in perl, can't get them
783 # to return same conversions that exim performs. Until I can figure this
784 # out, don't attempt any conversions (header_ will return same value as
786 #if ($c && $p[$i]{is_mime} && $self->_try_load('Encode')) {
787 # # XXX not sure how to catch errors here
788 # Encode::from_to($p[$i]{data}, $p[$i]{charset}, $c);
791 # replace binary zeros w/ '?' in decoded text
792 if ($p[$i]{is_mime}) { $p[$i]{data} =~ s|\x00|?|g; }
798 return(join('', map { $_->{data} } grep { !$_->{skip} } @p));
802 # This isn't a class func but I'm tired
813 my $f = $self->{_path} . '/' . $self->{_message} . '-D';
814 $self->{_vars}{message_body} = ""; # define var so we only come here once
816 open(I, "<$f") || return($self->_error("Couldn't open $f: $!"));
818 return(0) if ($self->{_message}.'-D' ne $_);
820 $self->{_vars}{message_body} = join('', <I>);
822 $self->{_vars}{message_body} =~ s/\n/ /g;
823 $self->{_vars}{message_body} =~ s/\000/ /g;
829 my $f = $self->{_path} . '/' . $self->{_message} . '-H';
830 $self->{_vars}{header_path} = $f;
831 $self->{_vars}{data_path} = $self->{_path} . '/' . $self->{_message} . '-D';
833 if (!open(I, "<$f")) {
834 # assume message went away and silently ignore
835 $self->{_delivered} = 1;
839 # There are a few numeric variables that should explicitly be set to
840 # zero if they aren't found in the header. Technically an empty value
841 # works just as well, but might as well be pedantic
842 $self->{_vars}{body_zerocount} = 0;
843 $self->{_vars}{host_lookup_deferred} = 0;
844 $self->{_vars}{host_lookup_failed} = 0;
845 $self->{_vars}{tls_certificate_verified} = 0;
848 return(0) if ($self->{_message}.'-H' ne $_);
849 $self->{_vars}{message_id} = $self->{_message};
850 $self->{_vars}{message_exim_id} = $self->{_message};
854 return(0) if (!/^(.+)\s(\-?\d+)\s(\-?\d+)$/);
855 $self->{_vars}{originator_login} = $1;
856 $self->{_vars}{originator_uid} = $2;
857 $self->{_vars}{originator_gid} = $3;
861 return(0) if (!/^<(.*)>$/);
862 $self->{_vars}{sender_address} = $1;
863 $self->{_vars}{sender_address_domain} = $1;
864 $self->{_vars}{sender_address_local_part} = $1;
865 $self->{_vars}{sender_address_domain} =~ s/^.*\@//;
866 $self->{_vars}{sender_address_local_part} =~ s/^(.*)\@.*$/$1/;
870 return(0) if (!/^(\d+)\s(\d+)$/);
871 $self->{_vars}{received_time} = $1;
872 $self->{_vars}{warning_count} = $2;
873 $self->{_vars}{message_age} = time() - $self->{_vars}{received_time};
877 if (/^(-\S+)\s*(.*$)/) {
880 if ($tag eq '-acl') {
882 return(0) if ($arg !~ /^(\d+)\s(\d+)$/);
883 if ($1 < $Exim::SpoolFile::ACL_C_MAX_LEGACY) {
886 $t = "acl_m" . ($1 - $Exim::SpoolFile::ACL_C_MAX_LEGACY);
888 read(I, $self->{_vars}{$t}, $2+1) || return(0);
889 chomp($self->{_vars}{$t});
890 } elsif ($tag eq '-aclc') {
891 #return(0) if ($arg !~ /^(\d+)\s(\d+)$/);
892 return(0) if ($arg !~ /^(\S+)\s(\d+)$/);
894 read(I, $self->{_vars}{$t}, $2+1) || return(0);
895 chomp($self->{_vars}{$t});
896 } elsif ($tag eq '-aclm') {
897 #return(0) if ($arg !~ /^(\d+)\s(\d+)$/);
898 return(0) if ($arg !~ /^(\S+)\s(\d+)$/);
900 read(I, $self->{_vars}{$t}, $2+1) || return(0);
901 chomp($self->{_vars}{$t});
902 } elsif ($tag eq '-local') {
903 $self->{_vars}{sender_local} = 1;
904 } elsif ($tag eq '-localerror') {
905 $self->{_vars}{local_error_message} = 1;
906 } elsif ($tag eq '-local_scan') {
907 $self->{_vars}{local_scan_data} = $arg;
908 } elsif ($tag eq '-spam_score_int') {
909 $self->{_vars}{spam_score_int} = $arg;
910 $self->{_vars}{spam_score} = $arg / 10;
911 } elsif ($tag eq '-bmi_verdicts') {
912 $self->{_vars}{bmi_verdicts} = $arg;
913 } elsif ($tag eq '-host_lookup_deferred') {
914 $self->{_vars}{host_lookup_deferred} = 1;
915 } elsif ($tag eq '-host_lookup_failed') {
916 $self->{_vars}{host_lookup_failed} = 1;
917 } elsif ($tag eq '-body_linecount') {
918 $self->{_vars}{body_linecount} = $arg;
919 } elsif ($tag eq '-max_received_linelength') {
920 $self->{_vars}{max_received_linelength} = $arg;
921 } elsif ($tag eq '-body_zerocount') {
922 $self->{_vars}{body_zerocount} = $arg;
923 } elsif ($tag eq '-frozen') {
924 $self->{_vars}{deliver_freeze} = 1;
925 $self->{_vars}{deliver_frozen_at} = $arg;
926 } elsif ($tag eq '-allow_unqualified_recipient') {
927 $self->{_vars}{allow_unqualified_recipient} = 1;
928 } elsif ($tag eq '-allow_unqualified_sender') {
929 $self->{_vars}{allow_unqualified_sender} = 1;
930 } elsif ($tag eq '-deliver_firsttime') {
931 $self->{_vars}{deliver_firsttime} = 1;
932 $self->{_vars}{first_delivery} = 1;
933 } elsif ($tag eq '-manual_thaw') {
934 $self->{_vars}{deliver_manual_thaw} = 1;
935 $self->{_vars}{manually_thawed} = 1;
936 } elsif ($tag eq '-auth_id') {
937 $self->{_vars}{authenticated_id} = $arg;
938 } elsif ($tag eq '-auth_sender') {
939 $self->{_vars}{authenticated_sender} = $arg;
940 } elsif ($tag eq '-sender_set_untrusted') {
941 $self->{_vars}{sender_set_untrusted} = 1;
942 } elsif ($tag eq '-tls_certificate_verified') {
943 $self->{_vars}{tls_certificate_verified} = 1;
944 } elsif ($tag eq '-tls_cipher') {
945 $self->{_vars}{tls_cipher} = $arg;
946 } elsif ($tag eq '-tls_peerdn') {
947 $self->{_vars}{tls_peerdn} = $arg;
948 } elsif ($tag eq '-host_address') {
949 $self->{_vars}{sender_host_port} = $self->_get_host_and_port(\$arg);
950 $self->{_vars}{sender_host_address} = $arg;
951 } elsif ($tag eq '-interface_address') {
952 $self->{_vars}{received_port} =
953 $self->{_vars}{interface_port} = $self->_get_host_and_port(\$arg);
954 $self->{_vars}{received_ip_address} =
955 $self->{_vars}{interface_address} = $arg;
956 } elsif ($tag eq '-active_hostname') {
957 $self->{_vars}{smtp_active_hostname} = $arg;
958 } elsif ($tag eq '-host_auth') {
959 $self->{_vars}{sender_host_authenticated} = $arg;
960 } elsif ($tag eq '-host_name') {
961 $self->{_vars}{sender_host_name} = $arg;
962 } elsif ($tag eq '-helo_name') {
963 $self->{_vars}{sender_helo_name} = $arg;
964 } elsif ($tag eq '-ident') {
965 $self->{_vars}{sender_ident} = $arg;
966 } elsif ($tag eq '-received_protocol') {
967 $self->{_vars}{received_protocol} = $arg;
968 } elsif ($tag eq '-N') {
969 $self->{_vars}{dont_deliver} = 1;
971 # unrecognized tag, save it for reference
972 $self->{$tag} = $arg;
979 # when we drop out of the while loop, we have the first line of the
980 # delivered tree in $_
984 } elsif ($_ =~ s/^[YN][YN]\s+//) {
985 $self->{_del_tree}{$_} = 1;
990 } while ($_ !~ /^\d+$/);
992 $self->{_numrecips} = $_;
993 $self->{_vars}{recipients_count} = $self->{_numrecips};
994 for (my $i = 0; $i < $self->{_numrecips}; $i++) {
998 if (/^(.*)\s\d+,(\d+),\d+$/) {
999 #print STDERR "exim3 type (untested): $_\n";
1000 $self->{_recips}{$1} = { pno => $2 };
1002 } elsif (/^(.*)\s(\d+)$/) {
1003 #print STDERR "exim4 original type (untested): $_\n";
1004 $self->{_recips}{$1} = { pno => $2 };
1006 } elsif (/^(.*)\s(.*)\s(\d+),(\d+)#1$/) {
1007 #print STDERR "exim4 new type #1 (untested): $_\n";
1008 return($self->_error("incorrect format: $_")) if (length($2) != $3);
1009 $self->{_recips}{$1} = { pno => $4, errors_to => $2 };
1011 } elsif (/^.*#(\d+)$/) {
1012 #print STDERR "exim4 #$1 style (unimplemented): $_\n";
1013 $self->_error("exim4 #$1 style (unimplemented): $_");
1015 #print STDERR "default type: $_\n";
1016 $self->{_recips}{$_} = {};
1019 $self->{_udel_tree}{$addr} = 1 if (!$self->{_del_tree}{$addr});
1021 $self->{_vars}{recipients} = join(', ', keys(%{$self->{_recips}}));
1022 $self->{_vars}{recipients_del} = join(', ', keys(%{$self->{_del_tree}}));
1023 $self->{_vars}{recipients_undel} = join(', ', keys(%{$self->{_udel_tree}}));
1024 $self->{_vars}{recipients_undel_count} = scalar(keys(%{$self->{_udel_tree}}));
1025 $self->{_vars}{recipients_del_count} = 0;
1026 foreach my $r (keys %{$self->{_del_tree}}) {
1027 next if (!$self->{_recips}{$r});
1028 $self->{_vars}{recipients_del_count}++;
1033 return(0) if (!/^$/);
1035 # start reading headers
1036 while (read(I, $_, 3) == 3) {
1038 return(0) if (!length($t));
1039 while ($t =~ /^\d$/) {
1045 $t = getc(I); # strip the space out of the file
1046 return(0) if (read(I, $_, $hdr_bytes) != $hdr_bytes);
1047 if ($hdr_flag ne '*') {
1048 $self->{_vars}{message_linecount} += (tr/\n//);
1049 $self->{_vars}{message_size} += $hdr_bytes;
1052 # mark (rb)?header_ vars as existing and store raw value. They'll be
1053 # processed further in get_var() if needed
1054 my($v,$d) = split(/:/, $_, 2);
1055 $v = "header_" . lc($v);
1056 $self->{_vars}{$v} = $self->{_vars}{"b$v"} = $self->{_vars}{"r$v"} = undef;
1057 push(@{$self->{_vars_raw}{"r$v"}{vals}}, $d);
1058 $self->{_vars_raw}{"r$v"}{type} = $hdr_flag;
1059 $self->{_vars}{message_headers_raw} .= $_;
1063 $self->{_vars}{message_body_size} =
1064 (stat($self->{_path}.'/'.$self->{_message}.'-D'))[7] - 19;
1065 if ($self->{_vars}{message_body_size} < 0) {
1066 $self->{_vars}{message_size} = 0;
1067 $self->{_vars}{message_body_missing} = 1;
1069 $self->{_vars}{message_size} += $self->{_vars}{message_body_size} + 1;
1072 $self->{_vars}{message_linecount} += $self->{_vars}{body_linecount};
1074 my $i = $self->{_vars}{message_size};
1075 if ($i == 0) { $i = ""; }
1076 elsif ($i < 1024) { $i = sprintf("%d", $i); }
1077 elsif ($i < 10240) { $i = sprintf("%.1fK", $i / 1024); }
1078 elsif ($i < 1048576) { $i = sprintf("%dK", ($i+512)/1024); }
1079 elsif ($i < 10485760) { $i = sprintf("%.1fM", $i/1048576); }
1080 else { $i = sprintf("%dM", ($i + 524288)/1048576); }
1081 $self->{_vars}{shown_message_size} = $i;
1086 # mimic exim's host_extract_port function - receive a ref to a scalar,
1087 # strip it of port, return port
1088 sub _get_host_and_port {
1090 my $host = shift; # scalar ref, be careful
1092 if ($$host =~ /^\[([^\]]+)\](?:\:(\d+))?$/) {
1095 } elsif ($$host =~ /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(?:\.(\d+))?$/) {
1098 } elsif ($$host =~ /^([\d\:]+)(?:\.(\d+))?$/) {
1106 # honoring all formatting preferences, return a scalar variable of the
1107 # information for the single message matching what exim -bp would show.
1108 # We can print later if we want.
1109 sub format_message {
1112 return if ($self->{_delivered});
1114 # define any vars we want to print out for this message. The requests
1115 # can be regexps, and the defined vars can change for each message, so we
1116 # have to build this list for each message
1118 if (@{$self->{_show_vars}}) {
1120 foreach my $e (@{$self->{_show_vars}}) {
1121 foreach my $v ($self->get_matching_vars($e)) {
1122 next if ($t{$v}); $t{$v}++; push(@vars, $v);
1127 if ($self->{_output_idonly}) {
1128 $o .= $self->{_message};
1129 foreach my $v (@vars) { $o .= " $v='" . $self->get_var($v) . "'"; }
1132 } elsif ($self->{_output_vars_only}) {
1133 foreach my $v (@vars) { $o .= $self->get_var($v) . "\n"; }
1137 if ($self->{_output_long} || $self->{_output_flatq}) {
1138 my $i = int($self->{_vars}{message_age} / 60);
1140 $i = int(($i+30)/60);
1141 if ($i > 72) { $o .= sprintf "%2dd ", int(($i+12)/24); }
1142 else { $o .= sprintf "%2dh ", $i; }
1143 } else { $o .= sprintf "%2dm ", $i; }
1145 if ($self->{_output_flatq} && @vars) {
1146 $o .= join(';', map { "$_='".$self->get_var($_)."'" } (@vars)
1149 $o .= sprintf "%5s", $self->{_vars}{shown_message_size};
1153 $o .= "$self->{_message} ";
1154 $o .= "From: " if ($self->{_output_brief});
1155 $o .= "<$self->{_vars}{sender_address}>";
1157 if ($self->{_output_long}) {
1158 $o .= " ($self->{_vars}{originator_login})"
1159 if ($self->{_vars}{sender_set_untrusted});
1161 # XXX exim contains code here to print spool format errors
1162 $o .= " *** frozen ***" if ($self->{_vars}{deliver_freeze});
1165 foreach my $v (@vars) {
1166 $o .= sprintf " %25s = '%s'\n", $v, $self->get_var($v);
1169 foreach my $r (keys %{$self->{_recips}}) {
1170 next if ($self->{_del_tree}{$r} && $self->{_undelivered_only});
1171 $o .= sprintf " %s %s\n", $self->{_del_tree}{$r} ? "D" : " ", $r;
1173 if ($self->{_show_generated}) {
1174 foreach my $r (keys %{$self->{_del_tree}}) {
1175 next if ($self->{_recips}{$r});
1176 $o .= sprintf " +D %s\n", $r;
1179 } elsif ($self->{_output_brief}) {
1181 foreach my $r (keys %{$self->{_recips}}) {
1182 next if ($self->{_del_tree}{$r});
1185 $o .= " To: " . join(';', @r);
1186 if (scalar(@vars)) {
1187 $o .= " Vars: ".join(';',map { "$_='".$self->get_var($_)."'" } (@vars));
1189 } elsif ($self->{_output_flatq}) {
1190 $o .= " *** frozen ***" if ($self->{_vars}{deliver_freeze});
1192 foreach my $r (keys %{$self->{_recips}}) {
1193 next if ($self->{_del_tree}{$r});
1196 $o .= " " . join(' ', @r);
1205 my $fh = shift || \*STDOUT;
1206 return if ($self->{_delivered});
1208 print $fh $self->format_message();
1214 foreach my $k (sort keys %$self) {
1215 my $r = ref($self->{$k});
1216 if ($r eq 'ARRAY') {
1217 printf "%20s <<EOM\n", $k;
1218 print @{$self->{$k}}, "EOM\n";
1219 } elsif ($r eq 'HASH') {
1220 printf "%20s <<EOM\n", $k;
1221 foreach (sort keys %{$self->{$k}}) {
1222 printf "%20s %s\n", $_, $self->{$k}{$_};
1226 printf "%20s %s\n", $k, $self->{$k};
1234 if ($ARGV[0] =~ /^--help$/i) {
1236 $ENV{PATH} .= ":" unless $ENV{PATH} eq "";
1237 $ENV{PATH} = "$ENV{PATH}$Config::Config{'installscript'}";
1238 #exec("perldoc", "-F", "-U", $0) || exit 1;
1239 $< = $> = 1 if ($> == 0 || $< == 0);
1240 exec("perldoc", $0) || exit 1;
1242 %Config::Config = ();
1243 } elsif ($ARGV[0] =~ /^--version$/i) {
1244 print "$p_name version $p_version\n\n$p_cp\n";
1256 exipick - selectively display messages from an Exim queue
1260 exipick [<options>] [<criterion> [<criterion> ...]]
1264 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.
1268 Delete every frozen message from queue:
1269 exipick -zi | xargs exim -Mrm
1271 Show only messages which have not yet been virus scanned:
1272 exipick '$received_protocol ne virus-scanned'
1274 Run the queue in a semi-random order:
1275 exipick -i --random | xargs exim -M
1277 Show the count and total size of all messages which either originated from localhost or have a received protocol of 'local':
1278 exipick --or --size --bpc \
1279 '$sender_host_address eq 127.0.0.1' \
1280 '$received_protocol eq local'
1282 Display all messages received on the MSA port, ordered first by the sender's email domain and then by the size of the emails:
1283 exipick --sort sender_address_domain,message_size \
1284 '$received_port == 587'
1286 Display only messages whose every recipient is in the example.com domain, also listing the IP address of the sending host:
1287 exipick --show-vars sender_host_address \
1288 '$each_recipients = example.com'
1290 Same as above, but show values for all defined variables starting with sender_ and the number of recipients:
1291 exipick --show-vars ^sender_,recipients_count \
1292 '$each_recipients = example.com'
1300 Display messages matching all criteria (default)
1304 Display messages in brief format (exiqgrep)
1308 Display messages in standard mailq format (default)
1312 Same as -bp, show generated addresses also (exim)
1316 Show a count of matching messages (exim)
1320 Same as '-bp --unsorted' (exim)
1324 Same as '-bpr --unsorted' (exim)
1328 Same as '-bpu --unsorted' (exim)
1332 Same as -bp, but only show undelivered messages (exim)
1336 Show a count of matching messages (exiqgrep)
1340 Make operators involving '=' honor case
1344 Override the default local character set for $header_ decoding
1348 Same as '$sender_address =~ /<regexp>/' (exiqgrep). Note that this preserves the default case sensitivity of exiqgrep's interface.
1352 Use a single-line output format
1354 =item --freeze <cache file>
1356 Save queue information in an quickly retrievable format
1364 Display only the message IDs (exiqgrep)
1368 Same as -bp (exiqgrep)
1376 Same as '$message_age > <seconds>' (exiqgrep)
1380 Display messages matching any criteria
1384 Same as --reverse (exiqgrep)
1388 Same as '$recipients =~ /<regexp>/' (exiqgrep). Note that this preserves the default case sensitivity of exiqgrep's interface.
1392 Display messages in random order
1396 Display messages in reverse order
1400 Same as '$shown_message_size eq <string>' (exiqgrep)
1402 =item --spool <path>
1404 Set the path to the exim spool to use
1408 Show the internal representation of each criterion specified
1412 Show the result of each criterion on each message
1414 =item --show-vars <variable>[,<variable>...]
1416 Show the value for <variable> for each displayed message. <variable> will be a regular expression if it begins with a circumflex.
1420 Show the total bytes used by each displayed message
1422 =item --thaw <cache file>
1424 Read queue information cached from a previous --freeze run
1426 =item --sort <variable>[,<variable>...]
1428 Display matching messages sorted according to <variable>
1432 Do not apply any sorting to output
1436 Display the version of this command
1440 Same as '!$deliver_freeze' (exiqgrep)
1444 Same as '$message_age < <seconds>' (exiqgrep)
1448 Same as '$deliver_freeze' (exiqgrep)
1454 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.
1456 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.
1458 See the VARIABLES and OPERATORS sections below for more details
1466 Boolean variables are checked simply by being true or false. There is no real operator except negation. Examples of valid boolean tests:
1472 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 mulitplied by 86400, 3600, 60, 1, 1048576, 1024, or 1 respectively. Examples of valid numeric tests:
1473 '$message_age >= 3d'
1474 '$local_interface == 587'
1475 '$message_size < 30K'
1479 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:
1480 '$received_protocol eq esmtp'
1481 '$sender_address = example.com'
1482 '$each_recipients =~ /^a[a-z]{2,3}@example.com$/'
1486 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 equivilant to adding a ! to the beginning of every test.
1492 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.
1494 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.
1497 B - Boolean variables
1498 S - String variables
1499 N - Numeric variables
1500 . - Standard variable matching Exim's content definition
1501 # - Standard variable, contents differ from Exim's definition
1502 + - Non-standard variable
1506 =item S . $acl_c0-$acl_c9, $acl_m0-$acl_m9
1508 User definable variables.
1510 =item B + $allow_unqualified_recipient
1512 TRUE if unqualified recipient addresses are permitted in header lines.
1514 =item B + $allow_unqualified_sender
1516 TRUE if unqualified sender addresses are permitted in header lines.
1518 =item S . $authenticated_id
1520 Optional saved information from authenticators, or the login name of the calling process for locally submitted messages.
1522 =item S . $authenticated_sender
1524 The value of AUTH= param for smtp messages, or a generated value from the calling processes login and qualify domain for locally submitted messages.
1526 =item S . $bheader_*, $bh_*
1528 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.
1530 =item S + $bmi_verdicts
1532 The verdict string provided by a Brightmail content scan
1534 =item N . $body_linecount
1536 The number of lines in the message's body.
1538 =item N . $body_zerocount
1540 The number of binary zero bytes in the message's body.
1542 =item S + $data_path
1544 The path to the body file's location in the filesystem.
1546 =item B + $deliver_freeze
1548 TRUE if the message is currently frozen.
1550 =item N + $deliver_frozen_at
1552 The epoch time at which message was frozen.
1554 =item B + $dont_deliver
1556 TRUE if, under normal circumstances, Exim will not try to deliver the message.
1558 =item S + $each_recipients
1560 This is a psuedo 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.
1562 =item S + $each_recipients_del
1564 Like $each_recipients, but for $recipients_del
1566 =item S + $each_recipients_undel
1568 Like $each_recipients, but for $recipients_undel
1570 =item B . $first_delivery
1572 TRUE if the message has never been deferred.
1574 =item S . $header_*, $h_*
1576 This will always match the contents of the corresponding $bheader_* variable currently (the same behaviour Exim displays when iconv is not installed).
1578 =item S + $header_path
1580 The path to the header file's location in the filesystem.
1582 =item B . $host_lookup_deferred
1584 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.
1586 =item B . $host_lookup_failed
1588 TRUE if there was an attempt to look up the host's name from its IP address, but the attempt returned a negative result.
1590 =item B + $local_error_message
1592 TRUE if the message is a locally-generated error message.
1594 =item S . $local_scan_data
1596 The text returned by the local_scan() function when a message is received.
1598 =item B . $manually_thawed
1600 TRUE when the message has been manually thawed.
1602 =item N . $max_received_linelength
1604 The number of bytes in the longest line that was received as part of the message, not counting line termination characters.
1606 =item N . $message_age
1608 The number of seconds since the message was received.
1610 =item S # $message_body
1612 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.
1614 =item B + $message_body_missing
1616 TRUE is a message's spool data file (-D file) is missing or unreadable.
1618 =item N . $message_body_size
1620 The size of the body in bytes.
1622 =item S . $message_exim_id, $message_id
1624 The unique message id that is used by Exim to identify the message. $message_id is deprecated as of Exim 4.53.
1626 =item S . $message_headers
1628 A concatenation of all the header lines except for lines added by routers or transports. RFC2047 decoding is performed
1630 =item S . $message_headers_raw
1632 A concatenation of all the header lines except for lines added by routers or transports. No decoding or translation is performed.
1634 =item N . $message_linecount
1636 The number of lines in the entire message (body and headers).
1638 =item N . $message_size
1640 The size of the message in bytes.
1642 =item N . $originator_gid
1644 The group id under which the process that called Exim was running as when the message was received.
1646 =item S + $originator_login
1648 The login of the process which called Exim.
1650 =item N . $originator_uid
1652 The user id under which the process that called Exim was running as when the message was received.
1654 =item S . $received_ip_address, $interface_address
1656 The address of the local IP interface for network-originated messages. $interface_address is deprecated as of Exim 4.64
1658 =item N . $received_port, $interface_port
1660 The local port number if network-originated messages. $interface_port is deprecated as of Exim 4.64
1662 =item N . $received_count
1664 The number of Received: header lines in the message.
1666 =item S . $received_protocol
1668 The name of the protocol by which the message was received.
1670 =item N . $received_time
1672 The epoch time at which the message was received.
1674 =item S # $recipients
1676 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.
1678 =item N . $recipients_count
1680 The number of envelope recipients for the message.
1682 =item S + $recipients_del
1684 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.
1686 =item N + $recipients_del_count
1688 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.
1690 =item S + $recipients_undel
1692 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.
1694 =item N + $recipients_undel_count
1696 The number of envelope recipients for the message which have not yet been delivered.
1698 =item S . $reply_address
1700 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.
1702 =item S . $rheader_*, $rh_*
1704 The value of the message's header(s) with the same name. See section 11.5 of Exim's spec.txt for full description.
1706 =item S . $sender_address
1708 The sender's address that was received in the message's envelope. For bounce messages, the value of this variable is the empty string.
1710 =item S . $sender_address_domain
1712 The domain part of $sender_address.
1714 =item S . $sender_address_local_part
1716 The local part of $sender_address.
1718 =item S . $sender_helo_name
1720 The HELO or EHLO value supplied for smtp or bsmtp messages.
1722 =item S . $sender_host_address
1724 The remote host's IP address.
1726 =item S . $sender_host_authenticated
1728 The name of the authenticator driver which successfully authenticated the client from which the message was received.
1730 =item S . $sender_host_name
1732 The remote host's name as obtained by looking up its IP address.
1734 =item N . $sender_host_port
1736 The port number that was used on the remote host for network-originated messages.
1738 =item S . $sender_ident
1740 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.
1742 =item B + $sender_local
1744 TRUE if the message was locally generated.
1746 =item B + $sender_set_untrusted
1748 TRUE if the envelope sender of this message was set by an untrusted local caller.
1750 =item S + $shown_message_size
1752 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.
1754 =item S . $smtp_active_hostname
1756 The value of the active host name when the message was received, as specified by the "smtp_active_hostname" option.
1758 =item S . $spam_score
1760 The spam score of the message, for example '3.4' or '30.5'. (Requires exiscan or WITH_CONTENT_SCAN)
1762 =item S . $spam_score_int
1764 The spam score of the message, multiplied by ten, as an integer value. For instance '34' or '305'. (Requires exiscan or WITH_CONTENT_SCAN)
1766 =item B . $tls_certificate_verified
1768 TRUE if a TLS certificate was verified when the message was received.
1770 =item S . $tls_cipher
1772 The cipher suite that was negotiated for encrypted SMTP connections.
1774 =item S . $tls_peerdn
1776 The value of the Distinguished Name of the certificate if Exim is configured to request one
1778 =item N + $warning_count
1780 The number of delay warnings which have been sent for this message.
1788 =item EMAIL: proj-exipick@jetmore.net
1790 =item HOME: jetmore.org/john/code/#exipick