3 # SET THIS TO THE PATH TO YOUR SPOOL DIR!
4 my $spool = '/var/spool/exim';
5 # SET THIS TO THE DEFAULT HEADER CHARACTER SET!
6 my $charset = 'ISO-8859-1';
8 # use 'exipick --help' to view documentation for this program.
9 # Documentation also viewable online at
10 # http://www.exim.org/eximwiki/ToolExipickManPage
15 my($p_name) = $0 =~ m|/?([^/]+)$|;
16 my $p_version = "20061117.2";
17 my $p_usage = "Usage: $p_name [--help|--version] (see --help for details)";
19 Copyright (c) 2003-2006 John Jetmore <jj33\@pobox.com>
21 This program is free software; you can redistribute it and/or modify
22 it under the terms of the GNU General Public License as published by
23 the Free Software Foundation; either version 2 of the License, or
24 (at your option) any later version.
26 This program is distributed in the hope that it will be useful,
27 but WITHOUT ANY WARRANTY; without even the implied warranty of
28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 GNU General Public License for more details.
31 You should have received a copy of the GNU General Public License
32 along with this program; if not, write to the Free Software
33 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
35 ext_usage(); # before we do anything else, check for --help
37 $| = 1; # unbuffer STDOUT
39 Getopt::Long::Configure("bundling_override");
41 'spool=s' => \$G::spool, # exim spool dir
42 'bp' => \$G::mailq_bp, # List the queue (noop - default)
43 'bpa' => \$G::mailq_bpa, # ... with generated address as well
44 'bpc' => \$G::mailq_bpc, # ... but just show a count of messages
45 'bpr' => \$G::mailq_bpr, # ... do not sort
46 'bpra' => \$G::mailq_bpra, # ... with generated addresses, unsorted
47 'bpru' => \$G::mailq_bpru, # ... only undelivered addresses, unsorted
48 'bpu' => \$G::mailq_bpu, # ... only undelivered addresses
49 'and' => \$G::and, # 'and' the criteria (default)
50 'or' => \$G::or, # 'or' the criteria
51 'f=s' => \$G::qgrep_f, # from regexp
52 'r=s' => \$G::qgrep_r, # recipient regexp
53 's=s' => \$G::qgrep_s, # match against size field
54 'y=s' => \$G::qgrep_y, # message younger than (secs)
55 'o=s' => \$G::qgrep_o, # message older than (secs)
56 'z' => \$G::qgrep_z, # frozen only
57 'x' => \$G::qgrep_x, # non-frozen only
58 'c' => \$G::qgrep_c, # display match count
59 'l' => \$G::qgrep_l, # long format (default)
60 'i' => \$G::qgrep_i, # message ids only
61 'b' => \$G::qgrep_b, # brief format
62 'size' => \$G::size_only, # sum the size of the matching msgs
63 'not' => \$G::negate, # flip every test
64 'R|reverse' => \$G::reverse, # reverse output (-R is qgrep option)
65 'sort=s' => \@G::sort, # allow you to choose variables to sort by
66 'freeze=s' => \$G::freeze, # freeze data in this file
67 'thaw=s' => \$G::thaw, # thaw data from this file
68 'unsorted' => \$G::unsorted, # unsorted, regardless of output format
69 'random' => \$G::random, # (poorly) randomize evaluation order
70 'flatq' => \$G::flatq, # brief format
71 'caseful' => \$G::caseful, # in '=' criteria, respect case
72 'caseless' => \$G::caseless, # ...ignore case (default)
73 'charset=s' => \$charset, # charset for $bh and $h variables
74 'show-vars=s' => \$G::show_vars, # display the contents of these vars
75 'just-vars' => \$G::just_vars, # only display vars, no other info
76 'show-rules' => \$G::show_rules, # display compiled match rules
77 'show-tests' => \$G::show_tests # display tests as applied to each message
80 # if both freeze and thaw specified, only thaw as it is less desctructive
81 $G::freeze = undef if ($G::freeze && $G::thaw);
82 freeze_start() if ($G::freeze);
83 thaw_start() if ($G::thaw);
85 # massage sort options (make '$var,Var:' be 'var','var')
86 for (my $i = scalar(@G::sort)-1; $i >= 0; $i--) {
87 $G::sort[$i] = lc($G::sort[$i]);
88 $G::sort[$i] =~ s/[\$:\s]//g;
89 if ((my @vars = split(/,/, $G::sort[$i])) > 1) {
90 $G::sort[$i] = $vars[0]; shift(@vars); # replace current slot w/ first var
91 splice(@G::sort, $i+1, 0, @vars); # add other vars after current pos
94 push(@G::sort, "message_exim_id") if (@G::sort);
95 die "empty value provided to --sort not allowed, exiting\n"
96 if (grep /^\s*$/, @G::sort);
98 # massage the qgrep options into standard criteria
99 push(@ARGV, "\$sender_address =~ /$G::qgrep_f/") if ($G::qgrep_f);
100 push(@ARGV, "\$recipients =~ /$G::qgrep_r/") if ($G::qgrep_r);
101 push(@ARGV, "\$shown_message_size eq $G::qgrep_s") if ($G::qgrep_s);
102 push(@ARGV, "\$message_age < $G::qgrep_y") if ($G::qgrep_y);
103 push(@ARGV, "\$message_age > $G::qgrep_o") if ($G::qgrep_o);
104 push(@ARGV, "\$deliver_freeze") if ($G::qgrep_z);
105 push(@ARGV, "!\$deliver_freeze") if ($G::qgrep_x);
107 $G::mailq_bp = $G::mailq_bp; # shut up -w
108 $G::and = $G::and; # shut up -w
109 $G::msg_ids = {}; # short circuit when crit is only MID
110 $G::caseless = $G::caseful ? 0 : 1; # nocase by default, case if both
111 @G::recipients_crit = (); # holds per-recip criteria
112 $spool = $G::spool if ($G::spool);
113 my $count_only = 1 if ($G::mailq_bpc || $G::qgrep_c);
114 my $unsorted = 1 if ($G::mailq_bpr || $G::mailq_bpra ||
115 $G::mailq_bpru || $G::unsorted);
116 my $msg = $G::thaw ? thaw_message_list()
117 : get_all_msgs($spool, $unsorted,
118 $G::reverse, $G::random);
119 die "Problem accessing thaw file\n" if ($G::thaw && !$msg);
120 my $crit = process_criteria(\@ARGV);
121 my $e = Exim::SpoolFile->new();
122 my $tcount = 0 if ($count_only); # holds count of all messages
123 my $mcount = 0 if ($count_only); # holds count of matching messages
124 my $total_size = 0 if ($G::size_only);
125 $e->set_undelivered_only(1) if ($G::mailq_bpru || $G::mailq_bpu);
126 $e->set_show_generated(1) if ($G::mailq_bpra || $G::mailq_bpa);
127 $e->output_long() if ($G::qgrep_l);
128 $e->output_idonly() if ($G::qgrep_i);
129 $e->output_brief() if ($G::qgrep_b);
130 $e->output_flatq() if ($G::flatq);
131 $e->output_vars_only() if ($G::just_vars && $G::show_vars);
132 $e->set_show_vars($G::show_vars) if ($G::show_vars);
133 $e->set_spool($spool);
136 foreach my $m (@$msg) {
137 next if (scalar(keys(%$G::msg_ids)) && !$G::or
138 && !$G::msg_ids->{$m->{message}});
140 my $data = thaw_data();
141 if (!$e->restore_state($data)) {
142 warn "Couldn't thaw $data->{_message}: ".$e->error()."\n";
146 if (!$e->parse_message($m->{message}, $m->{path})) {
147 warn "Couldn't parse $m->{message}: ".$e->error()."\n";
154 foreach my $c (@G::recipients_crit) { # handle each_recip* vars
155 foreach my $addr (split(/, /, $e->get_var($c->{var}))) {
156 my %t = ( 'cmp' => $c->{cmp}, 'var' => $c->{var} );
157 $t{cmp} =~ s/"?\$var"?/'$addr'/;
158 push(@local_crit, \%t);
161 if ($G::show_tests) { print $e->get_var('message_exim_id'), "\n"; }
163 foreach my $c (@$crit, @local_crit) {
164 my $var = $e->get_var($c->{var});
165 my $ret = eval($c->{cmp});
166 if ($G::show_tests) {
167 printf " %25s = '%s'\n %25s => $ret\n",$c->{var},$var,$c->{cmp},$ret;
170 print STDERR "Error in eval '$c->{cmp}': $@\n";
174 if ($G::or) { last CRITERIA; }
175 else { next CRITERIA; }
177 if ($G::or) { next CRITERIA; }
182 # skip this message if any criteria were supplied and it didn't match
183 next MSG if ((scalar(@$crit) || scalar(@local_crit)) && !$match);
185 if ($count_only || $G::size_only) {
187 $total_size += $e->get_var('message_size');
190 # if we are defining criteria to sort on, save the message here. If
191 # we don't save here and do the sort later, we have a chicken/egg
193 push(@G::to_print, { vars => {}, output => "" });
194 foreach my $var (@G::sort) {
195 # save any values we want to sort on. I don't like doing the internal
196 # struct access here, but calling get_var a bunch can be _slow_ =(
197 $G::sort_type{$var} ||= '<=>';
198 $G::to_print[-1]{vars}{$var} = $e->{_vars}{$var};
199 $G::sort_type{$var} = 'cmp' if ($G::to_print[-1]{vars}{$var} =~ /\D/);
201 $G::to_print[-1]{output} = $e->format_message();
203 print $e->format_message();
208 freeze_data($e->get_state());
209 push(@G::frozen_msgs, $m);
214 msg_sort(\@G::to_print, \@G::sort, $G::reverse);
215 foreach my $msg (@G::to_print) {
216 print $msg->{output};
221 print "$mcount matches out of $tcount messages" .
222 ($G::size_only ? " ($total_size)" : "") . "\n";
223 } elsif ($G::mailq_bpc) {
224 print "$mcount" . ($G::size_only ? " ($total_size)" : "") . "\n";
225 } elsif ($G::size_only) {
226 print "$total_size\n";
230 freeze_message_list(\@G::frozen_msgs);
238 # sender_address_domain,shown_message_size
245 foreach my $v (@G::sort) {
246 push(@pieces, "\$a->{vars}{\"$v\"} $G::sort_type{$v} \$b->{vars}{\"$v\"}");
248 my $sort_str = join(" || ", @pieces);
250 @$msgs = sort { eval $sort_str } (@$msgs);
251 @$msgs = reverse(@$msgs) if ($reverse);
261 # FREEZE FILE FORMAT:
267 # message_list_bytes <- 10 bytes, zero-packed, plus \n
270 eval("use Storable");
271 die "Storable module not found: $@\n" if ($@);
272 open(O, ">$G::freeze") || die "Can't open freeze file $G::freeze: $!\n";
273 $G::freeze_handle = \*O;
277 close($G::freeze_handle);
281 eval("use Storable");
282 die "Storable module not found: $@\n" if ($@);
283 open(I, "<$G::thaw") || die "Can't open freeze file $G::thaw: $!\n";
284 $G::freeze_handle = \*I;
288 close($G::freeze_handle);
292 my $h = Storable::freeze($_[0]);
293 print $G::freeze_handle length($h)+1, "\n$h\n";
296 sub freeze_message_list {
297 my $h = Storable::freeze($_[0]);
298 my $l = length($h) + 1;
299 printf $G::freeze_handle "EOM\n$l\n$h\n%010d\n", $l+11+length($l)+1;
302 sub thaw_message_list {
303 my $orig_pos = tell($G::freeze_handle);
304 seek($G::freeze_handle, -11, 2);
305 chomp(my $bytes = <$G::freeze_handle>);
306 seek($G::freeze_handle, $bytes * -1, 2);
307 my $obj = thaw_data();
308 seek($G::freeze_handle, 0, $orig_pos);
314 chomp(my $bytes = <$G::freeze_handle>);
315 return(undef) if (!$bytes || $bytes eq 'EOM');
316 my $read = read(I, $obj, $bytes);
317 die "Format error in thaw file (expected $bytes bytes, got $read)\n"
318 if ($bytes != $read);
320 return(Storable::thaw($obj));
323 sub process_criteria {
329 foreach my $t ('@') { s/$t/\\$t/g; }
330 if (/^(.*?)\s+(<=|>=|==|!=|<|>)\s+(.*)$/) {
331 #print STDERR "found as integer\n";
332 my $v = $1; my $o = $2; my $n = $3;
333 if ($n =~ /^(-?[\d\.]+)M$/) { $n = $1 * 1024 * 1024; }
334 elsif ($n =~ /^(-?[\d\.]+)K$/) { $n = $1 * 1024; }
335 elsif ($n =~ /^(-?[\d\.]+)B?$/) { $n = $1; }
336 elsif ($n =~ /^(-?[\d\.]+)d$/) { $n = $1 * 60 * 60 * 24; }
337 elsif ($n =~ /^(-?[\d\.]+)h$/) { $n = $1 * 60 * 60; }
338 elsif ($n =~ /^(-?[\d\.]+)m$/) { $n = $1 * 60; }
339 elsif ($n =~ /^(-?[\d\.]+)s?$/) { $n = $1; }
341 print STDERR "Expression $_ did not parse: numeric comparison with ",
346 push(@c, { var => lc($v), cmp => "(\$var $o $n)" });
347 } elsif (/^(.*?)\s+(=~|!~)\s+(.*)$/) {
348 #print STDERR "found as string regexp\n";
349 push(@c, { var => lc($1), cmp => "(\"\$var\" $2 $3)" });
350 } elsif (/^(.*?)\s+=\s+(.*)$/) {
351 #print STDERR "found as bare string regexp\n";
352 my $case = $G::caseful ? '' : 'i';
353 push(@c, { var => lc($1), cmp => "(\"\$var\" =~ /$2/$case)" });
354 # quote special characters in perl text string
355 #foreach my $t ('@') { $c[-1]{cmp} =~ s/$t/\\$t/g; }
356 } elsif (/^(.*?)\s+(eq|ne)\s+(.*)$/) {
357 #print STDERR "found as string cmp\n";
358 my $var = lc($1); my $op = $2; my $val = $3;
359 $val =~ s|^(['"])(.*)\1$|$2|;
360 push(@c, { var => $var, cmp => "(\"\$var\" $op \"$val\")" });
361 if (($var eq 'message_id' || $var eq 'message_exim_id') && $op eq "eq") {
362 #print STDERR "short circuit @c[-1]->{cmp} $val\n";
363 $G::msg_ids->{$val} = 1;
365 #foreach my $t ('@') { $c[-1]{cmp} =~ s/$t/\\$t/g; }
366 } elsif (/^(\S+)$/) {
367 #print STDERR "found as boolean\n";
368 push(@c, { var => lc($1), cmp => "(\$var)" });
370 print STDERR "Expression $_ did not parse\n";
374 # assign the results of the cmp test here (handle "!" negation)
375 # also handle global --not negation
376 if ($c[-1]{var} =~ s|^!||) {
377 $c[-1]{cmp} .= $G::negate ? " ? 1 : 0" : " ? 0 : 1";
379 $c[-1]{cmp} .= $G::negate ? " ? 0 : 1" : " ? 1 : 0";
381 # support the each_* psuedo variables. Steal the criteria off of the
382 # queue for special processing later
383 if ($c[-1]{var} =~ /^each_(recipients(_(un)?del)?)$/) {
385 push(@G::recipients_crit,pop(@c));
386 $G::recipients_crit[-1]{var} = $var; # remove each_ from the variable
392 if ($G::show_rules) { foreach (@c) { print "$_->{var}\t$_->{cmp}\n"; } }
398 my $d = shift() . '/input';
399 my $u = shift; # don't sort
400 my $r = shift; # right before returning, reverse order
401 my $o = shift; # if true, randomize list order before returning
404 opendir(D, "$d") || die "Couldn't opendir $d: $!\n";
405 foreach my $e (grep !/^\./, readdir(D)) {
406 if ($e =~ /^[a-zA-Z0-9]$/) {
407 opendir(DD, "$d/$e") || next;
408 foreach my $f (grep !/^\./, readdir(DD)) {
409 push(@m, { message => $1, path => "$d/$e" }) if ($f =~ /^(.{16})-H$/);
412 } elsif ($e =~ /^(.{16})-H$/) {
413 push(@m, { message => $1, path => $d });
420 # loop twice to pretend we're doing a good job of mixing things up
421 for (my $i = 0; $i < 2 * $c; $i++) {
422 my $rand = int(rand($c));
423 ($m[$i % $c],$m[$rand]) = ($m[$rand],$m[$i % $c]);
426 @m = sort { $a->{message} cmp $b->{message} } @m;
428 @m = reverse(@m) if ($r);
435 package Exim::SpoolFile;
437 # versions 4.61 and higher will not need these variables anymore, but they
438 # are left for handling legacy installs
439 $Exim::SpoolFile::ACL_C_MAX_LEGACY = 10;
440 #$Exim::SpoolFile::ACL_M_MAX _LEGACY= 10;
445 bless($self, $class);
447 $self->{_spool_dir} = '';
448 $self->{_undelivered_only} = 0;
449 $self->{_show_generated} = 0;
450 $self->{_output_long} = 1;
451 $self->{_output_idonly} = 0;
452 $self->{_output_brief} = 0;
453 $self->{_output_flatq} = 0;
454 $self->{_output_vars_only} = 0;
455 $self->{_show_vars} = [];
464 $self->{_output_long} = 1;
465 $self->{_output_idonly} = 0;
466 $self->{_output_brief} = 0;
467 $self->{_output_flatq} = 0;
468 $self->{_output_vars_only} = 0;
474 $self->{_output_long} = 0;
475 $self->{_output_idonly} = 1;
476 $self->{_output_brief} = 0;
477 $self->{_output_flatq} = 0;
478 $self->{_output_vars_only} = 0;
484 $self->{_output_long} = 0;
485 $self->{_output_idonly} = 0;
486 $self->{_output_brief} = 1;
487 $self->{_output_flatq} = 0;
488 $self->{_output_vars_only} = 0;
494 $self->{_output_long} = 0;
495 $self->{_output_idonly} = 0;
496 $self->{_output_brief} = 0;
497 $self->{_output_flatq} = 1;
498 $self->{_output_vars_only} = 0;
501 sub output_vars_only {
504 $self->{_output_long} = 0;
505 $self->{_output_idonly} = 0;
506 $self->{_output_brief} = 0;
507 $self->{_output_flatq} = 0;
508 $self->{_output_vars_only} = 1;
515 foreach my $v (split(/\s*,\s*/, $s)) {
516 push(@{$self->{_show_vars}}, $v);
520 sub set_show_generated {
522 $self->{_show_generated} = shift;
525 sub set_undelivered_only {
527 $self->{_undelivered_only} = shift;
532 return $self->{_error};
537 $self->{_error} = shift;
544 $self->{_error} = '';
545 $self->{_delivered} = 0;
546 $self->{_message} = '';
549 $self->{_vars_raw} = {};
551 $self->{_numrecips} = 0;
552 $self->{_udel_tree} = {};
553 $self->{_del_tree} = {};
554 $self->{_recips} = {};
563 $self->{_message} = shift || return(0);
564 $self->{_path} = shift; # optional path to message
565 return(0) if (!$self->{_spool_dir});
566 if (!$self->{_path} && !$self->_find_path()) {
567 # assume the message was delivered from under us and ignore
568 $self->{_delivered} = 1;
571 $self->_parse_header() || return(0);
576 # take the output of get_state() and set up a message internally like
577 # parse_message (except from a saved data struct, not by parsing the
583 return(1) if ($h->{_delivered});
585 $self->{_message} = $h->{_message} || return(0);
586 return(0) if (!$self->{_spool_dir});
588 $self->{_path} = $h->{_path};
589 $self->{_vars} = $h->{_vars};
590 $self->{_numrecips} = $h->{_numrecips};
591 $self->{_udel_tree} = $h->{_udel_tree};
592 $self->{_del_tree} = $h->{_del_tree};
593 $self->{_recips} = $h->{_recips};
595 $self->{_vars}{message_age} = time() - $self->{_vars}{received_time};
599 # This returns the state data for a specific message in a format that can
600 # be later frozen back in to regain state
602 # after calling this function, this specific state is not expect to be
603 # reused. That's because we're returning direct references to specific
604 # internal structures. We're also modifying the structure ourselves
605 # by deleting certain internal message variables.
608 my $h = {}; # this is the hash ref we'll be returning.
610 $h->{_delivered} = $self->{_delivered};
611 $h->{_message} = $self->{_message};
612 $h->{_path} = $self->{_path};
613 $h->{_vars} = $self->{_vars};
614 $h->{_numrecips} = $self->{_numrecips};
615 $h->{_udel_tree} = $self->{_udel_tree};
616 $h->{_del_tree} = $self->{_del_tree};
617 $h->{_recips} = $self->{_recips};
619 # delete some internal variables that we will rebuild later if needed
620 delete($h->{_vars}{message_body});
621 delete($h->{_vars}{message_age});
626 # keep this sub as a feature if we ever break this module out, but do away
627 # with its use in exipick (pass it in from caller instead)
631 return(0) if (!$self->{_message});
632 return(0) if (!$self->{_spool_dir});
634 # test split spool first on the theory that people concerned about
635 # performance will have split spool set =).
636 foreach my $f (substr($self->{_message}, 5, 1).'/', '') {
637 if (-f "$self->{_spool_dir}/input/$f$self->{_message}-H") {
638 $self->{_path} = $self->{_spool_dir} . "/input/$f";
647 $self->{_spool_dir} = shift;
650 sub get_matching_vars {
656 foreach my $v (keys %{$self->{_vars}}) { push(@r, $v) if ($v =~ /$e/); }
663 # accepts a variable with or without leading '$' or trailing ':'
666 my $var = lc(shift); $var =~ s/^\$//; $var =~ s/:$//;
668 if ($var eq 'message_body' && !defined($self->{_vars}{message_body})) {
670 } elsif ($var =~ s|^([rb]?h)(eader)?_|${1}eader_| &&
671 exists($self->{_vars}{$var}) && !defined($self->{_vars}{$var}))
673 if ((my $type = $1) eq 'rh') {
674 $self->{_vars}{$var} = join('', @{$self->{_vars_raw}{$var}{vals}});
676 # both bh_ and h_ build their strings from rh_. Do common work here
677 my $rh = $var; $rh =~ s|^b?|r|;
678 my $comma = 1 if ($self->{_vars_raw}{$rh}{type} =~ /^[BCFRST]$/);
679 foreach (@{$self->{_vars_raw}{$rh}{vals}}) {
680 my $x = $_; # editing $_ here would change the original, which is bad
683 if ($comma) { chomp($x); $self->{_vars}{$var} .= "$x,\n"; }
684 else { $self->{_vars}{$var} .= $x; }
686 $self->{_vars}{$var} =~ s|[\s\n]*$||;
687 $self->{_vars}{$var} =~ s|,$|| if ($comma);
688 # ok, that's the preprocessing, not do specific processing for h type
690 $self->{_vars}{$var} = $self->_decode_2047($self->{_vars}{$var});
692 $self->{_vars}{$var} =
693 $self->_decode_2047($self->{_vars}{$var}, $charset);
697 elsif ($var eq 'received_count' && !defined($self->{_vars}{received_count}))
699 $self->{_vars}{received_count} =
700 scalar(@{$self->{_vars_raw}{rheader_received}{vals}});
702 elsif ($var eq 'message_headers' && !defined($self->{_vars}{message_headers}))
704 $self->{_vars}{$var} =
705 $self->_decode_2047($self->{_vars}{message_headers_raw}, $charset);
706 chomp($self->{_vars}{$var});
708 elsif ($var eq 'reply_address' && !defined($self->{_vars}{reply_address}))
710 $self->{_vars}{reply_address} = exists($self->{_vars}{"header_reply-to"})
711 ? $self->get_var("header_reply-to") : $self->get_var("header_from");
714 #chomp($self->{_vars}{$var}); # I think this was only for headers, obsolete
715 return $self->{_vars}{$var};
720 my $s = shift; # string to decode
721 my $c = shift; # target charset. If empty, just decode, don't convert
722 my $t = ''; # the translated string
723 my $e = 0; # set to true if we get an error in here anywhere
725 return($s) if ($s !~ /=\?/); # don't even bother to look if there's no sign
728 foreach my $mw (split(/(=\?[^\?]{3,}\?[BQ]\?[^\?]{1,74}\?=)/i, $s)) {
730 if ($mw =~ /=\?([^\?]{3,})\?([BQ])\?([^\?]{1,74})\?=/i) {
731 push(@p, { data => $3, encoding => uc($2), charset => uc($1),
733 if ($p[-1]{encoding} eq 'Q') {
734 my @ow = split('', $p[-1]{data});
736 for (my $i = 0; $i < @ow; $i++) {
737 if ($ow[$i] eq '_') { push(@nw, ' '); }
738 elsif ($ow[$i] eq '=') {
739 if (scalar(@ow) - ($i+1) < 2) { # ran out of characters
741 } elsif ($ow[$i+1] !~ /[\dA-F]/i || $ow[$i+2] !~ /[\dA-F]/i) {
744 #push(@nw, chr('0x'.$ow[$i+1].$ow[$i+2]));
745 push(@nw, pack("C", hex($ow[$i+1].$ow[$i+2])));
749 elsif ($ow[$i] =~ /\s/) { # whitspace is illegal
753 else { push(@nw, $ow[$i]); }
755 $p[-1]{data} = join('', @nw);
756 } elsif ($p[-1]{encoding} eq 'B') {
757 my $x = $p[-1]{data};
758 $x =~ tr#A-Za-z0-9+/##cd;
760 $x =~ tr#A-Za-z0-9+/# -_#;
762 while ($x =~ s/(.{1,60})//s) {
763 $r .= unpack("u", chr(32 + int(length($1)*3/4)) . $1);
768 push(@p, { data => $mw, is_mime => 0,
769 is_ws => ($mw =~ m|^[\s\n]+|sm) ? 1 : 0 });
773 for (my $i = 0; $i < @p; $i++) {
774 # mark entities we want to skip (whitespace between consecutive mimewords)
775 if ($p[$i]{is_mime} && $p[$i+1]{is_ws} && $p[$i+2]{is_mime}) {
779 # if word is a mimeword and we have access to Encode and charset was
780 # specified, try to convert text
781 # XXX _cannot_ get consistent conversion results in perl, can't get them
782 # to return same conversions that exim performs. Until I can figure this
783 # out, don't attempt any conversions (header_ will return same value as
785 #if ($c && $p[$i]{is_mime} && $self->_try_load('Encode')) {
786 # # XXX not sure how to catch errors here
787 # Encode::from_to($p[$i]{data}, $p[$i]{charset}, $c);
790 # replace binary zeros w/ '?' in decoded text
791 if ($p[$i]{is_mime}) { $p[$i]{data} =~ s|\x00|?|g; }
797 return(join('', map { $_->{data} } grep { !$_->{skip} } @p));
801 # This isn't a class func but I'm tired
812 my $f = $self->{_path} . '/' . $self->{_message} . '-D';
813 $self->{_vars}{message_body} = ""; # define var so we only come here once
815 open(I, "<$f") || return($self->_error("Couldn't open $f: $!"));
817 return(0) if ($self->{_message}.'-D' ne $_);
819 $self->{_vars}{message_body} = join('', <I>);
821 $self->{_vars}{message_body} =~ s/\n/ /g;
822 $self->{_vars}{message_body} =~ s/\000/ /g;
828 my $f = $self->{_path} . '/' . $self->{_message} . '-H';
830 if (!open(I, "<$f")) {
831 # assume message went away and silently ignore
832 $self->{_delivered} = 1;
836 # There are a few numeric variables that should explicitly be set to
837 # zero if they aren't found in the header. Technically an empty value
838 # works just as well, but might as well be pedantic
839 $self->{_vars}{body_zerocount} = 0;
840 $self->{_vars}{host_lookup_deferred} = 0;
841 $self->{_vars}{host_lookup_failed} = 0;
842 $self->{_vars}{tls_certificate_verified} = 0;
845 return(0) if ($self->{_message}.'-H' ne $_);
846 $self->{_vars}{message_id} = $self->{_message};
847 $self->{_vars}{message_exim_id} = $self->{_message};
851 return(0) if (!/^(.+)\s(\-?\d+)\s(\-?\d+)$/);
852 $self->{_vars}{originator_login} = $1;
853 $self->{_vars}{originator_uid} = $2;
854 $self->{_vars}{originator_gid} = $3;
858 return(0) if (!/^<(.*)>$/);
859 $self->{_vars}{sender_address} = $1;
860 $self->{_vars}{sender_address_domain} = $1;
861 $self->{_vars}{sender_address_local_part} = $1;
862 $self->{_vars}{sender_address_domain} =~ s/^.*\@//;
863 $self->{_vars}{sender_address_local_part} =~ s/^(.*)\@.*$/$1/;
867 return(0) if (!/^(\d+)\s(\d+)$/);
868 $self->{_vars}{received_time} = $1;
869 $self->{_vars}{warning_count} = $2;
870 $self->{_vars}{message_age} = time() - $self->{_vars}{received_time};
874 if (/^(-\S+)\s*(.*$)/) {
877 if ($tag eq '-acl') {
879 return(0) if ($arg !~ /^(\d+)\s(\d+)$/);
880 if ($1 < $Exim::SpoolFile::ACL_C_MAX_LEGACY) {
883 $t = "acl_m" . ($1 - $Exim::SpoolFile::ACL_C_MAX_LEGACY);
885 read(I, $self->{_vars}{$t}, $2+1) || return(0);
886 chomp($self->{_vars}{$t});
887 } elsif ($tag eq '-aclc') {
888 #return(0) if ($arg !~ /^(\d+)\s(\d+)$/);
889 return(0) if ($arg !~ /^(\S+)\s(\d+)$/);
891 read(I, $self->{_vars}{$t}, $2+1) || return(0);
892 chomp($self->{_vars}{$t});
893 } elsif ($tag eq '-aclm') {
894 #return(0) if ($arg !~ /^(\d+)\s(\d+)$/);
895 return(0) if ($arg !~ /^(\S+)\s(\d+)$/);
897 read(I, $self->{_vars}{$t}, $2+1) || return(0);
898 chomp($self->{_vars}{$t});
899 } elsif ($tag eq '-local') {
900 $self->{_vars}{sender_local} = 1;
901 } elsif ($tag eq '-localerror') {
902 $self->{_vars}{local_error_message} = 1;
903 } elsif ($tag eq '-local_scan') {
904 $self->{_vars}{local_scan_data} = $arg;
905 } elsif ($tag eq '-spam_score_int') {
906 $self->{_vars}{spam_score_int} = $arg;
907 $self->{_vars}{spam_score} = $arg / 10;
908 } elsif ($tag eq '-bmi_verdicts') {
909 $self->{_vars}{bmi_verdicts} = $arg;
910 } elsif ($tag eq '-host_lookup_deferred') {
911 $self->{_vars}{host_lookup_deferred} = 1;
912 } elsif ($tag eq '-host_lookup_failed') {
913 $self->{_vars}{host_lookup_failed} = 1;
914 } elsif ($tag eq '-body_linecount') {
915 $self->{_vars}{body_linecount} = $arg;
916 } elsif ($tag eq '-body_zerocount') {
917 $self->{_vars}{body_zerocount} = $arg;
918 } elsif ($tag eq '-frozen') {
919 $self->{_vars}{deliver_freeze} = 1;
920 $self->{_vars}{deliver_frozen_at} = $arg;
921 } elsif ($tag eq '-allow_unqualified_recipient') {
922 $self->{_vars}{allow_unqualified_recipient} = 1;
923 } elsif ($tag eq '-allow_unqualified_sender') {
924 $self->{_vars}{allow_unqualified_sender} = 1;
925 } elsif ($tag eq '-deliver_firsttime') {
926 $self->{_vars}{deliver_firsttime} = 1;
927 $self->{_vars}{first_delivery} = 1;
928 } elsif ($tag eq '-manual_thaw') {
929 $self->{_vars}{deliver_manual_thaw} = 1;
930 $self->{_vars}{manually_thawed} = 1;
931 } elsif ($tag eq '-auth_id') {
932 $self->{_vars}{authenticated_id} = $arg;
933 } elsif ($tag eq '-auth_sender') {
934 $self->{_vars}{authenticated_sender} = $arg;
935 } elsif ($tag eq '-sender_set_untrusted') {
936 $self->{_vars}{sender_set_untrusted} = 1;
937 } elsif ($tag eq '-tls_certificate_verified') {
938 $self->{_vars}{tls_certificate_verified} = 1;
939 } elsif ($tag eq '-tls_cipher') {
940 $self->{_vars}{tls_cipher} = $arg;
941 } elsif ($tag eq '-tls_peerdn') {
942 $self->{_vars}{tls_peerdn} = $arg;
943 } elsif ($tag eq '-host_address') {
944 $self->{_vars}{sender_host_port} = $self->_get_host_and_port(\$arg);
945 $self->{_vars}{sender_host_address} = $arg;
946 } elsif ($tag eq '-interface_address') {
947 $self->{_vars}{received_port} =
948 $self->{_vars}{interface_port} = $self->_get_host_and_port(\$arg);
949 $self->{_vars}{received_ip_address} =
950 $self->{_vars}{interface_address} = $arg;
951 } elsif ($tag eq '-active_hostname') {
952 $self->{_vars}{smtp_active_hostname} = $arg;
953 } elsif ($tag eq '-host_auth') {
954 $self->{_vars}{sender_host_authenticated} = $arg;
955 } elsif ($tag eq '-host_name') {
956 $self->{_vars}{sender_host_name} = $arg;
957 } elsif ($tag eq '-helo_name') {
958 $self->{_vars}{sender_helo_name} = $arg;
959 } elsif ($tag eq '-ident') {
960 $self->{_vars}{sender_ident} = $arg;
961 } elsif ($tag eq '-received_protocol') {
962 $self->{_vars}{received_protocol} = $arg;
963 } elsif ($tag eq '-N') {
964 $self->{_vars}{dont_deliver} = 1;
966 # unrecognized tag, save it for reference
967 $self->{$tag} = $arg;
974 # when we drop out of the while loop, we have the first line of the
975 # delivered tree in $_
979 } elsif ($_ =~ s/^[YN][YN]\s+//) {
980 $self->{_del_tree}{$_} = 1;
985 } while ($_ !~ /^\d+$/);
987 $self->{_numrecips} = $_;
988 $self->{_vars}{recipients_count} = $self->{_numrecips};
989 for (my $i = 0; $i < $self->{_numrecips}; $i++) {
993 if (/^(.*)\s\d+,(\d+),\d+$/) {
994 #print STDERR "exim3 type (untested): $_\n";
995 $self->{_recips}{$1} = { pno => $2 };
997 } elsif (/^(.*)\s(\d+)$/) {
998 #print STDERR "exim4 original type (untested): $_\n";
999 $self->{_recips}{$1} = { pno => $2 };
1001 } elsif (/^(.*)\s(.*)\s(\d+),(\d+)#1$/) {
1002 #print STDERR "exim4 new type #1 (untested): $_\n";
1003 return($self->_error("incorrect format: $_")) if (length($2) != $3);
1004 $self->{_recips}{$1} = { pno => $4, errors_to => $2 };
1006 } elsif (/^.*#(\d+)$/) {
1007 #print STDERR "exim4 #$1 style (unimplemented): $_\n";
1008 $self->_error("exim4 #$1 style (unimplemented): $_");
1010 #print STDERR "default type: $_\n";
1011 $self->{_recips}{$_} = {};
1014 $self->{_udel_tree}{$addr} = 1 if (!$self->{_del_tree}{$addr});
1016 $self->{_vars}{recipients} = join(', ', keys(%{$self->{_recips}}));
1017 $self->{_vars}{recipients_del} = join(', ', keys(%{$self->{_del_tree}}));
1018 $self->{_vars}{recipients_undel} = join(', ', keys(%{$self->{_udel_tree}}));
1019 $self->{_vars}{recipients_undel_count} = scalar(keys(%{$self->{_udel_tree}}));
1020 $self->{_vars}{recipients_del_count} = 0;
1021 foreach my $r (keys %{$self->{_del_tree}}) {
1022 next if (!$self->{_recips}{$r});
1023 $self->{_vars}{recipients_del_count}++;
1028 return(0) if (!/^$/);
1030 # start reading headers
1031 while (read(I, $_, 3) == 3) {
1033 return(0) if (!length($t));
1034 while ($t =~ /^\d$/) {
1040 $t = getc(I); # strip the space out of the file
1041 return(0) if (read(I, $_, $hdr_bytes) != $hdr_bytes);
1042 if ($hdr_flag ne '*') {
1043 $self->{_vars}{message_linecount} += (tr/\n//);
1044 $self->{_vars}{message_size} += $hdr_bytes;
1047 # mark (rb)?header_ vars as existing and store raw value. They'll be
1048 # processed further in get_var() if needed
1049 my($v,$d) = split(/:/, $_, 2);
1050 $v = "header_" . lc($v);
1051 $self->{_vars}{$v} = $self->{_vars}{"b$v"} = $self->{_vars}{"r$v"} = undef;
1052 push(@{$self->{_vars_raw}{"r$v"}{vals}}, $d);
1053 $self->{_vars_raw}{"r$v"}{type} = $hdr_flag;
1054 $self->{_vars}{message_headers_raw} .= $_;
1058 $self->{_vars}{message_body_size} =
1059 (stat($self->{_path}.'/'.$self->{_message}.'-D'))[7] - 19;
1060 if ($self->{_vars}{message_body_size} < 0) {
1061 $self->{_vars}{message_size} = 0;
1062 $self->{_vars}{message_body_missing} = 1;
1064 $self->{_vars}{message_size} += $self->{_vars}{message_body_size} + 1;
1067 $self->{_vars}{message_linecount} += $self->{_vars}{body_linecount};
1069 my $i = $self->{_vars}{message_size};
1070 if ($i == 0) { $i = ""; }
1071 elsif ($i < 1024) { $i = sprintf("%d", $i); }
1072 elsif ($i < 10240) { $i = sprintf("%.1fK", $i / 1024); }
1073 elsif ($i < 1048576) { $i = sprintf("%dK", ($i+512)/1024); }
1074 elsif ($i < 10485760) { $i = sprintf("%.1fM", $i/1048576); }
1075 else { $i = sprintf("%dM", ($i + 524288)/1048576); }
1076 $self->{_vars}{shown_message_size} = $i;
1081 # mimic exim's host_extract_port function - receive a ref to a scalar,
1082 # strip it of port, return port
1083 sub _get_host_and_port {
1085 my $host = shift; # scalar ref, be careful
1087 if ($$host =~ /^\[([^\]]+)\](?:\:(\d+))?$/) {
1090 } elsif ($$host =~ /^(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})(?:\.(\d+))?$/) {
1093 } elsif ($$host =~ /^([\d\:]+)(?:\.(\d+))?$/) {
1101 # honoring all formatting preferences, return a scalar variable of the
1102 # information for the single message matching what exim -bp would show.
1103 # We can print later if we want.
1104 sub format_message {
1107 return if ($self->{_delivered});
1109 # define any vars we want to print out for this message. The requests
1110 # can be regexps, and the defined vars can change for each message, so we
1111 # have to build this list for each message
1113 if (@{$self->{_show_vars}}) {
1115 foreach my $e (@{$self->{_show_vars}}) {
1116 foreach my $v ($self->get_matching_vars($e)) {
1117 next if ($t{$v}); $t{$v}++; push(@vars, $v);
1122 if ($self->{_output_idonly}) {
1123 $o .= $self->{_message};
1124 foreach my $v (@vars) { $o .= " $v='" . $self->get_var($v) . "'"; }
1127 } elsif ($self->{_output_vars_only}) {
1128 foreach my $v (@vars) { $o .= $self->get_var($v) . "\n"; }
1132 if ($self->{_output_long} || $self->{_output_flatq}) {
1133 my $i = int($self->{_vars}{message_age} / 60);
1135 $i = int(($i+30)/60);
1136 if ($i > 72) { $o .= sprintf "%2dd ", int(($i+12)/24); }
1137 else { $o .= sprintf "%2dh ", $i; }
1138 } else { $o .= sprintf "%2dm ", $i; }
1140 if ($self->{_output_flatq} && @vars) {
1141 $o .= join(';', map { "$_='".$self->get_var($_)."'" } (@vars)
1144 $o .= sprintf "%5s", $self->{_vars}{shown_message_size};
1148 $o .= "$self->{_message} ";
1149 $o .= "From: " if ($self->{_output_brief});
1150 $o .= "<$self->{_vars}{sender_address}>";
1152 if ($self->{_output_long}) {
1153 $o .= " ($self->{_vars}{originator_login})"
1154 if ($self->{_vars}{sender_set_untrusted});
1156 # XXX exim contains code here to print spool format errors
1157 $o .= " *** frozen ***" if ($self->{_vars}{deliver_freeze});
1160 foreach my $v (@vars) {
1161 $o .= sprintf " %25s = '%s'\n", $v, $self->get_var($v);
1164 foreach my $r (keys %{$self->{_recips}}) {
1165 next if ($self->{_del_tree}{$r} && $self->{_undelivered_only});
1166 $o .= sprintf " %s %s\n", $self->{_del_tree}{$r} ? "D" : " ", $r;
1168 if ($self->{_show_generated}) {
1169 foreach my $r (keys %{$self->{_del_tree}}) {
1170 next if ($self->{_recips}{$r});
1171 $o .= sprintf " +D %s\n", $r;
1174 } elsif ($self->{_output_brief}) {
1176 foreach my $r (keys %{$self->{_recips}}) {
1177 next if ($self->{_del_tree}{$r});
1180 $o .= " To: " . join(';', @r);
1181 if (scalar(@vars)) {
1182 $o .= " Vars: ".join(';',map { "$_='".$self->get_var($_)."'" } (@vars));
1184 } elsif ($self->{_output_flatq}) {
1185 $o .= " *** frozen ***" if ($self->{_vars}{deliver_freeze});
1187 foreach my $r (keys %{$self->{_recips}}) {
1188 next if ($self->{_del_tree}{$r});
1191 $o .= " " . join(' ', @r);
1200 my $fh = shift || \*STDOUT;
1201 return if ($self->{_delivered});
1203 print $fh $self->format_message();
1209 foreach my $k (sort keys %$self) {
1210 my $r = ref($self->{$k});
1211 if ($r eq 'ARRAY') {
1212 printf "%20s <<EOM\n", $k;
1213 print @{$self->{$k}}, "EOM\n";
1214 } elsif ($r eq 'HASH') {
1215 printf "%20s <<EOM\n", $k;
1216 foreach (sort keys %{$self->{$k}}) {
1217 printf "%20s %s\n", $_, $self->{$k}{$_};
1221 printf "%20s %s\n", $k, $self->{$k};
1229 if ($ARGV[0] =~ /^--help$/i) {
1231 $ENV{PATH} .= ":" unless $ENV{PATH} eq "";
1232 $ENV{PATH} = "$ENV{PATH}$Config::Config{'installscript'}";
1233 #exec("perldoc", "-F", "-U", $0) || exit 1;
1234 $< = $> = 1 if ($> == 0 || $< == 0);
1235 exec("perldoc", $0) || exit 1;
1237 %Config::Config = ();
1238 } elsif ($ARGV[0] =~ /^--version$/i) {
1239 print "$p_name version $p_version\n\n$p_cp\n";
1251 exipick - selectively display messages from an Exim queue
1255 exipick [<options>] [<criterion> [<criterion> ...]]
1259 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.
1263 Delete every frozen message from queue:
1264 exipick -zi | xargs exim -Mrm
1266 Show only messages which have not yet been virus scanned:
1267 exipick '$received_protocol ne virus-scanned'
1269 Run the queue in a semi-random order:
1270 exipick -i --random | xargs exim -M
1272 Show the count and total size of all messages which either originated from localhost or have a received protocol of 'local':
1273 exipick --or --size --bpc \
1274 '$sender_host_address eq 127.0.0.1' \
1275 '$received_protocol eq local'
1277 Display all messages received on the MSA port, ordered first by the sender's email domain and then by the size of the emails:
1278 exipick --sort sender_address_domain,message_size \
1279 '$received_port == 587'
1281 Display only messages whose every recipient is in the example.com domain, also listing the IP address of the sending host:
1282 exipick --show-vars sender_host_address \
1283 '$each_recipients = example.com'
1285 Same as above, but show values for all defined variables starting with sender_ and the number of recipients:
1286 exipick --show-vars ^sender_,recipients_count \
1287 '$each_recipients = example.com'
1295 Display messages matching all criteria (default)
1299 Display messages in brief format (exiqgrep)
1303 Display messages in standard mailq format (default)
1307 Same as -bp, show generated addresses also (exim)
1311 Show a count of matching messages (exim)
1315 Same as '-bp --unsorted' (exim)
1319 Same as '-bpr --unsorted' (exim)
1323 Same as '-bpu --unsorted' (exim)
1327 Same as -bp, but only show undelivered messages (exim)
1331 Show a count of matching messages (exiqgrep)
1335 Make operators involving '=' honor case
1339 Override the default local character set for $header_ decoding
1343 Same as '$sender_address = <regexp>' (exiqgrep)
1347 Use a single-line output format
1349 =item --freeze <cache file>
1351 Save queue information in an quickly retrievable format
1359 Display only the message IDs (exiqgrep)
1363 Same as -bp (exiqgrep)
1371 Same as '$message_age > <seconds>' (exiqgrep)
1375 Display messages matching any criteria
1379 Same as --reverse (exiqgrep)
1383 Same as '$recipients = <regexp>' (exiqgrep)
1387 Display messages in random order
1391 Display messages in reverse order
1395 Same as '$shown_message_size eq <string>' (exiqgrep)
1397 =item --spool <path>
1399 Set the path to the exim spool to use
1403 Show the internal representation of each criterion specified
1407 Show the result of each criterion on each message
1409 =item --show-vars <variable>[,<variable>...]
1411 Show the value for <variable> for each displayed message. <variable> will be a regular expression if it begins with a circumflex.
1415 Show the total bytes used by each displayed message
1417 =item --thaw <cache file>
1419 Read queue information cached from a previous --freeze run
1421 =item --sort <variable>[,<variable>...]
1423 Display matching messages sorted according to <variable>
1427 Do not apply any sorting to output
1431 Display the version of this command
1435 Same as '!$deliver_freeze' (exiqgrep)
1439 Same as '$message_age < <seconds>' (exiqgrep)
1443 Same as '$deliver_freeze' (exiqgrep)
1449 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.
1451 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.
1453 See the VARIABLES and OPERATORS sections below for more details
1461 Boolean variables are checked simply by being true or false. There is no real operator except negation. Examples of valid boolean tests:
1467 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:
1468 '$message_age >= 3d'
1469 '$local_interface == 587'
1470 '$message_size < 30K'
1474 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:
1475 '$received_protocol eq esmtp'
1476 '$sender_address = example.com'
1477 '$each_recipients =~ /^a[a-z]{2,3}@example.com$/'
1481 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.
1487 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.
1489 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.
1492 B - Boolean variables
1493 S - String variables
1494 N - Numeric variables
1495 . - Standard variable matching Exim's content definition
1496 # - Standard variable, contents differ from Exim's definition
1497 + - Non-standard variable
1501 =item S . $acl_c0-$acl_c9, $acl_m0-$acl_m9
1503 User definable variables.
1505 =item B + $allow_unqualified_recipient
1507 TRUE if unqualified recipient addresses are permitted in header lines.
1509 =item B + $allow_unqualified_sender
1511 TRUE if unqualified sender addresses are permitted in header lines.
1513 =item S . $authenticated_id
1515 Optional saved information from authenticators, or the login name of the calling process for locally submitted messages.
1517 =item S . $authenticated_sender
1519 The value of AUTH= param for smtp messages, or a generated value from the calling processes login and qualify domain for locally submitted messages.
1521 =item S . $bheader_*, $bh_*
1523 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.
1525 =item S + $bmi_verdicts
1527 The verdict string provided by a Brightmail content scan
1529 =item N . $body_linecount
1531 The number of lines in the message's body.
1533 =item N . $body_zerocount
1535 The number of binary zero bytes in the message's body.
1537 =item B + $deliver_freeze
1539 TRUE if the message is currently frozen.
1541 =item N + $deliver_frozen_at
1543 The epoch time at which message was frozen.
1545 =item B + $dont_deliver
1547 TRUE if, under normal circumstances, Exim will not try to deliver the message.
1549 =item S + $each_recipients
1551 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.
1553 =item S + $each_recipients_del
1555 Like $each_recipients, but for $recipients_del
1557 =item S + $each_recipients_undel
1559 Like $each_recipients, but for $recipients_undel
1561 =item B . $first_delivery
1563 TRUE if the message has never been deferred.
1565 =item S . $header_*, $h_*
1567 This will always match the contents of the corresponding $bheader_* variable currently (the same behaviour Exim displays when iconv is not installed).
1569 =item B . $host_lookup_deferred
1571 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.
1573 =item B . $host_lookup_failed
1575 TRUE if there was an attempt to look up the host's name from its IP address, but the attempt returned a negative result.
1577 =item B + $local_error_message
1579 TRUE if the message is a locally-generated error message.
1581 =item S . $local_scan_data
1583 The text returned by the local_scan() function when a message is received.
1585 =item B . $manually_thawed
1587 TRUE when the message has been manually thawed.
1589 =item N . $message_age
1591 The number of seconds since the message was received.
1593 =item S # $message_body
1595 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.
1597 =item B + $message_body_missing
1599 TRUE is a message's spool data file (-D file) is missing or unreadable.
1601 =item N . $message_body_size
1603 The size of the body in bytes.
1605 =item S . $message_exim_id, $message_id
1607 The unique message id that is used by Exim to identify the message. $message_id is deprecated as of Exim 4.53.
1609 =item S . $message_headers
1611 A concatenation of all the header lines except for lines added by routers or transports. RFC2047 decoding is performed
1613 =item S . $message_headers_raw
1615 A concatenation of all the header lines except for lines added by routers or transports. No decoding or translation is performed.
1617 =item N . $message_linecount
1619 The number of lines in the entire message (body and headers).
1621 =item N . $message_size
1623 The size of the message in bytes.
1625 =item N . $originator_gid
1627 The group id under which the process that called Exim was running as when the message was received.
1629 =item S + $originator_login
1631 The login of the process which called Exim.
1633 =item N . $originator_uid
1635 The user id under which the process that called Exim was running as when the message was received.
1637 =item S . $received_ip_address, $interface_address
1639 The address of the local IP interface for network-originated messages. $interface_address is deprecated as of Exim 4.64
1641 =item N . $received_port, $interface_port
1643 The local port number if network-originated messages. $interface_port is deprecated as of Exim 4.64
1645 =item N . $received_count
1647 The number of Received: header lines in the message.
1649 =item S . $received_protocol
1651 The name of the protocol by which the message was received.
1653 =item N . $received_time
1655 The epoch time at which the message was received.
1657 =item S # $recipients
1659 The list of envelope recipients for a message. Unlike Exim's version, this variable always contains every recipient of the message. The recipients are seperated by a comma and a space. See also $each_recipients.
1661 =item N . $recipients_count
1663 The number of envelope recipients for the message.
1665 =item S + $recipients_del
1667 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.
1669 =item N + $recipients_del_count
1671 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.
1673 =item S + $recipients_undel
1675 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.
1677 =item N + $recipients_undel_count
1679 The number of envelope recipients for the message which have not yet been delivered.
1681 =item S . $reply_address
1683 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.
1685 =item S . $rheader_*, $rh_*
1687 The value of the message's header(s) with the same name. See section 11.5 of Exim's spec.txt for full description.
1689 =item S . $sender_address
1691 The sender's address that was received in the message's envelope. For bounce messages, the value of this variable is the empty string.
1693 =item S . $sender_address_domain
1695 The domain part of $sender_address.
1697 =item S . $sender_address_local_part
1699 The local part of $sender_address.
1701 =item S . $sender_helo_name
1703 The HELO or EHLO value supplied for smtp or bsmtp messages.
1705 =item S . $sender_host_address
1707 The remote host's IP address.
1709 =item S . $sender_host_authenticated
1711 The name of the authenticator driver which successfully authenticated the client from which the message was received.
1713 =item S . $sender_host_name
1715 The remote host's name as obtained by looking up its IP address.
1717 =item N . $sender_host_port
1719 The port number that was used on the remote host for network-originated messages.
1721 =item S . $sender_ident
1723 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.
1725 =item B + $sender_local
1727 TRUE if the message was locally generated.
1729 =item B + $sender_set_untrusted
1731 TRUE if the envelope sender of this message was set by an untrusted local caller.
1733 =item S + $shown_message_size
1735 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.
1737 =item S . $smtp_active_hostname
1739 The value of the active host name when the message was received, as specified by the "smtp_active_hostname" option.
1741 =item S . $spam_score
1743 The spam score of the message, for example '3.4' or '30.5'. (Requires exiscan or WITH_CONTENT_SCAN)
1745 =item S . $spam_score_int
1747 The spam score of the message, multiplied by ten, as an integer value. For instance '34' or '305'. (Requires exiscan or WITH_CONTENT_SCAN)
1749 =item B . $tls_certificate_verified
1751 TRUE if a TLS certificate was verified when the message was received.
1753 =item S . $tls_cipher
1755 The cipher suite that was negotiated for encrypted SMTP connections.
1757 =item S . $tls_peerdn
1759 The value of the Distinguished Name of the certificate if Exim is configured to request one
1761 =item N + $warning_count
1763 The number of delay warnings which have been sent for this message.
1771 =item EMAIL: proj-exipick@jetmore.net
1773 =item HOME: jetmore.org/john/code/#exipick