Mercurial > emacs
annotate lib-src/fakemail.c @ 7880:3dd8448eee15
(inhibit-startup-echo-area-message): Doc fix.
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Tue, 14 Jun 1994 00:21:40 +0000 |
parents | cd81dba38a49 |
children | dd3b83e4ceb0 |
rev | line source |
---|---|
18 | 1 /* sendmail-like interface to /bin/mail for system V, |
7307 | 2 Copyright (C) 1985, 1994 Free Software Foundation, Inc. |
18 | 3 |
4 This file is part of GNU Emacs. | |
5 | |
37 | 6 GNU Emacs is free software; you can redistribute it and/or modify |
7 it under the terms of the GNU General Public License as published by | |
6109 | 8 the Free Software Foundation; either version 2, or (at your option) |
37 | 9 any later version. |
18 | 10 |
37 | 11 GNU Emacs is distributed in the hope that it will be useful, |
12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 GNU General Public License for more details. | |
15 | |
16 You should have received a copy of the GNU General Public License | |
17 along with GNU Emacs; see the file COPYING. If not, write to | |
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
18 | 19 |
20 | |
21 #define NO_SHORTNAMES | |
4696
1fc792473491
Include <config.h> instead of "config.h".
Roland McGrath <roland@gnu.org>
parents:
3219
diff
changeset
|
22 #include <../src/config.h> |
18 | 23 |
24 #if defined (BSD) && !defined (BSD4_1) && !defined (USE_FAKEMAIL) | |
25 /* This program isnot used in BSD, so just avoid loader complaints. */ | |
26 main () | |
27 { | |
28 } | |
29 #else /* not BSD 4.2 (or newer) */ | |
5447
6f0905b05218
(main) [MSDOS]: Dummy stub just to make the file compile.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
30 #ifdef MSDOS |
6f0905b05218
(main) [MSDOS]: Dummy stub just to make the file compile.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
31 main () |
6f0905b05218
(main) [MSDOS]: Dummy stub just to make the file compile.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
32 { |
6f0905b05218
(main) [MSDOS]: Dummy stub just to make the file compile.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
33 } |
6f0905b05218
(main) [MSDOS]: Dummy stub just to make the file compile.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
34 #else /* not MSDOS */ |
18 | 35 /* This conditional contains all the rest of the file. */ |
36 | |
37 /* These are defined in config in some versions. */ | |
38 | |
39 #ifdef static | |
40 #undef static | |
41 #endif | |
42 | |
43 #ifdef read | |
44 #undef read | |
45 #undef write | |
46 #undef open | |
47 #undef close | |
48 #endif | |
49 | |
50 #include <stdio.h> | |
51 #include <string.h> | |
52 #include <ctype.h> | |
53 #include <time.h> | |
54 #include <pwd.h> | |
55 | |
56 /* Type definitions */ | |
57 | |
58 #define boolean int | |
59 #define true 1 | |
60 #define false 0 | |
61 | |
62 /* Various lists */ | |
63 | |
64 struct line_record | |
65 { | |
66 char *string; | |
67 struct line_record *continuation; | |
68 }; | |
69 typedef struct line_record *line_list; | |
70 | |
71 struct header_record | |
72 { | |
73 line_list text; | |
74 struct header_record *next; | |
75 struct header_record *previous; | |
76 }; | |
77 typedef struct header_record *header; | |
78 | |
79 struct stream_record | |
80 { | |
81 FILE *handle; | |
82 int (*action)(); | |
83 struct stream_record *rest_streams; | |
84 }; | |
85 typedef struct stream_record *stream_list; | |
86 | |
87 /* A `struct linebuffer' is a structure which holds a line of text. | |
88 * `readline' reads a line from a stream into a linebuffer | |
89 * and works regardless of the length of the line. | |
90 */ | |
91 | |
92 struct linebuffer | |
93 { | |
94 long size; | |
95 char *buffer; | |
96 }; | |
97 | |
98 struct linebuffer lb; | |
99 | |
100 #define new_list() \ | |
101 ((line_list) xmalloc (sizeof (struct line_record))) | |
102 #define new_header() \ | |
103 ((header) xmalloc (sizeof (struct header_record))) | |
104 #define new_stream() \ | |
105 ((stream_list) xmalloc (sizeof (struct stream_record))) | |
106 #define alloc_string(nchars) \ | |
107 ((char *) xmalloc ((nchars) + 1)) | |
108 | |
109 /* Global declarations */ | |
110 | |
111 #define BUFLEN 1024 | |
112 #define KEYWORD_SIZE 256 | |
113 #define FROM_PREFIX "From" | |
114 #define MY_NAME "fakemail" | |
115 #define NIL ((line_list) NULL) | |
116 #define INITIAL_LINE_SIZE 200 | |
117 | |
118 #ifndef MAIL_PROGRAM_NAME | |
119 #define MAIL_PROGRAM_NAME "/bin/mail" | |
120 #endif | |
121 | |
122 static char *my_name; | |
123 static char *the_date; | |
124 static char *the_user; | |
125 static line_list file_preface; | |
126 static stream_list the_streams; | |
127 static boolean no_problems = true; | |
128 | |
129 extern FILE *popen (); | |
130 extern int fclose (), pclose (); | |
131 extern char *malloc (), *realloc (); | |
132 | |
133 #ifdef CURRENT_USER | |
134 extern struct passwd *getpwuid (); | |
135 extern unsigned short geteuid (); | |
136 static struct passwd *my_entry; | |
137 #define cuserid(s) \ | |
138 (my_entry = getpwuid (((int) geteuid ())), \ | |
139 my_entry->pw_name) | |
140 #endif | |
141 | |
142 /* Utilities */ | |
143 | |
144 /* Print error message. `s1' is printf control string, `s2' is arg for it. */ | |
145 | |
146 static void | |
147 error (s1, s2) | |
148 char *s1, *s2; | |
149 { | |
150 printf ("%s: ", my_name); | |
151 printf (s1, s2); | |
152 printf ("\n"); | |
153 no_problems = false; | |
154 } | |
155 | |
156 /* Print error message and exit. */ | |
157 | |
158 static void | |
159 fatal (s1, s2) | |
160 char *s1, *s2; | |
161 { | |
162 error (s1, s2); | |
163 exit (1); | |
164 } | |
165 | |
166 /* Like malloc but get fatal error if memory is exhausted. */ | |
167 | |
168 static char * | |
169 xmalloc (size) | |
170 int size; | |
171 { | |
172 char *result = malloc (((unsigned) size)); | |
173 if (result == ((char *) NULL)) | |
174 fatal ("virtual memory exhausted", 0); | |
175 return result; | |
176 } | |
177 | |
178 static char * | |
179 xrealloc (ptr, size) | |
180 char *ptr; | |
181 int size; | |
182 { | |
183 char *result = realloc (ptr, ((unsigned) size)); | |
184 if (result == ((char *) NULL)) | |
185 fatal ("virtual memory exhausted"); | |
186 return result; | |
187 } | |
188 | |
189 /* Initialize a linebuffer for use */ | |
190 | |
191 void | |
192 init_linebuffer (linebuffer) | |
193 struct linebuffer *linebuffer; | |
194 { | |
195 linebuffer->size = INITIAL_LINE_SIZE; | |
196 linebuffer->buffer = ((char *) xmalloc (INITIAL_LINE_SIZE)); | |
197 } | |
198 | |
199 /* Read a line of text from `stream' into `linebuffer'. | |
200 * Return the length of the line. | |
201 */ | |
202 | |
203 long | |
204 readline (linebuffer, stream) | |
205 struct linebuffer *linebuffer; | |
206 FILE *stream; | |
207 { | |
208 char *buffer = linebuffer->buffer; | |
209 char *p = linebuffer->buffer; | |
210 char *end = p + linebuffer->size; | |
211 | |
212 while (true) | |
213 { | |
214 int c = getc (stream); | |
215 if (p == end) | |
216 { | |
217 linebuffer->size *= 2; | |
218 buffer = ((char *) xrealloc (buffer, linebuffer->size)); | |
6992
ed57331fb222
(readline): Fix updating of p when buffer grows.
Richard M. Stallman <rms@gnu.org>
parents:
6954
diff
changeset
|
219 p = buffer + (p - linebuffer->buffer); |
6954
774fdc20d115
(readline): When extending the buffer,
Richard M. Stallman <rms@gnu.org>
parents:
6109
diff
changeset
|
220 end = buffer + linebuffer->size; |
18 | 221 linebuffer->buffer = buffer; |
222 } | |
223 if (c < 0 || c == '\n') | |
224 { | |
225 *p = 0; | |
226 break; | |
227 } | |
228 *p++ = c; | |
229 } | |
230 | |
231 return p - buffer; | |
232 } | |
233 | |
234 char * | |
235 get_keyword (field, rest) | |
236 register char *field; | |
237 char **rest; | |
238 { | |
239 static char keyword[KEYWORD_SIZE]; | |
240 register char *ptr; | |
241 register char c; | |
242 | |
243 ptr = &keyword[0]; | |
244 c = *field++; | |
245 if ((isspace (c)) || (c == ':')) | |
246 return ((char *) NULL); | |
247 *ptr++ = ((islower (c)) ? (toupper (c)) : c); | |
248 while (((c = *field++) != ':') && (!(isspace (c)))) | |
249 *ptr++ = ((islower (c)) ? (toupper (c)) : c); | |
250 *ptr++ = '\0'; | |
251 while (isspace (c)) c = *field++; | |
252 if (c != ':') return ((char *) NULL); | |
253 *rest = field; | |
254 return &keyword[0]; | |
255 } | |
256 | |
257 boolean | |
258 has_keyword (field) | |
259 char *field; | |
260 { | |
261 char *ignored; | |
262 return (get_keyword (field, &ignored) != ((char *) NULL)); | |
263 } | |
264 | |
265 char * | |
266 add_field (the_list, field, where) | |
267 line_list the_list; | |
268 register char *field, *where; | |
269 { | |
270 register char c; | |
271 while (true) | |
272 { | |
273 *where++ = ' '; | |
274 while ((c = *field++) != '\0') | |
275 { | |
276 if (c == '(') | |
277 { | |
278 while (*field && *field != ')') ++field; | |
279 if (! (*field++)) break; /* no closer */ | |
280 if (! (*field)) break; /* closerNULL */ | |
281 c = *field; | |
282 } | |
283 *where++ = ((c == ','||c=='>'||c=='<') ? ' ' : c); | |
284 } | |
285 if (the_list == NIL) break; | |
286 field = the_list->string; | |
287 the_list = the_list->continuation; | |
288 } | |
289 return where; | |
290 } | |
291 | |
292 line_list | |
293 make_file_preface () | |
294 { | |
295 char *the_string, *temp; | |
296 long idiotic_interface; | |
297 long prefix_length; | |
298 long user_length; | |
299 long date_length; | |
300 line_list result; | |
301 | |
302 prefix_length = strlen (FROM_PREFIX); | |
303 time (&idiotic_interface); | |
304 the_date = ctime (&idiotic_interface); | |
305 /* the_date has an unwanted newline at the end */ | |
306 date_length = strlen (the_date) - 1; | |
307 the_date[date_length] = '\0'; | |
308 temp = cuserid ((char *) NULL); | |
309 user_length = strlen (temp); | |
310 the_user = alloc_string (user_length + 1); | |
311 strcpy (the_user, temp); | |
312 the_string = alloc_string (3 + prefix_length + | |
313 user_length + | |
314 date_length); | |
315 temp = the_string; | |
316 strcpy (temp, FROM_PREFIX); | |
317 temp = &temp[prefix_length]; | |
318 *temp++ = ' '; | |
319 strcpy (temp, the_user); | |
320 temp = &temp[user_length]; | |
321 *temp++ = ' '; | |
322 strcpy (temp, the_date); | |
323 result = new_list (); | |
324 result->string = the_string; | |
325 result->continuation = ((line_list) NULL); | |
326 return result; | |
327 } | |
328 | |
329 void | |
330 write_line_list (the_list, the_stream) | |
331 register line_list the_list; | |
332 FILE *the_stream; | |
333 { | |
334 for ( ; | |
335 the_list != ((line_list) NULL) ; | |
336 the_list = the_list->continuation) | |
337 { | |
338 fputs (the_list->string, the_stream); | |
339 putc ('\n', the_stream); | |
340 } | |
341 return; | |
342 } | |
343 | |
344 int | |
345 close_the_streams () | |
346 { | |
347 register stream_list rem; | |
348 for (rem = the_streams; | |
349 rem != ((stream_list) NULL); | |
350 rem = rem->rest_streams) | |
351 no_problems = (no_problems && | |
352 ((*rem->action) (rem->handle) == 0)); | |
353 the_streams = ((stream_list) NULL); | |
354 return (no_problems ? 0 : 1); | |
355 } | |
356 | |
357 void | |
358 add_a_stream (the_stream, closing_action) | |
359 FILE *the_stream; | |
360 int (*closing_action)(); | |
361 { | |
362 stream_list old = the_streams; | |
363 the_streams = new_stream (); | |
364 the_streams->handle = the_stream; | |
365 the_streams->action = closing_action; | |
366 the_streams->rest_streams = old; | |
367 return; | |
368 } | |
369 | |
370 int | |
371 my_fclose (the_file) | |
372 FILE *the_file; | |
373 { | |
374 putc ('\n', the_file); | |
375 fflush (the_file); | |
376 return fclose (the_file); | |
377 } | |
378 | |
379 boolean | |
380 open_a_file (name) | |
381 char *name; | |
382 { | |
383 FILE *the_stream = fopen (name, "a"); | |
384 if (the_stream != ((FILE *) NULL)) | |
385 { | |
386 add_a_stream (the_stream, my_fclose); | |
387 if (the_user == ((char *) NULL)) | |
388 file_preface = make_file_preface (); | |
389 write_line_list (file_preface, the_stream); | |
390 return true; | |
391 } | |
392 return false; | |
393 } | |
394 | |
395 void | |
396 put_string (s) | |
397 char *s; | |
398 { | |
399 register stream_list rem; | |
400 for (rem = the_streams; | |
401 rem != ((stream_list) NULL); | |
402 rem = rem->rest_streams) | |
403 fputs (s, rem->handle); | |
404 return; | |
405 } | |
406 | |
407 void | |
20 | 408 put_line (string) |
409 char *string; | |
18 | 410 { |
411 register stream_list rem; | |
412 for (rem = the_streams; | |
413 rem != ((stream_list) NULL); | |
414 rem = rem->rest_streams) | |
415 { | |
20 | 416 char *s = string; |
417 int column = 0; | |
418 | |
419 /* Divide STRING into lines. */ | |
420 while (*s != 0) | |
421 { | |
422 char *breakpos; | |
423 | |
5959
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
424 /* Find the last char that fits. */ |
20 | 425 for (breakpos = s; *breakpos && column < 78; ++breakpos) |
426 { | |
427 if (*breakpos == '\t') | |
428 column += 8; | |
429 else | |
430 column++; | |
431 } | |
5959
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
432 /* If we didn't reach end of line, break the line. */ |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
433 if (*breakpos) |
20 | 434 { |
5959
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
435 /* Back up to just after the last comma that fits. */ |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
436 while (breakpos != s && breakpos[-1] != ',') --breakpos; |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
437 |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
438 if (breakpos == s) |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
439 { |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
440 /* If no comma fits, move past the first address anyway. */ |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
441 while (*breakpos != 0 && *breakpos != ',') ++breakpos; |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
442 if (*breakpos != 0) |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
443 /* Include the comma after it. */ |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
444 ++breakpos; |
e4337a7bbe32
(put_line): Don't break the line if it all fits.
Richard M. Stallman <rms@gnu.org>
parents:
5447
diff
changeset
|
445 } |
20 | 446 } |
447 /* Output that much, then break the line. */ | |
448 fwrite (s, 1, breakpos - s, rem->handle); | |
449 column = 8; | |
450 | |
451 /* Skip whitespace and prepare to print more addresses. */ | |
452 s = breakpos; | |
453 while (*s == ' ' || *s == '\t') ++s; | |
3219
1aa8fa0a569e
(put_line): Don't output \n\t unless more text follows.
Richard M. Stallman <rms@gnu.org>
parents:
37
diff
changeset
|
454 if (*s != 0) |
1aa8fa0a569e
(put_line): Don't output \n\t unless more text follows.
Richard M. Stallman <rms@gnu.org>
parents:
37
diff
changeset
|
455 fputs ("\n\t", rem->handle); |
20 | 456 } |
18 | 457 putc ('\n', rem->handle); |
458 } | |
459 return; | |
460 } | |
461 | |
462 #define mail_error error | |
463 | |
464 void | |
465 setup_files (the_list, field) | |
466 register line_list the_list; | |
467 register char *field; | |
468 { | |
469 register char *start; | |
470 register char c; | |
471 while (true) | |
472 { | |
473 while (((c = *field) != '\0') && | |
474 ((c == ' ') || | |
475 (c == '\t') || | |
476 (c == ','))) | |
477 field += 1; | |
478 if (c != '\0') | |
479 { | |
480 start = field; | |
481 while (((c = *field) != '\0') && | |
482 (c != ' ') && | |
483 (c != '\t') && | |
484 (c != ',')) | |
485 field += 1; | |
486 *field = '\0'; | |
487 if (!open_a_file (start)) | |
488 mail_error ("Could not open file %s", start); | |
489 *field = c; | |
490 if (c != '\0') continue; | |
491 } | |
492 if (the_list == ((line_list) NULL)) return; | |
493 field = the_list->string; | |
494 the_list = the_list->continuation; | |
495 } | |
496 } | |
497 | |
498 int | |
499 args_size (the_header) | |
500 header the_header; | |
501 { | |
502 register header old = the_header; | |
503 register line_list rem; | |
504 register int size = 0; | |
505 do | |
506 { | |
507 char *field; | |
508 register char *keyword = get_keyword (the_header->text->string, &field); | |
509 if ((strcmp (keyword, "TO") == 0) || | |
510 (strcmp (keyword, "CC") == 0) || | |
511 (strcmp (keyword, "BCC") == 0)) | |
512 { | |
513 size += 1 + strlen (field); | |
514 for (rem = the_header->text->continuation; | |
515 rem != NIL; | |
516 rem = rem->continuation) | |
517 size += 1 + strlen (rem->string); | |
518 } | |
519 the_header = the_header->next; | |
520 } while (the_header != old); | |
521 return size; | |
522 } | |
523 | |
524 parse_header (the_header, where) | |
525 header the_header; | |
526 register char *where; | |
527 { | |
528 register header old = the_header; | |
529 do | |
530 { | |
531 char *field; | |
532 register char *keyword = get_keyword (the_header->text->string, &field); | |
533 if (strcmp (keyword, "TO") == 0) | |
534 where = add_field (the_header->text->continuation, field, where); | |
535 else if (strcmp (keyword, "CC") == 0) | |
536 where = add_field (the_header->text->continuation, field, where); | |
537 else if (strcmp (keyword, "BCC") == 0) | |
538 { | |
539 where = add_field (the_header->text->continuation, field, where); | |
540 the_header->previous->next = the_header->next; | |
541 the_header->next->previous = the_header->previous; | |
542 } | |
543 else if (strcmp (keyword, "FCC") == 0) | |
544 setup_files (the_header->text->continuation, field); | |
545 the_header = the_header->next; | |
546 } while (the_header != old); | |
547 *where = '\0'; | |
548 return; | |
549 } | |
550 | |
551 header | |
552 read_header () | |
553 { | |
554 register header the_header = ((header) NULL); | |
555 register line_list *next_line = ((line_list *) NULL); | |
556 | |
557 init_linebuffer (&lb); | |
558 | |
559 do | |
560 { | |
561 long length; | |
562 register char *line; | |
563 | |
564 readline (&lb, stdin); | |
565 line = lb.buffer; | |
566 length = strlen (line); | |
567 if (length == 0) break; | |
568 | |
569 if (has_keyword (line)) | |
570 { | |
571 register header old = the_header; | |
572 the_header = new_header (); | |
573 if (old == ((header) NULL)) | |
574 { | |
575 the_header->next = the_header; | |
576 the_header->previous = the_header; | |
577 } | |
578 else | |
579 { | |
580 the_header->previous = old; | |
581 the_header->next = old->next; | |
582 old->next = the_header; | |
583 } | |
584 next_line = &(the_header->text); | |
585 } | |
586 | |
587 if (next_line == ((line_list *) NULL)) | |
588 { | |
589 /* Not a valid header */ | |
590 exit (1); | |
591 } | |
592 *next_line = new_list (); | |
593 (*next_line)->string = alloc_string (length); | |
594 strcpy (((*next_line)->string), line); | |
595 next_line = &((*next_line)->continuation); | |
596 *next_line = NIL; | |
597 | |
598 } while (true); | |
599 | |
600 return the_header->next; | |
601 } | |
602 | |
603 void | |
604 write_header (the_header) | |
605 header the_header; | |
606 { | |
607 register header old = the_header; | |
608 do | |
609 { | |
610 register line_list the_list; | |
611 for (the_list = the_header->text; | |
612 the_list != NIL; | |
613 the_list = the_list->continuation) | |
614 put_line (the_list->string); | |
615 the_header = the_header->next; | |
616 } while (the_header != old); | |
617 put_line (""); | |
618 return; | |
619 } | |
620 | |
621 void | |
622 main (argc, argv) | |
623 int argc; | |
624 char **argv; | |
625 { | |
626 char *command_line; | |
627 header the_header; | |
628 long name_length; | |
629 char *mail_program_name; | |
630 char buf[BUFLEN + 1]; | |
631 register int size; | |
632 FILE *the_pipe; | |
633 | |
634 extern char *getenv (); | |
635 | |
636 mail_program_name = getenv ("FAKEMAILER"); | |
637 if (!(mail_program_name && *mail_program_name)) | |
638 mail_program_name = MAIL_PROGRAM_NAME; | |
639 name_length = strlen (mail_program_name); | |
640 | |
641 my_name = MY_NAME; | |
642 the_streams = ((stream_list) NULL); | |
643 the_date = ((char *) NULL); | |
644 the_user = ((char *) NULL); | |
645 | |
646 the_header = read_header (); | |
647 command_line = alloc_string (name_length + args_size (the_header)); | |
648 strcpy (command_line, mail_program_name); | |
649 parse_header (the_header, &command_line[name_length]); | |
650 | |
651 the_pipe = popen (command_line, "w"); | |
652 if (the_pipe == ((FILE *) NULL)) | |
653 fatal ("cannot open pipe to real mailer"); | |
654 | |
655 add_a_stream (the_pipe, pclose); | |
656 | |
657 write_header (the_header); | |
658 | |
659 /* Dump the message itself */ | |
660 | |
661 while (!feof (stdin)) | |
662 { | |
663 size = fread (buf, 1, BUFLEN, stdin); | |
664 buf[size] = '\0'; | |
665 put_string (buf); | |
666 } | |
667 | |
668 exit (close_the_streams ()); | |
669 } | |
670 | |
5447
6f0905b05218
(main) [MSDOS]: Dummy stub just to make the file compile.
Richard M. Stallman <rms@gnu.org>
parents:
4696
diff
changeset
|
671 #endif /* not MSDOS */ |
18 | 672 #endif /* not BSD 4.2 (or newer) */ |