Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/unix/volume18/elm2.2/part18

Internet Message Format | 1989-04-12 | 49.1 KB

Subject:  v18i097:  Elm mail system, release 2.2, Part18/24
Newsgroups: comp.sources.unix
Sender: sources
Approved: [e-mail]

Submitted-by: dsinc![e-mail] (Syd Weinstein)
Posting-number: Volume 18, Issue 97
Archive-name: elm2.2/part18

#!/bin/sh
# this is part 18 of a multipart archive
# do not concatenate these parts, unpack them in order with /bin/sh
# file src/opt_utils.c continued
#
CurArch=18
if test ! -r s2_seq_.tmp
then echo "Please unpack part 1 first!"
     exit 1; fi
( read Scheck
  if test "$Scheck" != $CurArch
  then echo "Please unpack part $Scheck next!"
       exit 1;
  else exit 0; fi
) < s2_seq_.tmp || exit 1
echo "x - Continuing file src/opt_utils.c"
sed 's/^X//' << 'SHAR_EOF' >> src/opt_utils.c
Xint size;
X{
X    /** Return the name of the current host machine. **/
X
X#ifdef XENIX
X    char    buf[32];
X    FILE    *fp;
X    char    *p;
X    char    *strchr();
X
X    if ((fp = fopen("/etc/systemid", "r")) != 0) {
X      fgets(buf, sizeof(buf) - 1, fp);
X      fclose(fp);
X      if ((p = strchr(buf, '\n')) != NULL)
X        *p = '\0';
X      (void) strncpy(hostname, buf, size - 1);
X      hostname[size - 1] = '\0';
X      return 0;
X    }
X
X#else   /* XENIX */
X
X#ifdef DOUNAME
X    /** This routine compliments of Scott McGregor at the HP
X        Corporate Computing Center **/
X
X    int uname();
X    struct utsname name;
X
X    (void) uname(&name);
X    (void) strncpy(hostname,name.nodename,size-1);
X#else
X    (void) strncpy(hostname, HOSTNAME, size-1);
X#endif    /* DOUNAME */
X
X    hostname[size - 1] = '\0';
X    return 0;
X
X#endif  /* XENIX */
X}
X
X#endif  /* GETHOSTNAME */
X
X
Xgethostdomain(hostdom, size)    /* get domain of current host */
Xchar *hostdom;
Xint size;
X{
X    char    buf[32];
X    FILE    *fp;
X    char    *p;
X    char    *strchr();
X
X    if ((fp = fopen(hostdomfile, "r")) != 0) {
X      fgets(buf, sizeof(buf) - 1, fp);
X      fclose(fp);
X      if ((p = strchr(buf, '\n')) != NULL)
X        *p = '\0';
X      if (buf[0] != '.') {
X        *hostdom++ = '.';
X        --size;
X      }
X      (void) strncpy(hostdom, buf, size - 1);
X      hostdom[size - 1] = '\0';
X    }
X    else {
X      (void) strncpy(hostdom, DEFAULT_DOMAIN, size - 1);
X      hostdom[size - 1] = '\0';
X    }
X
X    return 0;
X}
X
X
X#ifdef NEED_CUSERID
X
Xchar *cuserid(uname)
X     char *uname;
X{
X    /** Added for compatibility with Bell systems, this is the last-ditch
X        attempt to get the users login name, after getlogin() fails.  It
X        instantiates "uname" to the name of the user...(it also tries
X        to use "getlogin" again, just for luck)
X    **/
X    /** This wasn't really compatible.  According to our man page,
X     ** It was inconsistent.  If the parameter is NULL then you return
X     ** the name in a static area.  Else the ptr is supposed to be a
X     ** pointer to l_cuserid bytes of memory [probally 9 bytes]...
X     ** It's not mention what it should return if you copy the name
X     ** into the array, so I chose NULL.
X     **                     Sept 20, 1988
X     **                    **WJL**
X     **/
X
X  struct passwd *password_entry, *getpwuid();
X  char   *name, *getlogin();
X  static char buf[10];
X  register returnonly = 0;
X
X  if (uname == NULL) ++returnonly;
X
X  if ((name = getlogin()) != NULL) {
X    if (returnonly) {
X      return(name);
X    } else {
X      strcpy(uname, name);
X      return name;
X    }
X  }
X  else
X    if (( password_entry = getpwuid(getuid())) != NULL)
X      {
X    if (returnonly)
X      {
X        return(password_entry->pw_name);
X      }
X    else
X      {
X        strcpy(uname, password_entry->pw_name);
X        return name;
X      }
X      }
X    else
X      {
X    return NULL;
X      }
X}
X
X#endif
X
X#ifdef BSD
X
X/** some supplementary string functions for Berkeley Unix systems **/
X
Xint
Xtolower(ch)
Xchar ch;
X{
X    /** This should be a macro call, but if you use this as a macro
X        calls to 'tolower' where the argument is a function call will
X        cause the function to be called TWICE which is obviously the
X        wrong behaviour.  On the other hand, to just blindly translate
X        assuming the character is always uppercase can cause BIG
X        problems, so...
X    **/
X
X    return ( isupper(ch) ? ch - 'A' + 'a' : ch );
X}
X
Xint
Xtoupper(ch)
Xchar ch;
X{
X    /** see comment for above routine - tolower() **/
X
X    return ( islower(ch) ? ch - 'a' + 'A' : ch );
X}
X
Xstrspn(source, keys)
Xchar *source, *keys;
X{
X    /** This function returns the length of the substring of
X        'source' (starting at zero) that consists ENTIRELY of
X        characters from 'keys'.  This is used to skip over a
X        defined set of characters with parsing, usually.
X    **/
X
X    register int loc = 0, key_index = 0;
X
X    while (source[loc] != '\0') {
X      key_index = 0;
X      while (keys[key_index] != source[loc])
X        if (keys[key_index++] == '\0')
X          return(loc);
X      loc++;
X    }
X
X    return(loc);
X}
X
Xstrcspn(source, keys)
Xchar *source, *keys;
X{
X    /** This function returns the length of the substring of
X        'source' (starting at zero) that consists entirely of
X        characters NOT from 'keys'.  This is used to skip to a
X        defined set of characters with parsing, usually.
X        NOTE that this is the opposite of strspn() above
X    **/
X
X    register int loc = 0, key_index = 0;
X
X    while (source[loc] != '\0') {
X      key_index = 0;
X      while (keys[key_index] != '\0')
X        if (keys[key_index++] == source[loc])
X          return(loc);
X      loc++;
X    }
X
X    return(loc);
X}
X
Xchar *strtok(source, keys)
Xchar *source, *keys;
X{
X    /** This function returns a pointer to the next word in source
X        with the string considered broken up at the characters
X        contained in 'keys'.  Source should be a character pointer
X        when this routine is first called, then NULL subsequently.
X        When strtok has exhausted the source string, it will
X        return NULL as the next word.
X
X        WARNING: This routine will DESTROY the string pointed to
X        by 'source' when first invoked.  If you want to keep the
X        string, make a copy before using this routine!!
X     **/
X
X    register int  last_ch;
X    static   char *sourceptr;
X         char *return_value;
X
X    if (source != NULL)
X      sourceptr = source;
X
X    if (*sourceptr == '\0')
X      return(NULL);        /* we hit end-of-string last time!? */
X
X    sourceptr += strspn(sourceptr, keys);    /* skip leading crap */
X
X    if (*sourceptr == '\0')
X      return(NULL);        /* we've hit end-of-string */
X
X    last_ch = strcspn(sourceptr, keys);    /* end of good stuff */
X
X    return_value = sourceptr;        /* and get the ret   */
X
X    sourceptr += last_ch;            /* ...value          */
X
X    if (*sourceptr != '\0')        /* don't forget if we're at END! */
X      sourceptr++;               /* and skipping for next time */
X
X    return_value[last_ch] = '\0';        /* ..ending right    */
X
X    return((char *) return_value);        /* and we're outta here! */
X}
X
Xchar *strpbrk(source, keys)
Xchar *source, *keys;
X{
X    /** Returns a pointer to the first character of source that is any
X        of the specified keys, or NULL if none of the keys are present
X        in the source string.
X    **/
X
X    register int loc = 0, key_index = 0;
X
X    while (source[loc] != '\0') {
X      key_index = 0;
X      while (keys[key_index] != '\0')
X        if (keys[key_index++] == source[loc])
X          return((char *) (source + loc));
X      loc++;
X    }
X
X    return(NULL);
X}
X
Xchar *strchr(buffer, ch)
Xchar *buffer, ch;
X{
X    /** Returns a pointer to the first occurance of the character
X        'ch' in the specified string or NULL if it doesn't occur **/
X
X    char *address;
X
X    address = buffer;
X
X    while (*address != ch) {
X      if (*address == '\0')
X        return (NULL);
X      address++;
X    }
X
X    return ( (char *) address);
X}
X
Xchar *strrchr(buffer, ch)
Xchar *buffer, ch;
X{
X    /** Returns a pointer to the last occurance of the character
X        'ch' in the specified string or NULL if it doesn't occur **/
X
X    char *address;
X
X    address = buffer + strlen(buffer) - 1;
X
X    while (*address != ch) {
X      if (address == buffer)
X        return (NULL);
X      address--;
X    }
X
X    return ( (char *) address);
X}
X
X#endif
X
X#ifndef TEMPNAM
X/* and a tempnam for temporary files */
Xstatic int cnt = 0;
X
Xchar *tempnam( dir, pfx)
X char *dir, *pfx;
X{
X    char space[SLEN];
X    char *newspace;
X
X    char    *malloc();
X
X    if (dir == NULL) {
X        dir = "/usr/tmp";
X    } else if (*dir == '\0') {
X        dir = "/usr/tmp";
X    }
X
X    if (pfx == NULL) {
X        pfx = "";
X    }
X
X    sprintf(space, "%s%s%d.%d", dir, pfx, getpid(), cnt);
X    cnt++;
X
X    newspace = malloc(strlen(space) + 1);
X    if (newspace != NULL) {
X        strcpy(newspace, space);
X    }
X    return newspace;
X}
X
X#endif
X
X#ifndef GETOPT
X
X/*LINTLIBRARY*/
X#define NULL    0
X#define EOF    (-1)
X#define ERR(s, c)    if(opterr){\
X    extern int strlen(), write();\
X    char errbuf[2];\
X    errbuf[0] = c; errbuf[1] = '\n';\
X    (void) write(2, argv[0], (unsigned)strlen(argv[0]));\
X    (void) write(2, s, (unsigned)strlen(s));\
X    (void) write(2, errbuf, 2);}
X
Xextern int strcmp();
Xextern char *index();
X
Xint    opterr = 1;
Xint    optind = 1;
Xint    optopt;
Xchar    *optarg;
X
Xint
Xgetopt(argc, argv, opts)
Xint    argc;
Xchar    **argv, *opts;
X{
X    static int sp = 1;
X    register int c;
X    register char *cp;
X
X    if(sp == 1)
X        if(optind >= argc ||
X           argv[optind][0] != '-' || argv[optind][1] == '\0')
X            return(EOF);
X        else if(strcmp(argv[optind], "--") == NULL) {
X            optind++;
X            return(EOF);
X        }
X    optopt = c = argv[optind][sp];
X    if(c == ':' || (cp=index(opts, c)) == NULL) {
X        ERR(": illegal option -- ", c);
X        if(argv[optind][++sp] == '\0') {
X            optind++;
X            sp = 1;
X        }
X        return('?');
X    }
X    if(*++cp == ':') {
X        if(argv[optind][sp+1] != '\0')
X            optarg = &argv[optind++][sp+1];
X        else if(++optind >= argc) {
X            ERR(": option requires an argument -- ", c);
X            sp = 1;
X            return('?');
X        } else
X            optarg = argv[optind++];
X        sp = 1;
X    } else {
X        if(argv[optind][++sp] == '\0') {
X            sp = 1;
X            optind++;
X        }
X        optarg = NULL;
X    }
X    return(c);
X}
X
X#endif
X
X#ifndef RENAME
Xint rename(tmpfname, fname)
Xchar *tmpfname, *fname;
X{
X    int status;
X
X    (void) unlink(fname);
X    if ((status = link(tmpfname, fname)) != 0)
X        return(status);
X    (void) unlink(tmpfname);
X    return(0);
X}
X#endif
SHAR_EOF
echo "File src/opt_utils.c is complete"
chmod 0444 src/opt_utils.c || echo "restore of src/opt_utils.c fails"
echo "x - extracting src/options.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/options.c &&
X
Xstatic char rcsid[] = "@(#)$Id: options.c,v 2.9 89/03/25 21:46:54 syd Exp $";
X
X/*******************************************************************************
X *  The Elm Mail System  -  $Revision: 2.9 $   $State: Exp $
X *
X *             Copyright (c) 1986, 1987 Dave Taylor
X *             Copyright (c) 1988, 1989 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X *    Syd Weinstein, Elm Coordinator
X *    [e-mail]            dsinc!elm
X *
X *******************************************************************************
X * $Log:    options.c,v $
X * Revision 2.9  89/03/25  21:46:54  syd
X * Initial 2.2 Release checkin
X *
X *
X ******************************************************************************/
X
X/** This set of routines allows the alteration of a number of paramaters
X    in the Elm mailer, including the following;
X
X    calendar-file    <where to put calendar entries>
X    display pager    <how to page messages>
X    editor        <name of composition editor>
X    folder-dir    <folder directory>
X    sort-by        <how to sort folders>
X    sent-mail    <file to save outbound message copies to>
X    printmail    <how to print messages>
X    full_username    <your full user name for outgoing mail>
X
X    arrow-cursor    <on or off>
X    menu-display    <on or off>
X
X    user-level    <BEGINNER|INTERMEDIATE|EXPERT>
X        names-only      <on or off>
X
X    And others as they seem useful.
X
X**/
X
X#include "headers.h"
X
X#ifdef BSD
X#undef tolower
X#endif
X
X#undef onoff
X#define   onoff(n)    (n == 1? "ON ":"OFF")
X
Xchar *one_liner_for(), *level_name();
Xunsigned long sleep();
X
Xoptions()
X{
X    /** change options... **/
X    /* return:
X     *    > 0    if restort was done - to indicate we might need to
X     *         change the page of our headers as a consequence
X     *        of the new sort order
X     *    < 0    if user entered 'x' to quit elm immediately
X     *    0    otherwise
X     */
X
X    int    ch,
X             resort = 0;
X    char    *strcpy(),
X             temp[SLEN];    /* needed when an option is run through
X                 * expand_env(), because that function
X                 * is destructive of the original
X                 */
X
X    display_options();
X
X    clearerr(stdin);
X
X    while(1) {
X      ClearLine(LINES-4);
X
X      Centerline(LINES-4,
X "Select first letter of option line, '>' to save, or 'i' to return to index.");
X
X      PutLine0(LINES-2, 0, "Command: ");
X
X      ch = ReadCh();
X      ch = tolower(ch);
X
X      clear_error();    /* remove possible "sorting" message etc... */
X
X      one_liner(one_liner_for(ch));
X
X      switch (ch) {
X        case 'c' : optionally_enter(raw_calendar_file, 2, 23, FALSE, FALSE);
X               strcpy(temp, raw_calendar_file);
X               expand_env(calendar_file, temp);
X               break;
X        case 'd' : optionally_enter(raw_pager, 3, 23, FALSE, FALSE);
X               strcpy(temp, raw_pager);
X               expand_env(pager, temp);
X               clear_pages = (equal(pager, "builtin+") ||
X                         equal(pager, "internal+"));
X               break;
X        case 'e' : optionally_enter(raw_editor, 4, 23, FALSE, FALSE);
X               strcpy(temp, raw_editor);
X               expand_env(editor, temp);
X                   break;
X        case 'f' : optionally_enter(raw_folders, 5, 23, FALSE, FALSE);
X               strcpy(temp, raw_folders);
X               expand_env(folders, temp);
X               break;
X        case 's' : if(change_sort(6,23)) resort++;            break;
X        case 'o' : optionally_enter(raw_sentmail, 7, 23, FALSE, FALSE);
X               strcpy(temp, raw_sentmail);
X               expand_env(sent_mail, temp);
X               break;
X        case 'p' : optionally_enter(raw_printout, 8, 23, FALSE, FALSE);
X               strcpy(temp, raw_printout);
X               expand_env(printout, temp);
X               break;
X        case 'y' : optionally_enter(full_username, 9, 23, FALSE, FALSE);
X               break;
X        case 'a' : on_or_off(&arrow_cursor, 12, 23);         break;
X        case 'm' : on_or_off(&mini_menu, 13, 23);
X               headers_per_page = LINES - (mini_menu ? 13 : 8); break;
X
X        case 'u' : switch_user_level(&user_level,15, 23);        break;
X        case 'n' : on_or_off(&names_only, 16, 23);            break;
X
X        case '?' : options_help();
X                   PutLine0(LINES-2,0,"Command: ");            break;
X
X        case '>' : printf("Save options in .elm/elmrc...");
X               fflush(stdout);    save_options();        break;
X
X        case 'x' :    return(-1);    /* exit elm */
X        case 'q' :    /* pop back up to previous level, in this case == 'i' */
X        case 'i' :  /* return to index screen */
X            return(resort ? 1 : 0);
X        case ctrl('L'): display_options();                break;
X        default: error("Command unknown!");
X      }
X
X    }
X}
X
Xdisplay_options()
X{
X    /** Display all the available options.. **/
X
X    char *sort_name();
X
X    ClearScreen();
X    Centerline(0,"-- ELM Options Editor --");
X
X#ifdef ENABLE_CALENDAR
X    PutLine1(2, 0, "C)alendar file       : %s", raw_calendar_file);
X#endif
X    PutLine1(3, 0, "D)isplay mail using  : %s", raw_pager);
X    PutLine1(4, 0, "E)ditor              : %s", raw_editor);
X    PutLine1(5, 0, "F)older directory    : %s", raw_folders);
X    PutLine1(6, 0, "S)orting criteria    : %s", sort_name(FULL));
X    PutLine1(7, 0, "O)utbound mail saved : %s", raw_sentmail);
X    PutLine1(8, 0, "P)rint mail using    : %s", raw_printout);
X    PutLine1(9, 0, "Y)our full name      : %s", full_username);
X
X    PutLine1(12,0, "A)rrow cursor        : %s", onoff(arrow_cursor));
X    PutLine1(13,0, "M)enu display        : %s", onoff(mini_menu));
X
X    PutLine1(15,0, "U)ser level          : %s", level_name(user_level));
X    PutLine1(16,0, "N)ames only          : %s", onoff(names_only));
X}
X
Xon_or_off(var, x, y)
Xint *var, x,y;
X{
X    /** 'var' field at x.y toggles between on and off... **/
X
X    char ch;
X
X         PutLine0(x, y+6,
X        "(use <space> to toggle, any other key to leave)");
X
X    MoveCursor(x,y+3);    /* at end of value... */
X
X    do {
X      ch = ReadCh();
X
X      if (ch == SPACE) {
X        *var = ! *var;
X        PutLine0(x,y, onoff(*var));
X      }
X    } while (ch == SPACE);
X
X    MoveCursor(x,y+4);     CleartoEOLN();    /* remove help prompt */
X}
X
X
Xswitch_user_level(ulevel, x, y)
Xint *ulevel, x, y;
X{
X    /** step through possible user levels... **/
X
X         PutLine0(x, y+20, "<space> to change");
X
X    MoveCursor(x,y);    /* at end of value... */
X
X    while (ReadCh() == ' ') {
X      *ulevel = (*ulevel >= 2? 0 : *ulevel + 1);
X      PutLine1(x,y, "%s", level_name(*ulevel));
X    }
X
X    MoveCursor(x,y+20);     CleartoEOLN();    /* remove help prompt */
X}
X
Xchange_sort(x, y)
Xint x,y;
X{
X    /** change the sorting scheme... **/
X    /** return !0 if new sort order, else 0 **/
X
X    int last_sortby,    /* so we know if it changes... */
X        sign = 1;        /* are we reverse sorting??    */
X    int ch;            /* character typed in ...      */
X
X    last_sortby = sortby;    /* remember current ordering   */
X
X    PutLine0(x, COLUMNS-29, "(SPACE for next, or R)everse)");
X    sort_one_liner(sortby);
X    MoveCursor(x, y);
X
X    do {
X      ch = ReadCh();
X      ch = tolower(ch);
X      switch (ch) {
X        case SPACE : if (sortby < 0) {
X                   sign = -1;
X                   sortby = - sortby;
X               }
X             else sign = 1;        /* insurance! */
X               sortby = sign * ((sortby + 1) % (STATUS+2));
X             if (sortby == 0) sortby = sign;  /* snicker */
X               PutLine0(x, y, sort_name(PAD));
X             sort_one_liner(sortby);
X               MoveCursor(x, y);
X             break;
X
X        case 'r'   : sortby = - sortby;
X               PutLine0(x, y, sort_name(PAD));
X             sort_one_liner(sortby);
X               MoveCursor(x, y);
X     }
X        } while (ch == SPACE || ch == 'r');
X
X    MoveCursor(x, COLUMNS-30);    CleartoEOLN();
X
X    if (sortby != last_sortby) {
X      error("Resorting folder...");
X      sleep(1);
X      sort_mailbox(message_count, 0);
X    }
X    ClearLine(LINES-2);        /* clear sort_one_liner()! */
X    return(sortby-last_sortby);
X}
X
Xone_liner(string)
Xchar *string;
X{
X    /** A single-line description of the selected item... **/
X
X    ClearLine(LINES-4);
X    Centerline(LINES-4, string);
X}
X
Xsort_one_liner(sorting_by)
Xint sorting_by;
X{
X    /** A one line summary of the particular sorting scheme... **/
X
X    ClearLine(LINES-2);
X
X    switch (sorting_by) {
X
X      case -SENT_DATE : Centerline(LINES-2,
X"This sort will order most-recently-sent to least-recently-sent");    break;
X      case -RECEIVED_DATE : Centerline(LINES-2,
X"This sort will order most-recently-received to least-recently-received");
X                 break;
X      case -MAILBOX_ORDER : Centerline(LINES-2,
X"This sort will order most-recently-added-to-folder to least-recently");
X                 break;
X      case -SENDER : Centerline(LINES-2,
X"This sort will order by sender name, in reverse alphabetical order");    break;
X      case -SIZE   : Centerline(LINES-2,
X"This sort will order messages by longest to shortest");        break;
X      case -SUBJECT : Centerline(LINES-2,
X"This sort will order by subject, in reverse alphabetical order");    break;
X      case -STATUS  : Centerline(LINES-2,
X"This sort will order by reverse status - Deleted through Tagged...");    break;
X
X      case SENT_DATE : Centerline(LINES-2,
X"This sort will order least-recently-sent to most-recently-sent");    break;
X      case RECEIVED_DATE : Centerline(LINES-2,
X"This sort will order least-recently-received to most-recently-received");
X                        break;
X      case MAILBOX_ORDER : Centerline(LINES-2,
X"This sort will order least-recently-added-to-folder to most-recently");
X                 break;
X      case SENDER : Centerline(LINES-2,
X                "This sort will order by sender name");    break;
X      case SIZE   : Centerline(LINES-2,
X                "This sort will order messages by shortest to longest");
X            break;
X      case SUBJECT : Centerline(LINES-2,
X                    "This sort will order messages by subject");    break;
X      case STATUS  : Centerline(LINES-2,
X"This sort will order by status - Tagged through Deleted...");        break;
X    }
X}
X
Xchar *one_liner_for(c)
Xchar c;
X{
X    /** returns the one-line description of the command char... **/
X
X    switch (c) {
X        case 'c' : return(
X"This is the file where calendar entries from messages are saved.");
X
X        case 'd' : return(
X"This is the program invoked to display individual messages (try 'builtin')");
X
X        case 'e' : return(
X"This is the editor that will be used for sending messages, etc.");
X
X        case 'f' : return(
X"This is the folders directory used when '=' (etc) is used in filenames");
X
X        case 'm' : return(
X"This determines if you have the mini-menu displayed or not");
X
X        case 'n' : return(
X"Whether to display the names and addresses on mail, or names only");
X        case 'o' : return(
X"This is where copies of outbound messages are saved automatically.");
X
X        case 'p' : return(
X"This is how printouts are generated.  \"%s\" will be replaced by the filename.");
X
X        case 's' : return(
X"This is used to specify the sorting criteria for the folders");
X
X        case 'y' : return(
X"When mail is sent out, this is what your full name will be recorded as.");
X
X        case 'a' : return(
X"This defines whether the ELM cursor is an arrow or a highlight bar.");
X
X       case 'u' : return(
X"The level of knowledge you have about the ELM mail system.");
X
X        default : return("");    /* nothing if we don't know! */
X    }
X}
X
Xoptions_help()
X{
X    /** help menu for the options screen... **/
X
X    char c, *ptr;
X
X    Centerline(LINES-3,
X     "Enter the key you want help on, '?' for a list, or '.' to exit help");
X
X    lower_prompt("Key : ");
X
X    while ((c = ReadCh()) != '.') {
X      c = tolower(c);
X      if (c == '?') {
X         display_helpfile(OPTIONS_HELP);
X         display_options();
X         return;
X      }
X      if ((ptr = one_liner_for(c)) != NULL)
X        error2("%c = %s.", c, ptr);
X      else
X        error1("%c isn't used in this section.", c);
X      lower_prompt("Key : ");
X    }
X}
X
Xchar *level_name(n)
Xint n;
X{
X    /** return the 'name' of the level... **/
X
X    switch (n) {
X      case 0 : return("Beginning User   ");
X      case 1 : return("Intermediate User");
X      default: return("Expert User      ");
X    }
X}
SHAR_EOF
chmod 0444 src/options.c || echo "restore of src/options.c fails"
echo "x - extracting src/out_utils.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/out_utils.c &&
X
Xstatic char rcsid[] = "@(#)$Id: out_utils.c,v 2.5 89/03/25 21:46:56 syd Exp $";
X
X/*******************************************************************************
X *  The Elm Mail System  -  $Revision: 2.5 $   $State: Exp $
X *
X *             Copyright (c) 1986, 1987 Dave Taylor
X *             Copyright (c) 1988, 1989 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X *    Syd Weinstein, Elm Coordinator
X *    [e-mail]            dsinc!elm
X *
X *******************************************************************************
X * $Log:    out_utils.c,v $
X * Revision 2.5  89/03/25  21:46:56  syd
X * Initial 2.2 Release checkin
X *
X *
X ******************************************************************************/
X
X/** This file contains routines used for output in the ELM program.
X
X**/
X
X#include "headers.h"
X
X
Xstatic char err_buffer[SLEN];        /* store last error message */
X
Xstatic char central_message_buffer[SLEN];
X
Xchar *strcpy();
X
Xshow_last_error()
X{
X    /** rewrite last error message! **/
X
X    error(err_buffer);
X}
X
Xclear_error()
X{
X    MoveCursor(LINES,0);
X    CleartoEOLN();
X    err_buffer[0] = '\0';
X}
X
Xset_error(s)
Xchar *s;
X{
X    strcpy(err_buffer, s);
X}
X
Xerror(s)
Xchar *s;
X{
X    /** outputs error 's' to screen at line 22, centered! **/
X
X    if(batch_only)
X      printf("%s\n\r", s);
X    else {
X      MoveCursor(LINES,0);
X      CleartoEOLN();
X      PutLine0(LINES,(COLUMNS-strlen(s))/2,s);
X      fflush(stdout);
X    }
X    strcpy(err_buffer, s);    /* save it too! */
X}
X
X/*VARARGS1*/
X
Xerror1(s, a)
Xchar *s, *a;
X{
X    /** same as error, but with a 'printf' argument **/
X    char buffer[SLEN];
X
X    sprintf(buffer,s,a);
X    error(buffer);
X}
X
X/*VARARGS1*/
X
Xerror2(s, a1, a2)
Xchar *s, *a1, *a2;
X{
X    /** same as error, but with two 'printf' arguments **/
X    char buffer[SLEN];
X
X    sprintf(buffer,s, a1, a2);
X    error(buffer);
X}
X
X/*VARARGS1*/
X
Xerror3(s, a1, a2, a3)
Xchar *s, *a1, *a2, *a3;
X{
X    /** same as error, but with three 'printf' arguments **/
X    char buffer[SLEN];
X
X    sprintf(buffer,s, a1, a2, a3);
X    error(buffer);
X}
X
Xlower_prompt(s)
Xchar *s;
X{
X    /** prompt user for input on LINES-1 line, left justified **/
X
X    PutLine0(LINES-1,0,s);
X    CleartoEOLN();
X}
X
Xprompt(s)
Xchar *s;
X{
X    /** prompt user for input on LINES-3 line, left justified **/
X
X    PutLine0(LINES-3,0,s);
X    CleartoEOLN();
X}
X
X
Xset_central_message(string, arg)
Xchar *string, *arg;
X{
X    /** set up the given message to be displayed in the center of
X        the current window **/
X
X    sprintf(central_message_buffer, string, arg);
X}
X
Xdisplay_central_message()
X{
X    /** display the message if set... **/
X
X    if (central_message_buffer[0] != '\0') {
X      ClearLine(LINES-15);
X      Centerline(LINES-15, central_message_buffer);
X      fflush(stdout);
X    }
X}
X
Xclear_central_message()
X{
X    /** clear the central message buffer **/
X
X    central_message_buffer[0] = '\0';
X}
SHAR_EOF
chmod 0444 src/out_utils.c || echo "restore of src/out_utils.c fails"
echo "x - extracting src/pattern.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/pattern.c &&
X
Xstatic char rcsid[] = "@(#)$Id: pattern.c,v 2.10 89/03/25 21:46:57 syd Exp $";
X
X/*******************************************************************************
X *  The Elm Mail System  -  $Revision: 2.10 $   $State: Exp $
X *
X *             Copyright (c) 1986, 1987 Dave Taylor
X *             Copyright (c) 1988, 1989 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X *    Syd Weinstein, Elm Coordinator
X *    [e-mail]            dsinc!elm
X *
X *******************************************************************************
X * $Log:    pattern.c,v $
X * Revision 2.10  89/03/25  21:46:57  syd
X * Initial 2.2 Release checkin
X *
X *
X ******************************************************************************/
X
X/**    General pattern matching for the ELM mailer.
X
X**/
X
X#include <errno.h>
X
X#include "headers.h"
X
Xstatic char pattern[SLEN] = { "" };
Xstatic char alt_pattern[SLEN] = { "" };
X
Xextern int errno;
X
Xchar *error_name(), *shift_lower(), *strcpy();
X
Xint
Xmeta_match(function)
Xint function;
X{
X    char    ch;
X
X    /** Perform specific function based on whether an entered string
X        matches either the From or Subject lines..
X        Return TRUE if the current message was matched, else FALSE.
X    **/
X
X    register int i, tagged=0, count=0, curtag = 0;
X    static char     meta_pattern[SLEN];
X
X    PutLine1(LINES-3, strlen("Command: "),
X         "%s messages that match pattern...",
X         function==TAGGED?"Tag": function==DELETED?"Delete":"Undelete");
X
X    if (function == TAGGED) {    /* are messages already tagged??? */
X      for (i=0; i < message_count; i++)
X        if (ison(headers[i]->status,TAGGED))
X          tagged++;
X
X      if (tagged) {
X        if (tagged > 2)
X          PutLine0(LINES-2,0, "Some messages are already tagged.");
X        else
X          PutLine0(LINES-2,0, "A message is already tagged.");
X
X        Write_to_screen("Remove tag%s? y%c", 2, plural(tagged),BACKSPACE);
X
X        ch = ReadCh();
X        if (tolower(ch) != 'n') {    /* remove tags... */
X          Write_to_screen("Yes.", 0);
X          for (i=0; i < message_count; i++) {
X            clearit(headers[i]->status,TAGGED);
X        show_new_status(i);
X          }
X        } else
X          Write_to_screen("No.", 0);
X      }
X    }
X
X    PutLine0(LINES-2,0, "Enter pattern: "); CleartoEOLN();
X
X    optionally_enter(meta_pattern, LINES-2, strlen("Enter pattern: "),
X      FALSE, FALSE);
X
X    if (strlen(meta_pattern) == 0) {
X      ClearLine(LINES-2);
X      return(curtag);
X    }
X
X    strcpy(meta_pattern, shift_lower(meta_pattern));   /* lowercase it */
X
X    for (i = 0; i < message_count; i++) {
X      if (from_matches(i, meta_pattern)) {
X        if ((selected && headers[i]->status & VISIBLE) || ! selected) {
X          if (function == UNDELETE)
X            clearit(headers[i]->status, DELETED);
X          else
X            setit(headers[i]->status, function);
X          show_new_status(i);
X          if(i == current - 1) curtag++;
X          count++;
X        }
X      }
X      else if (subject_matches(i, meta_pattern)) {
X        if ((selected && headers[i]->status & VISIBLE) || ! selected) {
X          if (function == UNDELETE)
X            clearit(headers[i]->status, DELETED);
X          else
X            setit(headers[i]->status, function);
X          show_new_status(i);
X          if(i == current - 1) curtag++;
X          count++;
X        }
X      }
X    }
X
X    ClearLine(LINES-2);    /* remove "pattern: " prompt */
X
X    if (count > 0)
X      error3("%s %d messsage%s.",
X             function==TAGGED? "Tagged" :
X           function==DELETED? "Marked for deletion" : "Undeleted",
X         count, plural(count));
X    else
X      error1("No matches. No messages %s.",
X         function==TAGGED? "tagged" :
X           function==DELETED? "marked for deletion": "undeleted");
X
X    return(curtag);
X}
X
Xint
Xpattern_match()
X{
X    /** Get a pattern from the user and try to match it with the
X        from/subject lines being displayed.  If matched (ignoring
X        case), move current message pointer to that message, if
X        not, error and return ZERO **/
X
X    register int i;
X
X    PutLine0(LINES-3,40,"/ = Match anywhere in messages.");
X
X    PutLine0(LINES-1,0, "Match pattern:");
X
X    if (pattern_enter(pattern, alt_pattern, LINES-1, 16,
X        "Match pattern (in entire folder):"))
X      if (strlen(alt_pattern) > 0) {
X        strcpy(alt_pattern, shift_lower(alt_pattern));
X        return(match_in_message(alt_pattern));
X      }
X      else
X        return(1);
X
X    if (strlen(pattern) == 0)
X      return(0);
X    else
X      strcpy(pattern, shift_lower(pattern));
X
X    for (i = current; i < message_count; i++) {
X      if (from_matches(i, pattern)) {
X        if (!selected || (selected && headers[i]->status & VISIBLE)) {
X          current = ++i;
X          return(1);
X        }
X      }
X      else if (subject_matches(i, pattern)) {
X        if (!selected || (selected && headers[i]->status & VISIBLE)) {
X          current = ++i;
X          return(1);
X        }
X      }
X    }
X
X    return(0);
X}
X
Xint
Xfrom_matches(message_number, pat)
Xint message_number;
Xchar *pat;
X{
X    /** Returns true iff the pattern occurs in it's entirety
X        in the from line of the indicated message **/
X
X    return( in_string(shift_lower(headers[message_number]->from),
X        pat) );
X}
X
Xint
Xsubject_matches(message_number, pat)
Xint message_number;
Xchar *pat;
X{
X    /** Returns true iff the pattern occurs in it's entirety
X        in the subject line of the indicated message **/
X
X    return( in_string(shift_lower(headers[message_number]->subject),
X        pat) );
X}
X
Xmatch_in_message(pat)
Xchar *pat;
X{
X    /** Match a string INSIDE a message...starting at the current
X        message read each line and try to find the pattern.  As
X        soon as we do, set current and leave!
X        Returns 1 if found, 0 if not
X    **/
X
X    char buffer[LONG_STRING];
X    int  message_number, lines, line;
X
X    message_number = current-1;
X
X    error("Searching folder for pattern...");
X
X    while (message_number < message_count) {
X
X      if (fseek(mailfile, headers[message_number]->offset, 0L) == -1) {
X
X        dprint(1, (debugfile,
X        "Error: seek %ld bytes into file failed. errno %d (%s)\n",
X        headers[message_number]->offset, errno,
X        "match_in_message"));
X        error2("ELM [match] failed looking %ld bytes into file (%s).",
X           headers[message_number]->offset, error_name(errno));
X        return(1);    /* fake it out to avoid replacing error message */
X      }
X
X      line = 0;
X      lines = headers[message_number]->lines;
X
X      while (fgets(buffer, LONG_STRING, mailfile) != NULL && line < lines) {
X
X        if(buffer[strlen(buffer)-1] == '\n') line++;
X
X        if (in_string(shift_lower(buffer), pat)) {
X          current = message_number+1;
X          clear_error();
X          return(1);
X        }
X      }
X
X      /** now we've passed the end of THIS message...increment and
X          continue the search with the next message! **/
X
X      message_number++;
X    }
X
X    return(0);
X}
SHAR_EOF
chmod 0444 src/pattern.c || echo "restore of src/pattern.c fails"
echo "x - extracting src/pmalloc.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/pmalloc.c &&
X
Xstatic char rcsid[] = "@(#)$Id: pmalloc.c,v 2.3 89/03/25 21:46:59 syd Exp $";
X
X/*******************************************************************************
X *  The Elm Mail System  -  $Revision: 2.3 $   $State: Exp $
X *
X *             Copyright (c) 1986, 1987 Dave Taylor
X *             Copyright (c) 1988, 1989 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X *    Syd Weinstein, Elm Coordinator
X *    [e-mail]            dsinc!elm
X *
X *******************************************************************************
X * $Log:    pmalloc.c,v $
X * Revision 2.3  89/03/25  21:46:59  syd
X * Initial 2.2 Release checkin
X *
X *
X ******************************************************************************/
X
X/** This routine contains a cheap permanent version of the malloc call to
X    speed up the initial allocation of the weedout headers and the uuname
X    data.
X
X      This routine is originally from Jim Davis of HP Labs, with some
X    mods by me.
X**/
X
X#include <stdio.h>
X#include "defs.h"
X
X/*VARARGS0*/
X
Xchar *pmalloc(size)
Xint size;
X{
X    /** return the address of a specified block **/
X
X    static char *our_block = NULL;
X    static int   free_mem  = 0;
X
X    char   *return_value, *malloc();
X
X    /** if bigger than our threshold, just do the real thing! **/
X
X    if (size > PMALLOC_THRESHOLD)
X       return(malloc(size));
X
X    /** if bigger than available space, get more, tossing what's left **/
X
X    if (size > free_mem) {
X      if ((our_block = malloc(PMALLOC_BUFFER_SIZE)) == NULL) {
X        fprintf(stderr, "\n\r\n\rCouldn't malloc %d bytes!!\n\r\n\r",
X            PMALLOC_BUFFER_SIZE);
X        leave();
X          }
X      our_block += 4;  /* just for safety, don't give back true address */
X      free_mem = PMALLOC_BUFFER_SIZE-4;
X    }
X
X    return_value  = our_block;    /* get the memory */
X    size = ((size+3)/4)*4;        /* Go to quad byte boundary */
X    our_block += size;        /* use it up      */
X    free_mem  -= size;        /*  and decrement */
X
X    return( (char *) return_value);
X}
SHAR_EOF
chmod 0444 src/pmalloc.c || echo "restore of src/pmalloc.c fails"
echo "x - extracting src/quit.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/quit.c &&
X
Xstatic char rcsid[] = "@(#)$Id: quit.c,v 2.15 89/03/25 21:47:00 syd Exp $";
X
X/*******************************************************************************
X *  The Elm Mail System  -  $Revision: 2.15 $   $State: Exp $
X *
X *             Copyright (c) 1986, 1987 Dave Taylor
X *             Copyright (c) 1988, 1989 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X *    Syd Weinstein, Elm Coordinator
X *    [e-mail]            dsinc!elm
X *
X *******************************************************************************
X * $Log:    quit.c,v $
X * Revision 2.15  89/03/25  21:47:00  syd
X * Initial 2.2 Release checkin
X *
X *
X ******************************************************************************/
X
X/** quit: leave the current folder and quit the program.
X
X**/
X
X#include "headers.h"
X
Xlong bytes();
X
Xquit(prompt)
Xint prompt;
X{
X    /* a wonderfully short routine!! */
X
X    if (leave_mbox(FALSE, TRUE, prompt) == -1)
X      /* new mail - leave not done - can't change to another file yet
X       * check for change in mailfile_size in main() will do the work
X       * of calling newmbox to add in the new messages to the current
X       * file and fix the sorting sequence that leave_mbox may have
X       * changed for its own purposes */
X      return;
X
X    leave();
X}
X
Xint
Xresync()
X{
X    /** Resync on the current folder. Leave current and read it back in.
X        Return indicates whether a redraw of the screen is needed.
X     **/
X
X      if(leave_mbox(TRUE, FALSE, TRUE) ==-1)
X        /* new mail - leave not done - can't change to another file yet
X         * check for change in mailfile_size in main() will do the work
X         * of calling newmbox to add in the new messages to the current
X         * file and fix the sorting sequence that leave_mbox may have
X         * changed for its own purposes */
X        return(FALSE);
X
X      newmbox(cur_folder, FALSE);
X      return(TRUE);
X}
X
Xchange_file()
X{
X      /* Prompt user for name of folder to change to.
X       * If all okay with that folder, leave the current folder.
X       * If leave goes okay (i.e. no new messages in current folder),
X       * change to the folder that the user specified.
X       *
X       * Return value indicates whether a redraw is needed.
X       */
X
X      int redraw = FALSE;
X      char newfile[SLEN];
X      static char helpmsg[LONG_STRING];
X
X      char    *nameof();
X
X
X      /* get new file name */
X
X      MoveCursor(LINES-3, 30);
X      CleartoEOS();
X      PutLine0(LINES-3, 38, "(Use '?' for help/to list your folders.)");
X      PutLine0(LINES-2,0,"Name of new folder: ");
X      while(1) {
X        newfile[0] = '\0';
X        (void) optionally_enter(newfile, LINES-2, 21, FALSE, FALSE);
X        clear_error();
X
X        if(*newfile == '\0') {    /* if user didn't enter a file name */
X          MoveCursor(LINES-3, 30);    /* abort changing file process */
X          CleartoEOS();
X          return(redraw);
X
X        } else if (strcmp(newfile, "?") == 0) {
X
X          /* user wants to list folders */
X          if(!*helpmsg)    /* format helpmsg if not yet done */
X
X        strcpy(helpmsg,
X          "\n\r\n\rEnter: <nothing> to not change to a new folder,");
X        strcat(helpmsg,
X          "\n\r       '!' to change to your incoming mailbox (");
X        strcat(helpmsg, defaultfile);
X        strcat(helpmsg,
X          ")\n\r       '>' to change to your \"received\" folder (");
X        strcat(helpmsg, nameof(recvd_mail));
X        strcat(helpmsg,
X          ")\n\r       '<' to change to your \"sent\" folder (");
X        strcat(helpmsg, nameof(sent_mail));
X        strcat(helpmsg, ")\n\r       or a filename");
X        strcat(helpmsg,
X          " (leading '=' denotes your folder directory ");
X        strcat(helpmsg, folders);
X        strcat(helpmsg, ").\n\r");
X
X          list_folders(4, helpmsg);
X          PutLine0(LINES-2,0,"Name of new folder: ");    /* reprompt */
X          redraw = TRUE;        /* we'll need to clean the screen */
X
X        } else {
X
X          /* user entered a file name - expand it */
X          if (! expand_filename(newfile, TRUE))
X        continue;    /* prompt again */
X
X          /* don't accept the same file as the current */
X          if (strcmp(newfile, cur_folder) == 0) {
X        error("Already reading that folder!");
X        continue;    /* prompt again */
X          }
X
X          /* Make sure this is a file the user can open, unless it's the
X           * default mailfile, which is openable even if empty */
X          if (strcmp(newfile, defaultfile) != 0) {
X        if (can_access(newfile, READ_ACCESS)) {
X          error1("Can't open folder '%s' for reading!", newfile);
X          continue;     /* prompt again */
X        }
X          }
X          break;    /* exit loop - we got the name of a good file */
X        }
X      }
X
X      /* All's clear with the new file to go ahead and leave the current. */
X      MoveCursor(LINES-3, 30);
X      CleartoEOS();
X
X      if(leave_mbox(FALSE, FALSE, TRUE) ==-1) {
X        /* new mail - leave not done - can't change to another file yet
X         * check for change in mailfile_size in main() will do the work
X         * of calling newmbox to add in the new messages to the current
X         * file and fix the sorting sequence that leave_mbox may have
X         * changed for its own purposes */
X        return(redraw);
X      }
X
X      redraw = 1;
X      newmbox(newfile, FALSE);
X      return(redraw);
X}
SHAR_EOF
chmod 0444 src/quit.c || echo "restore of src/quit.c fails"
echo "x - extracting src/read_rc.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/read_rc.c &&
X
Xstatic char rcsid[] = "@(#)$Id: read_rc.c,v 2.26 89/03/29 15:47:27 syd Exp $";
X
X/*******************************************************************************
X *  The Elm Mail System  -  $Revision: 2.26 $   $State: Exp $
X *
X *             Copyright (c) 1986, 1987 Dave Taylor
X *             Copyright (c) 1988, 1989 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X *    Syd Weinstein, Elm Coordinator
X *    [e-mail]            dsinc!elm
X *
X *******************************************************************************
X * $Log:    read_rc.c,v $
X * Revision 2.26  89/03/29  15:47:27  syd
X * Enable backwards compatibility with the elmrc option "alwaysleave"
X * that we obsoleted recently.
X * From: Rob Bernardo <[e-mail]>
X *
X * Revision 2.25  89/03/25  21:47:01  syd
X * Initial 2.2 Release checkin
X *
X *
X ******************************************************************************/
X
X/** This file contains programs to allow the user to have a .elm/elmrc file
X    in their home directory containing any of the following:
X
X    fullname= <username string>
X    maildir = <directory>
X    sentmail = <file>
X    editor  = <editor>
X    receviedmail= <file>
X    calendar= <calendar file name>
X    shell   = <shell>
X    print   = <print command>
X    weedout = <list of headers to weed out>
X    prefix  = <copied message prefix string>
X    pager   = <command to use for displaying messages>
X
X    escape  = <single character escape, default = '~' >
X
X--
X    signature = <.signature file for all outbound mail>
XOR:
X    localsignature = <.signature file for local mail>
X    remotesignature = <.signature file for non-local mail>
X--
X
X    bounceback= <hop count threshold, or zero to disable>
X    timeout = <seconds for main menu timeout or zero to disable>
X    userlevel = <0=amateur, 1=okay, 2 or greater = expert!>
X
X    sortby  = <sent, received, from, size, subject, mailbox, status>
X
X    alternatives = <list of addresses that forward to us>
X
X    and/or the logical arguments:
X
X    autocopy    [on|off]
X    askcc        [on|off]
X    copy        [on|off]
X    resolve     [on|off]
X    weed        [on|off]
X    noheader    [on|off]
X    titles      [on|off]
X    savebyname  [on|off]
X    movepage    [on|off]
X    pointnew    [on|off]
X    hpkeypad    [on|off]
X    hpsoftkeys  [on|off]
X    alwayskeep [on|off]
X    alwaysstore [on|off]
X    alwaysdel   [on|off]
X    arrow        [on|off]
X    menus        [on|off]
X    forms        [on|off]
X    warnings    [on|off]
X    names        [on|off]
X    ask        [on|off]
X    keepempty   [on|off]
X    promptafter[on|off]
X
X
X    Lines starting with '#' are considered comments and are not checked
X    any further!
X
X    Modified 10/85 to know about "Environment" variables..
X    Modified 12/85 for the 'prefix' option
X    Modified  2/86 for the new 3.3 flags
X    Modified  8/86 (was I supposed to be keeping this up to date?)
X**/
X
X#include <ctype.h>
X#include "headers.h"
X
X#ifdef BSD
X#undef tolower
X#endif
X
Xextern char *pmalloc();
Xextern int errno;
X
Xchar  *error_name(), *error_description(), *shift_lower(),
X      *strtok(), *getenv(), *strcpy();
Xvoid  exit();
X
X#define  metachar(c)    (c == '+' || c == '%' || c == '=')
X
X#define NOTWEEDOUT    0
X#define WEEDOUT        1
X#define ALTERNATIVES    2
X
Xread_rc_file()
X{
X    /** this routine does all the actual work of reading in the
X        .rc file... **/
X
X    FILE *file;
X    char buffer[SLEN], filename[SLEN], *cp, word1[SLEN], word2[SLEN];
X    register int  i, last = NOTWEEDOUT, lineno = 0, ch,
X      rc_has_recvdmail = 0, rc_has_sentmail = 0, errors = 0;
X
X    /* Establish some defaults in case elmrc is incomplete or not there.
X     * Defaults for other elmrc options were established in their
X     * declaration - in elm.h.  And defaults for sent_mail and recvd_mail
X     * are established after the elmrc is read in since these default
X     * are based on the folders directory name, which may be given
X     * in the emrc.
X     * Also establish alternative_editor here since it is based on
X     * the default editor and not on the one that might be given in the
X     * elmrc.
X     */
X
X    default_weedlist();
X
X    alternative_addresses = NULL;     /* none yet! */
X
X    raw_local_signature[0] = raw_remote_signature[0] =
X        local_signature[0] = remote_signature[0] = '\0';
X        /* no defaults for those */
X
X    strcpy(raw_shell,((cp = getenv("SHELL")) == NULL)? default_shell : cp);
X    strcpy(shell, raw_shell);
X
X    strcpy(raw_pager,((cp = getenv("PAGER")) == NULL)? default_pager : cp);
X    strcpy(pager, raw_pager);
X
X    strcpy(raw_editor,((cp = getenv("EDITOR")) == NULL)? default_editor:cp);
X    strcpy(alternative_editor, raw_editor);
X    strcpy(editor, raw_editor);
X
X    strcpy(raw_printout, default_printout);
X    strcpy(printout, raw_printout);
X
X    sprintf(raw_folders, "%s/%s", home, default_folders);
X    strcpy(folders, raw_folders);
X
X    sprintf(raw_calendar_file, "%s/%s", home, dflt_calendar_file);
X    strcpy(calendar_file, raw_calendar_file);
X
X    /* see if the user has a $HOME/.elm directory */
X    sprintf(filename, "%s/.elm", home);
X    if (access(filename, 00) == -1) {
X      if(batch_only)  {
X        printf("\n\rNotice:\
X\n\rThis version of ELM requires the use of a .elm directory to store your\
X\n\relmrc and alias files. I'd like to create the directory .elm for you\
X\n\rand set it up, but I can't in \"batch mode\".\
X\n\rPlease run ELM in \"normal mode\" first.\n\r");
X        exit(0);
X      }
X
X      printf("\n\rNotice:\
X\n\rThis version of ELM requires the use of a .elm directory in your home\
X\n\rdirectory to store your elmrc and alias files. Shall I create the\
X\n\rdirectory .elm for you and set it up (y/n)? y%c",BACKSPACE);
X
X      fflush(stdout);
X      ch=getchar();
X      if (ch == 'n' || ch == 'N') {
X        printf("No.\n\rVery well. I won't create it.\
X        \n\rBut, you may run into difficulties later.\n\r");
X        sleep(4);
X      }
X      else {
X        printf("Yes.\n\rGreat! I'll do it now.\n\r");
X        create_new_elmdir();
X      }
X    }
X
X    /* Look for the elmrc file */
X    sprintf(filename,"%s/%s", home, elmrcfile);
X    if ((file = fopen(filename, "r")) == NULL) {
X      dprint(2,(debugfile,"Warning:User has no \".elm/elmrc\" file\n\n"));
X
X      /* look for old-style .elmrc file in $HOME */
X      sprintf(filename, "%s/.elmrc", home);
X      if (access(filename, 00) != -1) {
X        move_old_files_to_new();
X
X        /* try to open elmrc file again */
X        sprintf(filename,"%s/%s", home, elmrcfile);
X        if((file = fopen(filename, "r")) == NULL) {
X          dprint(2, (debugfile,
X        "Warning: could not open new \".elm/elmrc\" file.\n"));
X          dprint(2, (debugfile, "** %s - %s **\n", error_name(errno),
X           error_description(errno)));
X          printf("Warning: could not open new \".elm/elmrc\" file!");
X          printf(" Using default parameters.\n\r");
X          sleep(4);
X        }
X      }
X    }
X
X    if(file) {
X      while (fgets(buffer, SLEN, file) != NULL) {
X        lineno++;
X        no_ret(buffer);         /* remove return */
X        if (buffer[0] == '#') {     /* comment       */
X          last = NOTWEEDOUT;
X          continue;
X        }
X        if (strlen(buffer) < 2) {    /* empty line    */
X          last = NOTWEEDOUT;
X          continue;
X        }
X
X        if(breakup(buffer, word1, word2) == -1)
X          continue;        /* word2 is null - let default value stand */
X
X        strcpy(word1, shift_lower(word1));    /* to lower case */
X
X        if (equal(word1,"maildir") || equal(word1,"folders")) {
X          strcpy(raw_folders, word2);
X          expand_env(folders, word2);
X          last = NOTWEEDOUT;
X        }
X        else if (equal(word1, "fullname") || equal(word1,"username") ||
X             equal(word1, "name")) {
X          strcpy(full_username, word2);
X          last = NOTWEEDOUT;
X        }
X        else if (equal(word1, "prefix")) {
X          for (i=0; i < strlen(word2); i++)
X        prefixchars[i] = (word2[i] == '_' ? ' ' : word2[i]);
X          prefixchars[i] = '\0';
X
X          last = NOTWEEDOUT;
X        }
X        else if (equal(word1, "shell")) {
X          strcpy(raw_shell, word2);
X          expand_env(shell, word2);
X          last = NOTWEEDOUT;
X        }
X        else if (equal(word1, "sort") || equal(word1, "sortby")) {
X          strcpy(word2, shift_lower(word2));
X          if (equal(word2, "sent"))
X         sortby = SENT_DATE;
X          else if (equal(word2, "received") || equal(word2,"recieved"))
X         sortby = RECEIVED_DATE;
X          else if (equal(word2, "from") || equal(word2, "sender"))
X         sortby = SENDER;
X          else if (equal(word2, "size") || equal(word2, "lines"))
X        sortby = SIZE;
X          else if (equal(word2, "subject"))
X        sortby = SUBJECT;
X          else if (equal(word2, "mailbox") || equal(word2, "folder"))
X        sortby = MAILBOX_ORDER;
X          else if (equal(word2, "status"))
X        sortby = STATUS;
X          else if (equal(word2, "reverse-sent") || equal(word2,"rev-sent"))
X         sortby = - SENT_DATE;
X          else if (strncmp(word2, "reverse-rec",11) == 0 ||
X               strncmp(word2,"rev-rec",7) == 0)
X         sortby = - RECEIVED_DATE;
X          else if (equal(word2, "reverse-from") || equal(word2, "rev-from")
X            || equal(word2,"reverse-sender")||equal(word2,"rev-sender"))
X         sortby = - SENDER;
X          else if (equal(word2, "reverse-size") || equal(word2, "rev-size")
X            || equal(word2, "reverse-lines")|| equal(word2,"rev-lines"))
X        sortby = - SIZE;
X          else if (equal(word2, "reverse-subject") ||
X               equal(word2, "rev-subject"))
X        sortby = - SUBJECT;
X          else if (equal(word2, "reverse-mailbox") ||
X               equal(word2, "rev-mailbox") ||
X               equal(word2, "reverse-folder") ||
X               equal(word2, "rev-folder"))
X        sortby = - MAILBOX_ORDER;
X          else if (equal(word2, "reverse-status") ||
X               equal(word2, "rev-status"))
X        sortby = - STATUS;
X          else {
X        errors++;
X        printf(
X      "I can't understand sort key %s in line %d in your \".elm/elmrc\" file\n",
X             word2, lineno);
X            continue;
X          }
X        }
X        else if (equal (word1, "receivedmail") || equal(word1, "mailbox")) {
X          /* the last is an old name of this option - here for
X           * compatibility in case the user has never written out
X           * a new elmrc while in elm since the name change.
X           */
X          rc_has_recvdmail = TRUE;
SHAR_EOF
echo "End of part 18"
echo "File src/read_rc.c is continued in part 19"
echo "19" > s2_seq_.tmp
exit 0