home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / com / utils / elm / sources / addr_uti.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-01  |  33.9 KB  |  1,242 lines
  1.  
  2. static char rcsid[] = "@(#)$Id: addr_util.c,v 4.1.1.1 90/10/07 20:44:56 syd Exp $";
  3.  
  4. /*******************************************************************************
  5.  *  The Elm Mail System  -  $Revision: 4.1.1.1 $   $State: Exp $
  6.  *
  7.  *             Copyright (c) 1986, 1987 Dave Taylor
  8.  *             Copyright (c) 1988, 1989, 1990 USENET Community Trust
  9.  *******************************************************************************
  10.  * Bug reports, patches, comments, suggestions should be sent to:
  11.  *
  12.  *    Syd Weinstein, Elm Coordinator
  13.  *    elm@DSI.COM            dsinc!elm
  14.  *
  15.  *******************************************************************************
  16.  * $Log:    addr_util.c,v $
  17.  * Revision 4.1.1.1  90/10/07  20:44:56  syd
  18.  * Make time to seconds
  19.  * From: rhg@cpscom
  20.  *
  21.  * Revision 4.1  90/04/28  22:42:21  syd
  22.  * checkin of Elm 2.3 as of Release PL0
  23.  *
  24.  *
  25.  ******************************************************************************/
  26.  
  27. /** This file contains addressing utilities
  28.  
  29. **/
  30.  
  31. #include "headers.h"
  32.  
  33. #include <sys/types.h>
  34. #include <sys/stat.h>
  35. #ifdef PWDINSYS
  36. #  include <sys/pwd.h>
  37. #else
  38. #  include <pwd.h>
  39. #endif
  40.  
  41. #include <ctype.h>
  42.  
  43. #ifdef BSD
  44. #undef tolower
  45. #undef toupper
  46. #endif
  47.  
  48. char *get_alias_address(), *get_token();
  49. char *strtok(), *strcpy(), *strcat(), *strncpy(), *index(), *rindex();
  50.  
  51.  
  52. #define SKIP_WS(p) while (isspace(*p)) p++
  53. #define SKIP_ALPHA(p) while (isalpha(*p)) p++
  54. #define SKIP_DIGITS(p) while (isdigit(*p)) p++
  55.  
  56. static char *day_name[8] = {
  57.     "sun", "mon", "tue", "wed", "thu", "fri", "sat", 0
  58. };
  59.  
  60. static char *month_name[13] = {
  61.     "jan", "feb", "mar", "apr",
  62.     "may", "jun", "jul", "aug",
  63.     "sep", "oct", "nov", "dec", 0
  64. };
  65.  
  66. static int month_len[12] = {
  67.     31, 28, 31, 30, 31, 30, 31,
  68.     31, 30, 31, 30, 31 };
  69.  
  70. /* The following time zones are taken from a variety of sources.  They
  71.  * are by no means exhaustive, but seem to include most of those
  72.  * in common usage.  A comprehensive list is impossible, since the same
  73.  * abbreviation is sometimes used to mean different things in different
  74.  * parts of the world.
  75.  */
  76. static struct tzone {
  77.     char *str;
  78.     int offset; /* offset, in minutes, EAST of GMT */
  79. } tzone_info[] = {
  80.     /* the following are from rfc822 */
  81.     "ut", 0, "gmt", 0,
  82.     "est", -5*60, "edt", -4*60,
  83.     "cst", -6*60, "cdt", -5*60,
  84.     "mst", -7*60, "mdt", -6*60,
  85.     "pst", -8*60, "pdt", -7*60,
  86.     "z", 0, /* zulu time (the rest of the military codes are bogus) */
  87.  
  88.     /* these are also popular in Europe */
  89.     "wet", 0*60, "wet dst", 1*60, /* western european */
  90.     "met", 1*60, "met dst", 2*60, /* middle european */
  91.     "eet", 2*60, "eet dst", 3*60, /* eastern european */
  92.     "bst", 1*60, /* ??? british summer time (=+0100) */
  93.  
  94.     /* ... and Canada */
  95.     "ast", -4*60, "adt", -3*60, /* atlantic */
  96.     "nst", -3*60-30, "ndt", -2*60-30, /* newfoundland */
  97.     "yst", -9*60, "ydt", -8*60, /* yukon */
  98.     "hst", -10*60, /* hawaii (not really canada) */
  99.  
  100.     /* ... and Asia */
  101.     "jst", 9*60, /* japan */
  102.     "sst", 8*60, /* singapore */
  103.  
  104.     /* ... and the South Pacific */
  105.     "nzst", 12*60, "nzdt", 13*60, /* new zealand */
  106.     "wst", 8*60, "wdt", 9*60, /* western australia */
  107.     /* there's also central and eastern australia, but they insist on using
  108.      * cst, est, etc., which would be indistinguishable for the us zones */
  109.      (char *) 0, 0
  110. };
  111.  
  112. #ifndef OS2
  113. char *
  114. gcos_name(gcos_field, logname)
  115. char *logname, *gcos_field;
  116. {
  117.     /** Return the full name found in a passwd file gcos field **/
  118.  
  119. #ifdef BERKNAMES
  120.  
  121.     static char fullname[SLEN];
  122.     register char *fncp, *gcoscp, *lncp, *end;
  123.  
  124.  
  125.     /* full name is all chars up to first ',' (or whole gcos, if no ',') */
  126.     /* replace any & with logname in upper case */
  127.  
  128.     for(fncp = fullname, gcoscp= gcos_field, end = fullname + SLEN - 1;
  129.         (*gcoscp != ',' && *gcoscp != '\0' && fncp != end);
  130.     gcoscp++) {
  131.  
  132.     if(*gcoscp == '&') {
  133.         for(lncp = logname; *lncp; fncp++, lncp++)
  134.         *fncp = toupper(*lncp);
  135.     } else {
  136.         *fncp++ = *gcoscp;
  137.     }
  138.     }
  139.  
  140.     *fncp = '\0';
  141.     return(fullname);
  142. #else
  143. #ifdef USGNAMES
  144.  
  145.     char *firstcp, *lastcp;
  146.  
  147.     /* The last character of the full name is the one preceding the first
  148.      * '('. If there is no '(', then the full name ends at the end of the
  149.      * gcos field.
  150.      */
  151.     if(lastcp = index(gcos_field, '('))
  152.     *lastcp = '\0';
  153.  
  154.     /* The first character of the full name is the one following the
  155.      * last '-' before that ending character. NOTE: that's why we
  156.      * establish the ending character first!
  157.      * If there is no '-' before the ending character, then the fullname
  158.      * begins at the beginning of the gcos field.
  159.      */
  160.     if(firstcp = rindex(gcos_field, '-'))
  161.     firstcp++;
  162.     else
  163.     firstcp = gcos_field;
  164.  
  165.     return(firstcp);
  166.  
  167. #else
  168.     /* use full gcos field */
  169.     return(gcos_field);
  170. #endif
  171. #endif
  172. }
  173. #endif
  174.  
  175. char *
  176. get_full_name(logname)
  177. char *logname;
  178. {
  179.     /* return a pointer to the full user name for the passed logname
  180.      * or NULL if cannot be found
  181.      * If PASSNAMES get it from the gcos field, otherwise get it
  182.      * from ~/.fullname.
  183.      */
  184.  
  185. #ifndef PASSNAMES
  186.     FILE *fp;
  187.     char fullnamefile[SLEN];
  188. #endif
  189.     static char fullname[SLEN];
  190.     struct passwd *getpwnam(), *pass;
  191.  
  192.     if((pass = getpwnam(logname)) == NULL)
  193.       return(NULL);
  194. #ifdef PASSNAMES    /* get full_username from gcos field */
  195.     strcpy(fullname, gcos_name(pass->pw_gecos, logname));
  196. #else            /* get full_username from ~/.fullname file */
  197.     sprintf(fullnamefile, "%s/.fullname", pass->pw_dir);
  198.  
  199.     if(can_access(fullnamefile, READ_ACCESS) != 0)
  200.       return(NULL);        /* fullname file not accessible to user */
  201.     if((fp = fopen(fullnamefile, "r")) == NULL)
  202.       return(NULL);        /* fullname file cannot be opened! */
  203.     if(fgets(fullname, SLEN, fp) == NULL) {
  204.       fclose(fp);
  205.       return(NULL);        /* fullname file empty! */
  206.     }
  207.     fclose(fp);
  208.     no_ret(fullname);    /* remove trailing '\n' */
  209. #endif
  210.     return(fullname);
  211. }
  212.  
  213. int
  214. talk_to(sitename)
  215. char *sitename;
  216. {
  217.     /** If we talk to the specified site, return true, else
  218.         we're going to have to expand this baby out, so
  219.         return false! **/
  220.  
  221.     struct lsys_rec  *sysname;
  222.  
  223.     sysname = talk_to_sys;
  224.  
  225.     if (sysname == NULL) {
  226.      dprint(2, (debugfile,
  227.         "Warning: talk_to_sys is currently set to NULL!\n"));
  228.      return(0);
  229.     }
  230.  
  231.     while (sysname != NULL) {
  232.       if (strcmp(sysname->name, sitename) == 0)
  233.         return(1);
  234.       else
  235.         sysname = sysname->next;
  236.     }
  237.  
  238.     return(0);
  239. }
  240.  
  241. add_site(buffer, site, lastsite)
  242. char *buffer, *site, *lastsite;
  243. {
  244.     /** add site to buffer, unless site is 'uucp' or site is
  245.         the same as lastsite.   If not, set lastsite to site.
  246.     **/
  247.  
  248.     char local_buffer[SLEN], *stripped;
  249.     char *strip_parens();
  250.  
  251.     stripped = strip_parens(site);
  252.  
  253.     if (strcmp(stripped, "uucp") != 0)
  254.       if (strcmp(stripped, lastsite) != 0) {
  255.         if (buffer[0] == '\0')
  256.           strcpy(buffer, stripped);         /* first in list! */
  257.         else {
  258.           sprintf(local_buffer,"%s!%s", buffer, stripped);
  259.           strcpy(buffer, local_buffer);
  260.         }
  261.         strcpy(lastsite, stripped); /* don't want THIS twice! */
  262.       }
  263. }
  264.  
  265. #ifdef USE_EMBEDDED_ADDRESSES
  266.  
  267. get_address_from(prefix, line, buffer)
  268. char *prefix, *line, *buffer;
  269. {
  270.     /** This routine extracts the address from either a 'From:' line
  271.         or a 'Reply-To:' line.  The strategy is as follows:  if the
  272.         line contains a '<', then the stuff enclosed is returned.
  273.         Otherwise we go through the line and strip out comments
  274.         and return that.  White space will be elided from the result.
  275.     **/
  276.  
  277.     register char *s;
  278.  
  279.     /**  Skip start of line over prefix, e.g. "From:".  **/
  280.     line += strlen(prefix);
  281.  
  282.     /**  If there is a '<' then copy from it to '>' into the buffer.  **/
  283.     if ( (s = index(line,'<')) != NULL ) {
  284.     while ( ++s , *s != '\0' && *s != '>' ) {
  285.         if ( !isspace(*s) )
  286.         *buffer++ = *s;
  287.     }
  288.     *buffer = '\0';
  289.     return;
  290.     }
  291.  
  292.     /**  Otherwise, strip comments and get address with whitespace elided.  **/
  293.     for ( s = strip_parens(line) ; *s != '\0' ; ++s ) {
  294.     if ( !isspace(*s) )
  295.         *buffer++ = *s;
  296.     }
  297.     *buffer = '\0';
  298.  
  299. }
  300.  
  301. #endif
  302.  
  303. translate_return(addr, ret_addr)
  304. char *addr, *ret_addr;
  305. {
  306.     /** Return ret_addr to be the same as addr, but with the login
  307.             of the person sending the message replaced by '%s' for
  308.             future processing...
  309.         Fixed to make "%xx" "%%xx" (dumb 'C' system!)
  310.     **/
  311.  
  312.     register int loc, loc2, iindex = 0;
  313.  
  314.     loc2 = chloc(addr,'@');
  315.     if ((loc = chloc(addr, '%')) < loc2)
  316.       loc2 = loc;
  317.  
  318.     if (loc2 != -1) {    /* ARPA address. */
  319.       /* algorithm is to get to '@' sign and move backwards until
  320.          we've hit the beginning of the word or another metachar.
  321.       */
  322.       for (loc = loc2 - 1; loc > -1 && addr[loc] != '!'; loc--)
  323.          ;
  324.     }
  325.     else {            /* usenet address */
  326.       /* simple algorithm - find last '!' */
  327.  
  328.       loc2 = strlen(addr);    /* need it anyway! */
  329.  
  330.       for (loc = loc2; loc > -1 && addr[loc] != '!'; loc--)
  331.           ;
  332.     }
  333.  
  334.     /** now copy up to 'loc' into destination... **/
  335.  
  336.     while (iindex <= loc) {
  337.       ret_addr[iindex] = addr[iindex];
  338.       iindex++;
  339.     }
  340.  
  341.     /** now append the '%s'... **/
  342.  
  343.     ret_addr[iindex++] = '%';
  344.     ret_addr[iindex++] = 's';
  345.  
  346.     /** and, finally, if anything left, add that **/
  347.  
  348.     loc = strlen(addr);
  349.     while (loc2 < loc) {
  350.       ret_addr[iindex++] = addr[loc2++];
  351.       if (addr[loc2-1] == '%')    /* tweak for "printf" */
  352.         ret_addr[iindex++] = '%';
  353.     }
  354.  
  355.     ret_addr[iindex] = '\0';
  356. }
  357.  
  358. int
  359. build_address(to, full_to)
  360. char *to, *full_to;
  361. {
  362.     /** loop on all words in 'to' line...append to full_to as
  363.         we go along, until done or length > len.  Modified to
  364.         know that stuff in parens are comments...Returns non-zero
  365.         if it changed the information as it copied it across...
  366.     **/
  367.  
  368.     register int i, j, changed = 0, in_parens = 0, expanded_information = 0;
  369.     char word[SLEN], next_word[SLEN], *ptr, buffer[SLEN];
  370.     char new_to_list[SLEN];
  371.     char *strpbrk(), *strcat(), *gecos;
  372. #ifndef DONT_TOUCH_ADDRESSES
  373.     char *expand_system();
  374. #endif
  375.  
  376.     new_to_list[0] = '\0';
  377.  
  378.     i = get_word(to, 0, word);
  379.  
  380.     full_to[0] = '\0';
  381.  
  382.     while (i > 0) {
  383.  
  384.       j = get_word(to, i, next_word);
  385.  
  386. try_new_word:
  387.       if(word[0] == '(')
  388.         in_parens++;
  389.  
  390.       if (in_parens) {
  391.         if(word[strlen(word)-1] == ')')
  392.           in_parens--;
  393.         strcat(full_to, " ");
  394.         strcat(full_to, word);
  395.       }
  396.       else if (strpbrk(word,"!@:") != NULL) {
  397. #ifdef DONT_TOUCH_ADDRESSES
  398.         sprintf(full_to, "%s%s%s", full_to,
  399.                     full_to[0] != '\0'? ", " : "", word);
  400. #else
  401.         sprintf(full_to, "%s%s%s", full_to,
  402.                     full_to[0] != '\0'? ", " : "", expand_system(word, 1));
  403. #endif
  404.       }
  405.       else if ((ptr = get_alias_address(word, TRUE)) != NULL) {
  406.         sprintf(full_to, "%s%s%s", full_to,
  407.                     full_to[0] != '\0'? ", " : "", ptr);
  408.         expanded_information++;
  409.       }
  410.       else if (strlen(word) > 0) {
  411.         if (valid_name(word)) {
  412.           if (j > 0 && next_word[0] == '(')    /* already has full name */
  413.         gecos = NULL;
  414.           else                /* needs a full name */
  415.         gecos=get_full_name(word);
  416. #if defined(INTERNET) & defined(USE_DOMAIN)
  417.           sprintf(full_to, "%s%s%s@%s%s%s%s",
  418.               full_to,
  419.               (full_to[0] != '\0'? ", " : ""),
  420.               word,
  421.               hostfullname,
  422.               (gecos ? " (" : ""),
  423.               (gecos ? gecos : ""),
  424.               (gecos ? ")" : ""));
  425. #else /* INTERNET and USE_DOMAIN */
  426.           sprintf(full_to, "%s%s%s%s%s%s",
  427.               full_to,
  428.               (full_to[0] != '\0'? ", " : ""),
  429.               word,
  430.               (gecos ? " (" : ""),
  431.               (gecos ? gecos : ""),
  432.               (gecos ? ")" : ""));
  433. #endif /* INTERNET and USE_DOMAIN */
  434.         } else if (check_only) {
  435.           printf("(alias \"%s\" is unknown)\n\r", word);
  436.           changed++;
  437.         }
  438.         else if (! isatty(fileno(stdin)) ) {    /* batch mode error! */
  439.           fprintf(stderr,"Cannot expand alias '%s'!\n\r", word);
  440.           fprintf(stderr,"Use \"checkalias\" to find valid addresses!\n\r");
  441.           dprint(1, (debugfile,
  442.               "Can't expand alias %s - bailing out of build_address\n",
  443.               word));
  444.           leave(0);
  445.         }
  446.         else {
  447.           dprint(2,(debugfile,"Entered unknown address %s\n", word));
  448.           sprintf(buffer, "'%s' is an unknown address.  Replace with: ",
  449.                   word);
  450.           word[0] = '\0';
  451.           changed++;
  452.  
  453.           PutLine0(LINES, 0, buffer);
  454.  
  455.           (void)optionally_enter(word, LINES, strlen(buffer), FALSE, FALSE);
  456.           clear_error();
  457.           if (strlen(word) > 0) {
  458.             dprint(3,(debugfile, "Replaced with %s in build_address\n",
  459.              word));
  460.         goto try_new_word;
  461.           }
  462.           else
  463.         dprint(3,(debugfile,
  464.             "Address removed from TO list by build_address\n"));
  465.           continue;
  466.         }
  467.       }
  468.  
  469.       /* and this word to the new to list */
  470.       if(*new_to_list != '\0')
  471.         strcat(new_to_list, " ");
  472.       strcat(new_to_list, word);
  473.  
  474.       if((i = j) > 0)
  475.         strcpy(word, next_word);
  476.     }
  477.  
  478.     /* if new to list is different from original, update original */
  479.     if (changed)
  480.       strcpy(to, new_to_list);
  481.  
  482.     return( expanded_information > 0 ? 1 : 0 );
  483. }
  484.  
  485. int
  486. real_from(buffer, entry)
  487. char *buffer;
  488. struct header_rec *entry;
  489. {
  490.     /***** Returns true iff 's' has the seven 'from' fields, (or
  491.            8 - some machines include the TIME ZONE!!!)
  492.            Initialize the date and from entries in the record
  493.            and also the message received date/time if 'entry'
  494.            is not NULL.  *****/
  495.  
  496.     struct header_rec temp_rec, *rec_ptr;
  497.     char junk[STRING], timebuff[STRING], holding_from[SLEN], hold_tz[12];
  498.     char mybuf[BUFSIZ], timebuf2[STRING], *p, *q;
  499.     int  eight_fields = 0;
  500.         int mday, month, year, minutes, seconds, tz, i;
  501.         long gmttime;
  502.  
  503.     /* set rec_ptr according to whether the data is to be returned
  504.      * in the second argument */
  505.     rec_ptr = (entry == NULL ? &temp_rec : entry);
  506.  
  507.     rec_ptr->year[0] = '\0';
  508.     timebuff[0] = '\0';
  509.     junk[0] = '\0';
  510.     hold_tz[0] = '\0';
  511.  
  512.     /* From <user> <day> <month> <day> <hr:min:sec> <year> */
  513.  
  514.     sscanf(buffer, "%*s %*s %*s %*s %*s %s %s %s", timebuff, timebuf2, junk);
  515.  
  516.     if (strlen(timebuff) < 3 && strlen(timebuf2) < 3) {
  517.       dprint(3,(debugfile,
  518.         "Real_from returns FAIL [no time field] on\n-> %s\n",
  519.         buffer));
  520.       return(FALSE);
  521.     }
  522.  
  523.     if (timebuff[1] != ':' && timebuff[2] != ':' &&
  524.         timebuf2[1] != ':' && timebuf2[2] != ':') { /* UUPC ! */
  525.       dprint(3,(debugfile,
  526.         "Real_from returns FAIL [bad time field] on\n-> %s\n",
  527.         buffer));
  528.       return(FALSE);
  529.     }
  530.     if (junk[0] != '\0') {    /* try for 8 field entry */
  531.       junk[0] = '\0';
  532.       sscanf(buffer, "%*s %*s %*s %*s %*s %*s %*s %*s %s", junk);
  533.       if (junk[0] != '\0' && strcmp(junk, "remote")) {
  534.         dprint(3, (debugfile,             /* ^ UUPC ! */
  535.           "Real_from returns FAIL [too many fields] on\n-> %s\n",
  536.           buffer));
  537.         return(FALSE);
  538.       }
  539.       eight_fields++;
  540.     }
  541.  
  542.     /** now get the info out of the record! **/
  543.  
  544.     if (eight_fields)
  545.       sscanf(buffer, "%s %s %s %s %s %s %s %s",
  546.                 junk, holding_from, rec_ptr->dayname, rec_ptr->month,
  547.                     rec_ptr->day, rec_ptr->time, hold_tz, rec_ptr->year);
  548.     else
  549.       sscanf(buffer, "%s %s %s %s %s %s %s",
  550.                 junk, holding_from, rec_ptr->dayname, rec_ptr->month,
  551.                     rec_ptr->day, rec_ptr->time, rec_ptr->year);
  552.  
  553.         /* non-standard UUPC From line? */
  554.  
  555.         /* This is from UUPC rmail: */
  556.         /* From fkk Sat, 14 Mar 1992 14:53:27 MET remote from stasys */
  557.  
  558.         /* while this were normal: */
  559.         /* From fkk Sat Mar 14 14:53:27 1992 [MET] */
  560.  
  561.         if ( rec_ptr->dayname[strlen(rec_ptr->dayname) - 1] == ',' )
  562.         {
  563.       sscanf(buffer, "%s %s %s %s %s %s %s %s",
  564.              junk, holding_from, rec_ptr->dayname, rec_ptr->day,
  565.                  rec_ptr->month, rec_ptr->year, rec_ptr->time, hold_tz);
  566.           rec_ptr->dayname[strlen(rec_ptr->dayname) - 1] = 0;
  567.         }
  568.  
  569.     strncpy(rec_ptr->from, holding_from, STRING-1);
  570.     rec_ptr->from[STRING-1] = '\0';
  571.     resolve_received(rec_ptr);
  572.  
  573.         /* first get everything into lower case */
  574.         for (p=mybuf, q=mybuf+sizeof mybuf;
  575.          *buffer && p<q;
  576.          p++, buffer++) {
  577.       *p = isupper(*buffer) ? tolower(*buffer) : *buffer;
  578.         }
  579.     *p = 0;
  580.     p = mybuf;
  581.     while (!isspace(*p)) p++;    /* skip "from" */
  582.     SKIP_WS(p);
  583.     while (!isspace(*p)) p++;    /* skip from address */
  584.     SKIP_WS(p);
  585.     while (!isspace(*p)) p++;    /* skip day of week */
  586.     SKIP_WS(p);
  587.     month = prefix(month_name, p);
  588.     get_unix_date(p,&year, &mday, &minutes, &seconds, &tz);
  589.     month_len[1] = (year%4) ? 28 : 29;
  590.     if (mday < 0 || mday>month_len[month]) {
  591.       dprint(5,(debugfile, "ridiculous day %d of month %d\n",mday,month));
  592.     }
  593.  
  594.     minutes -= tz;
  595.     if (tz > 0) { /* east of Greenwich */
  596.       if (minutes < 0) {
  597.         if (--mday < 0) {
  598.           if (--month < 0) {
  599.         year--; /* don't worry about 1900! */
  600.         month = 11;
  601.           }
  602.           mday = month_len[month];
  603.         }
  604.         minutes += 24*60;
  605.       }
  606.     }
  607.     if (tz < 0) { /* west of Greenwich */
  608.       if (minutes <= 24*60) {
  609.         if (++mday > month_len[month]) {
  610.           if (++month >= 12) {
  611.         year++; /* don't worry about 1999! yet?? */
  612.         month = 0;
  613.           }
  614.           mday = 0;
  615.         }
  616.         minutes -= 24*60;
  617.       }
  618.     }
  619.         gmttime = year - 70;         /* make base year */
  620.         if (gmttime < 0)
  621.         gmttime += 100;
  622.         gmttime = gmttime * 365 + (gmttime + 1) / 4;  /* now we have days adjusted for leap years */
  623.         for (i = 0; i < month; i++)
  624.         gmttime += month_len[i];
  625.         if (month > 1 && (year % 4) == 0)
  626.         gmttime++;            /* now to month adjusted for leap year if after feb */
  627.         gmttime += mday - 1;        /* and now to the day */
  628.         gmttime *= 24 * 60;            /* convert to minutes */
  629.         gmttime += minutes;
  630.         rec_ptr->time_sent = gmttime * 60 + seconds;    /* now unix seconds since 1/1/70 00:00 GMT */
  631.  
  632.     return(rec_ptr->year[0] != '\0');
  633. }
  634.  
  635. forwarded(buffer, entry)
  636. char *buffer;
  637. struct header_rec *entry;
  638. {
  639.     /** Change 'from' and date fields to reflect the ORIGINATOR of
  640.         the message by iteratively parsing the >From fields...
  641.         Modified to deal with headers that include the time zone
  642.         of the originating machine... **/
  643.  
  644.     char machine[SLEN], buff[SLEN], holding_from[SLEN];
  645.  
  646.     machine[0] = holding_from[0] = '\0';
  647.  
  648.     sscanf(buffer, "%*s %s %s %s %s %s %s %*s %*s %s",
  649.                 holding_from, entry->dayname, entry->month,
  650.                     entry->day, entry->time, entry->year, machine);
  651.  
  652.     if (isdigit(entry->month[0])) { /* try for veeger address */
  653.       sscanf(buffer, "%*s %s %s%*c %s %s %s %s %*s %*s %s",
  654.                 holding_from, entry->dayname, entry->day, entry->month,
  655.                     entry->year, entry->time, machine);
  656.     }
  657.     if (isalpha(entry->year[0])) { /* try for address including tz */
  658.       sscanf(buffer, "%*s %s %s %s %s %s %*s %s %*s %*s %s",
  659.                 holding_from, entry->dayname, entry->month,
  660.                     entry->day, entry->time, entry->year, machine);
  661.     }
  662.  
  663.     /* the following fix is to deal with ">From xyz ... forwarded by xyz"
  664.        which occasionally shows up within AT&T.  Thanks to Bill Carpenter
  665.        for the fix! */
  666.  
  667.     if (strcmp(machine, holding_from) == 0)
  668.       machine[0] = '\0';
  669.  
  670.     if (machine[0] == '\0')
  671.       strcpy(buff, holding_from[0] ? holding_from : "anonymous");
  672.     else
  673.       sprintf(buff,"%s!%s", machine, holding_from);
  674.  
  675.     strncpy(entry->from, buff, STRING-1);
  676.     entry->from[STRING-1] = '\0';
  677. }
  678.  
  679. parse_arpa_who(buffer, newfrom, is_really_a_to)
  680. char *buffer, *newfrom;
  681. int is_really_a_to;
  682. {
  683.     /** try to parse the 'From:' line given... It can be in one of
  684.         two formats:
  685.         From: Dave Taylor <hplabs!dat>
  686.         or  From: hplabs!dat (Dave Taylor)
  687.  
  688.         Added: removes quotes if name is quoted (12/12)
  689.         Added: only copies STRING characters...
  690.         Added: if no comment part, copy address instead!
  691.         Added: if is_really_a_to, this is really a 'to' line
  692.            and treat as if we allow embedded addresses
  693.     **/
  694.  
  695.     int use_embedded_addresses;
  696.     char temp_buffer[SLEN], *temp;
  697.     register int i, j = 0, in_parens;
  698.  
  699.     temp = (char *) temp_buffer;
  700.     temp[0] = '\0';
  701.  
  702.     no_ret(buffer);        /* blow away '\n' char! */
  703.  
  704.     if (lastch(buffer) == '>') {
  705.       for (i=strlen("From: "); buffer[i] != '\0' && buffer[i] != '<' &&
  706.            buffer[i] != '('; i++)
  707.         temp[j++] = buffer[i];
  708.       temp[j] = '\0';
  709.     }
  710.     else if (lastch(buffer) == ')') {
  711.       in_parens = 1;
  712.       for (i=strlen(buffer)-2; buffer[i] != '\0' && buffer[i] != '<'; i--) {
  713.         switch(buffer[i]) {
  714.         case ')':    in_parens++;
  715.             break;
  716.         case '(':    in_parens--;
  717.             break;
  718.         }
  719.         if(!in_parens) break;
  720.         temp[j++] = buffer[i];
  721.       }
  722.       temp[j] = '\0';
  723.       reverse(temp);
  724.     }
  725.  
  726. #ifdef USE_EMBEDDED_ADDRESSES
  727.     use_embedded_addresses = TRUE;
  728. #else
  729.     use_embedded_addresses = FALSE;
  730. #endif
  731.  
  732.     if(use_embedded_addresses || is_really_a_to) {
  733.       /** if we have a null string at this point, we must just have a
  734.           From: line that contains an address only.  At this point we
  735.           can have one of a few possibilities...
  736.  
  737.           From: address
  738.           From: <address>
  739.           From: address ()
  740.       **/
  741.  
  742.       if (strlen(temp) == 0) {
  743.         if (lastch(buffer) != '>') {
  744.           for (i=strlen("From:");buffer[i] != '\0' && buffer[i] != '('; i++)
  745.         temp[j++] = buffer[i];
  746.           temp[j] = '\0';
  747.         }
  748.         else {    /* get outta '<>' pair, please! */
  749.           for (i=strlen(buffer)-2;buffer[i] != '<' && buffer[i] != ':';i--)
  750.         temp[j++] = buffer[i];
  751.           temp[j] = '\0';
  752.           reverse(temp);
  753.         }
  754.       }
  755.     }
  756.  
  757.     if (strlen(temp) > 0) {        /* mess with buffer... */
  758.  
  759.       /* remove leading spaces and quotes... */
  760.  
  761.       while (whitespace(temp[0]) || quote(temp[0]))
  762.         temp = (char *) (temp + 1);        /* increment address! */
  763.  
  764.       /* remove trailing spaces and quotes... */
  765.  
  766.       i = strlen(temp) - 1;
  767.  
  768.       while (whitespace(temp[i]) || quote(temp[i]))
  769.        temp[i--] = '\0';
  770.  
  771.       /* if anything is left, let's change 'from' value! */
  772.  
  773.       if (strlen(temp) > 0) {
  774.         strncpy(newfrom, temp, STRING-1);
  775.         newfrom[STRING-1] = '\0';
  776.       }
  777.     }
  778. }
  779.  
  780. /*
  781. Quoting from RFC 822:
  782.      5.  DATE AND TIME SPECIFICATION
  783.  
  784.      5.1.  SYNTAX
  785.  
  786.      date-time   =  [ day "," ] date time        ; dd mm yy
  787.                          ;  hh:mm:ss zzz
  788.  
  789.      day         =  "Mon"  / "Tue" /  "Wed"  / "Thu"
  790.          /  "Fri"  / "Sat" /  "Sun"
  791.  
  792.      date        =  1*2DIGIT month 2DIGIT        ; day month year
  793.                          ;  e.g. 20 Jun 82
  794.  
  795.      month       =  "Jan"  /  "Feb" /  "Mar"  /  "Apr"
  796.          /  "May"  /  "Jun" /  "Jul"  /  "Aug"
  797.          /  "Sep"  /  "Oct" /  "Nov"  /  "Dec"
  798.  
  799.      time        =  hour zone                    ; ANSI and Military
  800.  
  801.      hour        =  2DIGIT ":" 2DIGIT [":" 2DIGIT]
  802.                          ; 00:00:00 - 23:59:59
  803.  
  804.      zone        =  "UT"  / "GMT"                ; Universal Time
  805.                          ; North American : UT
  806.          /  "EST" / "EDT"                ;  Eastern:  - 5/ - 4
  807.          /  "CST" / "CDT"                ;  Central:  - 6/ - 5
  808.          /  "MST" / "MDT"                ;  Mountain: - 7/ - 6
  809.          /  "PST" / "PDT"                ;  Pacific:  - 8/ - 7
  810.          /  1ALPHA                       ; Military: Z = UT;
  811.                          ;  A:-1; (J not used)
  812.                          ;  M:-12; N:+1; Y:+12
  813.          / ( ("+" / "-") 4DIGIT )        ; Local differential
  814.                          ;  hours+min. (HHMM)
  815. */
  816.  
  817. /* Translate a symbolic timezone name (e.g. EDT or NZST) to a number of
  818.  * minutes *east* of gmt (if the local time is t, the gmt equivalent is
  819.  * t - tz_lookup(zone)).
  820.  * Return 0 if the timezone is not recognized.
  821.  */
  822. static int tz_lookup(str)
  823. char *str;
  824. {
  825.     struct tzone *p;
  826.  
  827.     for (p = tzone_info; p->str; p++) {
  828.     if (strcmp(p->str,str)==0) return p->offset;
  829.     }
  830.     dprint(5,(debugfile,"unknown time zone %s\n",str));
  831.     return 0;
  832. }
  833.  
  834. /* Return smallest i such that table[i] is a prefix of str.  Return -1 if not
  835.  * found.
  836.  */
  837. int prefix(table, str)
  838. char **table;
  839. char *str;
  840. {
  841.     int i;
  842.  
  843.     for (i=0;table[i];i++)
  844.     if (strncmp(table[i],str,strlen(*table))==0)
  845.         return i;
  846.     return -1;
  847. }
  848.  
  849. /* The following routines, get_XXX(p,...), expect p to point to a string
  850.  * of the appropriate syntax.  They return decoded values in result parameters,
  851.  * and return p updated to point past the parsed substring (also stripping
  852.  * trailing whitespace).
  853.  * Return 0 on syntax errors.
  854.  */
  855.  
  856. /* Parse a year: ['1' '9'] digit digit WS
  857.  */
  858. static char *
  859. get_year(p, result)
  860. char *p;
  861. int *result;
  862. {
  863.     int year;
  864.  
  865.     if (!isdigit(*p)) {
  866.     dprint(5,(debugfile,"missing year: %s\n",p));
  867.     return 0;
  868.     }
  869.     year = atoi(p);
  870.     /* be nice and allow 19xx, althought that's not really kosher */
  871.     if (year>=1900 && year <=1999) year -= 1900;
  872.     if (year<0 || year>99) {
  873.     dprint(5,(debugfile,"ridiculous year %d\n",year));
  874.     return 0;
  875.     }
  876.     SKIP_DIGITS(p);
  877.     SKIP_WS(p);
  878.     *result = year;
  879.     return p;
  880. }
  881.  
  882. /* Parse a time: hours ':' minutes [ ':' seconds ] WS
  883.  * Check that 0<=hours<24, 0<=minutes,seconds<60.
  884.  * Also allow the syntax "digit digit digit digit" with implied ':' in the
  885.  * middle.
  886.  * Convert to minutes and seconds, with results in (*m,*s).
  887.  */
  888. static char *
  889. get_time(p,m,s)
  890. char *p;
  891. int *m, *s;
  892. {
  893.     int hours, minutes, seconds;
  894.  
  895.     /* hour */
  896.     if (!isdigit(*p)) {
  897.     dprint(5,(debugfile,"missing time: %s\n",p));
  898.     return 0;
  899.     }
  900.     hours = atoi(p);
  901.     SKIP_DIGITS(p);
  902.     if (*p++ != ':') {
  903.     /* perhaps they just wrote hhmm instead of hh:mm */
  904.     minutes = hours % 60;
  905.     hours /= 60;
  906.     }
  907.     else {
  908.     if (hours<0 || hours>23) {
  909.         dprint(5,(debugfile,"ridiculous hour: %d\n",hours));
  910.         return 0;
  911.     }
  912.     minutes = atoi(p);
  913.     if (minutes<0 || minutes>59) {
  914.         dprint(5,(debugfile,"ridiculous minutes: %d\n",minutes));
  915.         return 0;
  916.     }
  917.     }
  918.     SKIP_DIGITS(p);
  919.     if (*p == ':') {
  920.     p++;
  921.     seconds = atoi(p);
  922.     if (seconds<0 || seconds>59) {
  923.         dprint(5,(debugfile,"ridiculous seconds: %d\n",seconds));
  924.         return 0;
  925.     }
  926.     SKIP_DIGITS(p);
  927.     }
  928.     else seconds = 0;
  929.     minutes += hours*60;
  930.     SKIP_WS(p);
  931.     *m = minutes;
  932.     *s = seconds;
  933.     return p;
  934. }
  935.  
  936. /* Parse a Unix date from which the leading week-day has been stripped.
  937.  * The syntax is "Jun 21 06:45:44 CDT 1989" with timezone optional.
  938.  * i.e., month day time [ zone ] year
  939.  * where day::=digit*, year and time are as defined above,
  940.  * and month and zone are alpha strings starting with a known 3-char prefix.
  941.  * The month has already been processed by the caller, so we just skip over
  942.  * a leading alpha* WS.
  943.  *
  944.  * Unlike the preceding routines, the result is not an updated pointer, but
  945.  * simply 1 for success and 0 for failure.
  946.  */
  947. int
  948. get_unix_date(p,y,d,m,s,t)
  949. char *p;
  950. int *y, *d, *m, *s, *t;
  951. {
  952.  
  953.     SKIP_ALPHA(p);
  954.     SKIP_WS(p);
  955.     if (!isdigit(*p)) return 0;
  956.     *d = atoi(p);  /* check the value for sanity after we know the month */
  957.     SKIP_DIGITS(p);
  958.     SKIP_WS(p);
  959.     p = get_time(p,m,s);
  960.     if (!p) return 0;
  961.     if (isalpha(*p)) {
  962.     *t = tz_lookup(p);
  963.     SKIP_ALPHA(p);
  964.     SKIP_WS(p);
  965.     }
  966.     else *t = 0;
  967.     p = get_year(p,y);
  968.     if (!p) return 0;
  969.     return 1;
  970. }
  971.  
  972.  
  973. /* Parse an rfc822 (with extensions) date.  Return 1 on success, 0 on failure.
  974.  */
  975. parse_arpa_date(string, entry)
  976. char *string;
  977. struct header_rec *entry;
  978. {
  979.     char buffer[BUFSIZ], *p, *q;
  980.     int mday, month, year, minutes, seconds, tz, i;
  981.     long gmttime;
  982.  
  983.     /* first get everything into lower case */
  984.     for (p=buffer, q=buffer+sizeof buffer; *string && p<q; p++, string++) {
  985.     *p = isupper(*string) ? tolower(*string) : *string;
  986.     }
  987.     *p = 0;
  988.     p = buffer;
  989.     SKIP_WS(p);
  990.  
  991.     if (prefix(day_name,p)>=0) {
  992.     /* accept anything that *starts* with a valid day name */
  993.     /* also, don't check whether it's right! */
  994.  
  995.     (void)strncpy(entry->dayname, p, 3);
  996.     entry->dayname[3] = 0;
  997.     SKIP_ALPHA(p);
  998.     SKIP_WS(p);
  999.  
  1000.     if (*p==',') {
  1001.         p++;
  1002.         SKIP_WS(p);
  1003.     }
  1004.     /* A comma is required here, but we'll be nice guys and look the other
  1005.      * way if it's missing.
  1006.      */
  1007.     }
  1008.  
  1009.     /* date */
  1010.  
  1011.     /* day of the month */
  1012.     if (!isdigit(*p)) {
  1013.     /* Missing day.  Maybe this is a Unix date?
  1014.      */
  1015.     month = prefix(month_name,p);
  1016.     if (month >= 0 &&
  1017.         get_unix_date(p, &year, &mday, &minutes, &seconds, &tz)) {
  1018.         goto got_date;
  1019.     }
  1020.     dprint(5,(debugfile,"missing day: %s\n",p));
  1021.     return 0;
  1022.     }
  1023.     mday = atoi(p);  /* check the value for sanity after we know the month */
  1024.     SKIP_DIGITS(p);
  1025.     SKIP_WS(p);
  1026.  
  1027.     /* month name */
  1028.     month = prefix(month_name,p);
  1029.     if (month < 0) {
  1030.     dprint(5,(debugfile,"missing month: %s\n",p));
  1031.     return 0;
  1032.     }
  1033.     SKIP_ALPHA(p);
  1034.     SKIP_WS(p);
  1035.  
  1036.     /* year */
  1037.     if (!(p = get_year(p,&year))) return 0;
  1038.  
  1039.     /* time */
  1040.     if (!(p = get_time(p,&minutes,&seconds))) return 0;
  1041.  
  1042.     /* zone */
  1043.     for (q=p; *q && !isspace(*q); q++) continue;
  1044.     *q = 0;
  1045.     if (*p=='-' || *p=='+') {
  1046.     char sign = *p++;
  1047.  
  1048.     if (isdigit(*p)) {
  1049.         for (i=0; i<4; i++) {
  1050.         if (!isdigit(p[i])) {
  1051.             dprint(5,(debugfile,"ridiculous numeric timezone: %s\n",p));
  1052.             return 0;
  1053.         }
  1054.         p[i] -= '0';
  1055.         }
  1056.         tz = (p[0]*10 + p[1])*60 + p[2]*10 + p[3];
  1057.         if (sign=='-') tz = -tz;
  1058.         sprintf(entry->time_zone, "%d", tz);
  1059.     }
  1060.     else {
  1061.         /* some brain-damaged dates use a '-' before a symbolic time zone */
  1062.         SKIP_WS(p);
  1063.         strncpy(entry->time_zone, p, sizeof(entry->time_zone) - 1);
  1064.         tz = tz_lookup(p);
  1065.     }
  1066.     }
  1067.     else {
  1068.     tz = tz_lookup(p);
  1069.     strncpy(entry->time_zone, p, sizeof(entry->time_zone) - 1);
  1070.     }
  1071.  
  1072. got_date:
  1073.     month_len[1] = (year%4) ? 28 : 29;
  1074.     if (mday<0 || mday>month_len[month]) {
  1075.     dprint(5,(debugfile,"ridiculous day %d of month %d\n",mday,month));
  1076.     return 0;
  1077.     }
  1078.  
  1079.     /* convert back to symbolic form (silly, but the rest of the program
  1080.      * expects it and I'm not about to change all that!)
  1081.      */
  1082.     sprintf(entry->year, "%02d", year);
  1083.     sprintf(entry->month, "%s", month_name[month]);
  1084.     entry->month[0] = toupper(entry->month[0]);
  1085.     sprintf(entry->day, "%d", mday);
  1086.     sprintf(entry->time, "%02d:%02d:%02d",minutes/60,minutes%60,seconds);
  1087.  
  1088.     /* shift everything to UTC (aka GMT) before making long time for sorting */
  1089.     minutes -= tz;
  1090.     if (tz > 0) { /* east of Greenwich */
  1091.     if (minutes < 0) {
  1092.         if (--mday < 0) {
  1093.         if (--month < 0) {
  1094.             year--; /* don't worry about 1900! */
  1095.             month = 11;
  1096.         }
  1097.         mday = month_len[month];
  1098.         }
  1099.         minutes += 24*60;
  1100.     }
  1101.     }
  1102.     if (tz < 0) { /* west of Greenwich */
  1103.     if (minutes >= 24*60) {
  1104.         if (++mday > month_len[month]) {
  1105.         if (++month >= 12) {
  1106.             year++; /* don't worry about 1999! */
  1107.             month = 0;
  1108.         }
  1109.         mday = 0;
  1110.         }
  1111.         minutes -= 24*60;
  1112.     }
  1113.     }
  1114.     gmttime = year - 70;         /* make base year */
  1115.     if (gmttime < 0)
  1116.     gmttime += 100;
  1117.     gmttime = gmttime * 365 + (gmttime + 1) / 4;  /* now we have days adjusted for leap years */
  1118.     for (i = 0; i < month; i++)
  1119.     gmttime += month_len[i];
  1120.     if (month > 1 && (year % 4) == 0)
  1121.     gmttime++;            /* now to month adjusted for leap year if after feb */
  1122.     gmttime += mday - 1;        /* and now to the day */
  1123.     gmttime *= 24 * 60;            /* convert to minutes */
  1124.     gmttime += minutes;
  1125.     entry->time_sent = gmttime * 60;    /* now unix seconds since 1/1/70 00:00 GMT */
  1126.  
  1127.     return 1;
  1128. }
  1129.  
  1130. fix_arpa_address(address)
  1131. char *address;
  1132. {
  1133.     /** Given a pure ARPA address, try to make it reasonable.
  1134.  
  1135.         This means that if you have something of the form a@b@b make
  1136.             it a@b.  If you have something like a%b%c%b@x make it a%b@x...
  1137.     **/
  1138.  
  1139.     register int host_count = 0, i;
  1140.     char     hosts[MAX_HOPS][NLEN];    /* array of machine names */
  1141.     char     *host, *addrptr;
  1142.  
  1143.     /*  break down into a list of machine names, checking as we go along */
  1144.  
  1145.     addrptr = (char *) address;
  1146.  
  1147.     while ((host = get_token(addrptr, "%@", 2)) != NULL) {
  1148.       for (i = 0; i < host_count && ! equal(hosts[i], host); i++)
  1149.           ;
  1150.  
  1151.       if (i == host_count) {
  1152.         strcpy(hosts[host_count++], host);
  1153.         if (host_count == MAX_HOPS) {
  1154.            dprint(2, (debugfile,
  1155.            "Can't build return address - hit MAX_HOPS in fix_arpa_address\n"));
  1156.            error("Can't build return address - hit MAX_HOPS limit!");
  1157.            return(1);
  1158.         }
  1159.       }
  1160.       else
  1161.         host_count = i + 1;
  1162.       addrptr = NULL;
  1163.     }
  1164.  
  1165.     /** rebuild the address.. **/
  1166.  
  1167.     address[0] = '\0';
  1168.  
  1169.     for (i = 0; i < host_count; i++)
  1170.       sprintf(address, "%s%s%s", address,
  1171.               address[0] == '\0'? "" :
  1172.              (i == host_count - 1 ? "@" : "%"),
  1173.               hosts[i]);
  1174.  
  1175.     return(0);
  1176. }
  1177.  
  1178. figure_out_addressee(buffer, mail_to)
  1179. char *buffer;
  1180. char *mail_to;
  1181. {
  1182.     /** This routine steps through all the addresses in the "To:"
  1183.         list, initially setting it to the first entry (if mail_to
  1184.         is NULL) or, if the user is found (eg "alternatives") to
  1185.         the current "username".
  1186.  
  1187.         Modified to know how to read quoted names...
  1188.         also modified to look for a comma or eol token and then
  1189.         try to give the maximal useful information when giving the
  1190.         default "to" entry (e.g. "Dave Taylor <taylor@hpldat>"
  1191.         will now give "Dave Taylor" rather than just "Dave")
  1192.     **/
  1193.  
  1194.     char *address, *bufptr, mybuf[SLEN];
  1195.     register int index2 = 0;
  1196.  
  1197.     if (equal(mail_to, username)) return;    /* can't be better! */
  1198.  
  1199.     bufptr = (char *) buffer;           /* use the string directly   */
  1200.  
  1201.     if (index(buffer,'"') != NULL) {    /* we have a quoted string */
  1202.       while (*bufptr != '"')
  1203.         bufptr++;
  1204.       bufptr++;    /* skip the leading quote */
  1205.       while (*bufptr != '"' && *bufptr)
  1206.         mail_to[index2++] = *bufptr++;
  1207.       mail_to[index2] = '\0';
  1208.     }
  1209.  
  1210.     else  {
  1211.  
  1212.       while ((address = strtok(bufptr, ",\t\n\r")) != NULL) {
  1213.  
  1214.         if (! okay_address(address, "don't match me!")) {
  1215.           strcpy(mail_to, username);    /* it's to YOU! */
  1216.           return;
  1217.         }
  1218.         else if (strlen(mail_to) == 0) {    /* it's SOMEthing! */
  1219.  
  1220.           /** this next bit is kinda gory, but allows us to use the
  1221.           existing routines to parse the address - by pretending
  1222.           it's a From: line and going from there...
  1223.               Ah well - you get what you pay for, right?
  1224.           **/
  1225.  
  1226.           if (strlen(address) > (sizeof mybuf) - 7)    /* ensure it ain't */
  1227.         address[(sizeof mybuf)-7] = '\0';    /*  too long mon!  */
  1228.  
  1229.           sprintf(mybuf, "From: %s", address);
  1230.           parse_arpa_who(mybuf, mail_to, TRUE);
  1231. /**
  1232.           get_return_name(address, mail_to, FALSE);
  1233. **/
  1234.         }
  1235.  
  1236.         bufptr = (char *) NULL;    /* set to null */
  1237.       }
  1238.     }
  1239.  
  1240.     return;
  1241. }
  1242.