lib-src/fakemail.c

   1 /* sendmail-like interface to /bin/mail for system V,
   2    Copyright (C) 1985, 1994, 1999, 2001, 2002, 2003, 2004,
   3                  2005, 2006, 2007, 2008, 2009, 2010  Free Software Foundation, Inc.
   4
   5 Author: Bill Rozas <jinx@martigny.ai.mit.edu>
   6 (according to ack.texi)
   7
   8 This file is part of GNU Emacs.
   9
  10 GNU Emacs is free software: you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation, either version 3 of the License, or
  13 (at your option) any later version.
  14
  15 GNU Emacs is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23
  24 #define _XOPEN_SOURCE 500       /* for cuserid */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include <config.h>
  28 #endif
  29
  30 #if defined (BSD_SYSTEM) && !defined (USE_FAKEMAIL)
  31 /* This program isnot used in BSD, so just avoid loader complaints.  */
  32 int
  33 main ()
  34 {
  35   return 0;
  36 }
  37 #else /* not BSD 4.2 (or newer) */
  38 #ifdef MSDOS
  39 int
  40 main ()
  41 {
  42   return 0;
  43 }
  44 #else /* not MSDOS */
  45 /* This conditional contains all the rest of the file.  */
  46
  47 /* These are defined in config in some versions. */
  48
  49 #ifdef static
  50 #undef static
  51 #endif
  52
  53 #ifdef WINDOWSNT
  54 #include "ntlib.h"
  55 #endif
  56
  57 #include <stdio.h>
  58 #include <string.h>
  59 #include <ctype.h>
  60 #include <time.h>
  61 #include <pwd.h>
  62
  63 /* This is to declare cuserid.  */
  64 #ifdef HAVE_UNISTD_H
  65 #include <unistd.h>
  66 #endif
  67 \f
  68 /* Type definitions */
  69
  70 #define boolean int
  71 #define true 1
  72 #define false 0
  73
  74 #define TM_YEAR_BASE 1900
  75
  76 /* Nonzero if TM_YEAR is a struct tm's tm_year value that causes
  77    asctime to have well-defined behavior.  */
  78 #ifndef TM_YEAR_IN_ASCTIME_RANGE
  79 # define TM_YEAR_IN_ASCTIME_RANGE(tm_year) \
  80     (1000 - TM_YEAR_BASE <= (tm_year) && (tm_year) <= 9999 - TM_YEAR_BASE)
  81 #endif
  82
  83 /* Various lists */
  84
  85 struct line_record
  86 {
  87   char *string;
  88   struct line_record *continuation;
  89 };
  90 typedef struct line_record *line_list;
  91
  92 struct header_record
  93 {
  94   line_list text;
  95   struct header_record *next;
  96   struct header_record *previous;
  97 };
  98 typedef struct header_record *header;
  99
 100 struct stream_record
 101 {
 102   FILE *handle;
 103   int (*action)(FILE *);
 104   struct stream_record *rest_streams;
 105 };
 106 typedef struct stream_record *stream_list;
 107
 108 /* A `struct linebuffer' is a structure which holds a line of text.
 109  * `readline' reads a line from a stream into a linebuffer
 110  * and works regardless of the length of the line.
 111  */
 112
 113 struct linebuffer
 114 {
 115   long size;
 116   char *buffer;
 117 };
 118
 119 struct linebuffer lb;
 120
 121 #define new_list()                                      \
 122   ((line_list) xmalloc (sizeof (struct line_record)))
 123 #define new_header()                            \
 124   ((header) xmalloc (sizeof (struct header_record)))
 125 #define new_stream()                            \
 126   ((stream_list) xmalloc (sizeof (struct stream_record)))
 127 #define alloc_string(nchars)                            \
 128   ((char *) xmalloc ((nchars) + 1))
 129 \f
 130 /* Global declarations */
 131
 132 #define BUFLEN 1024
 133 #define KEYWORD_SIZE 256
 134 #define FROM_PREFIX "From"
 135 #define MY_NAME "fakemail"
 136 #define NIL ((line_list) NULL)
 137 #define INITIAL_LINE_SIZE 200
 138
 139 #ifndef MAIL_PROGRAM_NAME
 140 #define MAIL_PROGRAM_NAME "/bin/mail"
 141 #endif
 142
 143 static char *my_name;
 144 static char *the_date;
 145 static char *the_user;
 146 static line_list file_preface;
 147 static stream_list the_streams;
 148 static boolean no_problems = true;
 149
 150 static void fatal (char *s1) NO_RETURN;
 151
 152 extern FILE *popen (const char *, const char *);
 153 extern int fclose (FILE *), pclose (FILE *);
 154
 155 #ifdef CURRENT_USER
 156 extern struct passwd *getpwuid ();
 157 extern unsigned short geteuid ();
 158 static struct passwd *my_entry;
 159 #define cuserid(s)                              \
 160 (my_entry = getpwuid (((int) geteuid ())),      \
 161  my_entry->pw_name)
 162 #endif
 163 \f
 164 /* Utilities */
 165
 166 /* Print error message.  `s1' is printf control string, `s2' is arg for it. */
 167
 168 static void
 169 error (char *s1, char *s2)
 170 {
 171   printf ("%s: ", my_name);
 172   printf (s1, s2);
 173   printf ("\n");
 174   no_problems = false;
 175 }
 176
 177 /* Print error message and exit.  */
 178
 179 static void
 180 fatal (char *s1)
 181 {
 182   error ("%s", s1);
 183   exit (EXIT_FAILURE);
 184 }
 185
 186 /* Like malloc but get fatal error if memory is exhausted.  */
 187
 188 static long *
 189 xmalloc (int size)
 190 {
 191   long *result = (long *) malloc (((unsigned) size));
 192   if (result == ((long *) NULL))
 193     fatal ("virtual memory exhausted");
 194   return result;
 195 }
 196
 197 static long *
 198 xrealloc (long int *ptr, int size)
 199 {
 200   long *result = (long *) realloc (ptr, ((unsigned) size));
 201   if (result == ((long *) NULL))
 202     fatal ("virtual memory exhausted");
 203   return result;
 204 }
 205 \f
 206 /* Initialize a linebuffer for use */
 207
 208 void
 209 init_linebuffer (struct linebuffer *linebuffer)
 210 {
 211   linebuffer->size = INITIAL_LINE_SIZE;
 212   linebuffer->buffer = ((char *) xmalloc (INITIAL_LINE_SIZE));
 213 }
 214
 215 /* Read a line of text from `stream' into `linebuffer'.
 216    Return the length of the line.  */
 217
 218 long
 219 readline (struct linebuffer *linebuffer, FILE *stream)
 220 {
 221   char *buffer = linebuffer->buffer;
 222   char *p = linebuffer->buffer;
 223   char *end = p + linebuffer->size;
 224
 225   while (true)
 226     {
 227       int c = getc (stream);
 228       if (p == end)
 229         {
 230           linebuffer->size *= 2;
 231           buffer = ((char *) xrealloc ((long *)buffer, linebuffer->size));
 232           p = buffer + (p - linebuffer->buffer);
 233           end = buffer + linebuffer->size;
 234           linebuffer->buffer = buffer;
 235         }
 236       if (c < 0 || c == '\n')
 237         {
 238           *p = 0;
 239           break;
 240         }
 241       *p++ = c;
 242     }
 243
 244   return p - buffer;
 245 }
 246 \f
 247 /* Extract a colon-terminated keyword from the string FIELD.
 248    Return that keyword as a string stored in a static buffer.
 249    Store the address of the rest of the string into *REST.
 250
 251    If there is no keyword, return NULL and don't alter *REST.  */
 252
 253 char *
 254 get_keyword (register char *field, char **rest)
 255 {
 256   static char keyword[KEYWORD_SIZE];
 257   register char *ptr;
 258   register int c;
 259
 260   ptr = &keyword[0];
 261   c = (unsigned char) *field++;
 262   if (isspace (c) || c == ':')
 263     return ((char *) NULL);
 264   *ptr++ = (islower (c) ? toupper (c) : c);
 265   while (((c = (unsigned char) *field++) != ':') && ! isspace (c))
 266     *ptr++ = (islower (c) ? toupper (c) : c);
 267   *ptr++ = '\0';
 268   while (isspace (c))
 269     c = (unsigned char) *field++;
 270   if (c != ':')
 271     return ((char *) NULL);
 272   *rest = field;
 273   return &keyword[0];
 274 }
 275
 276 /* Nonzero if the string FIELD starts with a colon-terminated keyword.  */
 277
 278 boolean
 279 has_keyword (char *field)
 280 {
 281   char *ignored;
 282   return (get_keyword (field, &ignored) != ((char *) NULL));
 283 }
 284
 285 /* Store the string FIELD, followed by any lines in THE_LIST,
 286    into the buffer WHERE.
 287    Concatenate lines, putting just a space between them.
 288    Delete everything contained in parentheses.
 289    When a recipient name contains <...>, we discard
 290    everything except what is inside the <...>.
 291
 292    We don't pay attention to overflowing WHERE;
 293    the caller has to make it big enough.  */
 294
 295 char *
 296 add_field (line_list the_list, register char *field, register char *where)
 297 {
 298   register char c;
 299   while (true)
 300     {
 301       char *this_recipient_where;
 302       int in_quotes = 0;
 303
 304       *where++ = ' ';
 305       this_recipient_where = where;
 306
 307       while ((c = *field++) != '\0')
 308         {
 309           if (c == '\\')
 310             *where++ = c;
 311           else if (c == '"')
 312             {
 313               in_quotes = ! in_quotes;
 314               *where++ = c;
 315             }
 316           else if (in_quotes)
 317             *where++ = c;
 318           else if (c == '(')
 319             {
 320               while (*field && *field != ')') ++field;
 321               if (! (*field++)) break; /* no close */
 322               continue;
 323             }
 324           else if (c == ',')
 325             {
 326               *where++ = ' ';
 327               /* When we get to the end of one recipient,
 328                  don't discard it if the next one has <...>.  */
 329               this_recipient_where = where;
 330             }
 331           else if (c == '<')
 332             /* Discard everything we got before the `<'.  */
 333             where = this_recipient_where;
 334           else if (c == '>')
 335             /* Discard the rest of this name that follows the `>'.  */
 336             {
 337               while (*field && *field != ',') ++field;
 338               if (! (*field++)) break; /* no comma */
 339               continue;
 340             }
 341           else
 342             *where++ = c;
 343         }
 344       if (the_list == NIL) break;
 345       field = the_list->string;
 346       the_list = the_list->continuation;
 347     }
 348   return where;
 349 }
 350 \f
 351 line_list
 352 make_file_preface (void)
 353 {
 354   char *the_string, *temp;
 355   long idiotic_interface;
 356   struct tm *tm;
 357   long prefix_length;
 358   long user_length;
 359   long date_length;
 360   line_list result;
 361
 362   prefix_length = strlen (FROM_PREFIX);
 363   time (&idiotic_interface);
 364   /* Convert to a string, checking for out-of-range time stamps.
 365      Don't use 'ctime', as that might dump core if the hardware clock
 366      is set to a bizarre value.  */
 367   tm = localtime (&idiotic_interface);
 368   if (! (tm && TM_YEAR_IN_ASCTIME_RANGE (tm->tm_year)
 369          && (the_date = asctime (tm))))
 370     fatal ("current time is out of range");
 371   /* the_date has an unwanted newline at the end */
 372   date_length = strlen (the_date) - 1;
 373   the_date[date_length] = '\0';
 374   temp = cuserid ((char *) NULL);
 375   user_length = strlen (temp);
 376   the_user = alloc_string (user_length + 1);
 377   strcpy (the_user, temp);
 378   the_string = alloc_string (3 + prefix_length
 379                              + user_length
 380                              + date_length);
 381   temp = the_string;
 382   strcpy (temp, FROM_PREFIX);
 383   temp = &temp[prefix_length];
 384   *temp++ = ' ';
 385   strcpy (temp, the_user);
 386   temp = &temp[user_length];
 387   *temp++ = ' ';
 388   strcpy (temp, the_date);
 389   result = new_list ();
 390   result->string = the_string;
 391   result->continuation = ((line_list) NULL);
 392   return result;
 393 }
 394
 395 void
 396 write_line_list (register line_list the_list, FILE *the_stream)
 397 {
 398   for ( ;
 399       the_list != ((line_list) NULL) ;
 400       the_list = the_list->continuation)
 401     {
 402       fputs (the_list->string, the_stream);
 403       putc ('\n', the_stream);
 404     }
 405   return;
 406 }
 407 \f
 408 int
 409 close_the_streams (void)
 410 {
 411   register stream_list rem;
 412   for (rem = the_streams;
 413        rem != ((stream_list) NULL);
 414        rem = rem->rest_streams)
 415     no_problems = (no_problems &&
 416                    ((*rem->action) (rem->handle) == 0));
 417   the_streams = ((stream_list) NULL);
 418   return (no_problems ? EXIT_SUCCESS : EXIT_FAILURE);
 419 }
 420
 421 void
 422 add_a_stream (FILE *the_stream, int (*closing_action) (FILE *))
 423 {
 424   stream_list old = the_streams;
 425   the_streams = new_stream ();
 426   the_streams->handle = the_stream;
 427   the_streams->action = closing_action;
 428   the_streams->rest_streams = old;
 429   return;
 430 }
 431
 432 int
 433 my_fclose (FILE *the_file)
 434 {
 435   putc ('\n', the_file);
 436   fflush (the_file);
 437   return fclose (the_file);
 438 }
 439
 440 boolean
 441 open_a_file (char *name)
 442 {
 443   FILE *the_stream = fopen (name, "a");
 444   if (the_stream != ((FILE *) NULL))
 445     {
 446       add_a_stream (the_stream, my_fclose);
 447       if (the_user == ((char *) NULL))
 448         file_preface = make_file_preface ();
 449       write_line_list (file_preface, the_stream);
 450       return true;
 451     }
 452   return false;
 453 }
 454
 455 void
 456 put_string (char *s)
 457 {
 458   register stream_list rem;
 459   for (rem = the_streams;
 460        rem != ((stream_list) NULL);
 461        rem = rem->rest_streams)
 462     fputs (s, rem->handle);
 463   return;
 464 }
 465
 466 void
 467 put_line (char *string)
 468 {
 469   register stream_list rem;
 470   for (rem = the_streams;
 471        rem != ((stream_list) NULL);
 472        rem = rem->rest_streams)
 473     {
 474       char *s = string;
 475       int column = 0;
 476
 477       /* Divide STRING into lines.  */
 478       while (*s != 0)
 479         {
 480           char *breakpos;
 481
 482           /* Find the last char that fits.  */
 483           for (breakpos = s; *breakpos && column < 78; ++breakpos)
 484             {
 485               if (*breakpos == '\t')
 486                 column += 8;
 487               else
 488                 column++;
 489             }
 490           /* If we didn't reach end of line, break the line.  */
 491           if (*breakpos)
 492             {
 493               /* Back up to just after the last comma that fits.  */
 494               while (breakpos != s && breakpos[-1] != ',') --breakpos;
 495
 496               if (breakpos == s)
 497                 {
 498                   /* If no comma fits, move past the first address anyway.  */
 499                   while (*breakpos != 0 && *breakpos != ',') ++breakpos;
 500                   if (*breakpos != 0)
 501                     /* Include the comma after it.  */
 502                     ++breakpos;
 503                 }
 504             }
 505           /* Output that much, then break the line.  */
 506           fwrite (s, 1, breakpos - s, rem->handle);
 507           column = 8;
 508
 509           /* Skip whitespace and prepare to print more addresses.  */
 510           s = breakpos;
 511           while (*s == ' ' || *s == '\t') ++s;
 512           if (*s != 0)
 513             fputs ("\n\t", rem->handle);
 514         }
 515       putc ('\n', rem->handle);
 516     }
 517   return;
 518 }
 519 \f
 520 #define mail_error error
 521
 522 /* Handle an FCC field.  FIELD is the text of the first line (after
 523    the header name), and THE_LIST holds the continuation lines if any.
 524    Call open_a_file for each file.  */
 525
 526 void
 527 setup_files (register line_list the_list, register char *field)
 528 {
 529   register char *start;
 530   register char c;
 531   while (true)
 532     {
 533       while (((c = *field) != '\0')
 534              && (c == ' '
 535                  || c == '\t'
 536                  || c == ','))
 537         field += 1;
 538       if (c != '\0')
 539         {
 540           start = field;
 541           while (((c = *field) != '\0')
 542                  && c != ' '
 543                  && c != '\t'
 544                  && c != ',')
 545             field += 1;
 546           *field = '\0';
 547           if (!open_a_file (start))
 548             mail_error ("Could not open file %s", start);
 549           *field = c;
 550           if (c != '\0') continue;
 551         }
 552       if (the_list == ((line_list) NULL))
 553         return;
 554       field = the_list->string;
 555       the_list = the_list->continuation;
 556     }
 557 }
 558 \f
 559 /* Compute the total size of all recipient names stored in THE_HEADER.
 560    The result says how big to make the buffer to pass to parse_header.  */
 561
 562 int
 563 args_size (header the_header)
 564 {
 565   register header old = the_header;
 566   register line_list rem;
 567   register int size = 0;
 568   do
 569     {
 570       char *field;
 571       register char *keyword = get_keyword (the_header->text->string, &field);
 572       if ((strcmp (keyword, "TO") == 0)
 573           || (strcmp (keyword, "CC") == 0)
 574           || (strcmp (keyword, "BCC") == 0))
 575         {
 576           size += 1 + strlen (field);
 577           for (rem = the_header->text->continuation;
 578                rem != NIL;
 579                rem = rem->continuation)
 580             size += 1 + strlen (rem->string);
 581         }
 582       the_header = the_header->next;
 583     } while (the_header != old);
 584   return size;
 585 }
 586
 587 /* Scan the header described by the lists THE_HEADER,
 588    and put all recipient names into the buffer WHERE.
 589    Precede each recipient name with a space.
 590
 591    Also, if the header has any FCC fields, call setup_files for each one.  */
 592
 593 void
 594 parse_header (header the_header, register char *where)
 595 {
 596   register header old = the_header;
 597   do
 598     {
 599       char *field;
 600       register char *keyword = get_keyword (the_header->text->string, &field);
 601       if (strcmp (keyword, "TO") == 0)
 602         where = add_field (the_header->text->continuation, field, where);
 603       else if (strcmp (keyword, "CC") == 0)
 604         where = add_field (the_header->text->continuation, field, where);
 605       else if (strcmp (keyword, "BCC") == 0)
 606         {
 607           where = add_field (the_header->text->continuation, field, where);
 608           the_header->previous->next = the_header->next;
 609           the_header->next->previous = the_header->previous;
 610         }
 611       else if (strcmp (keyword, "FCC") == 0)
 612         setup_files (the_header->text->continuation, field);
 613       the_header = the_header->next;
 614     } while (the_header != old);
 615   *where = '\0';
 616   return;
 617 }
 618 \f
 619 /* Read lines from the input until we get a blank line.
 620    Create a list of `header' objects, one for each header field,
 621    each of which points to a list of `line_list' objects,
 622    one for each line in that field.
 623    Continuation lines are grouped in the headers they continue.  */
 624
 625 header
 626 read_header (void)
 627 {
 628   register header the_header = ((header) NULL);
 629   register line_list *next_line = ((line_list *) NULL);
 630
 631   init_linebuffer (&lb);
 632
 633   do
 634     {
 635       long length;
 636       register char *line;
 637
 638       readline (&lb, stdin);
 639       line = lb.buffer;
 640       length = strlen (line);
 641       if (length == 0) break;
 642
 643       if (has_keyword (line))
 644         {
 645           register header old = the_header;
 646           the_header = new_header ();
 647           if (old == ((header) NULL))
 648             {
 649               the_header->next = the_header;
 650               the_header->previous = the_header;
 651             }
 652           else
 653             {
 654               the_header->previous = old;
 655               the_header->next = old->next;
 656               old->next = the_header;
 657             }
 658           next_line = &(the_header->text);
 659         }
 660
 661       if (next_line == ((line_list *) NULL))
 662         {
 663           /* Not a valid header */
 664           exit (EXIT_FAILURE);
 665         }
 666       *next_line = new_list ();
 667       (*next_line)->string = alloc_string (length);
 668       strcpy (((*next_line)->string), line);
 669       next_line = &((*next_line)->continuation);
 670       *next_line = NIL;
 671
 672     } while (true);
 673
 674   if (! the_header)
 675     fatal ("input message has no header");
 676   return the_header->next;
 677 }
 678 \f
 679 void
 680 write_header (header the_header)
 681 {
 682   register header old = the_header;
 683   do
 684     {
 685       register line_list the_list;
 686       for (the_list = the_header->text;
 687            the_list != NIL;
 688            the_list = the_list->continuation)
 689         put_line (the_list->string);
 690       the_header = the_header->next;
 691     } while (the_header != old);
 692   put_line ("");
 693   return;
 694 }
 695 \f
 696 int
 697 main (int argc, char **argv)
 698 {
 699   char *command_line;
 700   header the_header;
 701   long name_length;
 702   char *mail_program_name;
 703   char buf[BUFLEN + 1];
 704   register int size;
 705   FILE *the_pipe;
 706
 707   extern char *getenv (const char *);
 708
 709   mail_program_name = getenv ("FAKEMAILER");
 710   if (!(mail_program_name && *mail_program_name))
 711     mail_program_name = MAIL_PROGRAM_NAME;
 712   name_length = strlen (mail_program_name);
 713
 714   my_name = MY_NAME;
 715   the_streams = ((stream_list) NULL);
 716   the_date = ((char *) NULL);
 717   the_user = ((char *) NULL);
 718
 719   the_header = read_header ();
 720   command_line = alloc_string (name_length + args_size (the_header));
 721   strcpy (command_line, mail_program_name);
 722   parse_header (the_header, &command_line[name_length]);
 723
 724   the_pipe = popen (command_line, "w");
 725   if (the_pipe == ((FILE *) NULL))
 726     fatal ("cannot open pipe to real mailer");
 727
 728   add_a_stream (the_pipe, pclose);
 729
 730   write_header (the_header);
 731
 732   /* Dump the message itself */
 733
 734   while (!feof (stdin))
 735     {
 736       size = fread (buf, 1, BUFLEN, stdin);
 737       buf[size] = '\0';
 738       put_string (buf);
 739     }
 740
 741   exit (close_the_streams ());
 742 }
 743
 744 #endif /* not MSDOS */
 745 #endif /* not BSD 4.2 (or newer) */
 746
 747 /* arch-tag: acb0afa6-315a-4c5b-b9e3-def5725c8783
 748    (do not change this comment) */
 749
 750 /* fakemail.c ends here */