home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume6 / elm / part07 < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  57.5 KB
  1. Subject: v06i032:  Elm mail system (elm), Part07/14
  2. Newsgroups: mod.sources
  3. Approved: rs@mirror.UUCP
  4.  
  5. Submitted by: Dave Taylor <pyramid!hplabs!hpldat!taylor>
  6. Mod.sources: Volume 6, Issue 32
  7. Archive-name: elm/Part07
  8.  
  9. # Continuation of Shell Archive, created by hpldat!taylor
  10.  
  11. # This is part 7
  12.  
  13. # To unpack the enclosed files, please use this file as input to the
  14. # Bourne (sh) shell.  This can be most easily done by the command;
  15. #     sh < thisfilename
  16.  
  17.  
  18. if [ ! -d src ]
  19. then
  20.   echo creating directory src
  21.   mkdir src
  22. fi
  23.  
  24. # ---------- file src/newmbox.c ----------
  25.  
  26. filename="src/newmbox.c"
  27.  
  28. if [ -f $filename ]
  29. then
  30.   echo File \"$filename\" already exists\!  Skipping...
  31.   filename=/dev/null        # throw it away
  32. else
  33.   echo extracting file src/newmbox.c...
  34. fi
  35.  
  36. cat << 'END-OF-FILE' > $filename
  37. /**            newmbox.c            **/
  38.  
  39. /**  read new mailbox file, (C) Copyright 1986 by Dave Taylor  **/
  40.  
  41. #include <ctype.h>
  42.  
  43. #ifdef BSD
  44. #undef tolower        /* we have our own "tolower" routine instead! */
  45. #endif
  46.  
  47. #include "headers.h"
  48.  
  49. #include <sys/types.h>        
  50. #include <sys/stat.h>
  51. #include <errno.h>
  52.  
  53. #ifdef BSD            /* Berkeley has library elsewhere... */
  54. #  include <sys/time.h>
  55. #else
  56. #  include <time.h>
  57. #endif
  58.  
  59. extern int errno;
  60.  
  61. char *error_name(), error_description();
  62.  
  63. int
  64. newmbox(stat, resync, main_screen)
  65. int stat, resync, main_screen;
  66. {
  67.     /** Read a new mailbox file or resync on current file.
  68.  
  69.         Values of stat and what they mean;
  70.  
  71.         stat = 0    - changing mailboxes from within program
  72.         stat = 1    - read default mailbox or infile for the 
  73.                       first time
  74.             stat = 2    - read existing mailbox, new mail arrived
  75.  
  76.         resync is TRUE iff we know the current mailbox has changed.  If
  77.         it's set to true this means that we MUST READ SOMETHING, even 
  78.         if it's the current mailbox again!!
  79.  
  80.         main_screen simply tells where the counting line should be.
  81.     **/
  82.  
  83.     int  switching_to_default = 0;
  84.     char buff[SLEN];
  85.  
  86.     if (stat > 0) {
  87.       if (strlen(infile) == 0)    /* no filename yet?? */
  88.         sprintf(infile,"%s%s",mailhome, username);
  89.       if ((errno = can_access(infile, READ_ACCESS))) {
  90.         error2("Can't open mailbox '%s' for reading [%s]", infile,
  91.             error_name(errno));
  92.         exit(1);
  93.       }
  94.     }
  95.     else {              /* get name of new mailbox! */
  96.       MoveCursor(LINES-3, 30);
  97.       CleartoEOS();
  98.       show_last_error();
  99.       PutLine0(LINES-2,0,"Name of new mailbox: ");
  100.       buff[0] = '\0';
  101.       (void) optionally_enter(buff, LINES-2, 21, FALSE);
  102.       ClearLine(LINES-2);
  103.       if (strlen(buff) == 0) {
  104.         if (resync && file_changed)
  105.           strcpy(buff, infile);
  106.         else
  107.           return(FALSE);
  108.       }
  109.       if (strcmp(buff, "!") == 0 ||
  110.            strcmp(buff, "%") == 0)     /* go to mailbox */
  111.         sprintf(buff,"%s%s", mailhome, username);
  112.       else if (! expand_filename(buff)) {
  113.         error1("can't expand file %s", buff);
  114.         if (resync && file_changed)
  115.           strcpy(buff, infile);
  116.         else
  117.           return(FALSE);    
  118.       }
  119.  
  120.       if (strcmp(buff, infile) == 0 && ! resync) { 
  121.         dprint0(3,"User requested change to current mailbox! (newmbox)\n");
  122.         error("already reading that mailbox!");
  123.         return(FALSE);
  124.       }
  125.       if (first_word(buff, mailhome) && ! resync) {    /* a mail file! */
  126.         mbox_specified = 0;       /* fake program to think that */
  127.         stat = 1;                  /*     we're the default file */
  128.         switching_to_default++;      /*        remember this act!  */
  129.       }
  130.  
  131.       if ((errno = can_access(buff, READ_ACCESS))) {
  132.         dprint2(2,"Error: attempt to open %s as mailbox denied (%s)!\n",
  133.              buff, "newmbox");
  134.         error1("Permission to open file %s denied", buff);
  135.         if (resync && file_changed)
  136.           strcpy(buff, infile);
  137.         else
  138.           return(FALSE);    
  139.       }
  140.  
  141.       if (resync && file_changed && strcmp(buff, infile) == 0)
  142.         PutLine0(LINES-2,COLUMNS-40,"Resynchronizing file");
  143.       else
  144.         PutLine1(LINES-2,COLUMNS-40,"Mailbox: %s", buff);
  145.       CleartoEOLN();
  146.       strcpy(infile,buff);
  147.       if (! switching_to_default) mbox_specified = 1;
  148.  
  149.     }
  150.  
  151.     clear_error();
  152.     clear_central_message();
  153.  
  154.     header_page = 0;
  155.  
  156.     (void) fclose(mailfile);   /* close it first, to avoid too many open */
  157.  
  158.     if ((mailfile = fopen(infile,"r")) == NULL) 
  159.       message_count = 0;
  160.     else if (stat < 2) {          /* new mail file! */
  161.       current = 1;
  162.       if (notesfile)
  163.         message_count = read_notesfile();    /* can't get new notes! */
  164.       else
  165.         message_count = read_headers(FALSE, main_screen);
  166.       if (! message_count) current = 0;
  167.     }
  168.     else     /* resync with current mail file */
  169.       message_count = read_headers(TRUE, main_screen);
  170.  
  171.     return(TRUE);
  172. }
  173.  
  174. int
  175. read_headers(rereading, main_screen)
  176. int rereading, main_screen;
  177. {
  178.     /** Reads the headers into the header_table structure and leaves
  179.         the file rewound for further I/O requests.   If the file being
  180.         read is the default mailbox (ie incoming) then it is copied to
  181.         a temp file and closed, to allow more mail to arrive during 
  182.         the elm session.  If 'rereading' is set, the program will copy
  183.         the status flags from the previous data structure to the new 
  184.         one if possible.  This is (obviously) for re-reading a mailfile!
  185.     **/
  186.  
  187.     FILE *temp;
  188.     char buffer[LONG_STRING], temp_filename[SLEN];
  189.     long bytes = 0L, line_bytes = 0L;
  190.     register int line = 0, count = 0, subj = 0, copyit = 0, in_header = 1;
  191.     int count_x, count_y = 17, new_messages = 0, err;
  192.     int in_to_list = FALSE;
  193.  
  194.     static int first_read = 0;
  195.  
  196.     if (! first_read++) {
  197.       ClearLine(LINES-1);
  198.       ClearLine(LINES);
  199.       if (rereading)
  200.         PutLine1(LINES, 0, "Reading in %s, message: %d", infile, 
  201.              message_count);
  202.       else
  203.         PutLine1(LINES, 0, "Reading in %s, message: 0", infile);
  204.       count_x = LINES;
  205.           count_y = 22 + strlen(infile);
  206.     }
  207.     else {
  208.       count_x = LINES-2;
  209.       if (main_screen)
  210.         PutLine0(LINES-2, 0, "Reading message: 0");
  211.       else {
  212.         PutLine0(LINES, 0, "\n");
  213.         PutLine0(LINES, 0, "Reading message: 0");
  214.         count_x = LINES;
  215.       }
  216.     }
  217.  
  218.     if (mbox_specified == 0) {
  219.       lock(INCOMING);    /* ensure no mail arrives while we do this! */
  220.       sprintf(temp_filename,"%s%s",temp_mbox, username);
  221.       if (! rereading) {
  222.         if ((temp = fopen(temp_filename,"w")) == NULL) {
  223.          err = errno;
  224.          unlock();    /* remove lock file! */
  225.          Raw(OFF);
  226.          Write_to_screen(
  227.              "\nCouldn't open file %s for use as temp mailbox;\n", 1,
  228.                  temp_filename);
  229.          Write_to_screen("** %s - %s **\n", 2,
  230.              error_name(err), error_description(err));
  231.          dprint3(1,
  232.                 "Error: Couldn't open file %s as temp mbox.  errno %s (%s)\n",
  233.              temp_filename, error_name(err), "read_headers");
  234.          leave();
  235.         }
  236.        get_mailtime();
  237.        copyit++;
  238.        chown(temp_filename, userid, groupid);
  239.      }
  240.      else {
  241.        if ((temp = fopen(temp_filename,"a")) == NULL) {
  242.          err = errno;
  243.          unlock();    /* remove lock file! */
  244.          Raw(OFF);
  245.          Write_to_screen(
  246.              "\nCouldn't reopen file %s for use as temp mailbox;\n", 1,
  247.                  temp_filename);
  248.          Write_to_screen("** %s - %s **\n", 2,
  249.              error_name(err), error_description(err));
  250.          dprint3(1,
  251.                 "Error: Couldn't reopen file %s as temp mbox.  errno %s (%s)\n",
  252.              temp_filename, error_name(err), "read_headers");
  253.          emergency_exit();
  254.         }
  255.        copyit++;
  256.       }
  257.     }
  258.  
  259.     if (rereading) {
  260.        if (fseek(mailfile, mailfile_size, 0)) {
  261.          err = errno;
  262.          Write_to_screen(
  263.         "\nCouldn't seek to %ld (end of mailbox) in %s!\n", 2,
  264.              mailfile_size, infile);    
  265.          Write_to_screen("** %s - %s **\n", 2,
  266.              error_name(err), error_description(err));
  267.          dprint4(1,
  268.      "Error: Couldn't seek to end of mailbox %s: (offset %ld) Errno %s (%s)\n",
  269.             infile, mailfile_size, error_name(err), "read_headers");
  270.          emergency_exit();
  271.        }
  272.        count = message_count;        /* next available  */
  273.        bytes = mailfile_size;        /* start correctly */
  274.        if (message_count > 0)
  275.         line  = header_table[message_count - 1].lines;
  276.        else
  277.         line = 0;
  278.     }
  279.  
  280.     while (fgets(buffer, LONG_STRING, mailfile) != NULL) {
  281.       if (bytes == 0L) {     /* first line of file... */    
  282.  
  283.         if (! mbox_specified) {
  284.           if (first_word(buffer, "Forward to ")) 
  285.             set_central_message("Mail being forwarded to %s", 
  286.                    (char *) (buffer + 11));
  287.         }
  288.  
  289.         /* Are we reading in a notesfile file without the flag
  290.            turned on??? */
  291.     
  292.         if (first_word(buffer, NOTES_HEADER)) {    /* if so...  */
  293.           rewind(mailfile);
  294.           notesfile++;            /* set da flag, boss-man */
  295.           return(read_notesfile());     /* hop over to notes */
  296.         }
  297.       }
  298.  
  299.       if (copyit) fputs(buffer, temp);
  300.       line_bytes = (long) strlen(buffer); 
  301.       line++;
  302.       if (first_word(buffer,"From ")) {
  303.         if (real_from(buffer, &header_table[count])) {
  304.           header_table[count].offset = (long) bytes;
  305.           header_table[count].index_number = count+1;
  306.           if (! rereading || count > message_count) 
  307.             header_table[count].status = 0;            /* clear status! */
  308.           strcpy(header_table[count].subject, "");    /* clear subj    */
  309.           header_table[count-1].lines = line;
  310.           if (new_msg(header_table[count])) {
  311.             header_table[count].status |= NEW;    /* new message!  */
  312.  
  313.             if (! new_messages++ && point_to_new && ! rereading &&
  314.                 sortby == RECEIVED_DATE) {
  315.           current = count+1;
  316.               get_page(current);    /* make sure we're ON that page! */
  317.             }
  318.  
  319.         /* Quick comment on that last conditional test...
  320.  
  321.            We want to move the current pointer to the first new
  322.            message IF this is the first of the new messages, the
  323.            user requested this feature, we're not rereading the 
  324.            mailbox (imagine how THAT could screw the user up!),
  325.            and we're not in some funky sorting mode (received-date is
  326.            the default).  As always, I'm open to suggestions on
  327.            other ways to have this work intelligently.
  328.         */
  329.     
  330.           }
  331.           count++;
  332.           subj = 0;
  333.           line = 0;
  334.           in_header = 1;
  335.           PutLine1(count_x, count_y, "%d", count);
  336.         }
  337.       }
  338.       else if (in_header) {
  339.         if (first_word(buffer,">From")) 
  340.           forwarded(buffer, &header_table[count-1]); /* return address */
  341.         else if (first_word(buffer,"Subject:") ||
  342.              first_word(buffer,"Subj:") ||
  343.              first_word(buffer,"Re:")) {
  344.           if (! subj++) {
  345.             remove_first_word(buffer);
  346.             strncpy(header_table[count-1].subject, buffer, STRING);
  347.           }
  348.         }
  349.         else if (first_word(buffer,"From:"))
  350.           parse_arpa_from(buffer, header_table[count-1].from);
  351.         
  352.         /** when it was sent... **/
  353.  
  354.         else if (first_word(buffer, "Date:")) 
  355.           parse_arpa_date(buffer, &header_table[count-1]);
  356.  
  357.         /** some status things about the message... **/
  358.  
  359.         else if (first_word(buffer, "Priority:"))
  360.           header_table[count-1].status |= PRIORITY;
  361.         else if (first_word(buffer, "Action:"))
  362.           header_table[count-1].status |= ACTION;
  363.  
  364.         /** next let's see if it's to us or not... **/
  365.  
  366.         else if (first_word(buffer, "To:")) {
  367.           in_to_list = TRUE;
  368.           header_table[count-1].to[0] = '\0';    /* nothing yet */
  369.           figure_out_addressee((char *) buffer +3, 
  370.                    header_table[count-1].to);
  371.         }
  372.  
  373.         else if (buffer[0] == LINE_FEED || buffer[0] == '\0') {
  374.           if (in_header) {
  375.             in_header = 0;    /* in body of message! */
  376.             fix_date(&header_table[count-1]);
  377.           }
  378.         }
  379.         else if (in_to_list == TRUE) {
  380.           if (whitespace(buffer[0]))
  381.             figure_out_addressee(buffer, header_table[count-1].to);
  382.           else in_to_list = FALSE;
  383.         }
  384.       }
  385.       bytes += (long) line_bytes;
  386.     }
  387.  
  388.     header_table[count > 0? count-1:count].lines = line;
  389.  
  390.     if (mbox_specified == 0) {
  391.       unlock();    /* remove lock file! */
  392.       fclose(mailfile);
  393.       fclose(temp);
  394.       if ((mailfile = fopen(temp_filename,"r")) == NULL) {
  395.         err = errno;
  396.         MoveCursor(LINES,0);
  397.         Raw(OFF);
  398.         Write_to_screen("\nAugh! Couldn't reopen %s as temp mail file;\n",
  399.                1, temp_filename);
  400.         Write_to_screen("** %s - %s **\n", 2, error_name(err),
  401.            error_description(err));
  402.         dprint3(1,
  403.           "Error: Reopening %s as temp mail file failed!  errno %s (%s)\n",
  404.                temp_filename, error_name(errno), "read_headers");
  405.         leave();
  406.       }
  407.     }
  408.     else 
  409.           rewind(mailfile);
  410.  
  411.     sort_mailbox(count);             /* let's sort this baby now! */
  412.  
  413.     return(count);
  414. }
  415. END-OF-FILE
  416.  
  417. if [ "$filename" != "/dev/null" ]
  418. then
  419.   size=`wc -c < $filename`
  420.  
  421.   if [ $size != 11389 ]
  422.   then
  423.     echo $filename changed - should be 11389 bytes, not $size bytes
  424.   fi
  425.  
  426.   chmod 644 $filename
  427. fi
  428.  
  429. # ---------- file src/notesfile.c ----------
  430.  
  431. filename="src/notesfile.c"
  432.  
  433. if [ -f $filename ]
  434. then
  435.   echo File \"$filename\" already exists\!  Skipping...
  436.   filename=/dev/null        # throw it away
  437. else
  438.   echo extracting file src/notesfile.c...
  439. fi
  440.  
  441. cat << 'END-OF-FILE' > $filename
  442. /**            notesfile.c            **/
  443.  
  444. /**  Routine that reads in a file comprised of saved messages from
  445.      'notes'.  
  446.  
  447.      (C) Copyright 1986 Dave Taylor
  448. **/
  449.  
  450. #include "headers.h"
  451. #include <errno.h>
  452.  
  453. char *notes_machine();
  454.  
  455. extern int errno;
  456.  
  457. char *error_name(), *error_description();
  458.  
  459. int
  460. read_notesfile()
  461. {
  462.     /** read in the current mailfile, assuming it's actually a set
  463.         of stored notes from the notes program... **/
  464.  
  465.     char buffer[LONG_STRING];
  466.     register int line = 0, count = 0;
  467.     long  bytes = 0L, line_bytes = 0L;
  468.     static int first_read = 0;
  469.     int count_x , count_y = 17;
  470.  
  471.     if (! first_read++) {
  472.       MoveCursor(LINES-2, 0);
  473.       CleartoEOS();
  474.       PutLine1(LINES-1, 0, "Reading in %s, message: 0", infile);
  475.       count_x = LINES-1;
  476.           count_y = 22 + strlen(infile);
  477.     }
  478.     else {
  479.       PutLine0(LINES-2, 0, "Reading message: 0");
  480.       count_x = LINES-2;
  481.     }
  482.  
  483.     while (fgets(buffer, LONG_STRING, mailfile) != NULL) {
  484.  
  485.       if (line == 0) {
  486.     
  487.         /** Double check to make sure this is okay... if the first
  488.             word is "From " then we're actually reading a normal
  489.             file so cruise over to the read_headers() routine
  490.         instead! **/
  491.     
  492.         if (first_word(buffer, "From ")) {
  493.           notesfile = 0;   /* turn that bloody flag off! */
  494.           rewind(mailfile);  /* back up in da file... */
  495.           return( read_headers(FALSE) );
  496.         }
  497.       }
  498.     
  499.       line_bytes = (long) strlen(buffer); 
  500.       line++;
  501.  
  502.       if (first_word(buffer, "/***** ")) {
  503.         if (real_notes_header(buffer, &header_table[count])) {
  504.           header_table[count].offset = (long) bytes;
  505.           header_table[count].status = 0;
  506.           header_table[count++].lines = line;
  507.           PutLine1(count_x, count_y, "%d", count);
  508.           line = 0;
  509.         }
  510.       }
  511.       bytes += (long) line_bytes;
  512.     }
  513.  
  514.         rewind(mailfile);
  515.  
  516.     return(count);
  517. }
  518.  
  519. int
  520. real_notes_header(buffer, entry)
  521. char *buffer;
  522. struct header_rec *entry;
  523. {
  524.     /** confirms that we're looking at a REAL notes header,
  525.         and if so, saves it in the appropriate data entry  **/
  526.  
  527.     char subjectbuffer[SLEN], timebuffer[NLEN], lastbuffer[NLEN], 
  528.          am_pm[NLEN], the_day[NLEN], nullbuffer[NLEN];
  529.     
  530.     strcpy(nullbuffer, "NULL");
  531.     strcpy(lastbuffer, "LAST");
  532.  
  533.     sscanf(buffer, "%*s %s %*c %s %*c %s %s %s %s %s %s", 
  534.         subjectbuffer, entry->from, 
  535.         timebuffer, am_pm, entry->month, the_day,
  536.         lastbuffer, nullbuffer);
  537.  
  538.     if (strcmp(lastbuffer, "LAST") == 0) 
  539.       return(0);
  540.     
  541.     if (strcmp(nullbuffer,"NULL") != 0) 
  542.       return(0);
  543.  
  544.     if (timebuffer[1] != ':' && timebuffer[2] != ':') 
  545.       return(0);
  546.  
  547.     /* now let's play format! */
  548.  
  549.     clean_up(subjectbuffer);
  550.  
  551.     sprintf(entry->subject, "Note from group %s", subjectbuffer);
  552.     sprintf(entry->day,"%d", atoi(the_day));
  553.     sprintf(entry->year,"%d", atoi(lastbuffer) % 100);
  554.     sprintf(entry->time,"%s %s", timebuffer, am_pm);
  555.  
  556.     return(1);
  557. }
  558.  
  559. char *notes_machine()
  560. {
  561.     /** For those rare notes posted by someone on the machine that
  562.         the notesfiles are saved from, this routine will fix the
  563.         address to ensure it's valid.  The return value will be
  564.         either 'machine!' or NULL if it's from the machine we're on
  565.     **/
  566.  
  567.     static char machine_group[NLEN];
  568.     char buffer[SLEN];
  569.     register int i;
  570.  
  571.     if (fseek(mailfile, header_table[current-1].offset, 0) != 0) {
  572.       dprint3(1,"Error: errno %s encountered on seek to %d in file! (%s)\n", 
  573.           error_name(errno), header_table[current-1].offset, 
  574.            "notes_machine");
  575.       error1("error %s trying to seek!", 
  576.           error_name(errno));
  577.       return( NULL );
  578.     }
  579.  
  580.     if (fgets(buffer, SLEN, mailfile) == NULL) {
  581.       dprint2(1,"Error: errno %s encountered on read (%s)", 
  582.            error_name(errno), "notes_machine");
  583.       error1("error %s trying to read file!", error_name(errno));
  584.       return( NULL );
  585.     }
  586.  
  587.     sscanf(buffer,"%*s %s", machine_group);
  588.  
  589.     for (i=0; machine_group[i] != ':'; i++)
  590.        ;
  591.  
  592.     machine_group[i] = '\0';
  593.  
  594.     return( (char *) machine_group);
  595. }
  596. END-OF-FILE
  597.  
  598. if [ "$filename" != "/dev/null" ]
  599. then
  600.   size=`wc -c < $filename`
  601.  
  602.   if [ $size != 3815 ]
  603.   then
  604.     echo $filename changed - should be 3815 bytes, not $size bytes
  605.   fi
  606.  
  607.   chmod 644 $filename
  608. fi
  609.  
  610. # ---------- file src/pattern.c ----------
  611.  
  612. filename="src/pattern.c"
  613.  
  614. if [ -f $filename ]
  615. then
  616.   echo File \"$filename\" already exists\!  Skipping...
  617.   filename=/dev/null        # throw it away
  618. else
  619.   echo extracting file src/pattern.c...
  620. fi
  621.  
  622. cat << 'END-OF-FILE' > $filename
  623. /**            pattern.c            **/
  624.  
  625. /**    General pattern matching for the ELM mailer.     
  626.  
  627.        (C) Copyright 1986 Dave Taylor
  628. **/
  629.  
  630. #include <errno.h>
  631.  
  632. #include "headers.h"
  633.  
  634. static char pattern[SLEN] = { "" };
  635. static char alt_pattern[SLEN] = { "" };
  636.  
  637. extern int errno;
  638.  
  639. char *error_name();
  640.  
  641. meta_match(function)
  642. int function;
  643. {
  644.     /** Perform specific function based on whether an entered string 
  645.         matches either the From or Subject lines.. 
  646.     **/
  647.  
  648.     register int i, tagged=0, count=0;
  649.     static char     meta_pattern[SLEN];
  650.  
  651.     PutLine1(LINES-3, strlen("Command: "), 
  652.          "%s messages that match pattern...", 
  653.          function==TAGGED?"Tag":"Delete");
  654.  
  655.     if (function == TAGGED) {    /* are messages already tagged??? */
  656.       for (i=0; i < message_count; i++)
  657.         if (ison(header_table[i].status,TAGGED))
  658.           tagged++;
  659.  
  660.       if (tagged) {
  661.         if (tagged > 2) 
  662.           PutLine0(LINES-2,0, "Some messages are already tagged");
  663.         else
  664.           PutLine0(LINES-2,0, "A message is already tagged");
  665.     
  666.         Write_to_screen("- Remove tag%s? y%c", 2, plural(tagged),BACKSPACE);
  667.  
  668.         if (tolower(ReadCh()) != 'n') {    /* remove tags... */
  669.           for (i=0; i < message_count; i++) {
  670.             clearit(header_table[i].status,TAGGED);
  671.         show_new_status(i);
  672.           }
  673.         }
  674.       }
  675.     }
  676.     
  677.     PutLine0(LINES-2,0, "Enter pattern: "); CleartoEOLN();
  678.  
  679.     optionally_enter(meta_pattern, LINES-2,strlen("Enter pattern: "),FALSE);
  680.  
  681.     if (strlen(meta_pattern) == 0) {
  682.       ClearLine(LINES-2);
  683.       return(0);
  684.     }
  685.  
  686.     strcpy(meta_pattern, shift_lower(meta_pattern));   /* lowercase it */
  687.  
  688.     for (i = 0; i < message_count; i++) {
  689.       if (from_matches(i, meta_pattern)) {
  690.         setit(header_table[i].status, function);
  691.         show_new_status(i);
  692.         count++;
  693.       }
  694.       else if (subject_matches(i, meta_pattern)) {
  695.         setit(header_table[i].status, function);
  696.         show_new_status(i);
  697.         count++;
  698.       }
  699.     }
  700.  
  701.     ClearLine(LINES-2);    /* remove "pattern: " prompt */
  702.     
  703.     if (count > 0)
  704.       error3("%s %d messsage%s", 
  705.              function==TAGGED? "tagged" : "marked for deletion",
  706.          count, plural(count));
  707.     else
  708.       error1("no matches - no messages %s",
  709.          function==TAGGED? "tagged" : "marked for deletion");
  710.  
  711.     return(0);
  712. }
  713.       
  714. int
  715. pattern_match()
  716. {
  717.     /** Get a pattern from the user and try to match it with the
  718.         from/subject lines being displayed.  If matched (ignoring
  719.         case), move current message pointer to that message, if
  720.         not, error and return ZERO **/
  721.  
  722.     register int i;
  723.  
  724.     PutLine0(LINES-3,40,"/ = match anywhere in messages");
  725.     
  726.     PutLine0(LINES-1,0, "Match Pattern:");
  727.  
  728.     if (pattern_enter(pattern, alt_pattern, LINES-1, 16, 
  729.         "Match Pattern (in entire mailbox):"))
  730.       if (strlen(alt_pattern) > 0) {
  731.         strcpy(alt_pattern, shift_lower(alt_pattern));
  732.         return(match_in_message(alt_pattern));
  733.       }
  734.       else
  735.         return(1);
  736.       
  737.     if (strlen(pattern) == 0) 
  738.       return(0);
  739.     else
  740.       strcpy(pattern, shift_lower(pattern));
  741.  
  742.     for (i = current; i < message_count; i++) {
  743.       if (from_matches(i, pattern)) {
  744.         current = ++i;
  745.         return(1);
  746.       }
  747.       else if (subject_matches(i, pattern)) {
  748.         current = ++i;
  749.         return(1);
  750.       }
  751.     }
  752.  
  753.     return(0);
  754. }
  755.  
  756. int
  757. from_matches(message_number, pat)
  758. int message_number;
  759. char *pat;
  760. {
  761.     /** Returns true iff the pattern occurs in it's entirety
  762.         in the from line of the indicated message **/
  763.  
  764.     return( in_string(shift_lower(header_table[message_number].from), 
  765.         pat) );
  766. }
  767.  
  768. int
  769. subject_matches(message_number, pat)
  770. int message_number;
  771. char *pat;
  772. {
  773.     /** Returns true iff the pattern occurs in it's entirety
  774.         in the subject line of the indicated message **/
  775.  
  776.     return( in_string(shift_lower(header_table[message_number].subject), 
  777.         pat) );
  778. }
  779.  
  780. match_in_message(pat)
  781. char *pat;
  782. {
  783.     /** Match a string INSIDE a message...starting at the current 
  784.         message read each line and try to find the pattern.  As
  785.         soon as we do, set current and leave! 
  786.         Returns 1 if found, 0 if not
  787.     **/
  788.  
  789.     char buffer[LONG_STRING];
  790.     int  message_number;
  791.     long location;
  792.  
  793.     location = header_table[current-1].offset;
  794.     message_number = current-1;
  795.  
  796.     if (fseek(mailfile, location, 0) != 0) {
  797.  
  798.       dprint3(1,"Error: seek %ld bytes into file failed. errno %d (%s)\n",
  799.            location, errno, "match_in_message");
  800.       error2("ELM [match] failed looking %ld bytes into file (%s)",
  801.          location, error_name(errno));
  802.       return(1);    /* fake it out to avoid replacing error message */
  803.     }
  804.  
  805.     error("searching for pattern...");
  806.  
  807.     while (fgets(buffer, LONG_STRING, mailfile) != NULL) {
  808.     
  809.       if (in_string(shift_lower(buffer), pat)) {
  810.         current = message_number; 
  811.         clear_error();
  812.         return(1);
  813.       }
  814.  
  815.       location += (long) strlen(buffer);
  816.  
  817.       if (location > header_table[message_number].offset)
  818.         message_number++;
  819.     }
  820.  
  821.     return(0);
  822. }
  823. END-OF-FILE
  824.  
  825. if [ "$filename" != "/dev/null" ]
  826. then
  827.   size=`wc -c < $filename`
  828.  
  829.   if [ $size != 4687 ]
  830.   then
  831.     echo $filename changed - should be 4687 bytes, not $size bytes
  832.   fi
  833.  
  834.   chmod 644 $filename
  835. fi
  836.  
  837. # ---------- file src/quit.c ----------
  838.  
  839. filename="src/quit.c"
  840.  
  841. if [ -f $filename ]
  842. then
  843.   echo File \"$filename\" already exists\!  Skipping...
  844.   filename=/dev/null        # throw it away
  845. else
  846.   echo extracting file src/quit.c...
  847. fi
  848.  
  849. cat << 'END-OF-FILE' > $filename
  850. /**        quit.c        **/
  851.  
  852. /** quit: leave the current mailbox and quit the program.
  853.   
  854.     (C) Copyright 1985, Dave Taylor
  855. **/
  856.  
  857. #include "headers.h"
  858.  
  859. #ifndef TRUE
  860. #define TRUE    1
  861. #endif
  862.  
  863. quit()
  864. {
  865.     /* a wonderfully short routine!! */
  866.  
  867.     if (leave_mbox() == -1)
  868.       return;            /* new mail!  (damn it)  resync */
  869.  
  870.     leave();
  871. }
  872.  
  873. resync()
  874. {
  875.     /* Resync on the current mailbox... **/
  876.  
  877.     error("reading mailfile in again...");
  878.     sleep(1);
  879.  
  880.     newmbox(1, TRUE, FALSE);    /* pretend we've never seen it! */
  881.     showscreen();
  882.  
  883.     mailfile_size = bytes(infile);    /* complete resync */
  884. }
  885. END-OF-FILE
  886.  
  887. if [ "$filename" != "/dev/null" ]
  888. then
  889.   size=`wc -c < $filename`
  890.  
  891.   if [ $size != 550 ]
  892.   then
  893.     echo $filename changed - should be 550 bytes, not $size bytes
  894.   fi
  895.  
  896.   chmod 644 $filename
  897. fi
  898.  
  899. # ---------- file src/file_utils.c ----------
  900.  
  901. filename="src/file_utils.c"
  902.  
  903. if [ -f $filename ]
  904. then
  905.   echo File \"$filename\" already exists\!  Skipping...
  906.   filename=/dev/null        # throw it away
  907. else
  908.   echo extracting file src/file_utils.c...
  909. fi
  910.  
  911. cat << 'END-OF-FILE' > $filename
  912. /**            file_utils.c            **/
  913.  
  914. /** File oriented utility routines for ELM 
  915.  
  916.     (C) Copyright 1986 Dave Taylor
  917. **/
  918.  
  919. #include "headers.h"
  920. #include <sys/types.h>
  921. #include <sys/stat.h>
  922. #include <ctype.h>
  923. #include <errno.h>
  924.  
  925. #ifdef BSD
  926. #undef tolower
  927. #endif
  928. #include <signal.h>
  929. #include <errno.h>
  930.  
  931. extern int errno;        /* system error number */
  932.  
  933. char *error_name(), *error_description();
  934.  
  935. long
  936. bytes(name)
  937. char *name;
  938. {
  939.     /** return the number of bytes in the specified file.  This
  940.         is to check to see if new mail has arrived....  **/
  941.  
  942.     int ok = 1;
  943.     extern int errno;    /* system error number! */
  944.     struct stat buffer;
  945.  
  946.     if (stat(name, &buffer) != 0)
  947.       if (errno != 2) {
  948.         dprint2(1,"Error: errno %s on fstat of file %s (bytes)\n", 
  949.              error_name(errno), name);
  950.         Write_to_screen("\n\rError attempting fstat on file %s!\n\r",
  951.              1, name);
  952.         Write_to_screen("** %s - %s **\n\r", 2, error_name(errno),
  953.           error_description(errno));
  954.         emergency_exit();
  955.       }
  956.       else
  957.         ok = 0;
  958.     
  959.     return(ok ? (long) buffer.st_size : 0L);
  960. }
  961.  
  962. int
  963. can_access(file, mode)
  964. char *file; 
  965. int   mode;
  966. {
  967.     /** returns TRUE iff user can access file **/
  968.  
  969.     int status, pid, w;
  970.     register int (*istat)(), (*qstat)();
  971.     
  972. #ifdef NO_VM        /* machine without virtual memory!! */
  973.     if ((pid = fork()) == 0) {
  974. #else
  975.     if ((pid = vfork()) == 0) {
  976. #endif
  977.       setuid(userid);        /** back to normal userid **/
  978.       setgid(groupid);
  979.       errno = 0;
  980.       (void) access(file, mode);
  981.       _exit(errno);
  982.       _exit(127);
  983.     }
  984.  
  985.     istat = signal(SIGINT, SIG_IGN);
  986.     qstat = signal(SIGQUIT, SIG_IGN);
  987.  
  988.     while ((w = wait(&status)) != pid && w != -1)
  989.         ;
  990.  
  991.     if (w == -1) status = FALSE;
  992.     
  993.     signal(SIGINT, istat);
  994.     signal(SIGQUIT, qstat);
  995.  
  996.     return(status);
  997. }
  998.  
  999. int
  1000. can_open(file, mode)
  1001. char *file; 
  1002. char *mode;
  1003. {
  1004.     /** returns TRUE iff user can open the file.  This is not
  1005.         the same as can_access - it's used for when the file might
  1006.         not exist... **/
  1007.  
  1008.     int status, pid, w;
  1009.     register int (*istat)(), (*qstat)();
  1010.     
  1011. #ifdef NO_VM        /* machine without virtual memory!! */
  1012.     if ((pid = fork()) == 0) {
  1013. #else
  1014.     if ((pid = vfork()) == 0) {
  1015. #endif
  1016.       setuid(userid);        /** back to normal userid **/
  1017.       setgid(groupid);
  1018.       errno = 0;
  1019.       (void) fopen(file, mode);
  1020.       _exit(errno);
  1021.       _exit(127);
  1022.     }
  1023.  
  1024.     istat = signal(SIGINT, SIG_IGN);
  1025.     qstat = signal(SIGQUIT, SIG_IGN);
  1026.  
  1027.     while ((w = wait(&status)) != pid && w != -1)
  1028.         ;
  1029.  
  1030.     if (w == -1) status = FALSE;
  1031.     
  1032.     signal(SIGINT, istat);
  1033.     signal(SIGQUIT, qstat);
  1034.  
  1035.     return(status);
  1036. }
  1037.  
  1038. int
  1039. copy(from, to)
  1040. char *from, *to;
  1041. {
  1042.     /** this routine copies a specified file to the destination
  1043.         specified.  Non-zero return code indicates that something
  1044.         dreadful happened! **/
  1045.  
  1046.     FILE *from_file, *to_file;
  1047.     char buffer[VERY_LONG_STRING];
  1048.     
  1049.     if ((from_file = fopen(from, "r")) == NULL) {
  1050.       dprint1(1,"Error: could not open %s for reading (copy)\n", from);
  1051.       error1("could not open file %s", from);
  1052.       return(1);
  1053.     }
  1054.  
  1055.     if ((to_file = fopen(to, "w")) == NULL) {
  1056.       dprint1(1,"Error: could not open %s for writing (copy)\n", to);
  1057.       error1("could not open file %s", to);
  1058.       return(1);
  1059.     }
  1060.  
  1061.     while (fgets(buffer, VERY_LONG_STRING, from_file) != NULL)
  1062.       fputs(buffer, to_file);
  1063.  
  1064.     fclose(from_file);
  1065.     fclose(to_file);
  1066.  
  1067.     return(0);
  1068. }
  1069.  
  1070. int
  1071. append(fd, filename)
  1072. FILE *fd;
  1073. char *filename;
  1074. {
  1075.     /** This routine appends the specified file to the already
  1076.         open file descriptor.. Returns non-zero if fails.  **/
  1077.  
  1078.     FILE *my_fd;
  1079.     char buffer[VERY_LONG_STRING];
  1080.     
  1081.     if ((my_fd = fopen(filename, "r")) == NULL) {
  1082.       dprint1(1,"Error: could not open %s for reading (append)\n", filename);
  1083.       return(1);
  1084.     }
  1085.  
  1086.     while (fgets(buffer, VERY_LONG_STRING, my_fd) != NULL)
  1087.       fputs(buffer, fd);
  1088.  
  1089.     fclose(my_fd);
  1090.  
  1091.     return(0);
  1092. }
  1093.  
  1094. check_mailfile_size()
  1095. {
  1096.     /** Check to ensure we have mail.  Only used with the '-z'
  1097.         starting option. **/
  1098.  
  1099.     char filename[SLEN];
  1100.     struct stat buffer;
  1101.  
  1102.     strcpy(username,getlogin());
  1103.     if (strlen(username) == 0)
  1104.       cuserid(username);
  1105.  
  1106.     sprintf(filename,"%s/%s", mailhome, username);
  1107.  
  1108.     if (stat(filename, &buffer) == -1) {
  1109.       printf(" You have no mail.\n");
  1110.       exit(0);
  1111.     }
  1112.     else if (buffer.st_size < 2) {         /* maybe one byte??? */
  1113.       printf("You have no mail to read.\n");
  1114.       exit(0);
  1115.     }
  1116. }
  1117.  
  1118. create_readmsg_file()
  1119. {
  1120.     /** Creates the file ".current" in the users home directory
  1121.         for use with the "readmsg" program.
  1122.     **/
  1123.  
  1124.     FILE *fd;
  1125.     char buffer[SLEN];
  1126.  
  1127.     sprintf(buffer,"%s/%s", home, readmsg_file);
  1128.  
  1129.     if ((fd = fopen (buffer, "w")) == NULL) {
  1130.       dprint3(1,"Error: couldn't create file %s - error %s (%s)\n",
  1131.          buffer, error_name(errno), "create_readmsg_file");
  1132.       return;    /* no error to user */
  1133.     }
  1134.  
  1135.     fprintf(fd, "%d\n", header_table[current-1].index_number);
  1136.     fclose(fd);
  1137. }
  1138. END-OF-FILE
  1139.  
  1140. if [ "$filename" != "/dev/null" ]
  1141. then
  1142.   size=`wc -c < $filename`
  1143.  
  1144.   if [ $size != 4640 ]
  1145.   then
  1146.     echo $filename changed - should be 4640 bytes, not $size bytes
  1147.   fi
  1148.  
  1149.   chmod 644 $filename
  1150. fi
  1151.  
  1152. # ---------- file src/reply.c ----------
  1153.  
  1154. filename="src/reply.c"
  1155.  
  1156. if [ -f $filename ]
  1157. then
  1158.   echo File \"$filename\" already exists\!  Skipping...
  1159.   filename=/dev/null        # throw it away
  1160. else
  1161.   echo extracting file src/reply.c...
  1162. fi
  1163.  
  1164. cat << 'END-OF-FILE' > $filename
  1165. /**        reply.c        **/
  1166.  
  1167. /*** routine allows replying to the sender of the current message 
  1168.  
  1169.      (C) Copyright 1985, Dave Taylor
  1170. ***/
  1171.  
  1172. #include "headers.h"
  1173. #include <errno.h>
  1174.  
  1175. #ifndef BSD
  1176. #  include <sys/utsname.h>
  1177. #endif
  1178.  
  1179. /** Note that this routine generates automatic header information
  1180.     for the subject and (obviously) to lines, but that these can
  1181.     be altered while in the editor composing the reply message! 
  1182. **/
  1183.  
  1184. char *strip_parens(), *get_token(), *notes_machine();
  1185.  
  1186. extern int errno;
  1187.  
  1188. char *error_name();
  1189.  
  1190. int
  1191. reply()
  1192. {
  1193.     /** Reply to the current message.  Returns non-zero iff
  1194.         the screen has to be rewritten. **/
  1195.  
  1196.     char return_address[LONG_SLEN], subject[SLEN];
  1197.     int  return_value;
  1198.  
  1199.     get_return(return_address);
  1200.  
  1201.     if (first_word(header_table[current-1].from, "To:")) {
  1202.       strcpy(subject, header_table[current-1].subject);
  1203.       return_value = send(return_address, subject, TRUE);
  1204.     }
  1205.     else if (header_table[current-1].subject[0] != '\0') {
  1206.       if ((strncmp("Re:", header_table[current-1].subject, 3) == 0) ||
  1207.           (strncmp("RE:", header_table[current-1].subject, 3) == 0) ||
  1208.           (strncmp("re:", header_table[current-1].subject, 3) == 0)) 
  1209.         strcpy(subject, header_table[current-1].subject);
  1210.       else {
  1211.         strcpy(subject,"Re: ");
  1212.         strcat(subject,header_table[current-1].subject); 
  1213.       }
  1214.       return_value = send(return_address, subject, TRUE);
  1215.     }
  1216.     else
  1217.       return_value = send(return_address, "Re: your mail", TRUE);
  1218.  
  1219.     return(return_value);
  1220. }
  1221.  
  1222. int
  1223. reply_to_everyone()
  1224. {
  1225.     /** Reply to everyone who received the current message.  
  1226.         This includes other people in the 'To:' line and people
  1227.         in the 'Cc:' line too.  Returns non-zero iff the screen 
  1228.             has to be rewritten. **/
  1229.  
  1230.     char return_address[LONG_SLEN], subject[SLEN];
  1231.     char full_address[VERY_LONG_STRING];
  1232.     int  return_value;
  1233.  
  1234.     get_return(return_address);
  1235.  
  1236.     strcpy(full_address, return_address);    /* sender gets copy */
  1237.     
  1238.     get_and_expand_everyone(return_address, full_address);
  1239.  
  1240.     if (header_table[current-1].subject[0] != '\0') {
  1241.       if ((strncmp("Re:", header_table[current-1].subject, 3) == 0) ||
  1242.           (strncmp("RE:", header_table[current-1].subject, 3) == 0) ||
  1243.           (strncmp("re:", header_table[current-1].subject, 3) == 0)) 
  1244.         strcpy(subject, header_table[current-1].subject);
  1245.       else {
  1246.         strcpy(subject,"Re: ");
  1247.         strcat(subject,header_table[current-1].subject); 
  1248.       }
  1249.       return_value = send(full_address, subject, TRUE);
  1250.     }
  1251.     else
  1252.       return_value = send(full_address, "Re: your mail", TRUE);
  1253.  
  1254.     return(return_value);
  1255.  
  1256. }
  1257.  
  1258. int
  1259. forward()
  1260. {
  1261.     /** Forward the current message.  What this actually does is
  1262.         to set auto_copy to true, then call 'send' to get the 
  1263.         address and route the mail. 
  1264.     **/
  1265.  
  1266.     char subject[SLEN], address[VERY_LONG_STRING];
  1267.     int  original_cc, results, edit_msg;
  1268.  
  1269.     original_cc = auto_copy;
  1270.     address[0] = '\0';
  1271.  
  1272.     edit_msg = (want_to("Edit outgoing message (y/n) ? ",'y',FALSE) != 'n');
  1273.     Write_to_screen("%s", 1, edit_msg? "Yes" : "No");
  1274.  
  1275.     auto_cc = TRUE;            /* we want a copy */
  1276.  
  1277.     if (strlen(header_table[current-1].subject) > 0) {
  1278.       strcpy(subject,header_table[current-1].subject); 
  1279.       results = send(address, subject, edit_msg);
  1280.     }
  1281.     else
  1282.       results = send(address, "Forwarded Mail...", edit_msg);
  1283.     
  1284.     auto_copy = original_cc;
  1285.  
  1286.     return(results);
  1287. }
  1288.  
  1289. get_and_expand_everyone(return_address, full_address)
  1290. char *return_address, *full_address;
  1291. {
  1292.     /** Read the current message, extracting addresses from the 'To:'
  1293.         and 'Cc:' lines.   As each address is taken, ensure that it
  1294.         isn't to the author of the message NOR to us.  If neither,
  1295.         prepend with current return address and append to the 
  1296.         'full_address' string.
  1297.     **/
  1298.  
  1299.     char ret_address[LONG_SLEN], buf[LONG_SLEN], new_address[LONG_SLEN];
  1300.     char *bufptr, *address;
  1301.     int  in_message = 1, first_pass = 0;
  1302.  
  1303.     /** First off, get to the first line of the message desired **/
  1304.  
  1305.     if (fseek(mailfile, header_table[current-1].offset, 0) == -1) {
  1306.     dprint3(1,"Error: seek %ld resulted in errno %s (%s)\n", 
  1307.          header_table[current-1].offset, error_name(errno), 
  1308.          "get_and_expand_everyone");
  1309.     error2("ELM [seek] couldn't read %d bytes into file (%s)",
  1310.            header_table[current-1].offset, error_name(errno));
  1311.     return;
  1312.     }
  1313.  
  1314.     /** okay!  Now we're there!  **/
  1315.  
  1316.     /** let's fix the ret_address to reflect the return address of this
  1317.     message with '%s' instead of the persons login name... **/
  1318.  
  1319.     translate_return(return_address, ret_address);
  1320.  
  1321.     /** now let's parse the actual message! **/
  1322.  
  1323.     while (in_message) {
  1324.       in_message = (int) (fgets(buf, LONG_SLEN, mailfile) != NULL);
  1325.       if (first_word(buf, "From ") && first_pass++ != 0) 
  1326.     in_message = FALSE;
  1327.       else if (first_word(buf, "To:") || first_word(buf, "Cc:") ||
  1328.            first_word(buf, "CC:") || first_word(buf, "cc:")) {
  1329.     do {
  1330.       no_ret(buf);
  1331.  
  1332.       bufptr = (char *) (strip_parens(buf) + 3); /* 3 = strlen of prompt */
  1333.  
  1334.       while ((address = get_token(bufptr, "\t, ", 0)) != NULL) {
  1335.         if (okay_address(address, return_address)) {
  1336.           sprintf(new_address, ret_address, address);
  1337.           optimize_and_add(new_address, full_address);
  1338.         }
  1339.         bufptr = NULL;
  1340.       }
  1341.  
  1342.           in_message = (int) (fgets(buf, LONG_SLEN, mailfile) != NULL);
  1343.     
  1344.     } while (in_message && whitespace(buf[0]));
  1345.  
  1346.       }
  1347.       else if (strlen(buf) < 2)    /* done with header */
  1348.      in_message = FALSE;
  1349.     }
  1350. }
  1351.  
  1352. int
  1353. okay_address(address, return_address)
  1354. char *address, *return_address;
  1355. {
  1356.     /** This routine checks to ensure that the address we just got
  1357.         from the "To:" or "Cc:" line isn't us AND isn't the person    
  1358.         who sent the message.  Returns true iff neither is the case **/
  1359.  
  1360.     char our_address[SLEN];
  1361.     struct addr_rec  *alternatives;
  1362.  
  1363.     if (in_string(address, return_address))
  1364.       return(FALSE);
  1365.  
  1366.     sprintf(our_address, "%s!%s", hostname, username);
  1367.  
  1368.     if (in_string(address, our_address))
  1369.       return(FALSE);
  1370.  
  1371.     sprintf(our_address, "%s@%s", username, hostname);
  1372.       
  1373.     if (in_string(address, our_address))
  1374.       return(FALSE);
  1375.  
  1376.     alternatives = alternative_addresses;
  1377.  
  1378.     while (alternatives != NULL) {
  1379.       if (in_string(address, alternatives->address))
  1380.         return(FALSE);
  1381.       alternatives = alternatives->next;
  1382.     }
  1383.  
  1384.     return(TRUE);
  1385. }
  1386.         
  1387. optimize_and_add(new_address, full_address)
  1388. char *new_address, *full_address;
  1389. {
  1390.     /** This routine will add the new address to the list of addresses
  1391.         in the full address buffer IFF it doesn't already occur.  It
  1392.         will also try to fix dumb hops if possible, specifically hops
  1393.         of the form ...a!b...!a... and hops of the form a@b@b etc 
  1394.     **/
  1395.  
  1396.     register int len, host_count = 0, i;
  1397.     char     hosts[MAX_HOPS][SLEN];    /* array of machine names */
  1398.     char     *host, *addrptr;
  1399.  
  1400.     if (in_string(full_address, new_address))
  1401.       return(1);    /* duplicate address */
  1402.  
  1403.     /** optimize **/
  1404.     /*  break down into a list of machine names, checking as we go along */
  1405.     
  1406.     addrptr = (char *) new_address;
  1407.  
  1408.     while ((host = get_token(addrptr, "!", 1)) != NULL) {
  1409.       for (i = 0; i < host_count && ! equal(hosts[i], host); i++)
  1410.           ;
  1411.  
  1412.       if (i == host_count) {
  1413.         strcpy(hosts[host_count++], host);
  1414.         if (host_count == MAX_HOPS) {
  1415.            dprint1(2,
  1416.               "Error: hit max_hops limit trying to build return address (%s)\n",
  1417.               "optimize_and_add");
  1418.            error("Can't build return address - hit MAX_HOPS limit!");
  1419.            return(1);
  1420.         }
  1421.       }
  1422.       else 
  1423.         host_count = i + 1;
  1424.       addrptr = NULL;
  1425.     }
  1426.  
  1427.     /** fix the ARPA addresses, if needed **/
  1428.     
  1429.     if (chloc(hosts[host_count-1], '@') > -1)
  1430.       fix_arpa_address(hosts[host_count-1]);
  1431.       
  1432.     /** rebuild the address.. **/
  1433.  
  1434.     new_address[0] = '\0';
  1435.  
  1436.     for (i = 0; i < host_count; i++)
  1437.       sprintf(new_address, "%s%s%s", new_address, 
  1438.               new_address[0] == '\0'? "" : "!",
  1439.               hosts[i]);
  1440.  
  1441.     if (full_address[0] == '\0')
  1442.       strcpy(full_address, new_address);
  1443.     else {
  1444.       len = strlen(full_address);
  1445.       full_address[len  ] = ',';
  1446.       full_address[len+1] = ' ';
  1447.       full_address[len+2] = '\0';
  1448.       strcat(full_address, new_address);
  1449.     }
  1450.  
  1451.     return(0);
  1452. }
  1453.  
  1454. get_return_name(address, name, shift_lower)
  1455. char *address, *name;
  1456. int   shift_lower;
  1457. {
  1458.     /** Given the address (either a single address or a combined list 
  1459.         of addresses) extract the login name of the first person on
  1460.         the list and return it as 'name'.  Modified to stop at
  1461.         any non-alphanumeric character. **/
  1462.  
  1463.     /** An important note to remember is that it isn't vital that this
  1464.         always returns just the login name, but rather that it always
  1465.         returns the SAME name.  If the persons' login happens to be,
  1466.         for example, joe.richards, then it's arguable if the name 
  1467.         should be joe, or the full login.  It's really immaterial, as
  1468.         indicated before, so long as we ALWAYS return the same name! **/
  1469.  
  1470.     /** Another note: modified to return the argument as all lowercase
  1471.         always, unless shift_lower is FALSE... **/
  1472.  
  1473.     char single_address[LONG_SLEN];
  1474.     register int i, loc, index = 0;
  1475.  
  1476.     dprint2(6,"get_return_name called with (%s, <>, shift=%s)\n", 
  1477.            address, onoff(shift_lower));
  1478.  
  1479.     /* First step - copy address up to a comma, space, or EOLN */
  1480.  
  1481.     for (i=0; address[i] != ',' && ! whitespace(address[i]) && 
  1482.          address[i] != '\0'; i++)
  1483.       single_address[i] = address[i];
  1484.     single_address[i] = '\0';
  1485.  
  1486.     /* Now is it an ARPA address?? */
  1487.  
  1488.     if ((loc = chloc(single_address, '@')) != -1) {      /* Yes */
  1489.  
  1490.       /* At this point the algorithm is to keep shifting our copy 
  1491.          window left until we hit a '!'.  The login name is then
  1492.              located between the '!' and the first metacharacter to 
  1493.          it's right (ie '%', ':' or '@'). */
  1494.  
  1495.       for (i=loc; single_address[i] != '!' && i > -1; i--)
  1496.           if (single_address[i] == '%' || 
  1497.               single_address[i] == ':' ||
  1498.               single_address[i] == '.' ||    /* no domains */
  1499.           single_address[i] == '@') loc = i-1;
  1500.     
  1501.       if (i < 0 || single_address[i] == '!') i++;
  1502.  
  1503.       for (index = 0; index < loc - i + 1; index++)
  1504.         if (shift_lower)
  1505.           name[index] = tolower(single_address[index+i]);
  1506.         else
  1507.           name[index] = single_address[index+i];
  1508.       name[index] = '\0';
  1509.     }
  1510.     else {    /* easier - standard USENET address */
  1511.  
  1512.       /* This really is easier - we just cruise left from the end of
  1513.          the string until we hit either a '!' or the beginning of the
  1514.              line.  No sweat. */
  1515.  
  1516.       loc = strlen(single_address)-1;     /* last char */
  1517.  
  1518.       for (i = loc; single_address[i] != '!' && single_address[i] != '.' 
  1519.            && i > -1; i--)
  1520.          if (shift_lower)
  1521.            name[index++] = tolower(single_address[i]);
  1522.          else
  1523.            name[index++] = single_address[i];
  1524.       name[index] = '\0';
  1525.       reverse(name);
  1526.     }
  1527. }
  1528. END-OF-FILE
  1529.  
  1530. if [ "$filename" != "/dev/null" ]
  1531. then
  1532.   size=`wc -c < $filename`
  1533.  
  1534.   if [ $size != 10560 ]
  1535.   then
  1536.     echo $filename changed - should be 10560 bytes, not $size bytes
  1537.   fi
  1538.  
  1539.   chmod 644 $filename
  1540. fi
  1541.  
  1542. # ---------- file src/screen.c ----------
  1543.  
  1544. filename="src/screen.c"
  1545.  
  1546. if [ -f $filename ]
  1547. then
  1548.   echo File \"$filename\" already exists\!  Skipping...
  1549.   filename=/dev/null        # throw it away
  1550. else
  1551.   echo extracting file src/screen.c...
  1552. fi
  1553.  
  1554. cat << 'END-OF-FILE' > $filename
  1555. /**        screen.c        **/
  1556.  
  1557. /**  screen display routines for ELM program 
  1558.  
  1559.      (C) Copyright 1985, Dave Taylor
  1560. **/
  1561.  
  1562. #include "headers.h"
  1563.  
  1564. static   int  last_current     = -1;
  1565.  
  1566. showscreen()
  1567. {
  1568.     char buffer[SLEN];
  1569.  
  1570.     ClearScreen();
  1571.  
  1572.     if (notesfile) 
  1573.       sprintf(buffer, "Notes from '%s' (%d note%s) [Version %s]",
  1574.             infile, message_count, 
  1575.         plural(message_count), VERSION);
  1576.     else 
  1577.       sprintf(buffer, "Mailbox is '%s' with %d message%s [Version %s]",
  1578.             infile, message_count, 
  1579.         plural(message_count), VERSION);
  1580.     Centerline(1, buffer);
  1581.  
  1582.     last_header_page = -1;         /* force a redraw regardless */
  1583.     show_headers();
  1584.  
  1585.     if (mini_menu)
  1586.       show_menu();
  1587.  
  1588.     show_last_error();
  1589.     
  1590.     if (hp_terminal) 
  1591.       define_softkeys(MAIN);
  1592. }
  1593.  
  1594. update_title()
  1595. {
  1596.     /** display a new title line, probably due to new mail arriving **/
  1597.  
  1598.     char buffer[SLEN];
  1599.  
  1600.     if (notesfile) 
  1601.       sprintf(buffer, "Notes from '%s' (%d note%s) [Version %s]",
  1602.             infile, message_count, 
  1603.         plural(message_count), VERSION);
  1604.     else 
  1605.       sprintf(buffer, "Mailbox is '%s' with %d message%s [Version %s]",
  1606.             infile, message_count, 
  1607.         plural(message_count), VERSION);
  1608.  
  1609.     ClearLine(1);
  1610.  
  1611.     Centerline(1, buffer);
  1612. }
  1613.  
  1614. show_menu()
  1615. {
  1616.     /** write main system menu... **/
  1617.  
  1618.     Centerline(LINES-7,
  1619.   "|=pipe, !=shell, ?=help, <n>=set current to n, /=search pattern");
  1620.         Centerline(LINES-6,
  1621. "A)lias, C)hange mailbox, D)elete, E)dit, F)orward, G)roup reply, M)ail,"); 
  1622.     Centerline(LINES-5,
  1623.   "N)ext, O)ptions, P)rint, R)eply, S)ave, T)ag, Q)uit, U)ndelete, or eX)it");
  1624.  
  1625.     show_last_error();
  1626. }
  1627.  
  1628. int
  1629. show_headers()
  1630. {
  1631.     /** display page of headers (10) if present.  First check to 
  1632.         ensure that header_page is in bounds, fixing silently if not.
  1633.         If out of bounds, return zero, else return non-zero **/
  1634.  
  1635.     register int this_msg = 0, line = 4, last = 0, last_line;
  1636.     char newfrom[SLEN], buffer[SLEN];
  1637.     
  1638.     if (fix_header_page())
  1639.       return(FALSE);
  1640.  
  1641.     if (header_page == last_header_page)     /* nothing to do! */
  1642.       return(FALSE);
  1643.  
  1644.     /** compute last header to display **/
  1645.  
  1646.     this_msg = header_page * headers_per_page;
  1647.  
  1648.     last = this_msg + (headers_per_page - 1);
  1649.  
  1650.     if (last >= message_count) last = message_count-1;
  1651.  
  1652.     /** okay, now let's show the header page! **/
  1653.  
  1654.     ClearLine(line);    /* Clear the top line... */
  1655.  
  1656.     MoveCursor(line, 0);    /* and move back to the top of the page... */
  1657.  
  1658.     for (; this_msg <= last; this_msg++) {
  1659.  
  1660.       tail_of(header_table[this_msg].from, newfrom, TRUE); 
  1661.  
  1662.       if (this_msg == current-1)
  1663.         build_header_line(buffer, &header_table[this_msg], this_msg+1, TRUE, 
  1664.                   newfrom);
  1665.       else
  1666.         build_header_line(buffer, &header_table[this_msg], 
  1667.                   this_msg+1, FALSE, newfrom);
  1668.  
  1669.       Write_to_screen("%s\r\n", 1, buffer);    /* avoid '%' probs */
  1670.       CleartoEOLN();
  1671.       line++;        /* for clearing up in a sec... */
  1672.  
  1673.     }
  1674.  
  1675.     if (mini_menu)
  1676.       last_line = LINES-8;
  1677.     else
  1678.       last_line = LINES-3;
  1679.  
  1680.     while (line < last_line) {
  1681.       CleartoEOLN();
  1682.       Writechar('\r');
  1683.       Writechar('\n');
  1684.       line++;
  1685.     }
  1686.  
  1687.     display_central_message();
  1688.  
  1689.     last_current = current;
  1690.     last_header_page = header_page;
  1691.  
  1692.     return(TRUE);
  1693. }
  1694.  
  1695. show_current()
  1696. {
  1697.     /** Display page of headers (10) if present.  First check to 
  1698.         ensure that header_page is in bounds, fixing silently if not.
  1699.         Note that this will ensure that 'current' is always set to
  1700.         the top message on the screen if we go to a new screen! **/
  1701.  
  1702.     register int first = 0, last = 0, last_line, new_line;
  1703.     char     newfrom[SLEN], old_buffer[SLEN], new_buffer[SLEN];
  1704.  
  1705.     (void) fix_header_page();    /* Who cares what it does? ;-) */
  1706.  
  1707.     /** compute last header to display **/
  1708.  
  1709.     first = header_page * headers_per_page;
  1710.     last  = first + (headers_per_page - 1);
  1711.  
  1712.     if (last > message_count) 
  1713.       last = message_count;
  1714.  
  1715.     /** okay, now let's show the pointers... **/
  1716.  
  1717.     /** have we changed??? **/
  1718.  
  1719.     if (current == last_current) 
  1720.       return;
  1721.  
  1722.     last_line = ((last_current-1) % headers_per_page)+4;
  1723.     new_line  = ((current-1) % headers_per_page)+4;
  1724.  
  1725.     if (has_highlighting && ! arrow_cursor) {
  1726.       /** build the old and new header lines... **/
  1727.   
  1728.       tail_of(header_table[current-1].from, newfrom, TRUE); 
  1729.       build_header_line(new_buffer, &header_table[current-1], current, 
  1730.                 TRUE, newfrom);
  1731.  
  1732.       if (last_current > 0) {  /* say we went from no mail to new... */
  1733.         tail_of(header_table[last_current-1].from, newfrom, TRUE); 
  1734.         build_header_line(old_buffer, &header_table[last_current-1], 
  1735.             last_current, FALSE, newfrom);
  1736.  
  1737.         ClearLine(last_line);
  1738.         PutLine0(last_line, 0, old_buffer);
  1739.       }
  1740.       PutLine0(new_line, 0, new_buffer);
  1741.     }
  1742.     else {
  1743.       if (on_page(last_current)) 
  1744.         PutLine0(last_line,0,"  ");    /* remove old pointer... */
  1745.       if (on_page(current))
  1746.         PutLine0(new_line, 0,"->");
  1747.     }
  1748.     
  1749.     last_current = current;
  1750. }
  1751.  
  1752. build_header_line(buffer, entry, message_number, highlight, from)
  1753. char *buffer;
  1754. struct header_rec *entry;
  1755. int message_number, highlight;
  1756. char *from;
  1757. {
  1758.     /** Build in buffer the message header ... entry is the current
  1759.         message entry, 'from' is a modified (displayable) from line, 
  1760.         'highlight' is either TRUE or FALSE, and 'message_number'
  1761.         is the number of the message.
  1762.     **/
  1763.  
  1764.     /** Note: using 'strncpy' allows us to output as much of the
  1765.         subject line as possible given the dimensions of the screen.
  1766.         The key is that 'strncpy' returns a 'char *' to the string
  1767.         that it is handing to the dummy variable!  Neat, eh? **/
  1768.     
  1769.     char subj[LONG_SLEN],        /* to output subject */
  1770.          buff[NLEN];        /* keep start_highlight value */
  1771.  
  1772.     if (strcmp(start_highlight,"->") != 0 && arrow_cursor) {
  1773.       strcpy(buff, start_highlight);
  1774.       strcpy(start_highlight, "->");
  1775.     }
  1776.  
  1777.     strncpy(subj, entry->subject, COLUMNS-45);
  1778.  
  1779.     subj[COLUMNS-45] = '\0';    /* insurance, eh? */
  1780.  
  1781.     /* now THIS is a frightening format statement!!!  */
  1782.  
  1783.     sprintf(buffer, "%s%s%c%c%c%-3d %3.3s %-2d %-18.18s (%d) %s%s%s", 
  1784.         highlight? start_highlight : "",
  1785.         strcmp(start_highlight,"->") == 0 && highlight? "" : "  ",
  1786.         show_status(entry->status),
  1787.         (entry->status & DELETED? 'D' : ' '), 
  1788.         (entry->status & TAGGED?  '+' : ' '),
  1789.             message_number,
  1790.             entry->month, 
  1791.         atoi(entry->day), 
  1792.         from, 
  1793.         entry->lines, 
  1794.         (entry->lines / 1000   > 0? ""   :    /* spacing the  */
  1795.           entry->lines / 100   > 0? " "  :    /* same for the */
  1796.             entry->lines / 10  > 0? "  " :    /* lines in ()  */
  1797.                                     "   "),    /*   [wierd]    */
  1798.         subj,
  1799.         highlight? end_highlight : " ");
  1800.  
  1801.     /** Actually, it's rather an impressive feat that we can
  1802.         do so much in essentially one statement!  (Of course,
  1803.         I'll bet the test suite for the printf routine isn't
  1804.         THIS rigorous either!!!) (to be honest, though, just 
  1805.         looking at this statement makes me chuckle...)
  1806.     **/
  1807.  
  1808.     if (arrow_cursor)             /* restore! */
  1809.       strcpy(start_highlight, buff);
  1810.  
  1811. }
  1812.  
  1813. int
  1814. fix_header_page()
  1815. {
  1816.     /** this routine will check and ensure that the current header
  1817.         page being displayed contains messages!  It will silently
  1818.         fix 'header-page' if wrong.  Returns TRUE if changed.  **/
  1819.  
  1820.     int last_page, old_header;
  1821.  
  1822.     old_header = header_page;
  1823.  
  1824.     last_page = (int) ((message_count-1) / headers_per_page);
  1825.  
  1826.     if (header_page > last_page) 
  1827.       header_page = last_page;
  1828.     else if (header_page < 0) 
  1829.           header_page = 0;
  1830.  
  1831.     return(old_header != header_page);
  1832. }
  1833.  
  1834. int
  1835. on_page(message)
  1836. int message;
  1837. {
  1838.     /** Returns true iff the specified message is on the displayed page. **/
  1839.  
  1840.     if (message >= header_page * headers_per_page)
  1841.       if (message <= ((header_page+1) * headers_per_page)) 
  1842.         return(TRUE);
  1843.  
  1844.     return(FALSE);
  1845. }
  1846.  
  1847. show_status(status)
  1848. int status;
  1849. {
  1850.     /** This routine returns a single character indicative of
  1851.         the status of this message.  The precedence is;
  1852.  
  1853.         E = Expired message
  1854.             P = Priority message
  1855.         A = Action associated with message
  1856.         N = New message
  1857.         _ = (space) default 
  1858.     **/
  1859.  
  1860.          if (status & EXPIRED)  return( 'E' );
  1861.     else if (status & PRIORITY) return( 'P' );
  1862.     else if (status & ACTION)   return( 'A' );
  1863.     else if (status & NEW)      return( 'N' );
  1864.     else                 return( ' ' );
  1865. }
  1866. END-OF-FILE
  1867.  
  1868. if [ "$filename" != "/dev/null" ]
  1869. then
  1870.   size=`wc -c < $filename`
  1871.  
  1872.   if [ $size != 7956 ]
  1873.   then
  1874.     echo $filename changed - should be 7956 bytes, not $size bytes
  1875.   fi
  1876.  
  1877.   chmod 644 $filename
  1878. fi
  1879.  
  1880. # ---------- file src/strings.c ----------
  1881.  
  1882. filename="src/strings.c"
  1883.  
  1884. if [ -f $filename ]
  1885. then
  1886.   echo File \"$filename\" already exists\!  Skipping...
  1887.   filename=/dev/null        # throw it away
  1888. else
  1889.   echo extracting file src/strings.c...
  1890. fi
  1891.  
  1892. cat << 'END-OF-FILE' > $filename
  1893. /**            strings.c        **/
  1894.  
  1895. /** This file contains all the string oriented functions for the
  1896.     ELM Mailer, and lots of other generally useful string functions! 
  1897.  
  1898.     For BSD systems, this file also includes the function "tolower"
  1899.     to translate the given character from upper case to lower case.
  1900.  
  1901.     (C) Copyright 1985, Dave Taylor
  1902. **/
  1903.  
  1904. #include <stdio.h>
  1905. #include "headers.h"
  1906. #include <ctype.h>
  1907.  
  1908. #ifdef BSD
  1909. #undef tolower
  1910. #undef toupper
  1911. #endif
  1912.  
  1913. /** forward declarations **/
  1914.  
  1915. char *format_long(), *strip_commas(), *tail_of_string(), *shift_lower(),
  1916.      *get_token(), *strip_parens(), *argv_zero(), *change_ats();
  1917.  
  1918. #ifdef BSD
  1919.  
  1920. int
  1921. tolower(ch)
  1922. char ch;
  1923. {
  1924.     /** This should be a macro call, but if you use this as a macro
  1925.         calls to 'tolower' where the argument is a function call will
  1926.         cause the function to be called TWICE which is obviously the
  1927.         wrong behaviour.  On the other hand, to just blindly translate
  1928.         assuming the character is always uppercase can cause BIG
  1929.         problems, so...
  1930.     **/
  1931.  
  1932.     return ( isupper(ch) ? ch - 'A' + 'a' : ch );
  1933. }
  1934.  
  1935. int
  1936. toupper(ch)
  1937. char ch;
  1938. {
  1939.     /** see comment for above routine - tolower() **/
  1940.  
  1941.     return ( islower(ch) ? ch - 'a' + 'A' : ch );
  1942. }
  1943.  
  1944. #endif
  1945.  
  1946. int
  1947. printable_chars(string)
  1948. char *string;
  1949. {
  1950.     /** Returns the number of "printable" (ie non-control) characters
  1951.         in the given string... Modified 4/86 to know about TAB
  1952.         characters being every eight characters... **/
  1953.  
  1954.     register int count = 0, index;
  1955.  
  1956.     for (index = 0; index < strlen(string); index++)
  1957.       if (string[index] >= ' ') 
  1958.         if (string[index] == '\t')
  1959.           count += (7-(count % 8));
  1960.         else
  1961.           count++;
  1962.  
  1963.     return(count);
  1964. }
  1965.  
  1966. tail_of(from, buffer, header_line)
  1967. char *from, *buffer;
  1968. int   header_line;
  1969. {
  1970.     /** Return last two words of 'from'.  This is to allow
  1971.         painless display of long return addresses as simply the
  1972.         machine!username.  Alternatively, if the first three
  1973.         characters of the 'from' address are 'To:' and 'header_line'
  1974.         is TRUE, then return the buffer value prepended with 'To '. 
  1975.  
  1976.         Mangled to know about the PREFER_UUCP hack.  6/86
  1977.     **/
  1978.  
  1979.     /** Note: '!' delimits Usenet nodes, '@' delimits ARPA nodes,
  1980.               ':' delimits CSNet & Bitnet nodes, and '%' delimits
  1981.           multiple stage ARPA hops... **/
  1982.  
  1983.     register int loc, i = 0, cnt = 0;
  1984.     char     tempbuffer[SLEN];
  1985.     
  1986. #ifdef PREFER_UUCP
  1987.     
  1988.     /** let's see if we have an address appropriate for hacking **/
  1989.  
  1990.     if (chloc(from,'!') != -1 && in_string(from, BOGUS_INTERNET))
  1991.        from[strlen(from)-strlen(BOGUS_INTERNET)] = '\0';
  1992.  
  1993. #endif
  1994.  
  1995.     for (loc = strlen(from)-1; loc >= 0 && cnt < 2; loc--) {
  1996.       if (from[loc] == BANG || from[loc] == AT_SIGN ||
  1997.           from[loc] == COLON) cnt++;
  1998.       if (cnt < 2) buffer[i++] = from[loc];
  1999.     }
  2000.  
  2001.     buffer[i] = '\0';
  2002.  
  2003.     reverse(buffer);
  2004.  
  2005.     if ((strncmp(buffer,"To:", 3) == 0) && header_line)
  2006.       buffer[2] = ' ';
  2007.     else if ((strncmp(from, "To:", 3) == 0) && header_line) {
  2008.       sprintf(tempbuffer,"To %s", buffer); 
  2009.       strcpy(buffer, tempbuffer);
  2010.     }
  2011.     else if (strncmp(buffer, "To:", 3) == 0) {
  2012.       for (i=3; i < strlen(buffer); i++)
  2013.         tempbuffer[i-3] = buffer[i];
  2014.       tempbuffer[i-3] = '\0';
  2015.       strcpy(buffer, tempbuffer);
  2016.     }
  2017. }
  2018.  
  2019. char *format_long(inbuff, init_len)
  2020. char *inbuff;
  2021. int   init_len;
  2022. {
  2023.     /** Return buffer with \n\t sequences added at each point
  2024.         where it would be more than 80 chars long.  It only 
  2025.         allows the breaks at legal points (ie white spaces).
  2026.         init-len is the characters already on the first line...
  2027.         Changed so that if this is called while mailing without
  2028.         the overhead of "elm", it'll include "\r\n\t" instead.
  2029.     **/
  2030.  
  2031.     static char ret_buffer[VERY_LONG_STRING];
  2032.     register int index = 0, current_length = 0, depth=15, i;
  2033.     char     buffer[VERY_LONG_STRING];
  2034.     char     *word, *bufptr;
  2035.  
  2036.     strcpy(buffer, inbuff);
  2037.  
  2038.     bufptr = (char *) buffer;
  2039.  
  2040.     current_length = init_len + 2;    /* for luck */
  2041.  
  2042.     while ((word = get_token(bufptr," ", depth)) != NULL) {
  2043.       if (strlen(word) + current_length > 80) {
  2044.         if (index > 0) {
  2045.           if (mail_only)
  2046.             ret_buffer[index++] = '\r';
  2047.           ret_buffer[index++] = '\n';
  2048.           ret_buffer[index++] = '\t';
  2049.         }
  2050.         for (i=0; i<strlen(word); i++)
  2051.           ret_buffer[index++] = word[i];
  2052.         current_length = strlen(word) + 8;    /* 8 = TAB */
  2053.       }
  2054.       else {
  2055.         if (index > 0)
  2056.           ret_buffer[index++] = ' ';
  2057.         for (i=0; i<strlen(word); i++)
  2058.           ret_buffer[index++] = word[i];
  2059.         current_length += strlen(word) + 1;
  2060.       }
  2061.     
  2062.       bufptr = NULL;
  2063.     }
  2064.     
  2065.     ret_buffer[index] = '\0';
  2066.  
  2067.     return( (char *) ret_buffer);
  2068. }
  2069.  
  2070. char *strip_commas(string)
  2071. char *string;
  2072. {
  2073.     /** return string with all commas changed to spaces.  This IS
  2074.         destructive and will permanently change the input string.. **/
  2075.  
  2076.     register int i;
  2077.  
  2078.     for (i=0; i < strlen(string); i++)
  2079.       if (string[i] == COMMA)
  2080.         string[i] = SPACE;
  2081.  
  2082.     return( (char *) string);
  2083. }
  2084.  
  2085. char *strip_parens(string)
  2086. char *string;
  2087. {
  2088.     /** Return string with all parenthesized information removed.
  2089.         This is a non-destructive algorithm... **/
  2090.  
  2091.     static char  buffer[VERY_LONG_STRING];
  2092.     register int i, depth = 0, buffer_index = 0;
  2093.  
  2094.     for (i=0; i < strlen(string); i++) {
  2095.       if (string[i] == '(')
  2096.         depth++;
  2097.       else if (string[i] == ')') 
  2098.         depth--;
  2099.       else if (depth == 0)
  2100.         buffer[buffer_index++] = string[i];
  2101.     }
  2102.     
  2103.     buffer[buffer_index] = '\0';
  2104.  
  2105.     return( (char *) buffer);
  2106. }
  2107.  
  2108. move_left(string, chars)
  2109. char string[];
  2110. int  chars;
  2111. {
  2112.     /** moves string chars characters to the left DESTRUCTIVELY **/
  2113.  
  2114.     register int i;
  2115.  
  2116.     chars--; /* index starting at zero! */
  2117.  
  2118.     for (i=chars; string[i] != '\0' && string[i] != '\n'; i++)
  2119.       string[i-chars] = string[i];
  2120.  
  2121.     string[i-chars] = '\0';
  2122. }
  2123.  
  2124. remove_first_word(string)
  2125. char *string;
  2126. {    /** removes first word of string, ie up to first non-white space
  2127.         following a white space! **/
  2128.  
  2129.     register int loc;
  2130.  
  2131.     for (loc = 0; string[loc] != ' ' && string[loc] != '\0'; loc++) 
  2132.         ;
  2133.  
  2134.     while (string[loc] == ' ' || string[loc] == '\t')
  2135.       loc++;
  2136.     
  2137.     move_left(string, ++loc);
  2138. }
  2139.  
  2140. char *tail_of_string(string, maxchars)
  2141. char *string;
  2142. int  maxchars;
  2143. {
  2144.     /** Return a string that is the last 'maxchars' characters of the
  2145.         given string.  This is only used if the first word of the string
  2146.         is longer than maxchars, else it will return what is given to
  2147.         it... 
  2148.     **/
  2149.  
  2150.     static char buffer[SLEN];
  2151.     register int index, i;
  2152.  
  2153.     for (index=0;! whitespace(string[index]) && index < strlen(string); 
  2154.          index++)
  2155.       ;
  2156.  
  2157.     if (index < maxchars) {
  2158.       strncpy(buffer, string, maxchars-2);    /* word too short */
  2159.       buffer[maxchars-2] = '.';
  2160.       buffer[maxchars-1] = '.';
  2161.       buffer[maxchars]   = '.';
  2162.       buffer[maxchars+1] = '\0';
  2163.     } 
  2164.     else {
  2165.       i = maxchars;
  2166.       buffer[i--] = '\0';
  2167.       while (i > 1) 
  2168.         buffer[i--] = string[index--];
  2169.       buffer[2] = '.';
  2170.       buffer[1] = '.';
  2171.       buffer[0] = '.';
  2172.     }
  2173.  
  2174.     return( (char *) buffer);
  2175. }
  2176.  
  2177. reverse(string)
  2178. char *string;
  2179. {
  2180.     /** reverse string... pretty trivial routine, actually! **/
  2181.  
  2182.     char buffer[SLEN];
  2183.     register int i, j = 0;
  2184.  
  2185.     for (i = strlen(string)-1; i >= 0; i--)
  2186.       buffer[j++] = string[i];
  2187.  
  2188.     buffer[j] = '\0';
  2189.  
  2190.     strcpy(string, buffer);
  2191. }
  2192.  
  2193. int
  2194. get_word(buffer, start, word)
  2195. char *buffer, *word;
  2196. int start;
  2197. {
  2198.     /**    return next word in buffer, starting at 'start'.
  2199.         delimiter is space or end-of-line.  Returns the
  2200.         location of the next word, or -1 if returning
  2201.         the last word in the buffer.  -2 indicates empty
  2202.         buffer!  **/
  2203.  
  2204.     register int loc = 0;
  2205.  
  2206.     while (buffer[start] == ' ' && buffer[start] != '\0')
  2207.       start++;
  2208.  
  2209.     if (buffer[start] == '\0') return(-2);     /* nothing IN buffer! */
  2210.  
  2211.     while (buffer[start] != ' ' && buffer[start] != '\0')
  2212.       word[loc++] = buffer[start++];
  2213.  
  2214.     word[loc] = '\0';
  2215.     return(start);
  2216. }
  2217.  
  2218. char *shift_lower(string)
  2219. char *string;
  2220. {
  2221.     /** return 'string' shifted to lower case.  Do NOT touch the
  2222.         actual string handed to us! **/
  2223.  
  2224.     static char buffer[LONG_SLEN];
  2225.     register int i;
  2226.  
  2227.     for (i=0; i < strlen(string); i++)
  2228.       if (isupper(string[i]))
  2229.         buffer[i] = tolower(string[i]);
  2230.       else
  2231.         buffer[i] = string[i];
  2232.     
  2233.     buffer[strlen(string)] = 0;
  2234.     
  2235.     return( (char *) buffer);
  2236. }
  2237.  
  2238. int
  2239. words_in_string(buffer)
  2240. char *buffer;
  2241. {
  2242.     /** This routine returns the number of words in the given line.
  2243.         A word is defined as a series of characters surrounded by
  2244.         either the beginning of the string, the end of the string,
  2245.         or white space.
  2246.         For example, the following line has 8 words:
  2247.         "This is a test of the program, okay?"
  2248.     **/
  2249.  
  2250.     register int count = 0, i = 0;
  2251.     
  2252.     while (buffer[i] != '\0') {
  2253.       
  2254.       while (whitespace(buffer[i])) i++;
  2255.     
  2256.       if (buffer[i] != '\0')
  2257.           count++;
  2258.  
  2259.       while (! whitespace(buffer[i]) && buffer[i] != '\0') i++;
  2260.     }
  2261.     return(count);
  2262. }
  2263.  
  2264. clean_up(buffer)
  2265. char *buffer;
  2266. {
  2267.     /** This routine takes a string of the form "a:b" and returns it 
  2268.             as just "b"... **/
  2269.  
  2270.     char mybuffer[SLEN];
  2271.     register int loc, myloc = 0;
  2272.  
  2273.     for (loc=0; buffer[loc] != ':'; loc++)
  2274.        ;
  2275.  
  2276.     while (buffer[++loc] != '\0')
  2277.       mybuffer[myloc++] = buffer[loc];
  2278.  
  2279.     mybuffer[myloc] = '\0';
  2280.  
  2281.     strcpy(buffer, mybuffer);
  2282. }
  2283.  
  2284. Centerline(line, string)
  2285. int line;
  2286. char *string;
  2287. {
  2288.     /** Output 'string' on the given line, centered. **/
  2289.  
  2290.     register int length, col;
  2291.  
  2292.     length = strlen(string);
  2293.  
  2294.     if (length > COLUMNS)
  2295.       col = 0;
  2296.     else
  2297.       col = (COLUMNS - length) / 2;
  2298.  
  2299.     PutLine0(line, col, string);
  2300. }
  2301.  
  2302. char *argv_zero(string)
  2303. char *string;
  2304. {
  2305.     /** given a string of the form "/something/name" return a
  2306.         string of the form "name"... **/
  2307.  
  2308.     static char buffer[NLEN];
  2309.     register int i, j=0;
  2310.  
  2311.     for (i=strlen(string)-1; string[i] != '/'; i--)
  2312.       buffer[j++] = string[i];
  2313.     buffer[j] = '\0';
  2314.  
  2315.     reverse(buffer);
  2316.  
  2317.     return( (char *) buffer);
  2318. }
  2319.  
  2320. #define MAX_RECURSION        20        /* up to 20 deep recursion */
  2321.  
  2322. char *get_token(source, keys, depth)
  2323. char *source, *keys;
  2324. int   depth;
  2325. {
  2326.     /** This function is similar to strtok() (see "opt_utils")
  2327.         but allows nesting of calls via pointers... 
  2328.     **/
  2329.  
  2330.     register int  last_ch;
  2331.     static   char *buffers[MAX_RECURSION];
  2332.     char     *return_value, *sourceptr;
  2333.  
  2334.     if (depth > MAX_RECURSION) {
  2335.        error1("get_token calls nested greater than %d deep!", 
  2336.           MAX_RECURSION);
  2337.        emergency_exit();
  2338.     }
  2339.  
  2340.     if (source != NULL)
  2341.       buffers[depth] = source;
  2342.     
  2343.     sourceptr = buffers[depth];
  2344.     
  2345.     if (*sourceptr == '\0') 
  2346.       return(NULL);        /* we hit end-of-string last time!? */
  2347.  
  2348.     sourceptr += strspn(sourceptr, keys);      /* skip the bad.. */
  2349.     
  2350.     if (*sourceptr == '\0') {
  2351.       buffers[depth] = sourceptr;
  2352.       return(NULL);            /* we've hit end-of-string   */
  2353.     }
  2354.  
  2355.     last_ch = strcspn(sourceptr, keys);   /* end of good stuff   */
  2356.  
  2357.     return_value = sourceptr;          /* and get the ret     */
  2358.  
  2359.     sourceptr += last_ch;              /* ...value            */
  2360.  
  2361.     if (*sourceptr != '\0')        /** don't forget if we're at end! **/
  2362.       sourceptr++;                  
  2363.     
  2364.     return_value[last_ch] = '\0';          /* ..ending right      */
  2365.  
  2366.     buffers[depth] = sourceptr;          /* save this, mate!    */
  2367.  
  2368.     return((char *) return_value);         /* and we're outta here! */
  2369. }
  2370. END-OF-FILE
  2371.  
  2372. if [ "$filename" != "/dev/null" ]
  2373. then
  2374.   size=`wc -c < $filename`
  2375.  
  2376.   if [ $size != 10842 ]
  2377.   then
  2378.     echo $filename changed - should be 10842 bytes, not $size bytes
  2379.   fi
  2380.  
  2381.   chmod 644 $filename
  2382. fi
  2383.  
  2384. echo end of this archive file....
  2385. exit 0
  2386.  
  2387.