This file is indexed.

/usr/sbin/exinext is in exim4-base 4.76-3ubuntu3.

This file is owned by root:root, with mode 0o755.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
#! /bin/sh
# $Cambridge: exim/src/src/exinext.src,v 1.5 2009/11/16 19:50:36 nm4 Exp $

# Copyright (c) University of Cambridge, 1995 - 2007
# See the file NOTICE for conditions of use and distribution.

# Except when they appear in comments, the following placeholders in this
# source are replaced when it is turned into a runnable script:
#
# CONFIGURE_FILE_USE_NODE
# CONFIGURE_FILE
# BIN_DIRECTORY

# This file has been so processed.

# A shell+perl script to fish out the next retry time for a given domain;
# it first calls exim to find out which hosts are set up for that domain and
# then fishes out the retry data for each one.

# For testing the selection and formatting logic, and perhaps for use in
# special cases, the script can have an argument -C <filename> to specify
# the use of an alternate Exim configuration file. It may also have any number
# of -D options to set macros that are passed to exim.

config=
eximmacdef=
exim_path=

if expr -- $1 : '\-' >/dev/null ; then
  while expr -- $1 : '\-' >/dev/null ; do
    if [ "$1" = "-C" ]; then
      config=$2
      shift
      shift
    elif expr -- $1 : '\-D' >/dev/null ; then
      eximmacdef="$eximmacdef $1"
      if expr -- $1 : '\-DEXIM_PATH=' >/dev/null ; then
        exim_path=`expr -- $1 : '\-DEXIM_PATH=\(.*\)'`
      fi
      shift
    else
      break
    fi
  done
fi

# We need to save the script's argument because in the absence of -C we need to
# use shell arguments for sorting out the configuration file name.

argone=$1

# This is the normal case when no config file or macros are specified

if [ "$config" = "" ]; then
  # See if this installation is using the esoteric "USE_NODE" feature of Exim,
  # in which it uses the host's name as a suffix for the configuration file name.

  if [ "" = "yes" ]; then
    hostsuffix=.`uname -n`
  fi

  # Now find the configuration file name. This has got complicated because
  # /etc/exim4/exim4.conf:/var/lib/exim4/config.autogenerated may now be a list of files. The one that is used is the first
  # one that exists. Mimic the code in readconf.c by testing first for the
  # suffixed file in each case.

  set `awk -F: '{ for (i = 1; i <= NF; i++) print $i }' <<End
/etc/exim4/exim4.conf:/var/lib/exim4/config.autogenerated
End
`
  while [ "$config" = "" -a $# -gt 0 ] ; do
    if [ -f "$1$hostsuffix" ] ; then
      config="$1$hostsuffix"
    elif [ -f "$1" ] ; then
      config="$1"
    fi
    shift
  done
fi

# Determine where the spool directory is. Search for an exim_path setting
# in the configure file; otherwise use the bin directory. Call that version of
# Exim to find the spool directory and the qualify domain. BEWARE: a tab
# character is needed in the command below. It has had a nasty tendency to get
# lost in the past. Use a variable to hold a space and a tab to keep the tab in
# one place.

st='     '

if [ "$exim_path" = "" ]; then
  exim_path=`grep "^[$st]*exim_path" $config | sed "s/.*=[$st]*//"`
fi

if test "$exim_path" = ""; then exim_path=/usr/sbin/exim4; fi
spool_directory=`$exim_path $eximmacdef -bP spool_directory | sed 's/.*=[  ]*//'`
qualify_domain=`$exim_path $eximmacdef -bP qualify_domain | sed 's/.*=[  ]*//'`

# Now do the job. Perl uses $ so frequently that we don't want to have to
# escape them all from the shell, so pass in shell variable values as
# arguments.

# 16-May-1996  Fixed it to do better if routing fails to complete.
#              Improved the format of the output.
# 10-Jun-1996  Complain if no argument given.
# 02-Aug-1996  Lower case the domain.
# 14-Jan-1999  Add subject to want list even if remote host found, so as to
#              pick up routing delays after temporary recipient errors.
#              Also add unqualified subject if it looks like a message id.
# 01-Apr-2004  Add the -C feature for testing
# 22-Dec-2005  Complete the -C feature (!)

if [ "$argone" = "" ]; then
  echo "Usage: exinext <address>|<domain>|<local-part>"
  exit 1
fi

perl - $exim_path "$eximmacdef" $argone $spool_directory $qualify_domain $config <<'End'

  # Name the arguments

  $exim = $ARGV[0];
  $eximmacdef = $ARGV[1];
  $subject = $ARGV[2];
  $spool = $ARGV[3];
  $qualify = $ARGV[4];
  $config = $ARGV[5];

  # If the subject doesn't contain an @ then construct an address
  # for the domain, and ensure that in both cases the domain is
  # lower cased.

  $address = ($subject =~ /^([^\@]*)\@([^\@]*)$/)?
    "$1\@\L$2\E" : "User\@\L$subject\E";

  # Run Exim to get a list of hosts for the given domain; for
  # each one construct the appropriate retry key.

  open(LIST, "$exim -v -bt $address |") ||
    die "can't run exim to route $address";

  while (<LIST>)
    {
    chop;
    push(@list, $_) if s/\s*host (\S+)\s+\[(.+)\].*/$1:$2/;
    print "$_\n" if /cannot be resolved/;
    }
  close(LIST);

  # If there were no hosts, assume that what was given was a local
  # username, unless it contains an @, and construct a suitable retry
  # key for that. Also, if it looks like a message id, search for that
  # as well, so as to pick up message-specific retry data.

  if (scalar(@list) == 0)
    {
    push(@list, $subject) if $subject =~ /^\w{6}-\w{6}-\w{2}$/;

    if ($subject !~ /\@/ && $subject !~ /\./)
      {
      push(@list, "$subject\@$qualify");
      }
    else
      {
      print "No remote hosts found for $subject\n";
      }
    }

  # Always search for the full address, even if hosts are found, in case
  # there is a routing delay caused by a temporary recipient error.

  push(@list, $subject);

  # Run exim_dumpdb to get out the retry data and pick off what we want

  open(DATA, "/usr/sbin/exim_dumpdb $spool retry |") ||
    die "can't run exim_dumpdb";

  while (<DATA>)
    {
    for ($i = 0; $i <= $#list; $i++)
      {
      if (/$list[$i]/)
        {
        $printed = 1;
        if (/^\s*T:[^:\s]*:/)
          {
          ($key,$error,$error2,$text) = /^\s*T:(\S+)\s+(\S+)\s+(\S+)\s*(.*)$/;

          # Parsing the keys is a nightmare because of IPv6. The design of the
          # format for the keys is a complete shambles. All my fault (PH). But
          # I don't want to change it just for this purpose. If they key
          # contains more than 3 colons, we have an IPv6 address, because
          # an IPv6 address must contain at least two colons.

          # Deal with IPv4 addresses (3 colons or fewer)

          if ($key !~ /:([^:]*?:){3}/)
            {
            ($host,$ip,$port,$msgid) = $key =~
              /^([^:]*):([^:]*)(?::([^:]*)(?::(\S*)|)|)/;
            }

          # Deal with IPv6 addresses; sorting out the colons is a complete
          # mess. We should be able to find the host name and IP address from
          # further in the message. That seems the easiest escape plan here. We
          # can use those to match the rest of the key.

          else
            {
            ($host,$ip) = $text =~ /host\s(\S+)\s\[([^]]+)\]/;
            if (defined $host)
              {
              ($port,$msgid) = $key =~
                /^$host:$ip(?::([^:]*)(?::(\S*)|)|)/;
              }

           # This will probably be wrong...

           else
             {
             ($host,$ip) = $key =~ /([^:]*):(.*)/;
             }
            }

          printf("Transport: %s [%s]", $host, $ip);
          print ":$port" if defined $port;
          print " $msgid" if defined $msgid;
          print " error $error: $text\n";
          }

        else
          {
          ($type,$domain,$error,$error2,$text) =
            /^\s*(\S):(\S+)\s+(\S+)\s+(\S+)\s*(.*)$/;
          $type = ($type eq 'R')? "Route: " :
                  ($type eq 'T')? "Transport: " : "";
          print "$type$domain error $error: $text\n";
          }
        $_ = <DATA>;
        ($first,$last,$next,$expired) =
          /^(\S+\s+\S+)\s+(\S+\s+\S+)\s+(\S+\s+\S+)\s*(\*?)/;
        print "  first failed: $first\n";
        print "  last tried:   $last\n";
        print "  next try at:  $next\n";
        print "  past final cutoff time\n" if $expired eq "*";
        }
      }
    }

  close(DATA);
  print "No retry data found for $subject\n" if !$printed;
End