home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / mush-7.1.1 / addrs.c next >
Encoding:
C/C++ Source or Header  |  1990-05-02  |  32.6 KB  |  1,136 lines
  1. /* addrs.c -- copyright (c) Dan Heller 1/25/1989 */
  2.  
  3. #include "mush.h"
  4.  
  5. /*
  6.  * Check to see if all addressees in list1 is in list2.
  7.  * The lists must be as clean as the driven snow (no comments, aliases
  8.  * must have been expanded, all are separated by whitespace (for mk_argv).
  9.  *
  10.  * "user" matches "user" and "user@localhost"
  11.  * "*user" matches "user" at any address whatsoever."
  12.  * !host matches any user destined for the specified host.
  13.  * !some!path is the same, but can be more specifiec in the path.
  14.  * @dom.ain can match any user destined for any host within the domain.
  15.  *      @berkeley.edu would match: dheller@cory.berkeley.edu
  16.  */
  17. compare_addrs(list1, list2, ret_buf)
  18. char *list1, *list2, ret_buf[];
  19. {
  20.     register char    *p;
  21.     char        **addrv, **listv, buf[256]; /* addrs aren't long */
  22.     int            addrc, listc, a, l, h, ret_val;
  23.  
  24.     /* autosign2 list contains non-comment addresses */
  25.     listv = mk_argv(list1, &listc, FALSE);
  26.     addrv = mk_argv(list2, &addrc, FALSE);
  27.  
  28.     /* loop thru both lists and convert addresses to !-format
  29.      * then remove ourhost names so "user" matches "user!local"
  30.      * also remove possible trailing commas (from list).
  31.      */
  32.     for (a = 0; a < addrc; a++) {
  33.     if (a != addrc-1 && (p = index(addrv[a], ',')) && !p[1])
  34.         *p = 0;
  35.     if (addrv[a][0] == '!' || addrv[a][0] == '@')
  36.         continue;
  37.     (void) bang_form(buf, addrv[a]);
  38.     if (strcmp(addrv[a], buf)) /* if they differ... */
  39.         (void) strcpy(addrv[a], buf); /* save new version */
  40.     }
  41.     for (l = 0; l < listc; l++) {
  42.     if (l != listc-1 && (p = index(listv[l], ',')) && !p[1])
  43.         *p = 0;
  44.     if (listv[l][0] == '!' || listv[l][0] == '@')
  45.         continue;
  46.     (void) bang_form(buf, listv[l]);
  47.     if (strcmp(listv[l], buf)) /* if they differ... */
  48.         (void) strdup(listv[l], buf); /* save new version */
  49.     }
  50.  
  51.     Debug("\nlist1 = "), print_argv(listv);
  52.     Debug("list2 = "), print_argv(addrv), putchar('\n');
  53.  
  54.     /* loop thru each list comparing each element with the
  55.      * other, if necessary.
  56.      */
  57.     for (l = 0; l < listc; l++) {
  58.     ret_val = 0;
  59.     /* check if local recipient with was specified. */
  60.     if (!(p = rindex(listv[l], '!')))
  61.         for (a = 0; a < addrc; a++) {
  62.         /* we have a local user so far.  If addrv[] is
  63.          * not remote, then strcmp() immediately.
  64.          * Note that "!" with no host indicates *all*
  65.          * local users!!!
  66.          */
  67.         if (addrv[a][0] == '*') {
  68.             /* "*user" == "user" or "*" == login */
  69.             if (!addrv[a][1] && !lcase_strncmp(listv[l], login, -1) ||
  70.             !lcase_strncmp(listv[l], addrv[a]+1, -1))
  71.             ret_val = 1;
  72.         } else if (addrv[a][0] != '!') {
  73.            if (!lcase_strncmp(addrv[a], listv[l], -1) || !addrv[a][1])
  74.             ret_val = 1;
  75.         } else for (h = 0; ourname && ourname[h]; h++)
  76.             if (!lcase_strncmp(addrv[a]+1, ourname[h], -1)) {
  77.             ret_val = 1;
  78.             break;
  79.             }
  80.         if (ret_val)
  81.             break;
  82.         }
  83.     /* else this is a remote user */
  84.     else {
  85.         /* check all the addresses for @dom.ain stuff or
  86.          * !path!name type stuff only.
  87.          */
  88.         /* first back up p to the previous '!' */
  89.         char *start, *user = p + 1;
  90.         while (p > listv[l] && *--p != '!')
  91.         ;
  92.         start = p; /* Where to start for _domain_ addrs */
  93.         for (a = 0; a < addrc; a++) {
  94.         int len;
  95.         char *path;
  96.  
  97.         /* first check the cases of address unmodified by @ and !
  98.          * or check to see if  *user  is specified.
  99.          */ 
  100.         if (addrv[a][0] != '@' && addrv[a][0] != '!') {
  101.             if (addrv[a][0] == '*') {
  102.             /* we saved the username at "user" declaration. */
  103.             /* if "*" is by itself, check against user's login */
  104.             if (!addrv[a][1] && !lcase_strncmp(user, login, -1) ||
  105.                 addrv[a][1] && !lcase_strncmp(user,addrv[a]+1,-1)){
  106.                 ret_val = 1;
  107.                 break;
  108.             }
  109.             } else if (!lcase_strncmp(addrv[a], listv[l], -1)) {
  110.             ret_val = 1;
  111.             break;
  112.             }
  113.             continue;
  114.         }
  115.         path = addrv[a]+1;
  116.         while (addrv[a][0] == '@' && *path == '.')
  117.             path++;
  118.         if ((len = strlen(path)) == 0)
  119.             continue; /* localhost stuff only -- can't match */
  120.         /* first check against specified domains */
  121.         if (addrv[a][0] == '@') {
  122.             for (p = start; p; (p = index(p, '.')) && ++p)
  123.             if (!lcase_strncmp(p, path, len) &&
  124.                 (p[len] == '.' || p[len] == 0 || p[len] == '!')) {
  125.                 ret_val = 1;
  126.                 break;
  127.             }
  128.         } else if (addrv[a][0] == '!') {
  129.             /* for !path style, start at head of addr */
  130.             for (p = listv[l]; p; (p = index(p, '!')) && ++p)
  131.             if (!lcase_strncmp(p, path, len) &&
  132.                 (p[len] == '!' || p[len] == 0)) {
  133.                 ret_val = 1;
  134.                 break;
  135.             }
  136.         }
  137.         /* If address is in autosign2, goto next addr */
  138.         if (ret_val)
  139.             break;
  140.         }
  141.     }
  142.     if (!ret_val) {
  143.         /* this address isn't in autosign2 list */
  144.         if (ret_buf)
  145.         (void) strcpy(ret_buf, listv[l]);
  146.         break;
  147.     }
  148.     }
  149.     free_vec(listv);
  150.     free_vec(addrv);
  151.  
  152.     return ret_val;
  153. }
  154.  
  155. /*
  156.  * Parser for stupidly-formed RFC822 addresses.  It has been tested on
  157.  * several bizzare cases as well as the normal stuff and uucp paths.  It
  158.  * takes a string which is a bunch of addresses and unscrambles the first
  159.  * one in the string.  It returns a pointer to the first char past what it
  160.  * unscrambled and copies the unscrambled address to its second argument.
  161.  * 
  162.  * It does NOT deal with trailing (comment) strings --
  163.  *         <whoever@somewhere> (This is a comment)
  164.  *                            ^unscramble_addr return points here
  165.  * 
  166.  * It also does not deal well with malformed <addresses> --
  167.  *         <whoever@somewhere,nowhere>
  168.  *                           ^unscramble_addr return points here
  169.  * 
  170.  * In each of the above cases, the string "whoever@somewhere" is copied
  171.  * to the second argument.
  172.  * 
  173.  * Nothing is done to un-<>ed route-less RFC822/976 addresses, nor to
  174.  * uucp paths, nor to mixed-mode addresses not containing a route.
  175.  * Hopelessly scrambled addresses are not handled brilliantly --
  176.  *     @some.dumb.place,@any.other.place:sys2!user%sys3@sys1
  177.  * parses to
  178.  *     sys2!user%sys3@sys1
  179.  * i.e., the route is simply dropped.
  180.  *
  181.  * If UUCP is defined, a little more work is done with @: routes.  The
  182.  * mangled address given above will unwind to
  183.  *    some.dumb.place!any.other.place!sys1!sys2!sys3!user
  184.  * thanks to intelligence in bang_form().
  185.  */
  186. char *
  187. unscramble_addr(addr, naddr)
  188. char *addr;
  189. char *naddr;
  190. {
  191.     char *i, *r, *at;
  192.     char s[BUFSIZ], t[BUFSIZ];
  193.     int anglebrace = 0;
  194.  
  195.     /* Make a copy of the address so we can mangle it freely. */
  196.     if (addr && *addr) {
  197.     /* Skip any leading whitespace. */
  198.     for (i = addr; *i && (r = any(i, " \t")) == i;)
  199.         if (r)
  200.         i = r + 1;
  201.     if (*i == '\0')
  202.         return NULL;
  203.     /* Skip any leading double-quoted comment. */
  204.     if (*i == '"') {
  205.         if ((i = index(i + 1, '"')) && (*i == '\0' || *(++i) == '\0'))
  206.             return NULL;
  207.     }
  208.     /* Skip any more whitespace. */
  209.     for (; *i && (r = any(i, " \t")) == i;)
  210.         if (r)
  211.         i = r + 1;
  212.     if (*i == '\0')
  213.         return NULL;
  214.     /* Check for angle braces around the address. */
  215.     if (*i == '<') {
  216.         if (*(++i) == '\0')
  217.         return NULL;
  218.         ++anglebrace;
  219.     }
  220.     /*
  221.      * Look for a route.  A route is a comma-separated set of @-tagged
  222.      *  domains terminated by a colon.  Later versions might try to use
  223.      *  the route, but for now it confuses too many mailers.
  224.      */
  225.     if ((*i == '@') && (r = any(i, " \t:"))) {
  226.         if (*r != ':')
  227.         return NULL;
  228.         if (*(r + 1) == '\0')
  229.         return NULL;
  230. #ifndef UUCP
  231.         /*
  232.          * Back up to the rightmost @-tagged domain
  233.          *  (see note below about unwinding)
  234.          */
  235.         *r = '\0';
  236.         i = rindex(i, '@');
  237.         *r = ':';
  238. #endif /* !UUCP */
  239.     }
  240.     /* Remember how much we've skipped, and copy the rest. */
  241.     at = i;
  242.     (void) strncpy(t, i, sizeof t);
  243.     t[sizeof t - 1] = 0;
  244.     /* Strip from a trailing angle brace, if present. */
  245.     if (anglebrace) {
  246.         if (r = any(t, "> \t")) {
  247.         if (r == t || *r != '>')
  248.             return NULL;
  249.         else
  250.             *r = '\0';
  251.         --anglebrace;
  252.         } else
  253.         return NULL;
  254.     }
  255.     if (t[0] == '@') {
  256.         /* Chop off any invalid stuff after the address. */
  257.         if (r = any(index(t, ':'), " \t,(<"))
  258.         *r = '\0';
  259.     }
  260.     } else
  261.     return NULL;
  262.     /* Remember where we are so we can return it. */
  263.     at += strlen(t) + 1;
  264.     /*
  265.      * Unscramble the route, if present.
  266.      *  NOTE:  We assume that a route is present in only two cases:
  267.      *   1) addr was taken from the "From " line of a stupid mailer
  268.      *   2) addr was a well-formed, <> enclosed RFC822 address
  269.      */
  270.     if (t[0] == '@') {
  271. #ifdef UUCP
  272.     if (!bang_form(s, t))
  273.         return NULL;
  274. #else /* UUCP */
  275.     if (r = index(t, ':'))
  276.         r++;
  277.     else
  278.         return NULL;
  279.     /* Delete the route if extraneous, otherwise unwind it. */
  280.     if (i = index(r, '@'))
  281.         (void) strcpy(s, r);
  282.     else {
  283.         /*
  284.          * NOTE:  Unwinding currently uses only the rightmost domain
  285.          *  in the route.  This will break for mailers that need the
  286.          *  entire route.  Complete unwinding would require the use
  287.          *  of % characters, which are avoided for other reasons.
  288.          */
  289.         (void) strcpy(s, r);
  290.         *(--r) = '\0';
  291.         (void) strcat(s, t);
  292.     }
  293. #endif /* UUCP */
  294.     } else
  295.     (void) strcpy(s, t);
  296.     /*
  297.      * Ok, now the address should be in the form user@domain and
  298.      *  is held in buffer s (t[] is not copied directly to naddr
  299.      *  to allow future additional processing to be added here).
  300.      */
  301.     if (debug > 1) /* Don't dump this on trivial debugging */
  302.     wprint("Converting \"%s\" to \"%s\"\n", addr, s);
  303.     (void) strcpy(naddr, s);
  304.     return at;
  305. }
  306.  
  307. /*
  308.  * Convert RFC822 or mixed addresses to RFC976 `!' form,
  309.  *  copying the new address to d.  The source address is
  310.  *  translated according to RFC822 rules.
  311.  * Return a pointer to the end (nul terminus) of d.
  312.  */
  313. char *
  314. bang_form (d, s)
  315. char *d, *s;
  316. {
  317.     char *r, *t, *ab = NULL;
  318.  
  319.     *d = '\0';
  320.     /* If nothing to do, quit now */
  321.     if (!s || !*s) {
  322.     return d;
  323.     }
  324.     /* Avoid any angle braces */
  325.     if (*s == '<') {
  326.     if (ab = index(s + 1, '>'))
  327.         s++, *ab = '\0';
  328.     else
  329.         return NULL;
  330.     }
  331.     /*
  332.      * Look backwards for the first `@'; this gives us the
  333.      * primary domain of the RFC822 address
  334.      */
  335.     if (*s == '@') {
  336.     /* An RFC-822 "@domain1,@domain2:" routing */
  337.     if (t = any(++s, ",:")) {
  338.         char c = *t;
  339.         *t = '\0';
  340.         d += Strcpy(d, s);
  341.         *d++ = '!';
  342.         *t++ = c;
  343.         r = bang_form(d, t);
  344.     } else
  345.         r = NULL;
  346.     } else if ((t = rindex(s, '@')) && t != s) {
  347.     /* Copy the RFC822 domain as the UUCP head */
  348.     d += Strcpy(d, t + 1);
  349.     *d++ = '!';
  350.     *t = '\0';
  351.     r = bang_form(d, s);
  352.     *t = '@';
  353.     } else if (t = index(s, '!')) {
  354.     /* A normal UUCP path */
  355.     *t = '\0';
  356.     d += Strcpy(d, s);
  357.     *t++ = *d++ = '!';
  358.     r = bang_form(d, t);
  359.     } else if (t = rindex(s, '%')) {
  360.     /* An imbedded `%' -- treat as low-priority `@' */
  361.     *t = '@';
  362.     r = bang_form(d, s);
  363.     *t = '%';
  364.     } else
  365.     r = d + Strcpy(d, s);  /* No `@', `!', or `%' */
  366.     if (ab)
  367.     *ab = '>';
  368.     return r;
  369. }
  370.  
  371. /*
  372.  * Route addresses according to certain criteria.  This function is really
  373.  * just a front end for improve_uucp_paths() which does routing (differently).
  374.  * If "route" is null, this routine is being called incorrectly.
  375.  * If route is an address, just call improve_uucp_paths() and return.
  376.  * If route is the null string, then route all addresses via the sender's
  377.  * which is the first name/address on the To: list. If he's on a remote
  378.  * machine, chances are that the addresses of everyone else he mailed to
  379.  * are addresses from his machine.  Reconstruct those addresses to route
  380.  * thru the senders machine first.
  381.  */
  382. route_addresses(to, cc, route_path)
  383. char *to, *cc, *route_path;
  384. {
  385.     char pre_path[256], sender[HDRSIZ], tmp[256];
  386.     register char *next, *p;
  387.     int c;
  388.  
  389.     Debug("route_addresses()\n");
  390.     if (!route_path)
  391.     return;
  392.     if (*route_path) {
  393.     improve_uucp_paths(to, HDRSIZ, route_path);
  394.     improve_uucp_paths(cc, HDRSIZ, route_path);
  395.     return;
  396.     }
  397.  
  398.     pre_path[0] = 0;
  399.     /* Get the address of the sender (which is always listed first) */
  400.     if (!(next = get_name_n_addr(to, NULL, NULL)))
  401.     return;
  402.     c = *next, *next = 0;
  403.     (void) strcpy(sender, to);
  404.     *next = c;
  405.     /* fix up the sender's address; improve_uucp_paths to optimize pre_path */
  406.     improve_uucp_paths(sender, sizeof sender, NULL);
  407.  
  408.     /* check to see if there is only one addr on To: line and no Cc: header */
  409.     if (!*next && (!cc || !*cc)) {
  410.     (void) strcpy(to, sender);
  411.     return;
  412.     }
  413.     /* otherwise, get the pre_path */
  414.     if (p = get_name_n_addr(sender, NULL, tmp))
  415.     c = p - sender; /* save the original length */
  416.     if (*tmp) {
  417.     (void) bang_form(pre_path, tmp);
  418.     if (p = rindex(pre_path, '!')) {
  419.         *p = 0;
  420.         Debug("Routing thru \"%s\"\n", pre_path);
  421.     } else
  422.         pre_path[0] = 0;
  423.     } else
  424.     pre_path[0] = 0;
  425.  
  426.     while (*next == ',' || isspace(*next))
  427.     next++;
  428.     improve_uucp_paths(next, HDRSIZ - (int)(next - to), pre_path);
  429.     improve_uucp_paths(cc, HDRSIZ, pre_path);
  430.     p = sender + c;
  431.     *p++ = ',', *p++ = ' ';
  432.     (void) strcpy(p, next);
  433.     (void) strcpy(to, sender);
  434. }
  435.  
  436. /*
  437.  * pass a string describing header like, "Subject: ", current value, and
  438.  * whether or not to prompt for it or to just post the information.
  439.  * If do_prompt is true, "type in" the current value so user can either
  440.  * modify it, erase it, or add to it.
  441.  */
  442. char *
  443. set_header(str, curstr, do_prompt)
  444. register char *str, *curstr;
  445. {
  446.     static char       buf[HDRSIZ];
  447.     int        offset = 0;
  448.     register char  *p = curstr;
  449.  
  450.     if (!str)
  451.     str = "";
  452.  
  453.     buf[0] = 0;
  454.     print(str);
  455.     (void) fflush(stdout);         /* force str curstr */
  456.     if (do_prompt) {
  457.     if (curstr)
  458.         if (isoff(glob_flags, ECHO_FLAG)) {
  459.         Ungetstr(curstr);
  460.         } else
  461. #ifdef TIOCSTI
  462.         for (p = curstr; *p; p++)
  463.             if (ioctl(0, TIOCSTI, p) == -1) {
  464.             error("ioctl: TIOCSTI");
  465.             print("You must retype the entire line.\n%s", str);
  466.             break;
  467.             }
  468. #else /* !TIOCSTI */
  469.         print("WARNING: -e flag! Type the line over.\n%s", str);
  470. #endif /* TIOCSTI */
  471.  
  472.     if (istool)
  473.         return NULL;
  474.     /* simulate the fact that we're getting input for the letter even tho
  475.      * we may not be.  set_header is called before IS_GETTING is true,
  476.      * but if we set it to true temporarily, then signals will return to
  477.      * the right place (stop/continue).
  478.      */
  479.     {
  480.         u_long getting = ison(glob_flags, IS_GETTING);
  481.         int wrapping = wrapcolumn;
  482.         /* Funky trick here.  If the prompt string is empty,
  483.          * assume that we are allowed to do line wrap;
  484.          * otherwise, temporarily disable line wrap
  485.          */
  486.         if (*str)
  487.         wrapcolumn = 0;
  488.         if (!getting)
  489.         turnon(glob_flags, IS_GETTING);
  490.         if (Getstr(buf, sizeof(buf), offset) == -1) {
  491.         putchar('\n');
  492.         buf[0] = 0;
  493.         }
  494.         if (!getting)
  495.         turnoff(glob_flags, IS_GETTING);
  496.         wrapcolumn = wrapping;
  497.     }
  498.     } else
  499.     puts(strcpy(buf, curstr));
  500.     if (debug > 1)
  501.     print("returning (%s) from set_header\n", buf);
  502.     return buf;
  503. }
  504.  
  505. /*
  506.  * improve uucp paths by looking at the name of each host listed in the
  507.  * path given.
  508.  *    sun!island!pixar!island!argv
  509.  * It's a legal address, but redundant. Also, if we know we talk to particular
  510.  * hosts via uucp, then we can just start with that host and disregard the path
  511.  * preceding it.  So, first get the known hosts and save them. Then start
  512.  * at the end of the original path (at the last ! found), and move backwards
  513.  * saving each hostname.  If we get to a host that we know about, stop there
  514.  * and use that address.  If the system knows about domains, skip all paths
  515.  * that precede a domain hostname.  If we get to a host we've already seen,
  516.  * then delete it and all the hosts since then until the first occurrence of
  517.  * that hostname.  When we get to the beginning, the address will be complete.
  518.  * The route_path is prepended to each address to check make sure this path
  519.  * is used if no known_hosts precede it in that address.
  520.  *
  521.  * Return all results into the original buffer passed to us.  If route_path
  522.  * adds to the length of all the paths, then the original buffer could be
  523.  * overwritten.  someone should check for this!
  524.  */
  525. improve_uucp_paths(original, size, route_path)
  526. char *original, *route_path;
  527. {
  528.     char       name[256], addr[256], buf[2 * HDRSIZ], *end;
  529.     char      *hostnames[32], tmp[sizeof addr], *domain_path;
  530.     register char *p, *p2, *recipient, *start = original, *b = buf;
  531.     int           saved_hosts, i, is_domain;
  532.  
  533.     if (!original || !*original)
  534.     return;
  535.  
  536.     /* use domain_path to point to the path for pathnames that have
  537.      * a fully qualified domain host in them.
  538.      */
  539.     domain_path = do_set(set_options, "domain_route");
  540.     while (end = get_name_n_addr(start, name, tmp)) {
  541.     /* first copy the route path, then the rest of the address. */
  542.     p = addr;
  543.     if (route_path && *route_path) {
  544.         p += Strcpy(addr, route_path);
  545.         *p++ = '!';
  546.     }
  547.     (void) bang_form(p, tmp);
  548.     saved_hosts = 0;
  549.     if (p2 = rindex(p, '!')) {
  550.         recipient = p2+1;
  551.         /* save the uucp-style address *without* route_path in tmp */
  552.         (void) strcpy(tmp, p);
  553.         for (p = p2; p > addr; p--) {
  554.         is_domain = 0;
  555.         /* null the '!' separating the rest of the path from the part
  556.          * of the path preceding it and move p back to the previous
  557.          * '!' (or beginning to addr) for hostname to point to.
  558.          */
  559.         for (*p-- = 0; p > addr && *p != '!'; p--)
  560.             if (!is_domain && domain_path && *p == '.' &&
  561.                 lcase_strncmp(p, ".uucp", 5))
  562.             is_domain++;
  563.         /* if p is not at the addr, move it forward past the '!' */
  564.         if (p != addr)
  565.             ++p; /* now points to a null terminated hostname */
  566.         /* if host is ourselves, ignore this and preceding hosts */
  567.         for (i = 0; ourname && ourname[i]; i++)
  568.             if (!lcase_strncmp(p, ourname[i], -1))
  569.             break;
  570.         if (ourname && ourname[i]) {
  571.             is_domain = 0; /* we've eliminated all domains */
  572.             break;
  573.         }
  574.         /* check already saved hostnames. If host is one of them,
  575.          * delete remaining hostnames since there is a redundant path.
  576.          */
  577.         for (i = 0; i < saved_hosts; i++)
  578.             if (!lcase_strncmp(hostnames[i], p, -1))
  579.             saved_hosts = i;
  580.  
  581.         /* Add the hostname to the path being constructed */
  582.         hostnames[saved_hosts++] = p;
  583.  
  584.         /* If the original path or the address is a fully qualified
  585.          * hostname (domain info is included), then break here
  586.          */
  587.         if (p == addr || is_domain && domain_path)
  588.             break;
  589.         /* If we know that we call this host, break */
  590.         for (i = 0; known_hosts && known_hosts[i]; i++)
  591.             if (!lcase_strncmp(p, known_hosts[i], -1))
  592.             break;
  593.         if (known_hosts && known_hosts[i])
  594.             break;
  595.         }
  596.         /* temporary holder for where we are in buffer (save address) */
  597.         p2 = b;
  598.         if (is_domain && domain_path && *domain_path)
  599.         b += Strcpy(b, domain_path), *b++ = '!';
  600.         while (saved_hosts-- > 0) {
  601.         b += Strcpy(b, hostnames[saved_hosts]);
  602.         *b++ = '!';
  603.         }
  604.         b += Strcpy(b, recipient);
  605.         if (!strcmp(p2, tmp)) { /* if the same, address was unmodified */
  606.         b = p2; /* reset offset in buf (b) to where we were (p2) */
  607.         goto unmodified;
  608.         }
  609.         if (*name)
  610.         b += strlen(sprintf(b, " (%s)", name));
  611.     } else {
  612.         char c;
  613. unmodified:
  614.         c = *end;
  615.         *end = 0;
  616.         b += Strcpy(b, start); /* copy the entire address with comments */
  617.         *end = c;
  618.     }
  619.     if (b - buf > size) {
  620.         wprint("Warning: address list truncated!\n");
  621.         /* Use a very poor heuristic to find the last complete address */
  622.         for (b = buf+size - 1; *b != ','; b--)
  623.         ;
  624.         wprint("Lost addresses: %s%s\n", b, end); /* end = not yet parsed */
  625.         while (isspace(*b) || *b == ',')
  626.         b--;
  627.         break;
  628.     }
  629.     for (start = end; *start == ',' || isspace(*start); start++)
  630.         ;
  631.     if (!*start)
  632.         break;
  633.     *b++ = ',', *b++ = ' ', *b = '\0';
  634.     }
  635.     (void) strcpy(original, buf);
  636. }
  637.  
  638. /*
  639.  * rm_cmts_in_addr() removes the comment lines in addresses that result from
  640.  * sendmail or other mailers which append the user's "real name" on the
  641.  * from lines.  See get_name_n_addr().
  642.  */
  643. rm_cmts_in_addr(str)
  644. register char *str;
  645. {
  646.     char addr[BUFSIZ], buf[HDRSIZ], *start = str;
  647.     register char *b = buf;
  648.  
  649.     *b = 0;
  650.     do  {
  651.     if (!(str = get_name_n_addr(str, NULL, addr)))
  652.         break;
  653.     b += Strcpy(b, addr);
  654.     while (*str == ',' || isspace(*str))
  655.         str++;
  656.     if (*str)
  657.         *b++ = ',', *b++ = ' ', *b = '\0';
  658.     } while (*str);
  659.     for (b--; b > start && (*b == ',' || isspace(*b)); b--)
  660.     *b = 0;
  661.     (void) strcpy(start, buf);
  662. }
  663.  
  664. /*
  665.  * take_me_off() is intended to search for the user's login name in an
  666.  * address string and remove it.  If "metoo" is set, return without change.
  667.  * determine which addresses are the "user'"'s addresses by comparing them
  668.  * against the host/path names in alternates.  If the "*" is used, then
  669.  * this matches the address against the user's current login and -any- path.
  670.  *
  671.  * Note that the alternates list is an array of addresses stored *reversed*!
  672.  */
  673. take_me_off(str)
  674. char *str;
  675. {
  676.     int i = 0, rm_me;
  677.     char tmp[256], addr[256], buf[HDRSIZ], *start = str;
  678.     register char *p, *p2, *b = buf;
  679.  
  680.     if (!str || !*str)
  681.     return;
  682.  
  683.     Debug("take_me_off()\n");
  684.     *b = 0;
  685.     do  {
  686.     rm_me = FALSE;
  687.     /* get the first "address" and advance p to next addr (ignore name) */
  688.     if (!(p = get_name_n_addr(str, NULL, tmp)))
  689.         break; /* we've reached the end of the address list */
  690.     /* see if user's login is in the address */
  691.     if (!strcmp(login, tmp))
  692.         rm_me = TRUE;
  693.     else {
  694.         int len;
  695.         /* put address in !-format and store in "addr" */
  696.         (void) bang_form(addr, tmp);
  697.         (void) reverse(addr);
  698.         for (i = 0; alternates && alternates[i] && !rm_me; i++) {
  699.         if (alternates[i][0] == '*') {
  700.             if (alternates[i][1] == '\0')
  701.             p2 = reverse(strcpy(tmp, login));
  702.             else
  703.             p2 = reverse(strcpy(tmp, &alternates[i][1]));
  704.         } else
  705.             p2 = alternates[i];
  706.         if (!lcase_strncmp(p2, addr, (len = strlen(p2))) &&
  707.             (!addr[len] || addr[len] == '!')) {
  708.             Debug("\t%s\n", reverse(addr));
  709.             rm_me = TRUE;
  710.         }
  711.         }
  712.         for (i = 0; !rm_me && ourname && ourname[i]; i++) {
  713.         p2 = tmp + Strcpy(tmp, ourname[i]);
  714.         *p2++ = '!';
  715.         (void) strcpy(p2, login);
  716.         (void) reverse(tmp);
  717.         if (!lcase_strncmp(tmp, addr, (len = strlen(tmp))) &&
  718.             (!addr[len] || addr[len] == '!')) {
  719.             Debug("\t%s\n", reverse(addr));
  720.             rm_me = TRUE;
  721.         }
  722.         }
  723.     }
  724.     /* The address is not the user's -- put it into the returned list */
  725.     if (!rm_me) {
  726.         char c = *p;
  727.         *p = 0;
  728.         b += Strcpy(b, str);
  729.         *p = c;
  730.     }
  731.     while (*p == ',' || isspace(*p))
  732.         p++;
  733.     if (*p && !rm_me)
  734.         *b++ = ',', *b++ = ' ', *b = '\0';
  735.     } while (*(str = p));
  736.     for (b--; b > buf && (*b == ',' || isspace(*b)); b--)
  737.     *b = 0;
  738.     (void) strcpy(start, buf);
  739. }
  740.  
  741. /*
  742.  * Place commas in between all addresses that don't already have
  743.  * them.  Addresses which use comments which are in parens or _not_
  744.  * within angle brackets *must* already have commas around them or
  745.  * you can't determine what is a comment and what is an address.
  746.  */
  747. fix_up_addr(str)
  748. char *str;
  749. {
  750.     char buf[HDRSIZ], *start = str;
  751.     register char c, *p, *b = buf;
  752.  
  753.     *b = 0;
  754.     do  {
  755.     /* get_name returns a pointer to the next address */
  756.     if (!(p = get_name_n_addr(str, NULL, NULL)))
  757.         break;
  758.     c = *p, *p = 0;
  759.     if (strlen(str) + (b - buf) >= sizeof(buf) - 2) {
  760.         /* wprint("Address too long! Lost address: \"%s\"\n", str); */
  761.         *p = c;
  762.         break;
  763.     }
  764.     for (b += Strcpy(b, str); b > buf && isspace(*(b-1)); b--)
  765.         *b = 0;
  766.     for (*p = c; *p == ',' || isspace(*p); p++)
  767.         ;
  768.     if (*p)
  769.         *b++ = ',', *b++ = ' ', *b = '\0';
  770.     } while (*(str = p));
  771.     for (b--; b > buf && (*b == ',' || isspace(*b)); b--)
  772.     *b = 0;
  773.     (void) strcpy(start, buf);
  774. }
  775.  
  776. /*
  777.  * Remove redundant addresses.
  778.  * Assume improve_uucp_paths, fix_up_addr or whatever have already been called.
  779.  */
  780. rm_redundant_addrs(to, cc)
  781. char *to, *cc;
  782. {
  783.     char tmp[256], addr[256], buf[HDRSIZ];
  784.     char **list; /* a list of addresses for comparison */
  785.     int list_cnt = 0, l;
  786.     register char c, *p, *b, *start;
  787.  
  788.     Debug("rm_redundant_addrs()\n");
  789.     list = (char **) calloc(256, sizeof(char *));
  790.     if (!list) {
  791.     error("out of memory in rm_redundant_addrs");
  792.     return;
  793.     }
  794.     start = to;
  795.     b = buf, *b = 0;
  796.     /* first do the To header */
  797.     do  {
  798.     /* get_name returns a pointer to the next address */
  799.     if (!(p = get_name_n_addr(to, NULL, tmp)))
  800.         break;
  801.     c = *p, *p = 0;
  802.     (void) bang_form(addr, tmp);
  803.     for (l = 0; l < list_cnt; l++)
  804.         if (!lcase_strncmp(addr, list[l], -1))
  805.         break;
  806.     /* if l == list_cnt, we got a new address, store it and add to buf */
  807.     if (l == list_cnt) {
  808.         /* Don't overwrite buffer. */
  809.         if (list_cnt < 256)
  810.         list[list_cnt++] = savestr(addr);
  811.         if (b > buf)
  812.         *b++ = ',', *b++ = ' ', *b = '\0';
  813.         for (b += Strcpy(b, to); b > buf && isspace(*(b-1)); b--)
  814.         *b = 0;
  815.     } else
  816.         Debug("\t%s\n", tmp); /* already specified (removed from list) */
  817.     for (*p = c; *p == ',' || isspace(*p); p++)
  818.         ;
  819.     } while (*(to = p));
  820.     for (b--; b > buf && (*b == ',' || isspace(*b)); b--)
  821.     *b = 0;
  822.     (void) strcpy(start, buf);
  823.     b = buf, *b = 0;
  824.     /* Now do the Cc header.  If addr is listed in the To field, rm it in cc */
  825.     start = cc;
  826.     do  {
  827.     /* get_name returns a pointer to the next address */
  828.     if (!(p = get_name_n_addr(cc, NULL, tmp)))
  829.         break;
  830.     c = *p, *p = 0;
  831.     (void) bang_form(addr, tmp);
  832.     for (l = 0; l < list_cnt; l++)
  833.         if (!lcase_strncmp(addr, list[l], -1))
  834.         break;
  835.     if (l == list_cnt) {
  836.         /* Don't overwrite buffer. */
  837.         if (list_cnt < sizeof(list)/sizeof(char *))
  838.         list[list_cnt++] = savestr(addr);
  839.         if (b > buf)
  840.         *b++ = ',', *b++ = ' ', *b = '\0';
  841.         for (b += Strcpy(b, cc); b > buf && isspace(*(b-1)); b--)
  842.         *b = 0;
  843.     } else
  844.         Debug("\t%s\n", tmp); /* already specified (removed from list) */
  845.     for (*p = c; *p == ',' || isspace(*p); p++)
  846.         ;
  847.     } while (*(cc = p));
  848.     list[list_cnt] = NULL; /* for free_vec */
  849.     free_vec(list);
  850.     for (b--; b > buf && (*b == ',' || isspace(*b)); b--)
  851.     *b = 0;
  852.     (void) strcpy(start, buf);
  853. }
  854.  
  855. /*
  856.  * Get address and name from a string (str) which came from an address header
  857.  * in a message or typed by the user.  The string may contain one or more
  858.  * well-formed addresses.  Each must be separated by a comma.
  859.  *
  860.  * address, address, address
  861.  * address (comment or name here)
  862.  * comment or name <address>
  863.  * "Comment, even those with comma's!" <address>
  864.  * address (comma, (more parens), etc...)
  865.  *
  866.  * This does *not* handle cases like:
  867.  *    comment <address (comment)>
  868.  *
  869.  * find the *first* address here and return a pointer to the end of the
  870.  * address (usually a comma).  Return NULL on error: non-matching parens,
  871.  * brackets, quotes...
  872.  */
  873. char *
  874. get_name_n_addr(str, name, addr)
  875. register char *str, *name, *addr;
  876. {
  877.     register char *p, *p2, *beg_addr = addr, *beg_name = name, c;
  878.  
  879.     if (addr)
  880.     *addr = 0;
  881.     if (name)
  882.     *name = 0;
  883.     if (!str || !*str)
  884.     return NULL;
  885.  
  886.     while (isspace(*str))
  887.     str++;
  888.  
  889.     /* first check to see if there's something to look for */
  890.     if (!(p = any(str, ",(<\""))) {
  891.     /* no comma or indication of a quote character. Find a space and
  892.      * return that.  If nothing, the entire string is a complete address
  893.      */
  894.     if (p = any(str, " \t"))
  895.         c = *p, *p = 0;
  896.     if (addr)
  897.         (void) strcpy(addr, str);
  898.     if (p)
  899.         *p = c;
  900.     return p? p : str + strlen(str);
  901.     }
  902.  
  903.     /* comma terminated before any comment stuff.  If so, check for whitespace
  904.      * before-hand cuz it's possible that strings aren't comma separated yet
  905.      * and they need to be.
  906.      *
  907.      * address address address, address
  908.      *                        ^p  <- p points here.
  909.      *        ^p2 <- should point here.
  910.      */
  911.     if (*p == ',') {
  912.     c = *p, *p = 0;
  913.     if (p2 = any(str, " \t"))
  914.         *p = ',', c = *p2, p = p2, *p = 0;
  915.     if (addr)
  916.         (void) strcpy(addr, str);
  917.     *p = c;
  918.     return p;
  919.     }
  920.  
  921.     /* starting to get hairy -- we found an angle bracket. This means that
  922.      * everything outside of those brackets are comments until we find that
  923.      * all important comma.  A comment AFTER the <addr> :
  924.      *  <address> John Doe
  925.      * can't call this function recursively or it'll think that "John Doe"
  926.      * is a string with two legal address on it (each name being an address).
  927.      */
  928.     if (*p == '<') { /* note that "str" still points to comment stuff! */
  929.     if (name && *str) {
  930.         *p = 0;
  931.         name += Strcpy(name, str);
  932.         *p = '<';
  933.     }
  934.     if (!(p2 = index(p+1, '>'))) {
  935.         wprint("Warning! Malformed address: \"%s\"\n", str);
  936.         return NULL;
  937.     }
  938.     if (addr) {
  939.         /* to support <addr (comment)> style addresses, add code here */
  940.         *p2 = 0;
  941.         skipspaces(1);
  942.         addr += Strcpy(addr, p);
  943.         while (addr > beg_addr && isspace(*(addr-1)))
  944.         *--addr = 0;
  945.         *p2 = '>';
  946.     }
  947.     /* take care of the case "... <addr> com (ment)" */
  948.     {
  949.         int p_cnt = 0; /* parenthesis counter */
  950.         p = p2;
  951.         /* don't recurse yet -- scan till null, comma or '<'(add to name) */
  952.         for (p = p2; p[1] && (p_cnt || p[1] != ',' && p[1] != '<'); p++) {
  953.         if (p[1] == '(')
  954.             p_cnt++;
  955.         else if (p[1] == ')')
  956.             p_cnt--;
  957.         if (name)
  958.             *name++ = p[1];
  959.         }
  960.         if (p_cnt) {
  961.         wprint("Warning! Malformed name: \"%s\"\n", name);
  962.         return NULL;
  963.         }
  964.     }
  965.     if (name && name > beg_name) {
  966.         while (isspace(*(name-1)))
  967.         --name;
  968.         *name = 0;
  969.     }
  970.     }
  971.  
  972.     /* this is the worst -- now we have parentheses/quotes.  These guys can
  973.      * recurse pretty badly and contain commas within them.
  974.      */
  975.     if (*p == '(' || *p == '"') {
  976.     char *start = p;
  977.     int comment = 1;
  978.     c = *p;
  979.     /* "str" points to address while p points to comments */
  980.     if (addr && *str) {
  981.         *p = 0;
  982.         while (isspace(*str))
  983.         str++;
  984.         addr += Strcpy(addr, str);
  985.         while (addr > beg_addr && isspace(*(addr-1)))
  986.         *--addr = 0;
  987.         *p = c;
  988.     }
  989.     while (comment) {
  990.         if (c == '"' && !(p = index(p+1, '"')) ||
  991.         c == '(' && !(p = any(p+1, "()"))) {
  992.         wprint("Warning! Malformed address: \"%s\"\n", str);
  993.         return NULL;
  994.         }
  995.         if (*p == '(') /* loop again on parenthesis. quote ends loop */
  996.         comment++;
  997.         else
  998.         comment--;
  999.     }
  1000.     /* Something like ``Comment (Comment) <addr>''.  In this case
  1001.      * the name should include both comment parts with the
  1002.      * parenthesis.   We have to redo addr.
  1003.      */
  1004.     if ((p2 = any(p+1, "<,")) && *p2 == '<') {
  1005.         if (!(p = index(p2, '>'))) {
  1006.         wprint("Warning! Malformed address: \"%s\"\n", str);
  1007.         return NULL;
  1008.         }
  1009.         if (addr = beg_addr) { /* reassign addr and compare to null */
  1010.         c = *p; *p = 0;
  1011.         addr += Strcpy(addr, p2+1);
  1012.         while (addr > beg_addr && isspace(*(addr-1)))
  1013.             *--addr = 0;
  1014.         *p = c;
  1015.         }
  1016.         if (name) {
  1017.         c = *p2; *p2 = 0;
  1018.         name += Strcpy(name, str);
  1019.         while (name > beg_name && isspace(*(name-1)))
  1020.             *--name = 0;
  1021.         *p2 = c;
  1022.         }
  1023.     } else if (name && start[1]) {
  1024.         c = *p, *p = 0; /* c may be ')' instead of '(' now */
  1025.         name += Strcpy(name, start+1);
  1026.         while (name > beg_name && isspace(*(name-1)))
  1027.         *--name = 0;
  1028.         *p = c;
  1029.     }
  1030.     }
  1031.     skipspaces(1);
  1032.     /* this is so common, save time by returning now */
  1033.     if (!*p || *p == ',')
  1034.     return p;
  1035.     return get_name_n_addr(p, name, addr);
  1036. }
  1037.  
  1038. /* takes string 's' which can be a name or list of names separated by
  1039.  * commas and checks to see if each is aliased to something else.
  1040.  * return address of the static buf.
  1041.  */
  1042. char *
  1043. alias_to_address(s)
  1044. register char *s;
  1045. {
  1046.     static char buf[HDRSIZ];
  1047.     register char *p, *p2, *tmp;
  1048.     char newbuf[HDRSIZ], c;
  1049.     static int recursive;
  1050.  
  1051.     if (!aliases)
  1052.     return strcpy(buf, s);
  1053.     if (!s || !*s)
  1054.     return NULL;
  1055.     if (!recursive) {
  1056.     bzero(buf, sizeof buf);
  1057.     p2 = buf;  /* if we're starting all this, p2 starts at &buf[0] */
  1058.     } else
  1059.     p2 = buf+strlen(buf);   /* else, pick up where we left off */
  1060.  
  1061.     if (++recursive == 30) {
  1062.     wprint("alias references too many addresses!\n");
  1063.     recursive = 0;
  1064.     return NULL;
  1065.     }
  1066.     do  {
  1067.     char addr[256];
  1068.     if (!(p = get_name_n_addr(s, NULL, addr)))
  1069.         break;
  1070.     c = *p, *p = 0;
  1071.  
  1072.     /* On recursive calls, compare against the entire
  1073.      * previous expansion, not just the address part.
  1074.      */
  1075.     if (recursive > 1)
  1076.         (void) strcpy(addr, s);
  1077.  
  1078.     /* if this is an alias, recurse this routine to expand it out */
  1079.     if ((tmp = do_set(aliases, addr)) && *tmp) {
  1080.         if (!alias_to_address(strcpy(newbuf, tmp))) {
  1081.         *p = c;
  1082.         return NULL;
  1083.         } else
  1084.         p2 = buf+strlen(buf);
  1085.     /* Now, make sure the buffer doesn't overflow */
  1086.     } else if (strlen(s) + (p2-buf) + 2 > sizeof buf) {  /* add ", " */
  1087.         wprint("address length too long.\n");
  1088.         recursive = 0;
  1089.         *p = c;
  1090.         return NULL;
  1091.     } else {
  1092.         /* append the new alias (or unchanged address) onto the buffer */
  1093.         p2 += Strcpy(p2, s);
  1094.         *p2++ = ',', *p2++ = ' ', *p2 = '\0';
  1095.     }
  1096.     for (*p = c; *p == ',' || isspace(*p); p++)
  1097.         ;
  1098.     } while (*(s = p));
  1099.     if (recursive)
  1100.     recursive--;
  1101.     if (!recursive)
  1102.     *(p2-2) = 0;  /* get rid of last ", " if end of recursion */
  1103.     return buf;
  1104. }
  1105.  
  1106. /*
  1107.  * Wrap addresses so that the headers don't exceed n chars (typically 80).
  1108.  */
  1109. char *
  1110. wrap_addrs(str, n)
  1111. char *str;
  1112. {
  1113.     char buf[HDRSIZ * 2], *start = str;
  1114.     register char *b = buf, *p, c, *line_start = buf;
  1115.  
  1116.     *b = 0;
  1117.     do  {
  1118.     /* get_name returns a pointer to the next address */
  1119.     if (!(p = get_name_n_addr(str, NULL, NULL)))
  1120.         break;
  1121.     c = *p, *p = 0;
  1122.     if (b > buf) {
  1123.         *b++ = ',', *b++ = ' ', *b = '\0';
  1124.         if (b - line_start + strlen(str) + 8 /* \t = 8 */ >= n)
  1125.         *b++ = '\n', *b++ = '\t', line_start = b;
  1126.     }
  1127.     for (b += Strcpy(b, str); b > buf && isspace(*(b-1)); b--)
  1128.         *b = 0;
  1129.     for (*p = c; *p == ',' || isspace(*p); p++)
  1130.         ;
  1131.     } while (*(str = p));
  1132.     for (b--; b > buf && (*b == ',' || isspace(*b)); b--)
  1133.     *b = 0;
  1134.     return strcpy(start, buf);
  1135. }
  1136.