home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / mush-7.1.1 / hdrs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-02  |  21.2 KB  |  740 lines
  1. /* hdrs.c     (c) copyright 1986 (Dan Heller) */
  2.  
  3. /*
  4.  * Routines that deal with message headers inside messages
  5.  * msg_get(n, from, count) -- get the From_ line in msg n into "from".
  6.  * header_field(n, str) -- get the header named "str" from msg n.
  7.  * do_hdrs(argc, argv, list) -- diplay message headers.
  8.  * specl_hdrs(argv, list) -- display msgs that share common attributes.
  9.  * compose_hdr(cnt) -- compose a message header from msg n.
  10.  * reply_to(n, all, buf) -- construct a header based on the To: header of n.
  11.  * subject_to(n, buf) -- get the subject for replying to msg n.
  12.  * cc_to(n, buf) -- construct a Cc header based on the Cc of message n.
  13.  */
  14. #include "mush.h"
  15.  
  16. #ifdef SUNTOOL
  17. #define highlight(win,x,y,s) \
  18.     (void) (pw_text(win,x,y, PIX_SRC, mush_font, s), \
  19.     pw_text(win,x+1,y, \
  20.     (ison(glob_flags, REV_VIDEO))? PIX_NOT(PIX_SRC): PIX_SRC|PIX_DST, \
  21.     mush_font, s))
  22. #endif /* SUNTOOL */
  23.  
  24. /*
  25.  * Get a message from the current folder by its offset.
  26.  * Copy the From_ line to the second argument if the third arg > 0,
  27.  * and return the second argument, or NULL on an error.
  28.  */
  29. char *
  30. msg_get(n, from, count)
  31. int n, count;
  32. char *from;
  33. {
  34.     if (fseek(tmpf, msg[n].m_offset, L_SET) == -1) {
  35.     error("fseek in %s (msg %d, folder=%s)", tempfile, n+1, mailfile);
  36.     turnon(glob_flags, READ_ONLY);
  37.     return NULL;
  38.     }
  39.     if (count)
  40. #ifndef MSG_SEPARATOR
  41.     return fgets(from, count, tmpf);
  42. #else
  43.     *from = '\0';
  44. #endif
  45.     return from;
  46. }
  47.  
  48. /*
  49.  * get which message via the offset and search for the headers which
  50.  * match the string "str". there may be more than one of a field (like Cc:)
  51.  * so get them all and "cat" them together into the static buffer
  52.  * "buf" and return its address.
  53.  */
  54. char *
  55. header_field(n, str)
  56. char *str;
  57. {
  58.     static char    buf[HDRSIZ];
  59.     char        tmp[HDRSIZ];
  60.     register char  *p, *p2, *b = buf;
  61.     int contd_hdr;  /* true if next line is a continuation of the hdr we want */
  62.  
  63.     /* use msg_get as a test for fseek() -- don't let it fgets() (pass 0) */
  64.     if (!msg_get(n, tmp, 0))
  65.     return NULL;
  66.     *b = 0;
  67.     while((p = fgets(tmp, sizeof(tmp), tmpf)) && *p != '\n') {
  68.     if (*p != ' ' && *p != '\t') {
  69.         contd_hdr = 0;
  70.         /* strcmp ignoring case */
  71.         for(p2 = str; *p && *p2 && lower(*p2) == lower(*p); ++p, ++p2);
  72.         /* MATCH is true if p2 is at the end of str and *p is ':' */
  73.         if (*p2 || *p++ != ':')
  74.         continue;
  75.         else
  76.         contd_hdr = 1;
  77.         if (b > buf && (b - buf) < sizeof buf - 2)
  78.         *b++ = ',';
  79.     } else if (!contd_hdr)
  80.         continue;
  81.     skipspaces(0);
  82.     (void) no_newln(p);
  83.     if (strlen(p) + (b - buf) < sizeof buf - 1) {
  84.         if (b > buf)
  85.         *b++ = ' ';
  86.         b += Strcpy(b, p);
  87.     }
  88.     }
  89.     if (*--b == ',')
  90.     *b = 0;
  91.     return (*buf)? buf: NULL;
  92. }
  93.  
  94. do_hdrs(argc, argv, list)
  95. register char **argv, list[];
  96. {
  97.     register int   pageful = 0;
  98.     SIGRET        (*oldint)(), (*oldquit)();
  99.     int           show_deleted, srch = 1; /* search forward by default */
  100.     static int     cnt, oldscrn = 1;
  101.     register char  *p;
  102.     char        first_char = (argc) ? **argv: 'h';
  103.  
  104.     if (argc > 1 && !strcmp(argv[1], "-?"))
  105.     return help(0, "headers", cmd_help);
  106.  
  107.     if (!msg_cnt) {
  108.     if (ison(glob_flags, DO_PIPE))
  109.         return 0;
  110. #ifdef CURSES
  111.     if (iscurses)
  112.         clear();
  113. #endif /* CURSES */
  114. #ifdef SUNTOOL
  115.     if (istool)
  116.         mail_status(0);
  117. #endif /* SUNTOOL */
  118.     return 0;
  119.     }
  120.     if (first_char == ':' || (argc > 1 && argv[1][0] == ':')) {
  121.     if (first_char != ':')
  122.         argv++;
  123.     return specl_hdrs(argv, list);
  124.     } else if (argc > 1 && !strncmp(argv[1], "-H:", 3)) {
  125.     argv[1][0] = ':';
  126.     argv[1][1] = argv[1][3];
  127.     argv[1][2] = 0;
  128.     return specl_hdrs(&argv[1], list);
  129.     }
  130.  
  131.     on_intr();
  132.  
  133.     if (argc && (argv[0][1] == '-' || argc > 1 && !strcmp(argv[1], "-"))) {
  134.     cnt = max(n_array[0], 0);
  135.     srch = -1;    /* search backwards */
  136.     } else if (argc && (argv[0][1] == '+' ||
  137.         argc > 1 && !strcmp(argv[1], "+")) ||
  138.         first_char == 'z' && !argv[1]) {
  139.     if (msg_cnt > screen)
  140.         cnt = min(msg_cnt - screen, n_array[0] + screen);
  141.     else
  142.         cnt = 0;
  143.     } else if (argc && *++argv &&
  144.         (isdigit(**argv) || **argv == '^' ||
  145.         **argv == '$' || **argv == '.') ||
  146.         ison(glob_flags, IS_PIPE)) {
  147.     /* if we're coming from a pipe, start display at the first msg bit
  148.      * set in the msg_list
  149.      */
  150.     int fnd;
  151.     if (ison(glob_flags, IS_PIPE)) {
  152.         if (isoff(glob_flags, DO_PIPE))
  153.         for (fnd = 0; fnd < msg_cnt; fnd++)
  154.             if (msg_bit(list, fnd))
  155.             wprint("%s\n", compose_hdr(fnd));
  156.         off_intr();
  157.         return 0;
  158.     }
  159.     /* if a number was given, use it */
  160.     if (!(fnd = chk_msg(*argv))) {
  161.         off_intr();
  162.         return -1;
  163.     }
  164.     for (cnt = fnd - 1; cnt > 0 && cnt + screen > msg_cnt; cnt--)
  165.         ;
  166.     } else if (current_msg < n_array[0] || current_msg > n_array[oldscrn-1] ||
  167.         (iscurses || oldscrn != screen) &&
  168.         (cnt > current_msg + screen || cnt < current_msg - screen))
  169.     cnt = current_msg; /* adjust if reads have passed screen bounds */
  170.     else if (cnt >= msg_cnt || !argc || !*argv)
  171.     /* adjust window to maintain position */
  172.     cnt = (n_array[0] > msg_cnt) ? current_msg : n_array[0];
  173.  
  174.     oldscrn = screen;
  175.     show_deleted = !!do_set(set_options, "show_deleted");
  176.  
  177.     /* Make sure we have at least $screen headers to print */
  178.     if (cnt > 0 && !iscurses && first_char == 'h') {
  179.     int top, bot = cnt;
  180.     /* first count how many messages we can print without adjusting */
  181.     for (pageful = 0; pageful<screen && bot<msg_cnt && bot; bot += srch)
  182.         if (show_deleted || isoff(msg[bot].m_flags, DELETE))
  183.         pageful++;
  184.     /* if we can't print a pagefull of hdrs, back up till we can */
  185.     for (top = cnt-srch; pageful<screen && top && top<msg_cnt; top -= srch)
  186.         if (show_deleted || isoff(msg[top].m_flags, DELETE))
  187.         pageful++;
  188.     if (srch < 0)
  189.         cnt = bot;    /* the search was upside down */
  190.     else
  191.         cnt = top + (pageful == screen);
  192.     pageful = 0;    /* Used later as an index, so reset */
  193.     } else if (cnt > 0 && srch < 0)
  194.     cnt = max(cnt - screen, 0);
  195.     else
  196.     cnt = max(cnt, 0);
  197.  
  198.     for (;pageful<screen && cnt<msg_cnt && isoff(glob_flags, WAS_INTR); cnt++) {
  199.     if (!iscurses && !show_deleted && first_char == 'h'
  200.         && ison(msg[cnt].m_flags, DELETE))
  201.         continue;
  202.     n_array[pageful++] = cnt;
  203.     /* this message was displayed -- set the bit */
  204.     if (list)
  205.         set_msg_bit(list, cnt);
  206.     /* if do_pipe, don't output anything */
  207.     if (ison(glob_flags, DO_PIPE))
  208.         continue;
  209.     p = compose_hdr(cnt);
  210.     if (!istool && (!iscurses || ison(glob_flags, IS_GETTING)))
  211.         puts(p);
  212. #ifdef SUNTOOL
  213.     else if (istool) {
  214.         if (cnt == current_msg) /* embolden or reverse-video */
  215.         highlight(hdr_win, 0,pageful*l_height(), p);
  216.         else
  217.         (void) pw_text(hdr_win, 0, pageful * l_height(), PIX_SRC,
  218.                             mush_font, p);
  219.         Clrtoeol(hdr_win, strlen(p)*l_width(), pageful*l_height());
  220.     }
  221. #endif /* SUNTOOL */
  222.  
  223. #ifdef CURSES
  224.     else if (iscurses) {
  225.         move(pageful, 0);
  226.         printw("%-.*s", COLS-2, p), clrtoeol();
  227.     }
  228. #endif /* CURSES */
  229.     }
  230.     /* just in case a signal stopped us */
  231.     off_intr();
  232.     pageful++;
  233. #ifdef CURSES
  234.     if (iscurses && pageful < screen)
  235.     move(pageful, 0), clrtobot();
  236. #endif /* CURSES */
  237.     if (cnt == msg_cnt) {
  238.     while (pageful <= screen) {
  239.         n_array[pageful-1] = msg_cnt+1; /* assign out-of-range values */
  240. #ifdef SUNTOOL
  241.         if (istool)
  242.         Clrtoeol(hdr_win, 0, pageful * l_height());
  243. #endif /* SUNTOOL */
  244.         ++pageful;
  245.     }
  246.     }
  247. #ifdef SUNTOOL
  248.     if (istool) {
  249.     Scrollbar sb = (Scrollbar) window_get(hdr_sw, WIN_VERTICAL_SCROLLBAR);
  250.  
  251.     if (show_deleted) {
  252.         scrollbar_set(sb,
  253.         SCROLL_OBJECT_LENGTH,    msg_cnt,
  254.         SCROLL_VIEW_START,    n_array[0],
  255.         0);
  256.     } else {
  257.         int i, not_deleted, start;
  258.  
  259.         for (i = start = 0; i < n_array[0]; i++)
  260.         if (!ison(msg[i].m_flags, DELETE))
  261.             start++;
  262.         for (not_deleted = start; i < msg_cnt; i++)
  263.         if (!ison(msg[i].m_flags, DELETE))
  264.             not_deleted++;
  265.         scrollbar_set(sb,
  266.         SCROLL_OBJECT_LENGTH,    not_deleted,
  267.         SCROLL_VIEW_START,    start,
  268.         0);
  269.         }
  270.  
  271.     scrollbar_paint(sb);
  272.     mail_status(0);
  273.     }
  274. #endif /* SUNTOOL */
  275.  
  276.     return 0;
  277. }
  278.  
  279. #define NEW 1
  280. #define ALL 2
  281.  
  282. specl_hdrs(argv, list)
  283. char **argv, list[];
  284. {
  285.     u_long    special = 0;
  286.     int     n = 0;
  287.  
  288.     while (argv[0][++n])
  289.     switch(argv[0][n]) {
  290.         case 'a': special = ALL;
  291.         when 'n': special = NEW;
  292.         when 'u': special = UNREAD;
  293.         when 'o': special = OLD;
  294.         when 'd': special = DELETE;
  295.         when 'r': special = REPLIED;
  296.         when 's': special = SAVED;
  297.         when 'p': special = PRESERVE;
  298.         otherwise: print("choose from n,u,o,d,r,s,p or a"); return -1;
  299.     }
  300.     if (debug)
  301.     (void) check_flags(special);
  302.  
  303.     for (n = 0; n < msg_cnt; n++) {
  304.     /*
  305.      * First, see if we're looking for NEW messages.
  306.      * If so, then check to see if the msg is unread and not old.
  307.      * If special > ALL, then special has a mask of bits describing
  308.      * the state of the message.
  309.      */
  310.     if (ison(glob_flags, IS_PIPE)&& !msg_bit(list, n))
  311.         continue;
  312.     if (special == ALL || special == NEW &&
  313.            (ison(msg[n].m_flags, UNREAD) && isoff(msg[n].m_flags, OLD))) {
  314.         if (isoff(glob_flags, DO_PIPE))
  315.         print("%s\n", compose_hdr(n));
  316.         if (list)
  317.         set_msg_bit(list, n);
  318.     } else if (special > ALL && ison(msg[n].m_flags, special)) {
  319.         if (isoff(glob_flags, DO_PIPE))
  320.         print("%s\n", compose_hdr(n));
  321.         if (list)
  322.         set_msg_bit(list, n);
  323.     } else {
  324.         if (list)
  325.         unset_msg_bit(list, n);
  326.         if (debug) {
  327.         (void) printf("msg[%d].m_flags: %d", n, msg[n].m_flags);
  328.         (void) check_flags(msg[n].m_flags);
  329.         }
  330.     }
  331.     }
  332.     return 0;
  333. }
  334.  
  335. #define Strncpy(buf,p) (void)(strncpy(buf,p,sizeof(buf)),buf[sizeof(buf)-1]=0)
  336.  
  337. /*
  338.  * format a header from the information about a message (from, to, date,
  339.  * subject, etc..).  The header for message number "cnt" is built and is
  340.  * returned in the static buffer "buf".  There will be *at least* 9 chars
  341.  * in the buffer which will be something like: " 123 >N " The breakdown
  342.  * is as follows: 4 chars for the message number, 1 space, 1 char for '>'
  343.  * (if current message) and two spaces for message status (new, unread, etc)
  344.  * followed by 1 terminating space.
  345.  * Read other comments in the routine for more info.
  346.  */
  347. char *
  348. format_hdr(cnt, hdr_fmt, show_to)
  349. int cnt, show_to;
  350. char *hdr_fmt;
  351. {
  352.     static char        buf[256];
  353.     register char    *p, *p2, *b;
  354.     int            len, do_pad = FALSE, val, pad, got_dot, isauthor = 0, n;
  355.     char from[HDRSIZ], subject[256], date[64], lines[16];
  356.     char to[256], addr[256], name[256], status[4];
  357.     char Day[3], Mon[4], Tm[8], Yr[5], Wkday[4], Zone[8], *date_p;
  358.  
  359.     /* status of the message */
  360.     if (ison(msg[cnt].m_flags, DELETE))
  361.     status[0] = '*';
  362.     else if (ison(msg[cnt].m_flags, PRESERVE))
  363.     status[0] = 'P';
  364.     else if (ison(msg[cnt].m_flags, SAVED))
  365.     status[0] = 'S';
  366.     else if (ison(msg[cnt].m_flags, OLD) && ison(msg[cnt].m_flags, UNREAD))
  367.     status[0] = 'U';
  368.     else if (ison(msg[cnt].m_flags, PRINTED))
  369.     status[0] = 'p';
  370.     else if (ison(msg[cnt].m_flags, FORWARD))
  371.     status[0] = 'f';
  372.     else if (isoff(msg[cnt].m_flags, UNREAD))
  373.     status[0] = ' ';
  374.     else
  375.     status[0] = 'N';
  376.  
  377.     if (ison(msg[cnt].m_flags, REPLIED))
  378.     status[1] = 'r';
  379.     else
  380.     status[1] = ' ';
  381.  
  382.     to[0] = from[0] = subject[0] = date[0] = lines[0] = addr[0] =
  383.     name[0] = Day[0] = Mon[0] = Tm[0] = Yr[0] = Wkday[0] = 0;
  384.  
  385.     /* who's the message to */
  386.     if ((p = header_field(cnt, "resent-to")) ||
  387.     (p = header_field(cnt, "to")) ||
  388.     (p = header_field(cnt, "apparently-to")))
  389.     Strncpy(to, p);
  390.  
  391.     /* who's the message from */
  392.     if ((p = header_field(cnt, "from")) && strcpy(from, p)
  393.         || (p = reply_to(cnt, 0, from))) {
  394.     /* NOTE:  this fails if the sender has '<' or '!' in
  395.      * the RFC822 comment fields -- leading "comment"
  396.      * or trailing (comment) -- but that isn't critical
  397.      */
  398.     if ((p2 = rindex(p, '!')) || (p2 = index(p, '<')))
  399.         p = p2 + 1;
  400.     } else
  401.     p = strcpy(from, "unknown"); /* just in case */
  402.     /* If the From field contains the user's login name, then the message
  403.      * could be from the user -- attempt to give more useful information
  404.      * by telling to whom the message was sent.  This is not possible if
  405.      * the "to" header failed to get info (which is probably impossible).
  406.      * Use take_me_off() to be sure the message really is from the current
  407.      * user and not just someone with the same login at another site.
  408.      */
  409.     if (show_to && !strncmp(p, login, strlen(login)))
  410.     (void) take_me_off(from);
  411.     if (show_to && (isauthor = !*from)) {  /* assign and test */
  412.     (void) get_name_n_addr(to, name+4, addr+4);
  413.     if (addr[4])
  414.         (void) strncpy(addr, "TO: ", 4);
  415.     if (name[4]) {  /* check to see if a name got added */
  416.         (void) strncpy(name, "TO: ", 4);
  417.         Strncpy(from, name);
  418.     } else
  419.         Strncpy(from, addr);
  420.     } else
  421.     (void) get_name_n_addr(from, name, addr);
  422.  
  423.     if (ison(glob_flags, DATE_RECV))
  424.     date_p = msg[cnt].m_date_recv;
  425.     else
  426.     date_p = msg[cnt].m_date_sent;
  427.     (void) date_to_string(date_p, Yr, Mon, Day, Wkday, Tm, Zone, date);
  428.  
  429.     /* and the subject */
  430.     if (p = header_field(cnt, "subject"))
  431.     Strncpy(subject, p);
  432.  
  433.     /* now, construct a header out of a format string */
  434.     if (!hdr_fmt)
  435.     hdr_fmt = hdr_format;
  436.  
  437.     (void) sprintf(buf, "%4.d ", cnt+1);
  438.     b = buf+5;
  439.     *b++ = ((cnt == current_msg && !iscurses)? '>': ' ');
  440.     *b++ = status[0], *b++ = status[1];
  441.     *b++ = ' ';
  442.     /* Count chars since beginning of buf. Initialize to 9 (strlen(buf) so far)
  443.      * This magic number is used in other places in msgs.c and mail.c
  444.      */
  445.     n = 9;
  446.     for (p = hdr_fmt; *p; p++)
  447.     if (*p == '\\')
  448.         switch (*++p) {
  449.         case 't':
  450.             while (n % 8)
  451.             n++, *b++ = ' ';
  452.         when 'n':
  453.             n = 1, *b++ = '\n';
  454.         otherwise: n++, *b++ = *p;
  455.         }
  456.     else if (*p == '%') {
  457.         char fmt[64];
  458.  
  459.         p2 = fmt;
  460.         /* first check for string padding: %5n, %.4a, %10.5f, %-.3l etc. */
  461.         do_pad = pad = val = got_dot = 0;
  462.         *p2++ = '%';
  463.         if (p[1] != '-')
  464.         *p2++ = '-';
  465.         else
  466.         ++p;
  467.         while (isdigit(*++p) || !got_dot && *p == '.') {
  468.         if (*p == '.')
  469.             got_dot = TRUE, val = pad, pad = 0;
  470.         else
  471.             pad = pad * 10 + *p - '0';
  472.         *p2++ = *p;
  473.         }
  474.         if (!got_dot && isdigit(p[-1])) {
  475.         *p2 = 0; /* assure null termination */
  476.         val = atoi(fmt+1);
  477.         if (val < 0)
  478.             val = -val;
  479.         p2 += strlen(sprintf(p2, ".%d", val));
  480.         }
  481.         pad = min(pad, val);
  482.         *p2++ = 's', *p2 = 0;
  483.         if (!*p)
  484.         break;
  485.         switch (*p) {
  486.         case 'f': p2 = from, do_pad = TRUE;
  487.         when 'a':
  488.             if (!*(p2 = addr))
  489.             p2 = from;
  490.             do_pad = TRUE;
  491.         when 'n':
  492.             if (!*(p2 = name))
  493.             p2 = from, do_pad = TRUE;
  494.         when '%': p2 = "%";
  495.         when 't': p2 = to;
  496.         when 's': p2 = subject;
  497.         when 'l': p2 = sprintf(lines, "%d", msg[cnt].m_lines);
  498.         when 'c': p2 = sprintf(lines, "%ld", msg[cnt].m_size);
  499.         when 'i': (p2 = header_field(cnt, "message-id")) || (p2 = "");
  500.         /* date formatting chars */
  501.         when 'd': p2 = date; /* the full date */
  502.         when 'T': p2 = Tm;
  503.         when 'M': p2 = Mon;
  504.         when 'Y': p2 = Yr;
  505.         when 'y': p2 = Yr+2;
  506.         when 'N': p2 = Day;
  507.         when 'D': case 'W': p2 = Wkday;
  508.         when 'Z': p2 = Zone;
  509.         /* Any selected header */
  510.         when '?': {
  511.             p2 = p + 1;
  512.             p = index(p2, '?');
  513.             if (p) {
  514.             *p = 0;
  515.             if (!(p2 = header_field(cnt, p2)))
  516.                 p2 = "";
  517.             *p = '?';
  518.             } else {
  519.             p = p2 + (strlen(p2) - 1);
  520.             if (!(p2 = header_field(cnt, p2)))
  521.                 p2 = "";
  522.             }
  523.         }
  524.         otherwise: continue; /* unknown formatting char */
  525.         }
  526.         if (do_pad && pad && strlen(p2) > pad) {
  527.         char *old_p2 = p2, *p3;
  528.         /* if addr is too long, move pointer forward till the
  529.          * "important" part is readable only for ! paths/addresses.
  530.          */
  531.         while (p3 = index(p2, '!')) {
  532.             int tmp = strlen(p3+1); /* xenix has compiler problems */
  533.             p2 = p3+1;
  534.             if (tmp + isauthor*4 < pad) {
  535.             if (isauthor && (p2 -= 4) < old_p2)
  536.                 p2 = old_p2;
  537.             break;
  538.             }
  539.         }
  540.         if (isauthor && p2 > old_p2+4 && !p3 && strlen(p2) + 4 > pad)
  541.             p2 -= 4;
  542.         if (old_p2 != p2 && isauthor)
  543.             (void) strncpy(p2, "TO: ", 4); /* doesn't null terminate */
  544.         }
  545.         len = strlen(sprintf(b, fmt, p2));
  546.         n += len, b += len;
  547.         /* Get around a bug in 5.5 IBM RT which pads with NULs not ' ' */
  548.         while (n && !*(b-1))
  549.         b--, n--;
  550.     } else
  551.         n++, *b++ = *p;
  552.     for (*b-- = 0; isspace(*b) && *b != '\n'; --b)
  553.     *b = 0;
  554.     return buf;
  555. }
  556.  
  557. char *
  558. compose_hdr(cnt)
  559. int cnt;
  560. {
  561.     if (!hdr_format)
  562.     hdr_format = DEF_HDR_FMT;
  563.     return format_hdr(cnt, hdr_format, TRUE);
  564. }
  565.  
  566. /*
  567.  * Using message "n", build a list of recipients that you would mail to if
  568.  * you were to reply to this message.  If "all" is true, then it will take
  569.  * everyone from the To line in addition to the original sender.
  570.  * route_addresses() is called from mail.c, not from here.  There are too many
  571.  * other uses for reply_to to always require reconstruction of return paths.
  572.  * Note that we do NOT deal with Cc paths here either.
  573.  * Check to make sure that we in fact return a legit address (i.e. not blanks
  574.  * or null). If such a case occurs, return login name.  Always pad end w/blank.
  575.  */
  576. char *
  577. reply_to(n, all, buf)
  578. char buf[];
  579. {
  580.     register char *p = NULL, *p2, *b = buf, *field;
  581.     char line[256], name[256], addr[256], *unscramble_addr();
  582.  
  583.     if (field = do_set(set_options, "reply_to_hdr")) {
  584. #ifndef MSG_SEPARATOR
  585.     if (!*field)
  586.         goto DoFrom; /* special case -- get the colon-less From line */
  587. #endif /* MSG_SEPARATOR */
  588.     field = lcase_strcpy(line, field);
  589.     while (*field) {
  590.         if (p2 = any(field, " \t,:"))
  591.         *p2 = 0;
  592. #ifndef MSG_SEPARATOR
  593.         if (!lcase_strncmp(field, "from_", -1))
  594.         goto DoFrom;
  595. #endif /* MSG_SEPARATOR */
  596.         if ((p = header_field(n, field)) || !p2)
  597.         break;
  598.         else {
  599.         field = p2+1;
  600.         while (isspace(*field) || *field == ':' || *field == ',')
  601.             field++;
  602.         }
  603.     }
  604.     if (!p)
  605.         print("Warning: message contains no `reply_to_hdr' headers.\n");
  606.     }
  607.     if (p || (!p && ((p = header_field(n, field = "reply-to")) ||
  608.             (p = header_field(n, field = "from")) ||
  609.             (p = header_field(n, field = "return-path")))))
  610.     skipspaces(0);
  611.     else if (!p) {
  612. #ifndef MSG_SEPARATOR
  613. DoFrom:
  614.     field = "from_";
  615.     /* if all else fails, then get the first token in "From" line */
  616.     if (p2 = msg_get(n, line, sizeof line))
  617.         p = index(p2, ' ');
  618.     else
  619.         return "";
  620.     skipspaces(1);
  621.     if (p2 = index(p, ' '))
  622.         *p2 = 0;
  623.     (void) unscramble_addr(p, line); /* p is safely recopied to line */
  624.     p = line;
  625. #else /* MSG_SEPARATOR */
  626.     wprint("Warning: unable to find who msg %d is from!\n", n+1);
  627. #endif /* MSG_SEPARATOR */
  628.     }
  629.     (void) get_name_n_addr(p, name, addr);
  630.     if (!name[0] && (!lcase_strncmp(field, "return-path", -1) ||
  631.              !lcase_strncmp(field, "from_", -1))) {
  632.     /*
  633.      * Get the name of the author of the message we're replying to from the
  634.      * From: header since that header contains the author's name.  Only do
  635.      * this if the address was gotten from the return-path or from_ lines
  636.      * because this is the only way to guarantee that the return address
  637.      * matches the author's name.  Reply-To: may not be the same person!
  638.      * Check Resent-From: if the address came from the from_ line, else
  639.      * check From:, and finally Sender: or Name:.
  640.      */
  641.     if (!lcase_strncmp(field, "from_", -1) &&
  642.         (p = header_field(n, "resent-from")) ||
  643.             (p = header_field(n, "from")) ||
  644.             (p = header_field(n, "sender")))
  645.         (void) get_name_n_addr(p, name, NULL);
  646.     if (!name[0] && (p = header_field(n, "name")))
  647.         (void) strcpy(name, p);
  648.     if (name[0]) {
  649.         if ((p = any(name, "(<,\"")) && (*p == ',' || *p == '<'))
  650.         *b++ = '"';
  651.         b += Strcpy(b, name);
  652.         if (p && (*p == ',' || *p == '<'))
  653.         *b++ = '"';
  654.         *b++ = ' ', *b++ = '<';
  655.     }
  656.     b += Strcpy(b, addr);
  657.     if (name[0])
  658.         *b++ = '>', *b = 0;
  659.     } else
  660.     b += Strcpy(buf, p);
  661.  
  662.     /*
  663.      * if `all' is true, append everyone on the "To:" line(s).
  664.      * cc_to(), called separately, will catch the cc's
  665.      */
  666.     if (all) {
  667.     int lim = HDRSIZ - (b - buf) - 2;
  668.     /* Check for overflow on each copy.
  669.      * The assumption that HDRSIZ is correct is unwise, but I know it
  670.      * to be true for Mush.  Be forewarned if you call this routine.
  671.      */
  672.     if (lim > 0 && (p = header_field(n, "resent-to")) && *p) {
  673.         *b++ = ',', *b++ = ' ';
  674.         p[lim] = '\0'; /* prevent overflow */
  675.         b += Strcpy(b, p);
  676.         lim = HDRSIZ - (b - buf) - 2;
  677.     }
  678.     if (lim > 0 && (p = header_field(n, "to")) && *p) {
  679.         *b++ = ',', *b++ = ' ';
  680.         p[lim] = '\0'; /* prevent overflow */
  681.         b += Strcpy(b, p);
  682.         lim = HDRSIZ - (b - buf) - 2;
  683.     }
  684.     if (lim > 0 && (p = header_field(n, "apparently-to")) && *p) {
  685.         *b++ = ',', *b++ = ' ';
  686.         p[lim] = '\0'; /* prevent overflow */
  687.         b += Strcpy(b, p);
  688.         lim = HDRSIZ - (b - buf) - 2;
  689.     }
  690.     /* Also append the Resent-From address if there is one. */
  691.     if (lim > 0 && (p = header_field(n, "resent-from")) && *p) {
  692.         *b++ = ',', *b++ = ' ';
  693.         p[lim] = '\0'; /* prevent overflow */
  694.         (void) strcpy(b, p);
  695.     }
  696.     }
  697.     fix_up_addr(buf);
  698.     /* p2 used to save boolean value of $metoo */
  699.     if (!(p2 = do_set(set_options, "metoo"))) {
  700.     /* Save the original name/addr in case it is the only one */
  701.     (void) get_name_n_addr(buf, name, addr);
  702.     take_me_off(buf);
  703.     }
  704.     for (p = buf; *p == ',' || isspace(*p); p++)
  705.     ;
  706.     if (!*p)
  707.     if (p2) /* take_me_off() was not done */
  708.         (void) strcpy(buf, login);
  709.     else
  710.         (void) sprintf(buf, "%s <%s>", name, addr);
  711.     return buf;
  712. }
  713.  
  714. char *
  715. subject_to(n, buf)
  716. register char *buf;
  717. {
  718.     register char *p;
  719.     buf[0] = 0; /* make sure it's already null terminated */
  720.     if (!(p = header_field(n, "subject")))
  721.     return NULL;
  722.     if (lcase_strncmp(p, "Re:", 3))
  723.     (void) strcpy(buf, "Re: ");
  724.     return strcat(buf, p);
  725. }
  726.  
  727. char *
  728. cc_to(n, buf)
  729. register char *buf;
  730. {
  731.     register char *p;
  732.     buf[0] = 0; /* make sure it's already null terminated */
  733.     if (!(p = header_field(n, "cc")))
  734.     return NULL;
  735.     fix_up_addr(p);
  736.     if (!do_set(set_options, "metoo"))
  737.     take_me_off(p);
  738.     return strcpy(buf, p);
  739. }
  740.