Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/unix/volume4/msg/part5

Internet Message Format | 1986-11-30 | 62.8 KB

From: decvax!hplabs!hpcnou!dat (Dave Taylor)
Subject: Msg Shar.part.5
Newsgroups: mod.sources
Approved: [e-mail]

Mod.sources:  Volume 4, Issue 9
Submitted by: decvax!hplabs!hpcnou!dat (Dave Taylor)

# Msg Shar part 5 of 7

# Shell Archive created by hpcnou!dat at Wed Feb 26 15:56:34 1986

# To unpack the enclosed files, please use this file as input to the
# Bourne (sh) shell.  This can be most easily done by the command;
#     sh < thisfilename

# This archive contains;
#  src/notesfile.c  src/opt_utils.c     src/output_utils.c  src/pattern.c
#  src/quit.c       src/read_rc.c       src/reply.c         src/return_addr.c
#  src/savecopy.c   src/screen.c        src/showmsg.c       src/softkeys.c


if [ ! -d src ]
then
  echo creating directory src
  mkdir src
fi

# ---------- file src/notesfile.c ----------


if [ -f src/notesfile.c ]
then
  echo File 'src/notesfile.c' already exists\!
  exit 1
fi

echo extracting file src/notesfile.c...
cat << 'END-OF-FILE' > src/notesfile.c
/**            notesfile.c            **/

/**  Routine that reads in a file comprised of saved messages from
     'notes'.

     (C) Copyright 1986 Dave Taylor
**/

#include "headers.h"
#include <errno.h>

char *notes_machine();

extern int errno;

int
read_notesfile()
{
    /** read in the current mailfile, assuming it's actually a set
        of stored notes from the notes program... **/

    char buffer[LONG_STRING];
    register int line = 0, count = 0;
    long  bytes = 0L, line_bytes = 0L;
    static int first_read = 0;
    int count_x , count_y = 17;

    dprint0("read_notesfile()\n");

    if (! first_read++) {
      MoveCursor(LINES-2, 0);
      CleartoEOS();
      PutLine(LINES-1, 0, "Reading in %s, message: 0", infile);
      count_x = LINES-1;
          count_y = 22 + strlen(infile);
    }
    else {
      PutLine(LINES-2, 0, "Reading message: 0");
      count_x = LINES-2;
    }

    while (fgets(buffer, LONG_STRING, mailfile) != NULL) {

      if (line == 0) {

        /** Double check to make sure this is okay... if the first
            word is "From " then we're actually reading a normal
            file so cruise over to the read_headers() routine
        instead! **/

        if (first_word(buffer, "From ")) {
          notesfile = 0;   /* turn that bloody flag off! */
          rewind(mailfile);  /* back up in da file... */
          return( read_headers(FALSE) );
        }
      }

      line_bytes = (long) strlen(buffer);
      line++;

      if (first_word(buffer, "/***** ")) {
        if (real_notes_header(buffer, &header_table[count])) {
          header_table[count].offset = (long) bytes;
          header_table[count].delete = 0;
          header_table[count++].lines = line;
          header_table[count].priority = 0;
          PutLine(count_x, count_y, "%d", count);
          if (count > 1)
            header_table[count-2].lines = line -header_table[count-2].lines;
        }
      }
      bytes += (long) line_bytes;
    }

    total_lines_in_file = line;
    header_table[count-1].lines = line - header_table[count-1].lines;

        rewind(mailfile);

    return(count);
}

int
real_notes_header(buffer, entry)
char *buffer;
struct header_rec *entry;
{
    /** confirms that we're looking at a REAL notes header,
        and if so, saves it in the appropriate data entry  **/

    char subjectbuffer[SLEN], timebuffer[NLEN], lastbuffer[NLEN],
         am_pm[NLEN], the_day[NLEN], nullbuffer[NLEN];

    dprint1("real_notes_header(buffer='%s')\n", buffer);

    strcpy(nullbuffer, "NULL");
    strcpy(lastbuffer, "LAST");

    sscanf(buffer, "%*s %s %*c %s %*c %s %s %s %s %s %s",
        subjectbuffer, entry->from,
        timebuffer, am_pm, entry->month, the_day,
        lastbuffer, nullbuffer);

    if (strcmp(lastbuffer, "LAST") == 0)
      return(0);

    if (strcmp(nullbuffer,"NULL") != 0)
      return(0);

    if (timebuffer[1] != ':' && timebuffer[2] != ':')
      return(0);

    /* now let's play format! */

    clean_up(subjectbuffer);

    sprintf(entry->subject, "Note from group %s", subjectbuffer);
    sprintf(entry->day,"%d", atoi(the_day));
    sprintf(entry->year,"%d", atoi(lastbuffer) % 100);
    sprintf(entry->time,"%s %s", timebuffer, am_pm);

    return(1);
}

char *notes_machine()
{
    /** For those rare notes posted by someone on the machine that
        the notesfiles are saved from, this routine will fix the
        address to ensure it's valid.  The return value will be
        either 'machine!' or NULL if it's from the machine we're on
    **/

    static char machine_group[NLEN];
    char buffer[SLEN];
    register int i;

    dprint0("notes_machine()\n");

    if (fseek(mailfile, header_table[current-1].offset, 0L) != 0) {
      error("error [notes_machine] trying to seek!");
      dprint1("\n\tError %d trying to seek into file!\n\n", errno);
      return( NULL );
    }

    if (fgets(buffer, SLEN, mailfile) == NULL) {
      error("error [notes_machine] trying to read!");
      dprint1("\n\tError %d trying to read file!\n\n", errno);
      return( NULL );
    }

    sscanf(buffer,"%*s %s", machine_group);

    for (i=0; machine_group[i] != ':'; i++)
       ;

    machine_group[i] = '\0';

    return( (char *) machine_group);
}
END-OF-FILE

size=`wc -c < src/notesfile.c`

if [ $size != 3955 ]
then
  echo Warning: src/notesfile.c changed - should be 3955 bytes, not $size bytes
fi

chmod 644 src/notesfile.c

# ---------- file src/opt_utils.c ----------


if [ -f src/opt_utils.c ]
then
  echo File 'src/opt_utils.c' already exists\!
  exit 1
fi

echo extracting file src/opt_utils.c...
cat << 'END-OF-FILE' > src/opt_utils.c
/**            opt_utils.c            **/

/** This file contains routines that might be needed for the various
     machines that the mailer can run on.  Please check the Makefile
     for more help and/or information.

     (C) Copyright 1986 Dave Taylor
**/

#include "headers.h"

#ifdef BSD
#  include <pwd.h>
#endif

#ifdef UTS
#  include <sys/utsname.h>

gethostname(hostname,size) /* get name of current host */
int size;
char *hostname;
{
    /** Return the name of the current host machine.  UTS only **/

    /** This routine compliments of Scott McGregor at the HP
        Corporate Computing Center **/

    int uname();
    struct utsname name;

    (void) uname(&name);
    (void) strncpy(hostname,name.nodename,size-1);
    hostname[size] = '\0';

}

#endif /* def UTS */

#ifdef BSD

cuserid(username)
char *username;
{
    /** Added for compatibility with Bell systems, this is the last-ditch
        attempt to get the users login name, after getlogin() fails.  It
        instantiates "username" to the name of the user...
    **/

    struct passwd *password_entry, *getpwuid();

    password_entry = getpwuid(getuid());

    strcpy(username, password_entry->pw_name);
}

/** some supplementary string functions for Berkeley Unix systems **/

strspn(source, keys)
char *source, *keys;
{
    /** This function returns the length of the substring of
        'source' (starting at zero) that consists ENTIRELY of
        characters from 'keys'.  This is used to skip over a
        defined set of characters with parsing, usually.
    **/

    register int loc = 0, key_index = 0;

    while (source[loc] != '\0') {
      key_index = 0;
      while (keys[key_index] != source[loc])
        if (keys[key_index++] == '\0')
          return(loc);
      loc++;
    }

    return(loc);
}

strcspn(source, keys)
char *source, *keys;
{
    /** This function returns the length of the substring of
        'source' (starting at zero) that consists entirely of
        characters NOT from 'keys'.  This is used to skip to a
        defined set of characters with parsing, usually.
        NOTE that this is the opposite of strspn() above
    **/

    register int loc = 0, key_index = 0;

    while (source[loc] != '\0') {
      key_index = 0;
      while (keys[key_index] != '\0')
        if (keys[key_index++] == source[loc])
          return(loc);
      loc++;
    }

    return(loc);
}

char *strtok(source, keys)
char *source, *keys;
{
    /** This function returns a pointer to the next word in source
        with the string considered broken up at the characters
        contained in 'keys'.  Source should be a character pointer
        when this routine is first called, then NULL subsequently.
        When strtok has exhausted the source string, it will
        return NULL as the next word.

        WARNING: This routine will DESTROY the string pointed to
        by 'source' when first invoked.  If you want to keep the
        string, make a copy before using this routine!!
     **/

    register int  last_ch;
    static   char *sourceptr;
         char *return_value;

    if (source != NULL)
      sourceptr = source;

    if (*sourceptr == '\0')
      return(NULL);        /* we hit end-of-string last time!? */

    sourceptr += strspn(sourceptr, keys);    /* skip leading crap */

    if (*sourceptr == '\0')
      return(NULL);        /* we've hit end-of-string */

    last_ch = strcspn(sourceptr, keys);    /* end of good stuff */

    return_value = sourceptr;        /* and get the ret   */

    sourceptr += last_ch;            /* ...value          */

    if (*sourceptr != '\0')        /* don't forget if we're at END! */
      sourceptr++;               /* and skipping for next time */

    return_value[last_ch] = '\0';        /* ..ending right    */

    return((char *) return_value);        /* and we're outta here! */
}

char *strpbrk(source, keys)
char *source, *keys;
{
    /** Returns a pointer to the first character of source that is any
        of the specified keys, or NULL if none of the keys are present
        in the source string.
    **/

    register int loc = 0, key_index = 0;

    while (source[loc] != '\0') {
      key_index = 0;
      while (keys[key_index] != '\0')
        if (keys[key_index++] == source[loc])
          return((char *) (source + loc));
      loc++;
    }

    return(NULL);
}

#endif
END-OF-FILE

size=`wc -c < src/opt_utils.c`

if [ $size != 4053 ]
then
  echo Warning: src/opt_utils.c changed - should be 4053 bytes, not $size bytes
fi

chmod 644 src/opt_utils.c

# ---------- file src/output_utils.c ----------


if [ -f src/output_utils.c ]
then
  echo File 'src/output_utils.c' already exists\!
  exit 1
fi

echo extracting file src/output_utils.c...
cat << 'END-OF-FILE' > src/output_utils.c
/**            output_utils.c            **/

/** This file contains routines used for output in the MSG program.

    These routines (C) Copyright 1986 Dave Taylor
**/

#include "headers.h"


static char err_buffer[SLEN];        /* store last error message */

static char central_message_buffer[SLEN];


show_last_error()
{
    /** rewrite last error message! **/

    error(err_buffer);
}

clear_error()
{
    MoveCursor(LINES,0);
    CleartoEOLN();
    err_buffer[0] = '\0';
}

set_error(s)
char *s;
{
    strcpy(err_buffer, s);
}

error(s)
char *s;
{
    /** outputs error 's' to screen at line 22, centered! **/

    MoveCursor(LINES,0);
    CleartoEOLN();
    PutLine(LINES,(COLUMNS-strlen(s))/2,s);
    if (strlen(s) > 0)
      dprint1("\nError: %s\n\n", s);
    fflush(stdout);
    strcpy(err_buffer, s);    /* save it too! */
}

error1(s, a)
char *s, *a;
{
    /** same as error, but with a 'printf' argument **/
    char buffer[SLEN];

    sprintf(buffer,s,a);
    error(buffer);
}

error2(s, a1, a2)
char *s, *a1, *a2;
{
    /** same as error, but with two 'printf' arguments **/
    char buffer[SLEN];

    sprintf(buffer,s, a1, a2);
    error(buffer);
}

prompt(s)
char *s;
{
    /** prompt user for input on LINES-3 line, left justified **/

    PutLine(LINES-3,0,s);
    CleartoEOLN();
}

prompt1(s,a)
char *s, *a;
{
    /** same as prompt, but with a 'printf' argument **/
    char buffer[SLEN];

    sprintf(buffer,s,a);
    prompt(buffer);
}


set_central_message(string, arg)
char *string, *arg;
{
    /** set up the given message to be displayed in the center of
        the current window **/

    sprintf(central_message_buffer, string, arg);
}

display_central_message()
{
    /** display the message if set... **/

    if (central_message_buffer[0] != '\0') {
      ClearLine(LINES-15);
      Centerline(LINES-15, central_message_buffer);
      fflush(stdout);
    }
}

clear_central_message()
{
    /** clear the central message buffer **/

    central_message_buffer[0] = '\0';
}
END-OF-FILE

size=`wc -c < src/output_utils.c`

if [ $size != 1861 ]
then
  echo Warning: src/output_utils.c changed - should be 1861 bytes, not $size bytes
fi

chmod 644 src/output_utils.c

# ---------- file src/pattern.c ----------


if [ -f src/pattern.c ]
then
  echo File 'src/pattern.c' already exists\!
  exit 1
fi

echo extracting file src/pattern.c...
cat << 'END-OF-FILE' > src/pattern.c
/**            pattern.c            **/

/**    General pattern matching for the MSG mailer.

       (C) Copyright 1986 Dave Taylor
**/

#include <errno.h>

#include "headers.h"

static char pattern[SLEN] = { "" };
static char alt_pattern[SLEN] = { "" };

extern int errno;

int
pattern_match()
{
    /** Get a pattern from the user and try to match it with the
        from/subject lines being displayed.  If matched (ignoring
        case), move current message pointer to that message, if
        not, error and return ZERO **/

    register int i;

    PutLine(LINES-3,40,"/ =match anywhere in messages");

    PutLine(LINES-1,0, "Match Pattern:");

    if (pattern_enter(pattern, alt_pattern, LINES-1, 16,
        "Match Pattern (in entire mailbox):"))
      if (strlen(alt_pattern) > 0)
        return(match_in_message(alt_pattern));
      else
        return(1);

    if (strlen(pattern) == 0)
      return(0);

    for (i = current; i < message_count; i++) {
      if (from_matches(i, pattern)) {
        current = ++i;
        return(1);
      }
      else if (subject_matches(i, pattern)) {
        current = ++i;
        return(1);
      }
    }

    return(0);
}

int
from_matches(message_number, pattern)
int message_number;
char *pattern;
{
    /** Returns true iff the pattern occurs in it's entirety
        in the from line of the indicated message **/


    return( in_string(header_table[message_number].from, pattern) );
}

int
subject_matches(message_number, pattern)
int message_number;
char *pattern;
{
    /** Returns true iff the pattern occurs in it's entirety
        in the subject line of the indicated message **/


    return( in_string(header_table[message_number].subject, pattern) );
}

match_in_message(pattern)
char *pattern;
{
    /** Match a string INSIDE a message...starting at the current
        message read each line and try to find the pattern.  As
        soon as we do, set current and leave!
        Returns 1 if found, 0 if not
    **/

    char buffer[LONG_STRING];
    int  message_number;
    long location;

    dprint1("match_in_message(pattern='%s')\n", pattern);

    location = header_table[current-1].offset;
    message_number = current-1;

    if (fseek(mailfile, location, 0) != 0) {

      dprint2("\tfseek(mailfile, %ld, 0) failed with error %d\n",
           location, errno);

      error1("msg [match] failed looking %ld bytes into file",
         location);
      return(1);    /* fake it out to avoid replacing error message */
    }

    error("searching for pattern...");

    while (fgets(buffer, LONG_STRING, mailfile) != NULL) {

      if (in_string(buffer, pattern)) {
        current = message_number;
        clear_error();
        return(1);
      }

      location += strlen(buffer);

      if (location > header_table[message_number].offset)
        message_number++;
    }

    return(0);
}
END-OF-FILE

size=`wc -c < src/pattern.c`

if [ $size != 2675 ]
then
  echo Warning: src/pattern.c changed - should be 2675 bytes, not $size bytes
fi

chmod 644 src/pattern.c

# ---------- file src/quit.c ----------


if [ -f src/quit.c ]
then
  echo File 'src/quit.c' already exists\!
  exit 1
fi

echo extracting file src/quit.c...
cat << 'END-OF-FILE' > src/quit.c
/**        quit.c        **/

/** quit: leave the current mailbox and quit the program.

    (C) Copyright 1985, Dave Taylor
**/

#ifndef TRUE
#define TRUE    1
#endif

quit()
{
    /* a wonderfully short routine!! */

    leave_mbox();

    leave();
}

resync()
{
    /* leave the current mailbox and read it in again.  This
       is used as needed to allow editing of messages and so
       on... */

    leave_mbox();

    error("reading mailfile in again...");

    newmbox(2, TRUE);
    showscreen();
}
END-OF-FILE

size=`wc -c < src/quit.c`

if [ $size != 466 ]
then
  echo Warning: src/quit.c changed - should be 466 bytes, not $size bytes
fi

chmod 644 src/quit.c

# ---------- file src/read_rc.c ----------


if [ -f src/read_rc.c ]
then
  echo File 'src/read_rc.c' already exists\!
  exit 1
fi

echo extracting file src/read_rc.c...
cat << 'END-OF-FILE' > src/read_rc.c
/**            read_rc.c            **/

/** (C) Copyright 1985, Dave Taylor            **/

/** This file contains programs to allow the user to have a .msgrc file
    in their home directory containing any of the following:

    fullname= <username string>
    maildir = <directory>
    mailbox = <file>
    editor  = <editor>
    savemail= <savefile>
    shell   = <shell>
    print   = <print command>
    weedout = <list of headers to weed out>
    prefix  = <copied message prefix string>

    alternatives = <list of addresses that forward to us>

    and/or the logical arguments:

    autocopy [on|off]
    copy     [on|off]
    resolve  [on|off]
    weed     [on|off]
    noheader [on|off]
    titles   [on|off]
    editout  [on|off]
    savebyname [on|off]
    movepage [on|off]

    Lines starting with '#' are considered comments and are not checked
    any further!

    Modified 10/85 to know about "Environment" variables..
    Modified 12/85 for the 'prefix' option
    Modified  2/86 for the "movepage" flag
**/

#include <stdio.h>
#include <ctype.h>

#ifdef BSD
#undef tolower
#endif

#include "headers.h"

char *shift_lower(), *strtok(), *getenv();

#define NOTWEEDOUT    0
#define WEEDOUT        1
#define ALTERNATIVES    2

read_rc_file()
{
    /** this routine does all the actual work of reading in the
        .rc file... **/

    FILE *file;
    char buffer[SLEN], filename[SLEN];
    char word1[SLEN], word2[SLEN];
    int  errors = 0, last = NOTWEEDOUT;

    dprint0("read_rc_file()\n");

    sprintf(filename,"%s/%s", home, msgrcfile);

    default_weedlist();

    alternative_addresses = NULL;     /* none yet! */

    if ((file = fopen(filename, "r")) == NULL)
      return;    /* we're done! */

    while (fgets(buffer, SLEN, file) != NULL) {
      no_ret(buffer);         /* remove return */
      if (buffer[0] == '#') {     /* comment       */
        last = NOTWEEDOUT;
        continue;
      }
      if (strlen(buffer) < 2) {    /* empty line    */
        last = NOTWEEDOUT;
        continue;
      }

      breakup(buffer, word1, word2);

      strcpy(word1, shift_lower(word1));    /* to lower case */

      if (word2[0] == 0 && (last != WEEDOUT || last != ALTERNATIVES)) {
        fprintf(stderr, "Malformed line from .msgrc file: %s\n", buffer);
        errors++;
        continue;
      }

      if (equal(word1,"maildir") || equal(word1,"folders")) {
        expand_env(folders, word2);
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "fullname") || equal(word1,"username") ||
           equal(word1, "name")) {
        strcpy(full_username, word2);
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "prefix")) {
        strcpy(prefixchars, word2);
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "shell")) {
        expand_env(shell, word2);
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "mailbox")) {
        expand_env(mailbox, word2);
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "editor") || equal(word1,"mailedit")) {
        expand_env(editor, word2);
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "savemail") || equal(word1, "saveto")) {
        expand_env(savefile, word2);
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "print") || equal(word1, "printmail")) {
        expand_env(printout, word2);
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "autocopy")) {
        auto_copy = equal(shift_lower(word2), "on");
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "copy") || equal(word1, "auto_cc")) {
        auto_cc = equal(shift_lower(word2), "on");
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "resolve")) {
        resolve_mode = equal(shift_lower(word2), "on");
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "weed")) {
        filter = equal(shift_lower(word2), "on");
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "noheader")) {
        noheader = equal(shift_lower(word2), "on");
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "titles")) {
        title_messages = equal(shift_lower(word2), "on");
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "editout")) {
        edit_outbound = equal(shift_lower(word2), "on");
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "savebyname") || equal(word1, "savename")) {
        save_by_name = equal(shift_lower(word2), "on");
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "movepage") || equal(word1, "page") ||
           equal(word1, "movewhenpaged")) {
        move_when_paged = equal(shift_lower(word2), "on");
        last = NOTWEEDOUT;
      }
      else if (equal(word1, "weedout")) {
        weedout(word2);
        last = WEEDOUT;
      }
      else if (equal(word1, "alternatives")) {
        alternatives(word2);
        last = ALTERNATIVES;
      }
      else if (last == WEEDOUT)    /* could be multiple line weedout */
        weedout(buffer);
      else if (last == ALTERNATIVES)    /* multi-line addresses   */
        alternatives(buffer);
      else {
        fprintf(stderr, "Unknown line from .rc file: %s\n", buffer);
        errors++;
      }
    }

    if (errors) {
      fprintf(stderr,"Msg quit from errors in .msgrc file\n");
      exit(errors);
    }
}

weedout(string)
char *string;
{
    /** This routine is called with a list of headers to weed out.   **/

    register int i;
    char *strptr, *header;

    dprint1("weedout(string='%s')\n", string);

    strptr = (char *) string;

    while ((header = strtok(strptr, "\t ,\"'")) != NULL) {
      if (weedcount == MAX_IN_WEEDLIST)
        exit(fprintf(stderr, "Read in too many weed headers.  Max is %d\n",
           MAX_IN_WEEDLIST-1));
      if (strlen(header) > 0)
        if (strlen(header) > NLEN)
          fprintf(stderr, "Bad weed header: %s.  Too Long - Len is < %d!\n",
                 header, NLEN);
        else {
          for (i=0; i < strlen(header); i++)
            if (header[i] == '_') header[i] = ' ';
          strncpy(weedlist[weedcount++], header, NLEN);
        }
      strptr = (char *) NULL;
    }
}

alternatives(string)
char *string;
{
    /** This routine is called with a list of alternative addresses
        that you may receive mail from (forwarded) **/

    char *strptr, *address;
    struct addr_rec *current_record, *previous_record;

    dprint1("alternatives(string='%s')\n", string);

    previous_record = NULL;

    strptr = (char *) string;

    while ((address = strtok(strptr, "\t ,\"'")) != NULL) {
      if (previous_record == NULL) {
        previous_record = (struct addr_rec *)
                   malloc(sizeof *alternative_addresses);

        strcpy(previous_record->address, address);
        previous_record->next = NULL;
        alternative_addresses = previous_record;
      }
      else {
        current_record = (struct addr_rec *)
                   malloc(sizeof *alternative_addresses);

        strcpy(current_record->address, address);
        current_record->next = NULL;
        previous_record->next = current_record;
        previous_record = current_record;
      }
      strptr = (char *) NULL;
    }
}

default_weedlist()
{
    /** install the default headers to weed out! **/

    dprint0("default_weedlist()\n");

    weedcount = 0;

    strncpy(weedlist[weedcount++], ">From", NLEN);
    strncpy(weedlist[weedcount++], "In-Reply-To", NLEN);
    strncpy(weedlist[weedcount++], "References", NLEN);
    strncpy(weedlist[weedcount++], "Newsgroups", NLEN);
    strncpy(weedlist[weedcount++], "Received", NLEN);
    strncpy(weedlist[weedcount++], "Apparently-To:", NLEN);
    strncpy(weedlist[weedcount++], "Message-Id:", NLEN);
}

int
matches_weedlist(buffer)
char *buffer;
{
    /** returns true iff the first 'n' characters of 'buffer'
        match an entry of the weedlist **/

    register int i;

    dprint1("matches_weedlist(buffer='%s')\n", buffer);

    for (i=0;i < weedcount; i++)
      if (strncmp(buffer, weedlist[i], strlen(weedlist[i])) == 0)
        return(1);

    return(0);
}

breakup(buffer, word1, word2)
char *buffer, *word1, *word2;
{
    /** This routine breaks buffer down into word1, word2 where
        word1 is alpha characters only, and there is an equal
        sign delimiting the two...
        alpha = beta
        For lines with more than one 'rhs', word2 is set to the
        entire string...
    **/

    register int i;

    for (i=0;i<strlen(buffer) && isalpha(buffer[i]); i++)
      word1[i] = buffer[i];

    word1[i++] = '\0';    /* that's the first word! */

    /** spaces before equal sign? **/

    while (buffer[i] == ' ' || buffer[i] == '\t') i++;

    if (buffer[i] == '=') i++;

    /** spaces after equal sign? **/

    while (buffer[i] == ' ' || buffer[i] == '\t') i++;

    if (i < strlen(buffer))
      strcpy(word2, (char *) (buffer + i));
    else
      word2[0] = '\0';
}

expand_env(dest, buffer)
char *dest, *buffer;
{
    /** expand possible metacharacters in buffer and then copy
        to dest...
        This routine knows about "~" being the home directory,
        and "$xxx" being an environment variable.
    **/

    char  *word, *string, next_word[SLEN];

    if (buffer[0] == '/') {
      dest[0] = '/';
      dest[1] = '\0';
    }
    else
      dest[0] = '\0';
    string = (char *) buffer;

    while ((word = strtok(string, "/")) != NULL) {
      if (word[0] == '$') {
        strcpy(next_word, getenv((char *) (word + 1)));
        if (strlen(next_word) == 0)
          leave(printf("\n\rCan't expand environment variable '%s'\n\r",
            word));
      }
      else if (word[0] == '~' && word[1] == '\0')
        strcpy(next_word, home);
      else
        strcpy(next_word, word);

      sprintf(dest, "%s%s%s", dest, (strlen(dest) > 0? "/":""),
                  next_word);

      string = (char *) NULL;
    }
}
END-OF-FILE

size=`wc -c < src/read_rc.c`

if [ $size != 9083 ]
then
  echo Warning: src/read_rc.c changed - should be 9083 bytes, not $size bytes
fi

chmod 644 src/read_rc.c

# ---------- file src/reply.c ----------


if [ -f src/reply.c ]
then
  echo File 'src/reply.c' already exists\!
  exit 1
fi

echo extracting file src/reply.c...
cat << 'END-OF-FILE' > src/reply.c
/**        reply.c        **/

/*** routine allows replying to the sender of the current message

     (C) Copyright 1985, Dave Taylor
***/

#include "headers.h"
#ifndef BSD
#  include <sys/utsname.h>
#endif

/** Note that this routine generates automatic header information
    for the subject and (obviously) to lines, but that these can
    be altered while in the editor composing the reply message!
**/

char *strip_parens(), *get_token(), *notes_machine();

int
reply()
{
    /** Reply to the current message.  Returns non-zero iff
        the screen has to be rewritten. **/

    char return_address[LONG_SLEN], subject[SLEN];
    int  return_value;

    dprint0("reply()\n");

    get_return(return_address);

    if (header_table[current-1].subject[0] != '\0') {
      if ((strncmp("Re:", header_table[current-1].subject, 3) == 0) ||
          (strncmp("RE:", header_table[current-1].subject, 3) == 0) ||
          (strncmp("re:", header_table[current-1].subject, 3) == 0))
        strcpy(subject, header_table[current-1].subject);
      else {
        strcpy(subject,"Re: ");
        strcat(subject,header_table[current-1].subject);
      }
      return_value = send(return_address, subject, TRUE);
    }
    else
      return_value = send(return_address, "Re: your mail", TRUE);

    return(return_value);
}

int
reply_to_everyone()
{
    /** Reply to everyone who received the current message.
        This includes other people in the 'To:' line and people
        in the 'Cc:' line too.  Returns non-zero iff the screen
            has to be rewritten. **/

    char return_address[LONG_SLEN], subject[SLEN];
    char full_address[VERY_LONG_STRING];
    int  return_value;

    dprint0("reply_to_everyone()\n");

    get_return(return_address);

    strcpy(full_address, return_address);    /* sender gets copy */

    get_and_expand_everyone(return_address, full_address);

    if (header_table[current-1].subject[0] != '\0') {
      if ((strncmp("Re:", header_table[current-1].subject, 3) == 0) ||
          (strncmp("RE:", header_table[current-1].subject, 3) == 0) ||
          (strncmp("re:", header_table[current-1].subject, 3) == 0))
        strcpy(subject, header_table[current-1].subject);
      else {
        strcpy(subject,"Re: ");
        strcat(subject,header_table[current-1].subject);
      }
      return_value = send(full_address, subject, TRUE);
    }
    else
      return_value = send(full_address, "Re: your mail", TRUE);

    return(return_value);

}

int
forward()
{
    /** Forward the current message.  What this actually does is
        to set auto_copy to true, then call 'send' to get the
        address and route the mail.
    **/

    char subject[SLEN], address[VERY_LONG_STRING];
    int  original_cc, results, edit_msg;

    dprint0("forward()\n");

    original_cc = auto_copy;
    address[0] = '\0';

    edit_msg = (want_to("Edit outgoing message (y/n) ? ",'y',FALSE) != 'n');
    printf("%s", edit_msg? "Yes" : "No");

    auto_cc = TRUE;            /* we want a copy */

    if (strlen(header_table[current-1].subject) > 0) {
      strcpy(subject,header_table[current-1].subject);
      results = send(address, subject, edit_msg);
    }
    else
      results = send(address, "Forwarded Mail...", edit_msg);

    auto_copy = original_cc;

    return(results);
}

get_and_expand_everyone(return_address, full_address)
char *return_address, *full_address;
{
    /** Read the current message, extracting addresses from the 'To:'
        and 'Cc:' lines.   As each address is taken, ensure that it
        isn't to the author of the message NOR to us.  If neither,
        prepend with current return address and append to the
        'full_address' string.
    **/

    char ret_address[LONG_SLEN], buf[LONG_SLEN], new_address[LONG_SLEN];
    char *bufptr, *address;
    int  in_message = 1, first_pass = 0;

    dprint1("get_and_expand_everyone(return_address='%s', <buffer>)\n",
         return_address);

    /** First off, get to the first line of the message desired **/

    if (fseek(mailfile, header_table[current-1].offset, 0) == -1) {
    error1("msg [seek] couldn't read %d bytes into file",
           header_table[current-1].offset);
    return;
    }

    /** okay!  Now we're there!  **/

    /** let's fix the ret_address to reflect the return address of this
    message with '%s' instead of the persons login name... **/

    translate_return(return_address, ret_address);

    /** now let's parse the actual message! **/

    while (in_message) {
      in_message = (int) (fgets(buf, LONG_SLEN, mailfile) != NULL);
      if (first_word(buf, "From ") && first_pass++ != 0)
    in_message = FALSE;
      else if (first_word(buf, "To:") || first_word(buf, "Cc:") ||
           first_word(buf, "CC:") || first_word(buf, "cc:")) {
    do {
      no_ret(buf);

      bufptr = (char *) (strip_parens(buf) + 3); /* 3 = strlen of prompt */

      while ((address = get_token(bufptr, "\t, ", 0)) != NULL) {
        if (okay_address(address, return_address)) {
          sprintf(new_address, ret_address, address);
          optimize_and_add(new_address, full_address);
        }
        bufptr = NULL;
      }

          in_message = (int) (fgets(buf, LONG_SLEN, mailfile) != NULL);

    } while (in_message && whitespace(buf[0]));

      }
      else if (strlen(buf) < 2)    /* done with header */
     in_message = FALSE;
    }
}

int
okay_address(address, return_address)
char *address, *return_address;
{
    /** This routine checks to ensure that the address we just got
        from the "To:" or "Cc:" line isn't us AND isn't the person
        who sent the message.  Returns true iff neither is the case **/

    char our_address[SLEN];
    struct addr_rec  *alternatives;

    if (in_string(address, return_address))
      return(FALSE);

    sprintf(our_address, "%s!%s", hostname, username);

    if (in_string(address, our_address))
      return(FALSE);

    sprintf(our_address, "%s@%s", username, hostname);

    if (in_string(address, our_address))
      return(FALSE);

    alternatives = alternative_addresses;

    while (alternatives != NULL) {
      if (in_string(address, alternatives->address))
        return(FALSE);
      alternatives = alternatives->next;
    }

    return(TRUE);
}

optimize_and_add(new_address, full_address)
char *new_address, *full_address;
{
    /** This routine will add the new address to the list of addresses
        in the full address buffer IFF it doesn't already occur.  It
        will also try to fix dumb hops if possible, specifically hops
        of the form ...a!b...!a... and hops of the form a@b@b etc
    **/

    register int len, host_count = 0, i;
    char     hosts[MAX_HOPS][SLEN];    /* array of machine names */
    char     *host, *addrptr;

    if (in_string(full_address, new_address))
      return(1);    /* duplicate address */

    /** optimize **/
    /*  break down into a list of machine names, checking as we go along */

    addrptr = (char *) new_address;

    while ((host = get_token(addrptr, "!", 1)) != NULL) {
      for (i = 0; i < host_count && ! equal(hosts[i], host); i++)
          ;

      if (i == host_count) {
        strcpy(hosts[host_count++], host);
        if (host_count == MAX_HOPS) {
           error("Can't build return address - hit MAX_HOPS limit!");
           return(1);
        }
      }
      else
        host_count = i + 1;
      addrptr = NULL;
    }

    /** fix the ARPA addresses, if needed **/

    if (chloc(hosts[host_count-1], '@') > -1)
      fix_arpa_address(hosts[host_count-1]);

    /** rebuild the address.. **/

    new_address[0] = '\0';

    for (i = 0; i < host_count; i++)
      sprintf(new_address, "%s%s%s", new_address,
              new_address[0] == '\0'? "" : "!",
              hosts[i]);

    dprint1("\tgenerated address '%s'\n", new_address);

    if (full_address[0] == '\0')
      strcpy(full_address, new_address);
    else {
      len = strlen(full_address);
      full_address[len  ] = ',';
      full_address[len+1] = ' ';
      full_address[len+2] = '\0';
      strcat(full_address, new_address);
    }

    return(0);
}

get_return_name(address, name)
char *address, *name;
{
    /** Given the address (either a single address or a combined list
        of addresses) extract the login name of the first person on
        the list and return it as 'name'.  Modified to stop at
        any non-alphanumeric character. **/

    /** An important note to remember is that it isn't vital that this
        always returns just the login name, but rather that it always
        returns the SAME name.  If the persons' login happens to be,
        for example, joe.richards, then it's arguable if the name
        should be joe, or the full login.  It's really immaterial, as
        indicated before, so long as we ALWAYS return the same name! **/

    /** Another note: modified to return the argument as all lowercase
        always... **/

    char single_address[LONG_SLEN];
    register int i, loc, index = 0;

    /* first step - copy address up to a comma, space, or EOLN */

    for (i=0; address[i] != ',' && ! whitespace(address[i]) &&
         address[i] != '\0'; i++)
      single_address[i] = address[i];
    single_address[i] = '\0';

    /* Now is it an ARPA address?? */

    if ((loc = chloc(single_address, '@')) != -1) {      /* Yes */

      /* At this point the algorithm is to keep shifting our copy
         window left until we hit a '!'.  The login name is then
             located between the '!' and the first metacharacter to
         it's right (ie '%', ':' or '@'). */

      for (i=loc; single_address[i] != '!' && i > -1; i--)
          if (single_address[i] == '%' ||
              single_address[i] == ':' ||
              single_address[i] == '.' ||    /* no domains */
          single_address[i] == '@') loc = i-1;

      if (single_address[i] == '!') i++;

      for (index = 0; index < loc - i + 1; index++)
        name[index] = tolower(single_address[index+i]);
      name[index] = '\0';
    }
    else {    /* easier - standard USENET address */

      /* This really is easier - we just cruise left from the end of
         the string until we hit either a '!' or the beginning of the
             line.  No sweat. */

      loc = strlen(single_address)-1;     /* last char */

      for (i = loc; single_address[i] != '!' && single_address[i] != '.'
           && i > -1; i--)
         name[index++] = tolower(single_address[i]);
      name[index] = '\0';
      reverse(name);
    }
}
END-OF-FILE

size=`wc -c < src/reply.c`

if [ $size != 9927 ]
then
  echo Warning: src/reply.c changed - should be 9927 bytes, not $size bytes
fi

chmod 644 src/reply.c

# ---------- file src/return_addr.c ----------


if [ -f src/return_addr.c ]
then
  echo File 'src/return_addr.c' already exists\!
  exit 1
fi

echo extracting file src/return_addr.c...
cat << 'END-OF-FILE' > src/return_addr.c
/**            return_addr.c            **/

/** This set of routines is used to generate real return addresses
    and also return addresses suitable for inclusion in a users
    alias files (ie optimized based on the pathalias database).

    These routines (C) Copyright 1986 Dave Taylor
**/

#include "headers.h"

#include <sys/types.h>
#include <sys/stat.h>

char *shift_lower(), *notes_machine(), *expand_address();

optimize_return(address)
char *address;
{
    /** This routine tries to create an optimized address, that is,
        an address that has the minimal information needed to
        route a message to this person given the current path
        database...
    **/

    /** first step is to figure out what sort of address we
        have... **/

    dprint1("\noptimize_return(address='%s')\n", address);

    if (chloc(address, '%') != -1)
      optimize_cmplx_arpa(address);
    else if (chloc(address, '@') != -1)
      optimize_arpa(address);
    else
      optimize_usenet(address);
}

optimize_cmplx_arpa(address)
char *address;
{
    /** Try to optimize a complex ARPA address.  A Complex address is one
        that contains '%' (deferred '@').  For example:
        veeger!hpcnof!hplabs!joe%sytech@syte
        is a complex address (no kidding, right?).  The algorithm for
        trying to resolve it is to move all the way to the right, then
        back up left until the first '!' then from there to the SECOND
        metacharacter on the right is the name@host address...(in this
            example, it would be "joe%sytech").  Check this in the routing
        table.  If not present, keep backing out to the right until we
        find a host that is present, or we hit the '@' sign.  Once we
        have a 'normal' ARPA address, hand it to optimize_arpa().
    **/

    char name[SHORT_SLEN], buffer[SLEN], junk[SLEN];
    char host[SHORT_SLEN], old_host[SHORT_SLEN];
    register int i, loc, nloc = 0, hloc = 0, passes = 1;

    dprint1("optimize_cmplx_arpa(address='%s')\n", address);

    /** first off, get the name%host... **/

    for (loc = strlen(address)-1; address[loc] != '!' && loc > -1; loc--)
       ;

    while (address[loc] != '\0') {

      if (passes == 1) {
        loc++;

        while (address[loc] != '%' && address[loc] != '@')
          name[nloc++] = address[loc++];
      }
      else {
        for (i=0; old_host[i] != '\0'; i++)
          name[nloc++] = old_host[i];
      }

      loc++;

      while (address[loc] != '%' && address[loc] != '@')
        host[hloc++] = address[loc++];

      host[hloc] = name[nloc] = '\0';

      dprint2("\tgot name = %s and host = %s\n", name, host);

      strcpy(old_host, host);
      remove_domains(host);

      sprintf(buffer, "%s@%s", name, shift_lower(host));

      if (expand_site(buffer, junk) == 0) {
        strcpy(address, buffer);
        return;
      }
      else if (address[loc] == '@') {
        optimize_arpa(address);
        return;
      }
      else
        name[nloc++] = '%';    /* for next pass through */

    }
}

optimize_arpa(address)
char *address;
{
    /** Get an arpa address and simplify it to the minimal
        route needed to get mail to this person... **/

    char name[SHORT_SLEN], buffer[SLEN], junk[SLEN];
    char host[SHORT_SLEN];
    register int loc, nloc = 0, hloc = 0, at_sign = 0;

    dprint1("optimize_arpa(address='%s')\n", address);

    for (loc = strlen(address)-1; address[loc] != '!' && loc > -1; loc--) {
      if (address[loc] == '@')
         at_sign++;    /* remember this spot! */
      else if (at_sign)
        name[nloc++] = address[loc];
      else
        host[hloc++] = address[loc];
    }

    name[nloc] = host[hloc] = '\0';

    reverse(name);
    reverse(host);

    remove_domains(host);

    dprint2("\tname = %s and host = %s\n", name, shift_lower(host));

    sprintf(buffer,"%s@%s", name, shift_lower(host));

    if (expand_site(buffer, junk) == 0) {
      strcpy(address, buffer);
      return;
    }

    optimize_usenet(address);    /* that didn't work... */
}

optimize_usenet(address)
char *address;
{
    /** optimize the return address IFF it's a standard usenet
        address...
    **/

    char name[SHORT_SLEN],  new_address[SLEN], buffer[SLEN], junk[SLEN];
    register int loc, nloc = 0, aloc = 0, passes = 1;

    dprint1("\noptimize_usenet(address='%s')\n", address);

    for (loc = strlen(address)-1; address[loc] != '!' && loc > -1; loc--)
      name[nloc++] = address[loc];
    name[nloc] = '\0';

    reverse(name);

    dprint1("\tgot name = %s\n", name);

    new_address[0] = '\0';

    /* got name, now get machine until we can get outta here */

    while (loc > -1) {

      new_address[aloc++] = address[loc--];    /* the '!' char */

      while (address[loc] != '!' && loc > -1)
        new_address[aloc++] = address[loc--];

      new_address[aloc] = '\0';

      strcpy(buffer, new_address);
      reverse(buffer);

      if (expand_site(buffer, junk) == 0) {
        if (passes == 1 && chloc(name, '@') == -1) {
          buffer[strlen(buffer) - 1] = '\0';    /* remove '!' */
          dprint2("\tReturning address %s@%s\n", name, buffer);
          sprintf(address, "%s@%s", name, buffer);
        }
        else {
          dprint2("\tReturning address '%s%s'\n", buffer, name);
          sprintf(address, "%s%s", buffer, name);
        }
        return;        /* success! */
      }
      else
        dprint1("\taddress %s failed!\n", buffer);

      passes++;
    }

    dprint0("\tnothing to do!\n");
    return;        /* nothing to do! */
}

get_return(buffer)
char *buffer;
{
    /** reads 'current' message again, building up the full return
        address including all machines that might have forwarded
        the message.  **/

    char buf[LONG_SLEN], name1[SLEN], name2[SLEN], lastname[SLEN];
    char hold_return[LONG_SLEN], alt_name2[SLEN];
    int ok = 1, lines;

    dprint0("get_return(<buffer>)\n");

    /** are we reading a notesfile file??  **/

    if (notesfile) {
      strcpy(buf, header_table[current-1].from);
      if (chloc(buf, '!') == -1)
        sprintf(buf, "%s!%s", notes_machine(), header_table[current-1].from);
      strcpy(buffer, expand_system(buf, 1));
      dprint1("\treturn address [notes] = %s\n", buffer);
      return;
    }

    /** get to the first line of the message desired **/

    if (fseek(mailfile, header_table[current-1].offset, 0) == -1) {
    error1("msg [seek] couldn't read %d bytes into file",
           header_table[current-1].offset);
    return;
    }

    /** okay!  Now we're there!  **/

    lines = header_table[current-1].lines;

    buffer[0] = '\0';

    while (ok && lines--) {
      ok = (int) (fgets(buf, LONG_SLEN, mailfile) != NULL);
      if (first_word(buf, "From ")) {
    sscanf(buf, "%*s %s", hold_return);
      }
      else if (first_word(buf, ">From")) {
    sscanf(buf,"%*s %s %*s %*s %*s %*s %*s %*s %*s %s %s",
           name1, name2, alt_name2);
    if (strcmp(name2, "from") == 0)
      strcpy(name2, alt_name2);
    add_site(buffer, name2, lastname);
      }

#ifdef USE_EMBEDDED_ADDRESSES

      else if (first_word(buf, "From:")) {
    get_address_from("From:", buf, hold_return);
      }
      else if (first_word(buf, "Reply-To:")) {
    get_address_from("Reply-To:", buf, buffer);
    return;
      }

#endif

      else if (strlen(buf) < 2)    /* done with header */
         lines = 0; /* let's get outta here!  We're done!!! */
     }

    if (buffer[0] == '\0')
      strcpy(buffer, hold_return); /* default address! */
    else
      add_site(buffer, name1, lastname);    /* get the user name too! */

    dprint1("\treturn address = '%s'\n", buffer);

}
END-OF-FILE

size=`wc -c < src/return_addr.c`

if [ $size != 7247 ]
then
  echo Warning: src/return_addr.c changed - should be 7247 bytes, not $size bytes
fi

chmod 644 src/return_addr.c

# ---------- file src/savecopy.c ----------


if [ -f src/savecopy.c ]
then
  echo File 'src/savecopy.c' already exists\!
  exit 1
fi

echo extracting file src/savecopy.c...
cat << 'END-OF-FILE' > src/savecopy.c
/**             savecopy.c            **/

/** Save a copy of the specified message in the users savemail mailbox.

         (C) Copyright 1986, Dave Taylor
**/

#include "headers.h"
#ifdef BSD
#  include <sys/time.h>
#else
#  include <time.h>
#endif

char *format_long(), *get_arpa_date();

extern char reply_to[SLEN];    /* In-Reply-To: string */
extern int gotten_key;        /* for encryption      */

save_copy(subject, to, cc, filename, original_to)
char *subject, *to, *cc, *filename, *original_to;
{
    /** This routine appends a copy of the outgoing message to the
        file specified by the SAVEFILE environment variable.  **/

    FILE *save,        /* file id for file to save to */
         *message;        /* the actual message body     */
    long  thetime;        /* variable holder for time    */
    char  buffer[SLEN],    /* read buffer                */
          savename[SLEN],    /* name of file saving into    */
          newbuffer[SLEN];  /* first name in 'to' line     */
    register int i;        /* for chopping 'to' line up   */
    int   crypted=0;    /* are we encrypting?          */

    dprint5(
"save_copy(subject='%s', to='%s', cc='%s', filename='%s', original-to='%s')\n",
         subject, to, cc, filename, original_to);

    savename[0] = '\0';

    if (save_by_name) {
      get_return_name(to, buffer);
      sprintf(savename, "%s%s%s", folders,
              lastch(folders) == '/'? "" : "/", buffer);
      if (access(savename, ACCESS_EXISTS) == -1)     /* don't create new! */
        savename[0] = '\0';
    }

    if (strlen(savename) == 0) {
      if (strlen(savefile) == 0)
        return(error("variable 'SAVEFILE' not defined!"));
      strcpy(savename, savefile);
      if (save_by_name)
        error2("Not creating file '%s'...saving in %s instead",
             buffer, savename);
    }

    dprint1("\tsaving copy of outbound message to file '%s'\n", savename);

    if ((save = fopen(savename, "a")) == NULL)
      return(error1("couldn't append to %s", savename));

    if ((message = fopen(filename, "r")) == NULL) {
      fclose(save);
      return(error1("save_copy couldn't read file %s!", filename));
    }

    for (i=0; original_to[i] != '\0' && ! whitespace(original_to[i]); i++)
      newbuffer[i] = original_to[i];

    newbuffer[i] = '\0';

    tail_of(newbuffer, buffer, FALSE);

    thetime = time(0);    /* this must be here for it to work! */

    fprintf(save,"\nFrom To:%s %s", buffer, (char *) ctime(&thetime));

    fprintf(save, "Date: %s\n", get_arpa_date());

    fprintf(save,"To: %s\nSubject: %s\n",
        format_long(to,strlen("To: ")), subject);

    if (strlen(cc) > 0)
      fprintf(save,"Cc: %s\n",
          format_long(cc, strlen("Cc:")));

    if (strlen(reply_to) > 0)
      fprintf(save, "In-Reply-To: %s\n", reply_to);

    (void) putc('\n', save);    /* put another return, please! */

    /** now copy over the message... **/

    while (fgets(buffer, SLEN, message) != NULL) {
      if (buffer[0] == '[') {
        if (strncmp(buffer, START_ENCODE, strlen(START_ENCODE))==0)
          crypted = 1;
        else if (strncmp(buffer, END_ENCODE, strlen(END_ENCODE))==0)
          crypted = 0;
        else if (strncmp(buffer, DONT_SAVE, strlen(DONT_SAVE)) == 0) {
          fclose(message);
          fclose(save);
          chown(savename, userid, getgid());
          return(TRUE);
        }
      }
      else if (crypted) {
        if (! gotten_key++)
          getkey(ON);
        encode(buffer);
      }
      fputs(buffer, save);
    }

    dprint0("\tclosing the files...\n");

    fclose(message);
    fclose(save);

    /* make sure save file isn't owned by root! */
    chown(savename, userid, getgid());

    return(TRUE);
}
END-OF-FILE

size=`wc -c < src/savecopy.c`

if [ $size != 3441 ]
then
  echo Warning: src/savecopy.c changed - should be 3441 bytes, not $size bytes
fi

chmod 644 src/savecopy.c

# ---------- file src/screen.c ----------


if [ -f src/screen.c ]
then
  echo File 'src/screen.c' already exists\!
  exit 1
fi

echo extracting file src/screen.c...
cat << 'END-OF-FILE' > src/screen.c
/**        screen.c        **/

/**  screen display routines for MSG program

     (C) Copyright 1985, Dave Taylor
**/

#include "headers.h"

static   int  last_current     = -1;

showscreen()
{
    char buffer[SLEN];

    dprint0("showscreen()\n");

    ClearScreen();

    if (notesfile)
      sprintf(buffer, "Notes from '%s' (%d note%s) [Version %s]",
            infile, message_count,
        plural(message_count), VERSION);
    else
      sprintf(buffer, "Mailbox is '%s' with %d message%s [Version %s]",
            infile, message_count,
        plural(message_count), VERSION);
    Centerline(1, buffer);

    last_header_page = -1;         /* force a redraw regardless */
    show_headers();

    if (mini_menu)
      show_menu();

    show_last_error();

    if (hp_terminal)
      define_softkeys(MAIN);
}

show_menu()
{
    /** write main system menu... **/

    Centerline(LINES-7,
  "|=pipe, !=shell, ?=help, <n>=set current to n, /=search pattern");
        Centerline(LINES-6,
  "A)lias, C)hange mailbox, D)elete, F)orward, G)roup reply, M)ail,");
    Centerline(LINES-5,
   "N)ext, P)rint, R)eply, S)ave to file, Q)uit, U)ndelete, or eX)it");
}

int
show_headers()
{
    /** display page of headers (10) if present.  First check to
        ensure that header_page is in bounds, fixing silently if not.
        If out of bounds, return zero, else return non-zero **/

    register int first = 0, line = 4, last = 0, last_line;
    char newfrom[SLEN], buffer[SLEN];

    dprint0("show_headers()\n");

    if (fix_header_page())
      return(FALSE);

    if (header_page == last_header_page)     /* nothing to do! */
      return(FALSE);

    /** compute last header to display **/

    first= header_page * headers_per_page;

    last = first + (headers_per_page - 1);

    if (last >= message_count) last = message_count-1;

    dprint2("\tdisplaying headers %d thru %d\n", first, last);

    /** okay, now let's show the header page! **/

    while (first <= last) {
      tail_of(header_table[first].from, newfrom, TRUE);
      build_header_line(buffer, &header_table[first], first+1, newfrom);
      PutLine(line,COLUMNS-80,"%s", buffer);    /* avoid '%' probs */
      CleartoEOLN();
      first++;
      line++;    /* for clearing up in a sec... */
    }

    /* clear up the rest of the screen! */

    if (mini_menu)
      last_line = LINES-8;
    else
      last_line = LINES-3;

    while (line < last_line) {
      MoveCursor(line,0);
      CleartoEOLN();
      line++;
    }

    display_central_message();

    last_current = current;
    last_header_page = header_page;

    return(TRUE);
}

show_current()
{
    /** display page of headers (10) if present.  First check to
        ensure that header_page is in bounds, fixing silently if not.
        Note that this will ensure that 'current' is always set to
        the top message on the screen if we go to a new screen! **/

    register int first = 0, last = 0, line = 4, changed;

    dprint0("show_current()\n");

    changed = fix_header_page();

    /** compute last header to display **/

    first = header_page * headers_per_page;
    last  = first + (headers_per_page - 1);

    if (last > message_count)
      last = message_count;

    /** okay, now let's show the pointers... **/

    /** have we changed??? **/

    if (current == last_current) {
      dprint0("\tno change.  at same message!\n");
      return;
    }

    /** first condition - current on this page & last too */

    if (last_current >= first && last_current <= last+1) {
      dprint2("\tMoving arrow from %d to (current) %d\n",
               last_current, current);
      PutLine(((last_current-1) % headers_per_page) + 4, COLUMNS-76,"  ");
      PutLine(((current-1) % headers_per_page) + 4, COLUMNS-76,"<-");
    }

    /** second condition - current on this page **/
    else if (! changed) {
      dprint1("\tMoving arrow to (current) %d\n", current);
      PutLine(((current-1) % headers_per_page) + 4, COLUMNS-76,"<-");
    }

    /** third condition - page changed!        **/
    else {
          dprint2("\tdisplaying from message %d to %d\n", first, last);

      while (first <= last) {
        if (current-1 == first)   PutLine(line++,COLUMNS-76,"<-");
         else                PutLine(line++,COLUMNS-76,"  ");
        first++;
      }
    }
    last_current = current;
}

build_header_line(buffer, entry, number, from)
char *buffer;
struct header_rec *entry;
int number;
char *from;
{
    /** Build in buffer the message header ... entry is the current
        message entry, number is the numerical ID of the message,
        and 'from' is a modified (displayable) from line... **/

    /** Note: using 'strncpy' allows us to output as much of the
        subject line as possible given the dimensions of the screen.
        The key is that 'strncpy' returns a 'char *' to the string
        that it is handing to the dummy variable!  Neat, eh? **/

    char subj[LONG_SLEN];        /* to output subject */

    strncpy(subj, entry->subject, COLUMNS-34);

    subj[COLUMNS-34] = '\0';    /* insurance, eh? */

    sprintf(buffer, "%c%3d%s %c %3.3s %-2d %-18.18s  %s",
            (entry->priority? 'U' : new_msg(entry)? 'N' : ' '),
        number, (number == current? "<-" : "  "),
        (entry->delete? '*' : ' '),
            entry->month, atoi(entry->day), from, subj);
}

int
fix_header_page()
{
    /** this routine will check and ensure that the current header
        page being displayed contains messages!  It will silently
        fix 'header-page' if wrong.  Returns TRUE if changed.  **/

    int last_page, old_header;

    dprint1("fix_header_page() [%d messages total]\n", message_count);

    old_header = header_page;

    last_page = (int) ((message_count-1) / headers_per_page);

    dprint2("\tThere are 0 to %d pages in file [%d per page]\n",
        last_page, headers_per_page);

    if (header_page > last_page)
      header_page = last_page;
    else if (header_page < 0)
          header_page = 0;

    return(old_header != header_page);
}
END-OF-FILE

size=`wc -c < src/screen.c`

if [ $size != 5636 ]
then
  echo Warning: src/screen.c changed - should be 5636 bytes, not $size bytes
fi

chmod 644 src/screen.c

# ---------- file src/showmsg.c ----------


if [ -f src/showmsg.c ]
then
  echo File 'src/showmsg.c' already exists\!
  exit 1
fi

echo extracting file src/showmsg.c...
cat << 'END-OF-FILE' > src/showmsg.c
/**         showmsg.c        **/

/** This file contains all the routines needed to display the specified
    message.

   These routines (C) Copyright 1986 Dave Taylor
**/


#include "headers.h"
#include <ctype.h>

#ifdef BSD
#undef tolower
#endif

int
show_msg(number)
int number;
{
    /*** display number'th message.  Get starting and ending lines
         of message from headers data structure, then fly through
         the file, displaying only those lines that are between the
         two!
         Returns non-zero if message shown!
    ***/

    dprint1("show_msg(number=%d)\n", number);

    if (number > message_count) {
      error1("Only %d messages!", message_count);
      return(0);
    }
    else if (number < 1) {
      error("you can't read THAT message!");
      return(0);
    }

    return(show_message(header_table[number-1].lines,
           header_table[number-1].offset,number));
}

int
show_message(lines, file_loc, msgnumber)
int lines, msgnumber;
long file_loc;
{
    /*** Show the indicated range of lines from mailfile
         for message 'msgnumber' by using 'display'
             Returns non-zero if it actually put something on
         the screen.
    ***/

    dprint3("show_message(lines=%d, loc=%ld, msg-number=%d)\n",
            lines, file_loc, msgnumber);

    if (fseek(mailfile, file_loc, 0) != 0) {
      error1("msg [seek] failed looking %d bytes into file",
          file_loc);
      return(FALSE);
    }

    /* next read will get 'this' line so must be at end of previous */

    Raw(OFF);
    display(lines, msgnumber);
    Raw(ON);

    return(TRUE);    /* we did it boss! */
}


/** these two variables are used iff the variable 'title_message' is
    set, and are buffers for output of message title... **/

static char top_of_screen_left [LONG_STRING],
             top_of_screen_right[LONG_STRING];

display(lines, msgnum)
int lines, msgnum;
{
    /** Display specified number of lines from file mailfile.
        Note: This routine MUST be placed at the first line
        of the input file! **/

    char buffer[LONG_STRING], *full_month();

    int lines_on_screen = 0;        /* display */
    int crypted = 0, gotten_key = 0;    /* encryption */
    int weed_header, weeding_out = 0;    /* weeding */

    dprint2("display(lines=%d, msgnum=%d)\n", lines, msgnum);

    if (title_messages) {
      tail_of(header_table[msgnum-1].from, buffer, FALSE);
      sprintf(top_of_screen_left, "%s #%d %s %s",
           notesfile? "Note" : "Message", msgnum,
           (strncmp(header_table[msgnum-1].from, "To:", 3) == 0?
            "to": "from"), buffer);
      sprintf(top_of_screen_right," %s %s %s, %d at %s",
          notesfile? "Posted" : "Mailed",
               full_month(header_table[msgnum-1].month),
          header_table[msgnum-1].day,
              atoi(header_table[msgnum-1].year) + 1900,
              header_table[msgnum-1].time);

      dprint1("\ttos_left: '%s'\n", top_of_screen_left);
      dprint1("\ttos_right: '%s'\n", top_of_screen_right);
    }

    weed_header = filter;    /* allow us to change it after header */

    ClearScreen();

    if (cursor_control) transmit_functions(OFF);

    while (lines > 0) {

        if (fgets(buffer, LONG_STRING, mailfile) == NULL) {
          PutLine(LINES-1, 0, "Please press <space> to return: ");
          (void) ReadCh();
          if (cursor_control) transmit_functions(ON);
          return(TRUE);
        }

        if (strlen(buffer) > 0)
              no_ret(buffer);

        if (strlen(buffer) == 0) {
          weed_header = 0;        /* past header! */
          weeding_out = 0;
        }

        lines--;

        if (notesfile) {    /* treat notes differently! */

          if (filter && (first_word(buffer, NOTES_HEADER) ||
              first_word(buffer, NOTES_FOOTER)) )
            /*** weed this line out of the display! ***/;
          else if (show_line(buffer, &lines_on_screen, &lines)) {
              if (cursor_control) transmit_functions(ON);
              return(TRUE);
          }
        }

        else { /* "normal" message */

          if (weed_header && matches_weedlist(buffer))
            weeding_out = 1;     /* aha!  We don't want to see this! */
          else if (buffer[0] == '[') {
            if (strcmp(buffer, START_ENCODE)==0)
          crypted++;
            else if (strcmp(buffer, END_ENCODE)==0)
              crypted--;
            else if (crypted) {
                  encode(buffer);
              if (show_line(buffer, &lines_on_screen, &lines)) {
                if (cursor_control) transmit_functions(ON);
                return(TRUE);
              }
            }
            else
              if (show_line(buffer, &lines_on_screen, &lines)) {
                if (cursor_control) transmit_functions(ON);
                return(TRUE);
              }
          }
          else if (crypted) {
            if (! gotten_key++) getkey(OFF);
            encode(buffer);
            if (show_line(buffer, &lines_on_screen, &lines)) {
              if (cursor_control) transmit_functions(ON);
              return(TRUE);
            }
          }
          else if (weeding_out) {
            weeding_out = (whitespace(buffer[0]));    /* 'n' line weed */
            if (! weeding_out)     /* just turned on! */
              if (show_line(buffer, &lines_on_screen, &lines)) {
                if (cursor_control) transmit_functions(ON);
                return(TRUE);
              }
          }
          else
            if (show_line(buffer, &lines_on_screen, &lines)) {
              if (cursor_control) transmit_functions(ON);
              return(TRUE);
            }
        }
      }


    PutLine(LINES-1, 0, "Please press <space> to return: ");
    Raw(ON);
    (void) ReadCh();
        if (cursor_control) transmit_functions(ON);
    return(TRUE);
}

int
show_line(buffer, lines_on_screen, total)
char *buffer;
int  *lines_on_screen, *total;
{
    /** Displays the given line if it can.  if not, it will put the
        'ole 'space to continue' prompt on the bottom of the screen
        and wait for either a 'space' or 'return'.  If 'return' is
        hit (or 'q'), then it will return non-zero, otherwise it'll
        return zero.
    **/

    static char overlap [LONG_SLEN];
           char mybuffer[SLEN], ch;
           int  last_line_loc;

    dprint3("show_line(buffer=%s, on-screen=%d, total=%d)\n",
         buffer, *lines_on_screen, *total);

    last_line_loc     = *lines_on_screen;    /* one back... */

    *lines_on_screen += ((strlen(buffer) / COLUMNS) + 1);

    if (last_line_loc == 0 && title_messages) {
      display_title(*total);
      last_line_loc = 2;
      *lines_on_screen += 2;
    }


    if (*lines_on_screen > LINES-2) {
      if (*total > 0) {
        sprintf(mybuffer, "%d line%s left", *total, plural(*total));
        PutLine(LINES-1, COLUMNS-20, "%s", mybuffer);
        PutLine(LINES-1, 0, "Press <space> to continue: ");
      }
      else
        PutLine(LINES-1, 0, "Please press <space> to return: ");
      Raw(ON);
      ch = ReadCh();
      if (ch == '\n' || ch == '\r' || tolower(ch) == 'q')
        return(TRUE);
      if (ch == ' ' && *total == 0)    /* don't want '0' lines left */
        return(TRUE);
      Raw(OFF);
      ClearScreen();
      *lines_on_screen = 0;

      if (title_messages) {
        display_title(*total);
        *lines_on_screen = 2;
      }

      PutLine(*lines_on_screen, 0, "%s", overlap);
      *lines_on_screen  += ((strlen(overlap) / COLUMNS) + 1);
      last_line_loc = *lines_on_screen;
      *lines_on_screen += ((strlen(buffer) / COLUMNS) + 1);
    }

    PutLine(last_line_loc, 0, "%s", buffer);

    if (*lines_on_screen > LINES-6)        /* in case next is too LONG */
      strcpy(overlap, buffer);

    return(FALSE);
}

display_title(lines_into_message)
int lines_into_message;
{
    /** Display top title, including "Page N" **/

    register int page;

    dprint1("displaytitle(lines-into-message=%d)\n", lines_into_message);

    page = (int) (lines_into_message) / (LINES - 4);

    PutLine(0,0,top_of_screen_left);

    PutLine(0, COLUMNS-strlen(top_of_screen_right),
            top_of_screen_right, page);
}
END-OF-FILE

size=`wc -c < src/showmsg.c`

if [ $size != 7604 ]
then
  echo Warning: src/showmsg.c changed - should be 7604 bytes, not $size bytes
fi

chmod 644 src/showmsg.c

# ---------- file src/softkeys.c ----------


if [ -f src/softkeys.c ]
then
  echo File 'src/softkeys.c' already exists\!
  exit 1
fi

echo extracting file src/softkeys.c...
cat << 'END-OF-FILE' > src/softkeys.c
/**            softkeys.c            **/

/** This file and associated routines: (C) Copyright 1986, Dave Taylor **/

#include <stdio.h>
#include "headers.h"

define_softkeys(level)
int level;
{
    dprint0("define_softkeys(level=");

    if (! hp_softkeys) {
      dprint0("0) [error: no softkeys!]\n");
      return;
    }

    if (level == MAIN) {
      dprint0("MAIN)\n");
      if (notesfile) {
        define_key(f1, "  Show    Note",   "\r");
        define_key(f2, "  Reply  to Note",  "r");
        define_key(f3, " Change  Mailbox", "c");
        define_key(f4, "  Save    Note",   "s");
        define_key(f5, " Delete/Undelete", "^");
        define_key(f6, " Print    Note",   "p");
        define_key(f7, "  HELP",           "?");
        define_key(f8, "  Quit     Msg",   "q");
      }
      else {
        define_key(f1, "  Show     Msg",   "\r");
        define_key(f2, "  Mail     Msg",   "m");
        define_key(f3, "  Reply  to Msg",  "r");
        define_key(f4, " Change  Mailbox", "c");
        define_key(f5, "  Save     Msg",   "s");
        define_key(f6, " Delete/Undelete", "^");
        define_key(f7, " Print     Msg",   "p");
        define_key(f8, "  Quit     Msg",   "q");
      }
    }
    else if (level == ALIAS) {
      dprint0("ALIAS)\n");
      define_key(f1, " Alias  Current",  "a");
      define_key(f2, " Check   Alias",   "c");
      define_key(f3, " Make    Alias",   "m");
      clear_key(f4);
      clear_key(f5);
      clear_key(f6);
      clear_key(f7);
      define_key(f8, " Return  to Msg",  "r");
    }
    else if (level == YESNO) {
      dprint0("YES-NO)\n");
      define_key(f1, "  Yes",  "y");
      clear_key(f2);
      clear_key(f3);
      clear_key(f4);
      clear_key(f5);
      clear_key(f6);
      clear_key(f7);
      define_key(f8, "   No",  "n");
    }
    else if (level == READ) {
      dprint0("READ)\n");
      define_key(f1, "  Next    Page  ", " ");
      clear_key(f2);
      clear_key(f3);
      clear_key(f4);
      clear_key(f5);
      clear_key(f6);
      clear_key(f7);
      define_key(f8, " Return  to Msg", "\n");
    }
    else if (level == CHANGE) {
      dprint0("CHANGE)\n");
      define_key(f1, "  Mail  Directry", "=/");
      define_key(f2, "  Home  Directry", "~/");
      clear_key(f3);
      define_key(f4, "Incoming Mailbox", "!\n");
      clear_key(f5);
      clear_key(f6);
      clear_key(f7);
      define_key(f8, " Cancel", "\n");
    }

    softkeys_on();
}

define_key(key, display, send)
int key;
char *display, *send;
{

    char buffer[30];

    dprint3("define-key(key=%d, display='%s', send='%s'\n",
             key, display, send);

    sprintf(buffer,"%s%s", display, send);

    printf("%c&f%dk%dd%dL%s", ESCAPE, key,
        strlen(display), strlen(send), buffer);
}

softkeys_on()
{
    /* turn on softkeys (esc&jB) and turn on MENU and USER/SYSTEM */

    if (hp_softkeys)
      printf("%c&jB%c&jR", ESCAPE, ESCAPE);
}

softkeys_off()
{
    /* turn off softkeys (esc&j@) */

    if (hp_softkeys)
      printf("%c&j@", ESCAPE);
}

clear_key(key)
{
    /** set a key to nothing... **/

    if (hp_softkeys)
       define_key(key, "                ", "");
}
END-OF-FILE

size=`wc -c < src/softkeys.c`

if [ $size != 2900 ]
then
  echo Warning: src/softkeys.c changed - should be 2900 bytes, not $size bytes
fi

chmod 644 src/softkeys.c

echo done

exit 0