rsalz@uunet.uu.net (Rich Salz) (06/05/90)
Submitted-by: Syd Weinstein <syd@dsinc.dsi.com>
Posting-number: Volume 22, Issue 80
Archive-name: elm2.3/part21
---- Cut Here and unpack ----
#!/bin/sh
# this is part 21 of a multipart archive
# do not concatenate these parts, unpack them in order with /bin/sh
# file src/returnadd.c continued
#
CurArch=21
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/returnadd.c"
sed 's/^X//' << 'SHAR_EOF' >> src/returnadd.c
X
X buffer[0] = '\0';
X
X ok = (int) (fgets(buf2, SLEN, mailfile) != NULL);
X if (ok)
X if(buf2[strlen(buf2)-1] == '\n') lines--; /* got a full line */
X
X while (ok && lines) {
X buf[0] = '\0';
X strncat(buf, buf2, SLEN);
X ok = (int) (fgets(buf2, SLEN, mailfile) != NULL);
X if (ok)
X if(buf2[strlen(buf2)-1] == '\n') lines--; /* got a full line */
X while (ok && lines && whitespace(buf2[0])) {
X if (buf[strlen(buf)-1] == '\n')
X buf[strlen(buf)-1] = '\0';
X strncat(buf, buf2, (SLEN-strlen(buf)-1));
X ok = (int) (fgets(buf2, SLEN, mailfile) != NULL);
X if (ok)
X if(buf2[strlen(buf2)-1] == '\n') lines--; /* got a full line */
X }
X
X/* At this point, "buf" contains the unfolded header line, while "buf2" contains
X the next single line of text from the mail file */
X
X if (first_word(buf, "From "))
X sscanf(buf, "%*s %s", hold_return);
X else if (first_word(buf, ">From")) {
X sscanf(buf,"%*s %s %*s %*s %*s %*s %*s %*s %*s %s %s",
X name1, name2, alt_name2);
X if (strcmp(name2, "from") == 0) /* remote from xyz */
X strcpy(name2, alt_name2);
X else if (strcmp(name2, "by") == 0) /* forwarded by xyz */
X strcpy(name2, alt_name2);
X add_site(buffer, name2, lastname);
X }
X
X#ifdef USE_EMBEDDED_ADDRESSES
X
X else if (first_word(buf, "From:")) {
X get_address_from("From:", buf, hold_return);
X buffer[0] = '\0';
X }
X else if (first_word(buf, "Reply-To:")) {
X get_address_from("Reply-To:", buf, buffer);
X return(using_to);
X }
X
X#endif
X
X else if (strlen(buf) < 2) /* done with header */
X lines = 0; /* let's get outta here! We're done!!! */
X }
X
X if (buffer[0] == '\0')
X strcpy(buffer, hold_return); /* default address! */
X else
X add_site(buffer, name1, lastname); /* get the user name too! */
X
X if (first_word(buffer, "To:")) { /* for backward compatibility */
X get_existing_address(buffer,msgnum);
X using_to = TRUE;
X }
X else {
X /*
X * KLUDGE ALERT - DANGER WILL ROBINSON
X * We can't just leave a bare login name as the return address,
X * or it will be alias-expanded.
X * So we qualify it with the current host name (and, maybe, domain).
X * Sigh.
X */
X
X if (chloc(buffer, '@') < 0
X && chloc(buffer, '%') < 0
X && chloc(buffer, '!') < 0)
X {
X#ifdef INTERNET
X sprintf(buffer + strlen(buffer), "@%s", hostfullname);
X#else
X strcpy(buf, buffer);
X sprintf(buffer, "%s!%s", hostname, buf);
X#endif
X }
X
X /*
X * If we have a space character,
X * or we DON'T have '!' or '@' chars,
X * append the user-readable name.
X */
X if (chloc(headers[msgnum]->from, ' ') >= 0 ||
X (chloc(headers[msgnum]->from, '!') < 0 &&
X chloc(headers[msgnum]->from, '@') < 0)) {
X sprintf(buffer + strlen(buffer),
X " (%s)", headers[msgnum]->from);
X }
X }
X
X return(using_to);
X}
X
Xget_existing_address(buffer, msgnum)
Xchar *buffer;
Xint msgnum;
X{
X /** This routine is called when the message being responded to has
X "To:xyz" as the return address, signifying that this message is
X an automatically saved copy of a message previously sent. The
X correct to address can be obtained fairly simply by reading the
X To: header from the message itself and (blindly) copying it to
X the given buffer. Note that this header can be either a normal
X "To:" line (Elm) or "Originally-To:" (previous versions e.g.Msg)
X **/
X
X char mybuf[LONG_STRING];
X register char ok = 1, in_to = 0;
X
X buffer[0] = '\0';
X
X /** first off, let's get to the beginning of the message... **/
X
X if(msgnum < 0 || msgnum >= message_count || message_count < 1) {
X dprint(1, (debugfile,
X "Error: %d not a valid message number message_count = %d (%s)",
X msgnum, message_count, "get_existing_address"));
X error1("%d not a valid message number!");
X return;
X }
X if (fseek(mailfile, headers[msgnum]->offset, 0) == -1) {
X dprint(1, (debugfile,
X "Error: seek %ld bytes into file hit errno %s (%s)",
X headers[msgnum]->offset, error_name(errno),
X "get_existing_address"));
X error2("Couldn't seek %d bytes into the file (%s).",
X headers[msgnum]->offset, error_name(errno));
X return;
X }
X
X /** okay! Now we're there! **/
X
X while (ok) {
X ok = (int) (fgets(mybuf, LONG_STRING, mailfile) != NULL);
X no_ret(mybuf); /* remove return character */
X
X if (first_word(mybuf, "To: ")) {
X in_to = TRUE;
X strcpy(buffer, (char *) mybuf + strlen("To: "));
X }
X else if (first_word(mybuf, "Original-To:")) {
X in_to = TRUE;
X strcpy(buffer, (char *) mybuf + strlen("Original-To:"));
X }
X else if (in_to && whitespace(mybuf[0])) {
X strcat(buffer, " "); /* tag a space in */
X strcat(buffer, (char *) mybuf + 1); /* skip 1 whitespace */
X }
X else if (strlen(mybuf) < 2)
X return; /* we're done for! */
X else
X in_to = 0;
X }
X}
SHAR_EOF
echo "File src/returnadd.c is complete"
chmod 0444 src/returnadd.c || echo "restore of src/returnadd.c fails"
echo "x - extracting src/save_opts.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/save_opts.c &&
X
Xstatic char rcsid[] = "@(#)$Id: save_opts.c,v 4.1 90/04/28 22:44:00 syd Exp $";
X
X/*******************************************************************************
X * The Elm Mail System - $Revision: 4.1 $ $State: Exp $
X *
X * Copyright (c) 1986, 1987 Dave Taylor
X * Copyright (c) 1988, 1989, 1990 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X * Syd Weinstein, Elm Coordinator
X * elm@DSI.COM dsinc!elm
X *
X *******************************************************************************
X * $Log: save_opts.c,v $
X * Revision 4.1 90/04/28 22:44:00 syd
X * checkin of Elm 2.3 as of Release PL0
X *
X *
X ******************************************************************************/
X
X/** This file contains the routine needed to allow the users to change the
X Elm parameters and then save the configuration in a ".elm/elmrc" file in
X their home directory. With any luck this will allow them never to have
X to actually EDIT the file!!
X
X**/
X
X#include "headers.h"
X#include <errno.h>
X
X#undef onoff
X#define onoff(n) (n == 1? "ON":"OFF")
X
X#define absolute(x) ((x) < 0? -(x) : (x))
X
Xextern int errno;
Xextern char version_buff[];
X
Xchar *error_name(), *sort_name();
Xlong ftell();
X
X#include "save_opts.h"
X
XFILE *elminfo; /* informational file as needed... */
X
Xsave_options()
X{
X /** Save the options currently specified to a file. This is a
X fairly complex routine since it tries to put in meaningful
X comments and such as it goes along. The comments are
X extracted from the file ELMRC_INFO as defined in the sysdefs.h
X file. THAT file has the format;
X
X varname
X <comment>
X <comment>
X <blank line>
X
X and each comment is written ABOVE the variable to be added. This
X program also tries to make 'pretty' stuff like the alternatives
X and such.
X **/
X
X FILE *newelmrc;
X char oldfname[SLEN], newfname[SLEN];
X
X sprintf(newfname, "%s/%s", home, elmrcfile);
X sprintf(oldfname, "%s/%s", home, old_elmrcfile);
X
X /** first off, let's see if they already HAVE a .elm/elmrc file **/
X
X save_file_stats(newfname);
X if (access(newfname, ACCESS_EXISTS) != -1) {
X /** YES! Copy it to the file ".old.elmrc".. **/
X if (rename(newfname, oldfname) < 0)
X dprint(2, (debugfile, "Unable to rename %s to %s\n",
X newfname, oldfname));
X (void) chown(oldfname, userid, groupid);
X
X }
X
X /** now let's open the datafile if we can... **/
X
X if ((elminfo = fopen(ELMRC_INFO, "r")) == NULL)
X error1("Warning: saving without comments! Can't get to %s.",
X ELMRC_INFO);
X
X /** next, open the new .elm/elmrc file... **/
X
X if ((newelmrc = fopen(newfname, "w")) == NULL) {
X error2("Can't save configuration! Can't write to %s [%s].",
X newfname, error_name(errno));
X return;
X }
X
X save_user_options(elminfo, newelmrc);
X restore_file_stats(newfname);
X
X error1("Options saved in file %s.", newfname);
X}
X
Xsave_user_options(elminfo_fd, newelmrc)
XFILE *elminfo_fd, *newelmrc;
X{
X /** save the information in the file. If elminfo_fd == NULL don't look
X for comments!
X **/
X
X if (elminfo_fd != NULL)
X build_offset_table(elminfo_fd);
X
X fprintf(newelmrc,
X "#\n# .elm/elmrc - options file for the ELM mail system\n#\n");
X
X if (strlen(full_username) > 0)
X fprintf(newelmrc, "# Saved automatically by ELM %s for %s\n#\n\n",
X version_buff, full_username);
X else
X fprintf(newelmrc, "# Saved automatically by ELM %s\n#\n\n", version_buff);
X fprintf(newelmrc,"# For yes/no settings with ?, ON means yes, OFF means no\n\n");
X
X save_option_string(CALENDAR, raw_calendar_file, newelmrc, FALSE);
X save_option_string(EDITOR, raw_editor, newelmrc, FALSE);
X
X save_option_char(ESCAPECHAR, escape_char, newelmrc);
X
X save_option_string(FULLNAME, full_username, newelmrc, FALSE);
X save_option_string(RECEIVEDMAIL, raw_recvdmail, newelmrc, FALSE);
X save_option_string(MAILDIR, raw_folders, newelmrc, FALSE);
X save_option_string(TMPDIR, temp_dir, newelmrc, FALSE);
X save_option_string(PAGER, raw_pager, newelmrc, FALSE);
X save_option_string(PREFIX, prefixchars, newelmrc, TRUE);
X save_option_string(PRINT, raw_printout, newelmrc, FALSE);
X save_option_string(SENTMAIL, raw_sentmail, newelmrc, FALSE);
X save_option_string(SHELL, raw_shell, newelmrc, FALSE);
X
X save_option_string(LOCALSIGNATURE, raw_local_signature,
X newelmrc, FALSE);
X save_option_string(REMOTESIGNATURE, raw_remote_signature,
X newelmrc, FALSE);
X save_option_on_off(SIGDASHES, sig_dashes, newelmrc);
X
X save_option_sort(SORTBY, newelmrc);
X
X save_option_on_off(ALWAYSDELETE, always_del, newelmrc);
X save_option_on_off(ALWAYSSTORE, always_store, newelmrc);
X save_option_on_off(ALWAYSKEEP, always_keep, newelmrc);
X save_option_on_off(ARROW, arrow_cursor, newelmrc);
X save_option_on_off(ASK, question_me, newelmrc);
X save_option_on_off(ASKCC, prompt_for_cc, newelmrc);
X save_option_string(ATTRIBUTION, attribution, newelmrc, FALSE);
X save_option_on_off(AUTOCOPY, auto_copy, newelmrc);
X
X save_option_number(BOUNCEBACK, bounceback, newelmrc);
X
X save_option_on_off(COPY, auto_cc, newelmrc);
X save_option_on_off(FORCENAME, force_name, newelmrc);
X save_option_on_off(FORMS, (allow_forms != NO), newelmrc);
X save_option_on_off(KEEPEMPTY, keep_empty_files, newelmrc);
X save_option_on_off(KEYPAD, hp_terminal, newelmrc);
X save_option_on_off(MENU, mini_menu, newelmrc);
X save_option_on_off(MOVEPAGE, move_when_paged, newelmrc);
X save_option_on_off(NAMES, names_only, newelmrc);
X save_option_on_off(NOHEADER, noheader, newelmrc);
X save_option_on_off(POINTNEW, point_to_new, newelmrc);
X save_option_on_off(PROMPTAFTER, prompt_after_pager, newelmrc);
X save_option_on_off(RESOLVE, resolve_mode, newelmrc);
X save_option_on_off(SAVENAME, save_by_name, newelmrc);
X save_option_on_off(SOFTKEYS, hp_softkeys, newelmrc);
X
X save_option_number(TIMEOUT, (int) timeout, newelmrc);
X
X save_option_on_off(TITLES, title_messages, newelmrc);
X
X save_option_number(USERLEVEL, user_level, newelmrc);
X
X save_option_on_off(WARNINGS, warnings, newelmrc);
X save_option_on_off(WEED, filter, newelmrc);
X
X save_option_weedlist(WEEDOUT, newelmrc);
X save_option_alternatives(ALTERNATIVES, alternative_addresses, newelmrc);
X
X fclose(newelmrc);
X if ( elminfo_fd != NULL ) {
X fclose(elminfo_fd);
X }
X}
X
Xsave_option_string(iindex, value, fd, underscores)
Xint iindex, underscores;
Xchar *value;
XFILE *fd;
X{
X /** Save a string option to the file... only subtlety is when we
X save strings with spaces in 'em - translate to underscores!
X **/
X
X char buffer[SLEN], *bufptr;
X
X add_comment(iindex, fd);
X
X strcpy(buffer, value);
X
X if (underscores)
X for (bufptr = buffer; *bufptr; bufptr++)
X if (*bufptr == SPACE) *bufptr = '_';
X
X fprintf(fd, "%s = %s\n\n", save_info[iindex].name, buffer);
X}
X
Xsave_option_sort(iindex, fd)
Xint iindex;
XFILE *fd;
X{
X /** save the current sorting option to a file **/
X
X add_comment(iindex, fd);
X
X fprintf(fd, "%s = %s\n\n", save_info[iindex].name,
X sort_name(SHORT));
X}
X
Xsave_option_char(iindex, value, fd)
Xint iindex;
Xchar value;
XFILE *fd;
X{
X /** Save a character option to the file **/
X
X add_comment(iindex, fd);
X
X fprintf(fd, "%s = %c\n\n", save_info[iindex].name, value);
X}
X
Xsave_option_number(iindex, value, fd)
Xint iindex, value;
XFILE *fd;
X{
X /** Save a binary option to the file - boy is THIS easy!! **/
X
X add_comment(iindex, fd);
X
X fprintf(fd, "%s = %d\n\n", save_info[iindex].name, value);
X}
X
Xsave_option_on_off(iindex, value, fd)
Xint iindex, value;
XFILE *fd;
X{
X /** Save a binary option to the file - boy is THIS easy!! **/
X
X add_comment(iindex, fd);
X
X fprintf(fd, "%s = %s\n\n", save_info[iindex].name, onoff(value));
X}
X
Xsave_option_weedlist(iindex, fd)
Xint iindex;
XFILE *fd;
X{
X /** save a list of weedout headers to the file **/
X
X int length_so_far = 0, i;
X
X add_comment(iindex, fd);
X
X length_so_far = strlen(save_info[iindex].name) + 4;
X
X fprintf(fd, "%s = ", save_info[iindex].name);
X
X /** first off, skip till we get past the default list **/
X
X for (i = 0; i < weedcount; i++)
X if (strcmp(weedlist[i],"*end-of-defaults*") == 0)
X break;
X
X while (i < weedcount) {
X if (strcmp(weedlist[i], "*end-of-defaults*") != 0)
X break;
X i++; /* and get PAST it too! */
X }
X
X while (i < weedcount) {
X if (strlen(weedlist[i]) + length_so_far > 78) {
X fprintf(fd, "\n\t");
X length_so_far = 8;
X }
X fprintf(fd, "\"%s\" ", weedlist[i]);
X length_so_far += (strlen(weedlist[i]) + 4);
X i++;
X }
X fprintf(fd, "\t\"*end-of-user-headers*\"\n\n");
X}
X
Xsave_option_alternatives(iindex, list, fd)
Xint iindex;
Xstruct addr_rec *list;
XFILE *fd;
X{
X /** save a list of options to the file **/
X int length_so_far = 0;
X struct addr_rec *alternate;
X
X if (list == NULL) return; /* nothing to do! */
X
X add_comment(iindex, fd);
X
X alternate = list; /* don't LOSE the top!! */
X
X length_so_far = strlen(save_info[iindex].name) + 4;
X
X fprintf(fd, "%s = ", save_info[iindex].name);
X
X while (alternate != NULL) {
X if (strlen(alternate->address) + length_so_far > 78) {
X fprintf(fd, "\n\t");
X length_so_far = 8;
X }
X fprintf(fd, "%s ", alternate->address);
X length_so_far += (strlen(alternate->address) + 3);
X alternate = alternate->next;
X }
X fprintf(fd, "\n\n");
X}
X
Xadd_comment(iindex, fd)
Xint iindex;
XFILE *fd;
X{
X /** get to and add the comment to the file **/
X char buffer[SLEN];
X
X /** first off, add the comment from the comment file, if available **/
X
X if (save_info[iindex].offset > 0L) {
X if (fseek(elminfo, save_info[iindex].offset, 0) == -1) {
X dprint(1,(debugfile,
X "** error %s seeking to %ld in elm-info file!\n",
X error_name(errno), save_info[iindex].offset));
X }
X else while (fgets(buffer, SLEN, elminfo) != NULL) {
X if (buffer[0] != '#')
X break;
X else
X fprintf(fd, "%s", buffer);
X }
X }
X}
X
Xbuild_offset_table(elminfo_fd)
XFILE *elminfo_fd;
X{
X /** read in the info file and build the table of offsets.
X This is a rather laborious puppy, but at least we can
X do a binary search through the array for each element and
X then we have it all at once!
X **/
X
X char line_buffer[SLEN];
X
X while (fgets(line_buffer, SLEN, elminfo_fd) != NULL) {
X if (strlen(line_buffer) > 1)
X if (line_buffer[0] != '#' && !whitespace(line_buffer[0])) {
X no_ret(line_buffer);
X if (find_and_store_loc(line_buffer, ftell(elminfo_fd))) {
X dprint(1, (debugfile,"** Couldn't find and store \"%s\" **\n",
X line_buffer));
X }
X }
X }
X}
X
Xfind_and_store_loc(name, offset)
Xchar *name;
Xlong offset;
X{
X /** given the name and offset, find it in the table and store it **/
X
X int first = 0, last, middle, compare;
X
X last = NUMBER_OF_SAVEABLE_OPTIONS;
X
X while (first <= last) {
X
X middle = (first+last) / 2;
X
X if ((compare = strcmp(name, save_info[middle].name)) < 0) /* a < b */
X last = middle - 1;
X else if (compare == 0) { /* a = b */
X save_info[middle].offset = offset;
X return(0);
X }
X else /* greater */ /* a > b */
X first = middle + 1;
X }
X
X return(-1);
X}
SHAR_EOF
chmod 0444 src/save_opts.c || echo "restore of src/save_opts.c fails"
echo "x - extracting src/savecopy.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/savecopy.c &&
X
Xstatic char rcsid[] = "@(#)$Id: savecopy.c,v 4.1 90/04/28 22:44:02 syd Exp $";
X
X/*******************************************************************************
X * The Elm Mail System - $Revision: 4.1 $ $State: Exp $
X *
X * Copyright (c) 1986, 1987 Dave Taylor
X * Copyright (c) 1988, 1989, 1990 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X * Syd Weinstein, Elm Coordinator
X * elm@DSI.COM dsinc!elm
X *
X *******************************************************************************
X * $Log: savecopy.c,v $
X * Revision 4.1 90/04/28 22:44:02 syd
X * checkin of Elm 2.3 as of Release PL0
X *
X *
X ******************************************************************************/
X
X/** Save a copy of the specified message in a folder.
X
X**/
X
X#include "headers.h"
X#ifdef I_TIME
X# include <time.h>
X#endif
X#ifdef I_SYSTIME
X# include <sys/time.h>
X#endif
X
X#include <errno.h>
X
Xchar *format_long();
Xchar *error_name(), *error_description();
Xchar *ctime();
X
Xextern char in_reply_to[SLEN]; /* In-Reply-To: string */
Xextern int errno;
X
Xchar *strcat(), *strcpy();
Xunsigned long sleep();
Xlong time();
X
Xsave_copy(to, cc, bcc, filename, copy_file, form)
Xchar *to, *cc, *bcc, *filename, *copy_file;
Xint form;
X{
X /** This routine appends a copy of the outgoing message to the
X file specified. **/
X
X FILE *save, /* file id for file to save to */
X *message, /* file id for file with message body */
X *write_header_info();
X char buffer[SLEN], /* read buffer */
X savename[SLEN]; /* name of file saving into */
X
X
X /* presume copy_file is okay as is for now */
X strcpy(savename, copy_file);
X
X /* if save-by-name wanted */
X if((strcmp(copy_file, "=") == 0) || (strcmp(copy_file, "=?") == 0)) {
X
X get_return_name(to, buffer, TRUE); /* determine 'to' login */
X if (strlen(buffer) == 0) {
X
X /* can't get file name from 'to' -- use sent_mail instead */
X dprint(3, (debugfile,
X "Warning: get_return_name couldn't break down %s\n", to));
X error1(
X"Cannot determine `to' name to save by! Saving to \"sent\" folder %s instead.",
X sent_mail);
X strcpy(savename, "<");
X sleep(3);
X } else
X sprintf(savename, "=%s", buffer); /* good! */
X }
X
X expand_filename(savename, TRUE); /* expand special chars */
X
X /* If saving conditionally by logname but folder doesn't exist
X * save to sent folder instead. */
X if((strcmp(copy_file, "=?") == 0)
X && (access(savename, ACCESS_EXISTS) != 0)) {
X dprint(5, (debugfile,
X "Conditional save by name: file %s doesn't exist - using \"<\".\n",
X savename));
X strcpy(savename, "<");
X expand_filename(savename, TRUE);
X }
X
X if ((errno = can_open(savename, "a"))) {
X dprint(2, (debugfile,
X "Error: attempt to autosave to a file that can't be appended to!\n"));
X dprint(2, (debugfile, "\tfilename = \"%s\"\n", savename));
X dprint(2, (debugfile, "** %s - %s **\n", error_name(errno),
X error_description(errno)));
X
X /* Lets try sent_mail before giving up */
X if(strcmp(sent_mail, savename) == 0) {
X /* we are ALREADY using sent_mail! */
X error1("Cannot save to %s!", savename);
X sleep(3);
X return(FALSE);
X }
X
X if ((errno = can_open(sent_mail, "a"))) {
X dprint(2, (debugfile,
X "Error: attempt to autosave to a file that can't be appended to!\n"));
X dprint(2, (debugfile, "\tfilename = \"%s\"\n", sent_mail));
X dprint(2, (debugfile, "** %s - %s **\n", error_name(errno),
X error_description(errno)));
X error2("Cannot save to %s nor to \"sent\" folder %s!",
X savename, sent_mail);
X sleep(3);
X return(FALSE);
X }
X error2("Cannot save to %s! Saving to \"sent\" folder %s instead.",
X savename, sent_mail);
X sleep(3);
X strcpy(savename, sent_mail);
X }
X
X save_file_stats(savename);
X
X /* Write header */
X if ((save = write_header_info(savename, to, cc, bcc,
X form == YES, TRUE)) == NULL)
X return(FALSE);
X
X /* Now add file with message as handed to mailer */
X if ((message = fopen(filename, "r")) == NULL) {
X fclose(save);
X dprint(1, (debugfile,
X "Error: Couldn't read folder %s (save_copy)\n", filename));
X dprint(1, (debugfile, "** %s - %s **\n", error_name(errno),
X error_description(errno)));
X error1("Couldn't read folder %s!", filename);
X sleep(3);
X return(FALSE);
X }
X
X copy_message_across(message, save, TRUE);
X
X
X fclose(save);
X fclose(message);
X
X restore_file_stats(savename);
X
X return(TRUE);
X}
Xchar *
Xcf_english(fn)
Xchar *fn;
X{
X /** Return "English" expansion for special copy file name abbreviations
X or just the file name **/
X
X if(!*fn)
X return("<no save>");
X else if(!fn[1]) {
X if(*fn == '=')
X return("<unconditionally save by name>");
X else if(*fn == '<')
X return("<\"sent\" folder>");
X } else if ((fn[0] == '=') && (fn[1] == '?'))
X return("<conditionally save by name>");
X
X return(fn);
X}
X
X#define NCF_PROMPT "Save copy in (use '?' for help/to list folders): "
Xint
Xname_copy_file(fn)
Xchar *fn;
X{
X /** Prompt user for name of file for saving copy of outbound msg to.
X Return true if we need a redraw. **/
X
X int redraw = 0; /* set when we ask for help = need redraw */
X char buffer[SLEN], origbuffer[SLEN];
X static char helpmsg[LONG_STRING];
X
X /* expand passed copy file name into English */
X strcpy(buffer, cf_english(fn));
X
X /* prepare screen with instructions */
X MoveCursor(LINES-2, 0);
X CleartoEOS();
X PutLine0(LINES-2, 0, NCF_PROMPT);
X
X while(1) {
X
X /* get file name from user input */
X strcpy(origbuffer, buffer);
X optionally_enter(buffer, LINES-2, strlen(NCF_PROMPT), FALSE, FALSE);
X
X if(strcmp(buffer, "?") != 0) { /* got what we wanted - non-help choice */
X
X if(strcmp(origbuffer, buffer) != 0)
X /* user changed from our English expansion
X * so we'd better copy user input to fn
X */
X strcpy(fn, buffer);
X
X /* else user presumably left our English expansion - no change in fn */
X
X /* display English expansion of new user input a while */
X PutLine1(LINES-2, strlen(NCF_PROMPT), cf_english(fn));
X MoveCursor(LINES, 0);
X sleep(1);
X MoveCursor(LINES-2, 0);
X CleartoEOS();
X
X return(redraw);
X }
X
X /* give help and list folders */
X redraw = TRUE;
X if(!*helpmsg) /* help message not yet formulated */
X sprintf(helpmsg,
X "\n\r%s\n\r%s%s%s\n\r%s\n\r%s\n\r%s\n\r%s\n\r%s\n\r\n\r",
X "Enter: <nothing> to not save a copy of the message,",
X " '<' to save in your \"sent\" folder (", sent_mail, "),",
X " '=' to save by name (the folder name depends on whom the",
X " message is to, in the end),",
X " '=?' to save by name if the folder already exists,",
X " and if not, to your \"sent\" folder,",
X " or a filename (a leading '=' denotes your folder directory).");
X
X list_folders(4, helpmsg);
X PutLine0(LINES-2, 0, NCF_PROMPT);
X
X /* restore as default to English version of the passed copy file name */
X strcpy(buffer, cf_english(fn));
X
X }
X}
SHAR_EOF
chmod 0444 src/savecopy.c || echo "restore of src/savecopy.c fails"
echo "x - extracting src/screen.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/screen.c &&
X
Xstatic char rcsid[] = "@(#)$Id: screen.c,v 4.1 90/04/28 22:44:04 syd Exp $";
X
X/*******************************************************************************
X * The Elm Mail System - $Revision: 4.1 $ $State: Exp $
X *
X * Copyright (c) 1986, 1987 Dave Taylor
X * Copyright (c) 1988, 1989, 1990 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X * Syd Weinstein, Elm Coordinator
X * elm@DSI.COM dsinc!elm
X *
X *******************************************************************************
X * $Log: screen.c,v $
X * Revision 4.1 90/04/28 22:44:04 syd
X * checkin of Elm 2.3 as of Release PL0
X *
X *
X ******************************************************************************/
X
X/** screen display routines for ELM program
X
X**/
X
X#include "headers.h"
X
X#define minimum(a,b) ((a) < (b) ? (a) : (b))
X
Xstatic int last_current = -1;
X
Xchar *strcpy(), *strncpy(), *nameof(), *show_status(), *index();
X
Xextern char version_buff[];
X
Xshowscreen()
X{
X
X ClearScreen();
X
X update_title();
X
X last_header_page = -1; /* force a redraw regardless */
X show_headers();
X
X if (mini_menu)
X show_menu();
X
X show_last_error();
X
X if (hp_terminal)
X define_softkeys(MAIN);
X}
X
Xupdate_title()
X{
X /** display a new title line, probably due to new mail arriving **/
X
X char buffer[SLEN];
X
X if (selected)
X sprintf(buffer,
X "%s is '%s' with %d shown out of %d [ELM %s]",
X (folder_type == SPOOL ? "Mailbox" : "Folder"),
X nameof(cur_folder), selected, message_count, version_buff);
X else
X sprintf(buffer, "%s is '%s' with %d message%s [ELM %s]",
X (folder_type == SPOOL ? "Mailbox" : "Folder"),
X nameof(cur_folder), message_count,
X plural(message_count), version_buff);
X
X ClearLine(1);
X
X Centerline(1, buffer);
X}
X
Xshow_menu()
X{
X /** write main system menu... **/
X
X if (user_level == 0) { /* a rank beginner. Give less options */
X Centerline(LINES-7,
X "You can use any of the following commands by pressing the first character;");
X Centerline(LINES-6,
X"d)elete or u)ndelete mail, m)ail a message, r)eply or f)orward mail, q)uit");
X Centerline(LINES-5,
X "To read a message, press <return>. j = move down, k = move up, ? = help");
X } else {
X Centerline(LINES-7,
X "|=pipe, !=shell, ?=help, <n>=set current to n, /=search pattern");
X Centerline(LINES-6,
X"a)lias, C)opy, c)hange folder, d)elete, e)dit, f)orward, g)roup reply, m)ail,"
X);
X Centerline(LINES-5,
X "n)ext, o)ptions, p)rint, q)uit, r)eply, s)ave, t)ag, u)ndelete, or e(x)it");
X }
X}
X
Xint
Xshow_headers()
X{
X /** Display page of headers (10) if present. First check to
X ensure that header_page is in bounds, fixing silently if not.
X If out of bounds, return zero, else return non-zero
X Modified to only show headers that are "visible" to ze human
X person using ze program, eh?
X **/
X
X register int this_msg = 0, line = 4, last = 0, last_line,
X displayed = 0, using_to;
X char newfrom[SLEN], buffer[SLEN];
X
X if (fix_header_page())
X return(FALSE);
X
X if (selected) {
X if ((header_page*headers_per_page) > selected)
X return(FALSE); /* too far! too far! */
X
X this_msg = visible_to_index(header_page * headers_per_page + 1);
X displayed = header_page * headers_per_page;
X
X last = displayed+headers_per_page;
X
X }
X else {
X if (header_page == last_header_page) /* nothing to do! */
X return(FALSE);
X
X /** compute last header to display **/
X
X this_msg = header_page * headers_per_page;
X last = this_msg + (headers_per_page - 1);
X }
X
X if (last >= message_count) last = message_count-1;
X
X /** Okay, now let's show the header page! **/
X
X ClearLine(line); /* Clear the top line... */
X
X MoveCursor(line, 0); /* and move back to the top of the page... */
X
X while ((selected && displayed < last) || this_msg <= last) {
X using_to = tail_of(headers[this_msg]->from, newfrom,
X headers[this_msg]->to);
X
X if (this_msg == current-1)
X build_header_line(buffer, headers[this_msg], this_msg+1,
X TRUE, newfrom, using_to);
X else
X build_header_line(buffer, headers[this_msg],
X this_msg+1, FALSE, newfrom, using_to);
X if (selected)
X displayed++;
X
X if (this_msg == current-1 && has_highlighting && ! arrow_cursor) {
X StartInverse();
X Write_to_screen("%s\n\r", 1, buffer); /* avoid '%' probs */
X EndInverse();
X } else
X Write_to_screen("%s\n\r", 1, buffer); /* avoid '%' probs */
X CleartoEOLN();
X line++; /* for clearing up in a sec... */
X
X if (selected) {
X if ((this_msg = next_message(this_msg, FALSE)) < 0)
X break; /* GET OUTTA HERE! */
X
X /* the preceeding looks gross because we're using an INDEX
X variable to pretend to be a "current" counter, and the
X current counter is always 1 greater than the actual
X index. Does that make sense??
X */
X }
X else
X this_msg++; /* even dumber... */
X }
X
X /* clear unused lines */
X
X if (mini_menu)
X last_line = LINES-8;
X else
X last_line = LINES-4;
X
X while (line < last_line) {
X CleartoEOLN();
X NewLine();
X line++;
X }
X
X display_central_message();
X
X last_current = current;
X last_header_page = header_page;
X
X return(TRUE);
X}
X
Xshow_current()
X{
X /** Show the new header, with all the usual checks **/
X
X register int first = 0, last = 0, last_line, new_line, using_to;
X char newfrom[SLEN], old_buffer[SLEN], new_buffer[SLEN];
X
X (void) fix_header_page(); /* Who cares what it does? ;-) */
X
X /** compute the first and last header on this page **/
X first = header_page * headers_per_page + 1;
X last = first + (headers_per_page - 1);
X
X /* if not a full page adjust last to be the real last */
X if (selected && last > selected)
X last = selected;
X if (!selected && last > message_count)
X last = message_count;
X
X /** okay, now let's show the pointers... **/
X
X /** have we changed??? **/
X if (current == last_current)
X return;
X
X if (selected) {
X last_line = ((compute_visible(last_current)-1) %
X headers_per_page)+4;
X new_line = ((compute_visible(current)-1) % headers_per_page)+4;
X } else {
X last_line = ((last_current-1) % headers_per_page)+4;
X new_line = ((current-1) % headers_per_page)+4;
X }
X
X if (has_highlighting && ! arrow_cursor) {
X
X using_to = tail_of(headers[current-1]->from, newfrom,
X headers[current-1]->to);
X build_header_line(new_buffer, headers[current-1], current,
X TRUE, newfrom, using_to);
X
X /* clear last current if it's in proper range */
X if (last_current > 0 /* not a dummy value */
X && compute_visible(last_current) <= last
X && compute_visible(last_current) >= first) {
X
X dprint(5, (debugfile,
X "\nlast_current = %d ... clearing [1] before we add [2]\n",
X last_current));
X dprint(5, (debugfile, "first = %d, and last = %d\n\n",
X first, last));
X
X using_to = tail_of(headers[last_current-1]->from, newfrom,
X headers[last_current-1]->to);
X build_header_line(old_buffer, headers[last_current-1],
X last_current, FALSE, newfrom, using_to);
X
X ClearLine(last_line);
X PutLine0(last_line, 0, old_buffer);
X }
X MoveCursor(new_line, 0);
X StartInverse();
X Write_to_screen("%s", 1, new_buffer);
X EndInverse();
X }
X else {
X if (on_page(last_current-1))
X PutLine0(last_line,0," "); /* remove old pointer... */
X if (on_page(current-1))
X PutLine0(new_line, 0,"->");
X }
X
X last_current = current;
X}
X
Xbuild_header_line(buffer, entry, message_number, highlight, from, really_to)
Xchar *buffer;
Xstruct header_rec *entry;
Xint message_number, highlight, really_to;
Xchar *from;
X{
X /** Build in buffer the message header ... entry is the current
X message entry, 'from' is a modified (displayable) from line,
X 'highlight' is either TRUE or FALSE, and 'message_number'
X is the number of the message.
X **/
X
X /** Note: using 'strncpy' allows us to output as much of the
X subject line as possible given the dimensions of the screen.
X The key is that 'strncpy' returns a 'char *' to the string
X that it is handing to the dummy variable! Neat, eh? **/
X
X int who_width = 18, subj_width;
X char *dot = index(from, '.');
X char *bang = index(from, '!');
X
X /* truncate 'from' to 18 characters -
X * this includes the leading "To" if really_to is true.
X * Note:
X * 'from' is going to be of three forms
X * - full name (truncate on the right for readability)
X * - logname@machine (truncate on the right to preserve
X * logname over machine name
X * - machine!logname -- a more complex situation
X * If this form doesn't fit, either machine
X * or logname are long. If logname is long,
X * we can stand to loose part of it, so we
X * truncate on the right. If machine name is
X * long, we'd better truncate on the left,
X * to insure we get the logname. Now if the
X * machine name is long, it will have "." in
X * it.
X * Therfore, we truncate on the left if there is a "." and a "!"
X * in 'from', else we truncate on the right.
X */
X
X /* Note that one huge sprintf() is too hard for some compilers. */
X sprintf(buffer, "%s%s%c%-3d %3.3s %-2d ",
X (highlight && arrow_cursor)? "->" : " ",
X show_status(entry->status),
X (entry->status & TAGGED? '+' : ' '),
X message_number,
X entry->month,
X atoi(entry->day));
X
X /* show "To " in a way that it can never be truncated. */
X if (really_to) {
X strcat(buffer, "To ");
X who_width -= 3;
X }
X
X /* truncate 'from' on left if needed.
X * sprintf will truncate on right afterward if needed. */
X if ((strlen(from) > who_width) && dot && bang && (dot < bang)) {
X from += (strlen(from) - who_width);
X }
X
X /* Set the subject display width.
X * If it is too long, truncate it to fit.
X * If it is highlighted but not with the arrow cursor,
X * expand it to fit so that the reverse video bar extends
X * aesthetically the full length of the line.
X */
X if ((highlight && !arrow_cursor)
X || (COLUMNS-44 < (subj_width =strlen(entry->subject))))
X subj_width = COLUMNS-44;
X
X /* complete line with sender, length and subject. */
X sprintf(buffer + strlen(buffer), "%-*.*s (%d) %s%-*.*s",
X /* give max and min width parameters for 'from' */
X who_width,
X who_width,
X from,
X
X entry->lines,
X (entry->lines / 1000 > 0? "" : /* spacing the */
X entry->lines / 100 > 0? " " : /* same for the */
X entry->lines / 10 > 0? " " : /* lines in () */
X " "), /* [wierd] */
X
X subj_width, subj_width, entry->subject);
X}
X
Xint
Xfix_header_page()
X{
X /** this routine will check and ensure that the current header
X page being displayed contains messages! It will silently
X fix 'header-page' if wrong. Returns TRUE if changed. **/
X
X int last_page, old_header;
X
X old_header = header_page;
X
X last_page = (int) ((message_count-1) / headers_per_page);
X
X if (header_page > last_page)
X header_page = last_page;
X else if (header_page < 0)
X header_page = 0;
X
X return(old_header != header_page);
X}
X
Xint
Xon_page(message)
Xint message;
X{
X /** Returns true iff the specified message is on the displayed page. **/
X
X if (selected) message = compute_visible(message);
X
X if (message >= header_page * headers_per_page)
X if (message < ((header_page+1) * headers_per_page))
X return(TRUE);
X
X return(FALSE);
X}
X
Xchar *show_status(status)
Xint status;
X{
X /** This routine returns a pair of characters indicative of
X the status of this message. The first character represents
X the interim status of the message (e.g. the status within
X the mail system):
X
X E = Expired message
X N = New message
X O = Unread old message dsi mailx emulation addition
X D = Deleted message
X _ = (space) default
X
X and the second represents the permanent attributes of the
X message:
X
X C = Company Confidential message
X U = Urgent (or Priority) message
X P = Private message
X A = Action associated with message
X F = Form letter
X _ = (space) default
X **/
X
X static char mybuffer[3];
X
X /** the first character, please **/
X
X if (status & DELETED) mybuffer[0] = 'D';
X else if (status & EXPIRED) mybuffer[0] = 'E';
X else if (status & NEW) mybuffer[0] = 'N';
X else if (status & UNREAD) mybuffer[0] = 'O';
X else mybuffer[0] = ' ';
X
X /** and the second... **/
X
X if (status & CONFIDENTIAL) mybuffer[1] = 'C';
X else if (status & URGENT) mybuffer[1] = 'U';
X else if (status & PRIVATE) mybuffer[1] = 'P';
X else if (status & ACTION) mybuffer[1] = 'A';
X else if (status & FORM_LETTER) mybuffer[1] = 'F';
X else mybuffer[1] = ' ';
X
X mybuffer[2] = '\0';
X
X return( (char *) mybuffer);
X}
SHAR_EOF
chmod 0444 src/screen.c || echo "restore of src/screen.c fails"
echo "x - extracting src/showmsg.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > src/showmsg.c &&
X
Xstatic char rcsid[] = "@(#)$Id: showmsg.c,v 4.1 90/04/28 22:44:06 syd Exp $";
X
X/*******************************************************************************
X * The Elm Mail System - $Revision: 4.1 $ $State: Exp $
X *
X * Copyright (c) 1986, 1987 Dave Taylor
X * Copyright (c) 1988, 1989, 1990 USENET Community Trust
X *******************************************************************************
X * Bug reports, patches, comments, suggestions should be sent to:
X *
X * Syd Weinstein, Elm Coordinator
X * elm@DSI.COM dsinc!elm
X *
X *******************************************************************************
X * $Log: showmsg.c,v $
X * Revision 4.1 90/04/28 22:44:06 syd
X * checkin of Elm 2.3 as of Release PL0
X *
X *
X ******************************************************************************/
X
X/** This file contains all the routines needed to display the specified
X message.
X**/
X
X#include "headers.h"
X#include <ctype.h>
X#include <errno.h>
X
X#ifdef BSD
X# include <sys/wait.h>
X# undef tolower
X#endif
X
Xextern int errno;
X
Xchar *error_name(), *strcat(), *strcpy();
Xvoid _exit();
X
Xint memory_lock = FALSE; /* is it available?? */
Xint pipe_abort = FALSE; /* did we receive a SIGNAL(SIGPIPE)? */
X
XFILE *pipe_wr_fp; /* file pointer to write to external pager */
Xextern int lines_displayed, /* defined in "builtin" */
X lines_put_on_screen; /* ditto too! */
X
Xint
Xshow_msg(number)
Xint number;
X{
X /*** Display number'th message. Get starting and ending lines
X of message from headers data structure, then fly through
X the file, displaying only those lines that are between the
X two!
X
X Return 0 to return to the index screen or a character entered
X by the user to initiate a command without returning to
X the index screen (to be processed via process_showmsg_cmd()).
X ***/
X
X char title1[SLEN], title2[SLEN], title3[SLEN], titlebuf[SLEN];
X char who[LONG_STRING], buffer[VERY_LONG_STRING];
X#if defined(BSD) && !defined(WEXITSTATUS)
X union wait wait_stat;
X#else
X int wait_stat;
X#endif
X
X int crypted = 0; /* encryption */
X int weed_header, weeding_out = 0; /* weeding */
X int using_to, /* misc use */
X pipe_fd[2], /* pipe file descriptors */
X new_pipe_fd, /* dup'ed pipe fil des */
X lines, /* num lines in msg */
X fork_ret, /* fork return value */
X wait_ret, /* wait return value */
X form_letter = FALSE, /* Form ltr? */
X form_letter_section = 0, /* section */
X padding = 0, /* counter */
X builtin = FALSE, /* our pager? */
X val = 0, /* return val */
X buf_len; /* line length */
X struct header_rec *current_header = headers[number-1];
X
X
X lines = current_header->lines;
X
X dprint(4, (debugfile,"displaying %d lines from message %d using %s\n",
X lines, number, pager));
X
X if (number > message_count || number < 1)
X return(val);
X
X if(ison(current_header->status, NEW)) {
X clearit(current_header->status, NEW); /* it's been read now! */
X current_header->status_chgd = TRUE;
X }
X if(ison(current_header->status, UNREAD)) {
X clearit(current_header->status, UNREAD); /* it's been read now! */
X current_header->status_chgd = TRUE;
X }
X
X memory_lock = FALSE;
X
X /* some explanation for that last one - We COULD use memory locking
X to speed up the paging, but the action of "ClearScreen" on a screen
X with memory lock turned on seems to vary considerably (amazingly so)
X so it's safer to only allow memory lock to be a viable bit of
X trickery when dumping text to the screen in scroll mode.
X Philosophical arguments should be forwarded to Bruce at the
X University of Walamazoo, Australia, via ACSNet *wry chuckle* */
X
X if (fseek(mailfile, current_header->offset, 0) == -1) {
X dprint(1, (debugfile,
X "Error: seek %d bytes into file, errno %s (show_message)\n",
X current_header->offset, error_name(errno)));
X error2("ELM failed seeking %d bytes into file (%s).",
X current_header->offset, error_name(errno));
X return(val);
X }
X if(current_header->encrypted)
X getkey(OFF);
X
X if(builtin=(first_word(pager,"builtin")||first_word(pager,"internal")))
X
X start_builtin(lines);
X
X else {
X
X /* put terminal out of raw mode so external pager has normal env */
X Raw(OFF);
X
X /* create pipe for external pager and fork */
X
X if(pipe(pipe_fd) == -1) {
X dprint(1, (debugfile, "Error: pipe failed, errno %s (show_msg)\n",
X error_name(errno)));
X error1("Could not prepare for external pager(pipe()-%s).",
X error_name(errno));
X Raw(ON);
X return(val);
X }
X
X if((fork_ret = fork()) == -1) {
X
X dprint(1, (debugfile, "Error: fork failed, errno %s (show_msg)\n",
X error_name(errno)));
X error1("Could not prepare for external pager(fork()-%s).",
X error_name(errno));
X Raw(ON);
X return(val);
X
X } else if (fork_ret == 0) {
X
X /* child fork */
X
X /* close write-only pipe fd and fit read-only pipe fd to stdin */
X
X close(pipe_fd[1]);
X close(fileno(stdin));
X if((new_pipe_fd = dup(pipe_fd[0])) == -1) {
X dprint(1, (debugfile, "Error: dup failed, errno %s (show_msg)\n",
X error_name(errno)));
X error1("Could not prepare for external pager(dup()-%s).",
X error_name(errno));
X _exit(errno);
X }
X close(pipe_fd[0]); /* original pipe fd no longer needed */
X
X /* use stdio on new pipe fd */
X if(fdopen(new_pipe_fd, "r") == NULL) {
X dprint(1,
X (debugfile, "Error: child fdopen failed, errno %s (show_msg)\n",
X error_name(errno)));
X error1("Could not prepare for external pager(child fdopen()-%s).",
X error_name(errno));
X _exit(errno);
X }
X
X /* now execute pager and exit */
X
X /* system_call() will return user to user's normal permissions.
X * This is what makes this pipe secure - user won't have elm's
X * special setgid permissions (if so configured) and will only
X * be able to execute a pager that user normally has permission
X * to execute */
X
X _exit(system_call(pager, SH, TRUE, TRUE));
X
X } /* else this is the parent fork */
X
X /* close read-only pipe fd and do write-only with stdio */
X close(pipe_fd[0]);
X
X if((pipe_wr_fp = fdopen(pipe_fd[1], "w")) == NULL) {
X dprint(1,
X (debugfile, "Error: parent fdopen failed, errno %s (show_msg)\n",
X error_name(errno)));
X error1("Could not prepare for external pager(parent fdopen()-%s).",
X error_name(errno));
X
X /* Failure - must close pipe and wait for child */
X close(pipe_fd[1]);
X while ((wait_ret = wait(&wait_stat)) != fork_ret && wait_ret!= -1)
X ;
X
X Raw(OFF);
X return(val); /* pager may have already touched the screen */
X }
X
X /* and that's it! */
X lines_displayed = 0;
X }
X
X ClearScreen();
X
X if (cursor_control) transmit_functions(OFF);
X
X pipe_abort = FALSE;
X
X if (form_letter = (current_header->status&FORM_LETTER)) {
X if (filter)
X form_letter_section = 1; /* initialize to section 1 */
X }
X
X if (title_messages && filter) {
X
X using_to =
X tail_of(current_header->from, who, current_header->to);
X
X sprintf(title1, "%s %d/%d ",
X headers[current-1]->status & DELETED ? "[deleted]" :
X form_letter ? "Form": "Message",
X number, message_count);
X sprintf(title2, "%s %s", using_to? "To" : "From", who);
X sprintf(title3, " %s %s '%d at %s %s",
X current_header->month, current_header->day,
X atoi(current_header->year), current_header->time,
X current_header->time_zone);
X
X /* truncate or pad title2 portion on the right
X * so that line fits exactly */
X padding =
X COLUMNS -
X (strlen(title1) + (buf_len=strlen(title2)) + strlen(title3));
X
X sprintf(titlebuf, "%s%-*.*s%s\n", title1, buf_len+padding,
X buf_len+padding, title2, title3);
X
X if (builtin)
X display_line(titlebuf);
X else
X fprintf(pipe_wr_fp, "%s", titlebuf);
X
X /** if there's a subject, let's output it next,
X centered if it fits on a single line. **/
X
X if ((buf_len = strlen(current_header->subject)) > 0 &&
X matches_weedlist("Subject:")) {
X padding = (buf_len < COLUMNS ? COLUMNS - buf_len : 0);
X sprintf(buffer, "%*s%s\n", padding/2, "", current_header->subject);
X } else
X strcpy(buffer, "\n");
X
X if (builtin)
X display_line(buffer);
X else
X fprintf(pipe_wr_fp, "%s", buffer);
X
X /** was this message address to us? if not, then to whom? **/
X
X if (! using_to && matches_weedlist("To:") && filter &&
X strcmp(current_header->to,username) != 0 &&
X strlen(current_header->to) > 0) {
X if (strlen(current_header->to) > 60)
X sprintf(buffer, "%s(message addressed to %.60s)\n",
X strlen(current_header->subject) > 0 ? "\n" : "",
X current_header->to);
X else
X sprintf(buffer, "%s(message addressed to %s)\n",
X strlen(current_header->subject) > 0 ? "\n" : "",
X current_header->to);
X if (builtin)
X display_line(buffer);
X else
X fprintf(pipe_wr_fp, "%s", buffer);
X }
X
X /** The test above is: if we didn't originally send the mail
X (e.g. we're not reading "mail.sent") AND the user is currently
X weeding out the "To:" line (otherwise they'll get it twice!)
X AND the user is actually weeding out headers AND the message
X wasn't addressed to the user AND the 'to' address is non-zero
X (consider what happens when the message doesn't HAVE a "To:"
X line...the value is NULL but it doesn't match the username
X either. We don't want to display something ugly like
X "(message addressed to )" which will just clutter up the
X screen!).
X
X And you thought programming was EASY!!!!
X **/
X
X /** one more friendly thing - output a line indicating what sort
X of status the message has (e.g. Urgent etc). Mostly added
X for X.400 support, this is nonetheless generally useful to
X include...
X **/
X
X buffer[0] = '\0';
X
X /* we want to flag Urgent, Confidential, Private and Expired tags */
X
X if (current_header->status & PRIVATE)
X strcpy(buffer, "\n(** This message is tagged Private");
X else if (current_header->status & CONFIDENTIAL)
X strcpy(buffer, "\n(** This message is tagged Company Confidential");
X
X if (current_header->status & URGENT) {
X if (buffer[0] == '\0')
X strcpy(buffer, "\n(** This message is tagged Urgent");
X else if (current_header->status & EXPIRED)
X strcat(buffer, ", Urgent");
X else
X strcat(buffer, " and Urgent");
X }
X
X if (current_header->status & EXPIRED) {
X if (buffer[0] == '\0')
X strcpy(buffer, "\n(** This message has Expired");
X else
X strcat(buffer, ", and has Expired");
X }
X
X if (buffer[0] != '\0') {
X strcat(buffer, " **)\n");
X if (builtin)
X display_line(buffer);
X else
X fprintf(pipe_wr_fp, buffer);
X }
X
X if (builtin) /* this is for a one-line blank */
X display_line("\n"); /* separator between the title */
X else /* stuff and the actual message */
X fprintf(pipe_wr_fp, "\n"); /* we're trying to display */
X
X }
X
X weed_header = filter; /* allow us to change it after header */
X
X while (lines > 0 && pipe_abort == FALSE) {
X
X if (fgets(buffer, VERY_LONG_STRING, mailfile) == NULL) {
X
X dprint(1, (debugfile,
X "Premature end of file! Lines left = %d msg = %s (show_msg)\n",
X lines, number));
X
X error("Premature end of file!");
SHAR_EOF
echo "End of part 21"
echo "File src/showmsg.c is continued in part 22"
echo "22" > s2_seq_.tmp
exit 0
exit 0 # Just in case...
--
Please send comp.sources.unix-related mail to rsalz@uunet.uu.net.
Use a domain-based address or give alternate paths, or you may lose out.