| blob | f074f27c84d7aefe66ff110020ba9cc1e627640c |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2013-2016 Eduardo Chappa
8 * Copyright 2006-2008 University of Washington
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * ========================================================================
17 */
52 /* this is used in pine_send and pine_simple_send */
53 /* name::type::canedit::writehdr::localcopy::rcptto */
54 PINEFIELD pf_template[] = {
81 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
83 #endif
85 };
88 PRIORITY_S priorities[] = {
95 };
98 #define ctrl(c) ((c) & 0x1f)
100 /* which message part to test for xliteration */
104 /*
105 * Internal prototypes
106 */
118 #ifndef _WINDOWS
126 #endif
145 /*
146 * Storage object where the FCC (or postponed msg) is to be written.
147 * This is amazingly bogus. Much work was done to put messages
148 * together and encode them as they went to the tmp file for sendmail
149 * or into the SMTP slot (especially for for DOS, to prevent a temporary
150 * file (and needlessly copying the message).
151 *
152 * HOWEVER, since there's no piping into c-client routines
153 * (particularly mail_append() which copies the fcc), the fcc will have
154 * to be copied to disk. This global tells pine's copy of the rfc822
155 * output functions where to also write the message bytes for the fcc.
156 * With piping in the c-client we could just have two pipes to shove
157 * down rather than messing with damn copies. FIX THIS!
158 *
159 * The function open_fcc, locates the actual folder and creates it if
160 * requested before any mailing or posting is done.
161 */
165 /*
166 * Locally global pointer to stream used for sending/posting.
167 * It's also used to indicate when/if we write the Bcc: field in
168 * the header.
169 */
182 /*
183 * Hooks for prompts and confirmations
184 */
199 piped_host /* return local host (NOTE: same as host!) */
200 };
203 /*
204 * Since c-client preallocates, it's necessary here to define a limit
205 * such that we don't blow up in c-client (see rfc822_address_line()).
206 */
207 #define MAX_SINGLE_ADDR MAILTMPLEN
212 /*
213 * Phone home hash controls
214 */
215 #define PH_HASHBITS 24
216 #define PH_MAXHASH (1<<(PH_HASHBITS))
219 /*
220 * postponed_stream - return stream associated with postponed messages
221 * in argument.
222 */
223 int
225 {
236 /*
237 * find default context to look for folder...
238 *
239 * The "mbox" is assumed to be local if we're given what looks
240 * like an absolute path. This is different from Goto/Save
241 * where we do alot of work to interpret paths relative to the
242 * server. This reason is to support all the pre-4.00 pinerc'
243 * that specified a path and because there's yet to be a way
244 * in c-client to specify otherwise in the face of a remote
245 * context.
246 */
251 /* check to see if the folder exists, the user wants to continue
252 * and that we can actually read something in...
253 */
261 /*
262 * The mbox is relative to the home directory.
263 * Make it absolute so we can compare it to
264 * stream->mailbox.
265 */
267 SIZEOF_20KBUF);
270 }
293 }
294 }
303 }
304 }
305 }
310 }
311 }
319 }
322 int
327 {
333 gf_io_t pc;
350 /* grok any user-defined or non-c-client headers */
353 /*
354 * The custom headers to look for in the suspended message should
355 * have been stored in the X-Our-Headers header. So first we get
356 * that list. If we can't find it (version that stored the
357 * message < 4.30) then we use the global custom list.
358 */
368 hdrval++)
369 ;
370 }
372 /* count elements in list */
375 commas++;
383 }
388 }
391 }
396 #define INDEX_FCC 0
397 #define INDEX_POSTERR 1
398 #define INDEX_REPLYUID 2
399 #define INDEX_REPLYMBOX 3
400 #define INDEX_SMTP 4
401 #define INDEX_NNTP 5
402 #define INDEX_CURSORPOS 6
403 #define INDEX_OUR_REPLYTO 7
405 #define FIELD_COUNT 9
409 /*
410 * Having these two fields separated isn't the slickest, but
411 * converting the pointer array for fetchheader_lines() to
412 * a list of structures or some such for simple_header_parse()
413 * is too goonie. We could do something like re-use c-client's
414 * PARAMETER struct which is a simple char * pairing, but that
415 * doesn't make sense to pass to fetchheader_lines()...
416 */
442 /*
443 * translate RFC 1522 strings,
444 * starting with "Lcc" field
445 */
452 len++;
455 }
459 }
466 }
470 }
476 /*
477 * Because the value is already in the envelope.
478 */
481 }
488 }
492 i++;
493 }
498 /*
499 * Since c-client fills in the reply_to field in the envelope
500 * even if there isn't a Reply-To header in the message we
501 * have to work around that. When we postpone we add
502 * a second header that has value "Empty" if there really
503 * was a Reply-To and it was empty. It has the
504 * value "Full" if we put the Reply-To contents there
505 * intentionally (and it isn't empty).
506 */
514 }
525 }
538 }
547 /*
548 * Turn the space delimited list of smtp servers into
549 * a char ** list.
550 */
554 cnt++;
569 }
570 else
572 }
576 }
582 /*
583 * Turn the space delimited list of smtp nntp into
584 * a char ** list.
585 */
589 cnt++;
604 }
605 else
607 }
611 }
614 /*
615 * The redraft cursor position is written as two fields
616 * separated by a space. First comes the name of the
617 * header field we're in, or just a ":" if we're in the
618 * body. Then comes the offset into that header or into
619 * the body.
620 */
624 *redraft_pos
635 }
636 else
638 }
641 }
645 else
647 }
654 /*
655 * If the postponed message has a From which is different from
656 * the default, it is either because allow-changing-from is on
657 * or because there was a role with a from that allowed it to happen.
658 * If allow-changing-from is not on, put this back in a role
659 * so that it will be allowed again in pine_send.
660 */
664 /*
665 * Now check to see if the from is different from default from.
666 */
685 added_to_role++;
686 }
689 }
691 /*
692 * Look at each empty address and see if the user has specified
693 * a default for that field or not. If they have, that means
694 * they have erased it before postponing, so they won't want
695 * the default to come back. If they haven't specified a default,
696 * then the default should be generated in pine_send. We prevent
697 * the default from being assigned by assigning an empty address
698 * to the variable here.
699 *
700 * BUG: We should do this for custom Address headers, too, but
701 * there isn't such a thing yet.
702 */
711 /* user erased reply-to before postponing */
715 /*
716 * If empty is not the normal default, make the outgoing
717 * reply_to be an emtpy address. If it is default, leave it
718 * as NULL and the default will be used.
719 */
721 PINEFIELD pf;
730 }
731 }
732 }
736 /*
737 * The reply-to is real. If it is different from the default
738 * reply-to, put it in the role so that it will show up when
739 * the user edits.
740 */
742 PINEFIELD pf;
750 /* standard value, leave it alone */
751 ;
752 }
754 add_to_role++;
757 }
758 }
760 add_to_role++;
764 }
766 add_to_role++;
770 added_to_role++;
773 }
777 }
778 }
780 /* this is a bogus c-client generated replyto */
783 }
790 }
796 }
802 /*
803 * Now, this is interesting. We should have found
804 * the "fcc:" field if pine wrote the message being
805 * redrafted. Hence, we probably can't trust the
806 * "originator" type fields, so we'll blast them and let
807 * them get set later in pine_send. This should allow
808 * folks with custom or edited From's and such to still
809 * use redraft reasonably, without inadvertently sending
810 * messages that appear to be "From" others...
811 */
815 /*
816 * Ditto for Reply-To and Sender...
817 */
823 }
827 /*
828 * Generate a fresh message id for pretty much the same
829 * reason From and such got wacked...
830 * Also, if we're coming from a form letter, we need to
831 * generate a different id each time.
832 */
837 }
847 }
848 }
854 }
855 }
870 }
873 /* let outgoing routines decide on charset */
878 }
889 }
900 /* let outgoing routines decide on charset */
909 }
910 else
912 }
913 }
920 }
924 /* We have what we want, blast this message... */
929 }
930 else
934 }
937 /*----------------------------------------------------------------------
938 Clear deleted messages from given stream and expunge if necessary
940 Args: stream --
941 problem --
943 ----*/
944 int
946 {
957 }
968 }
970 /* if it is current, we have to change folders */
972 do_the_broach++;
974 /*
975 * This is the stream to the empty postponed-msgs folder.
976 * We are going to delete the folder in a second. It is
977 * probably preferable to unselect the mailbox and leave
978 * this stream open for re-use instead of actually closing it,
979 * so we do that if possible.
980 */
982 /*
983 * This does the UNSELECT on the stream. A NULL
984 * return should mean that something went wrong and
985 * a mail_close already happened, so that should have
986 * cleaned things up in the callback.
987 */
990 /* now close it so it is put into the stream cache */
993 }
994 }
995 else
1002 }
1006 /* TRANSLATORS: Arg is a mailbox name */
1011 }
1012 }
1015 }
1018 /*----------------------------------------------------------------------
1019 Parse the given header text for any given fields
1021 Args: text -- Text to parse for fcc and attachments refs
1022 fields -- array of field names to look for
1023 values -- array of pointer to save values to, returned NULL if
1024 fields isn't in text.
1026 This function simply looks for the given fields in the given header
1027 text string.
1028 NOTE: newlines are expected CRLF, and we'll ignore continuations
1029 ----*/
1030 void
1032 {
1039 /*---- Loop until the end of the header ----*/
1050 }
1055 }
1064 }
1065 else
1067 }
1070 }
1073 }
1076 }
1078 /* Skip to end of line, what ever it was */
1083 }
1084 }
1085 }
1088 /*----------------------------------------------------------------------
1089 build a fresh REPLY_S from the given string (see pine_send for format)
1091 Args: s -- "X-Reply-UID" header value
1093 Returns: filled in REPLY_S or NULL on parse error
1094 ----*/
1095 REPLY_S *
1097 {
1102 /* FORMAT: (n prefix)(n validity uidlist)mailbox */
1103 /* if 'n prefix' is empty, uid list represents forwarded msgs */
1107 }
1110 ;
1118 }
1119 }
1120 else
1122 }
1126 ;
1131 ;
1146 else
1148 }
1151 i++;
1154 }
1163 else
1169 }
1170 else
1172 }
1173 }
1174 }
1175 }
1176 }
1179 }
1182 /*
1183 * pine_new_env - allocate a new METAENV and fill it in.
1184 */
1185 METAENV *
1187 {
1195 /* how many fields are there? */
1197 ;
1202 cnt++;
1204 /* temporary PINEFIELD array */
1218 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
1219 # define NN 4
1220 #else
1221 # define NN 3
1222 #endif
1224 /* initialize pfield */
1230 /* slide string over so it is Sender instead of X-X-Sender */
1319 }
1360 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
1365 #endif
1375 }
1392 }
1393 }
1396 i--;
1398 /*
1399 * NOTE: "i" is assumed to now index first custom field in sending
1400 * order.
1401 */
1415 BuildTo bldto;
1421 /* change default text into an ADDRESS */
1422 /* strip quotes around whole default */
1430 }
1443 }
1444 }
1445 }
1449 }
1452 void
1454 {
1460 ;
1467 }
1470 }
1476 }
1479 /*----------------------------------------------------------------------
1480 Check for addresses the user is not permitted to send to, or probably
1481 doesn't want to send to
1483 Returns: 0 if OK
1484 1 if there are only empty groups
1485 -1 if the message shouldn't be sent
1487 Queues a message indicating what happened
1488 ---*/
1489 int
1491 {
1496 /*---- Is he/she trying to send mail to the mailer-daemon ----*/
1504 /* TRANSLATORS: First arg is the address we can't
1505 send to, second arg is "not in addressbook". */
1512 }
1518 }
1522 }
1525 }
1526 }
1529 }
1532 /*
1533 * If this isn't general enough we can modify it. The value passed in
1534 * is expected to be one of the desc settings from the priorities array,
1535 * like "High". The header value is X-Priority: 2 (High)
1536 * or something similar. If value doesn't match any of the values then
1537 * the actual value is used instead.
1538 */
1539 PINEFIELD *
1541 {
1564 }
1565 else
1567 }
1568 }
1570 }
1573 /*----------------------------------------------------------------------
1574 Set answered flags for messages specified by reply structure
1576 Args: reply --
1578 Returns: with appropriate flags set and index cache entries suitably tweeked
1579 ----*/
1580 void
1582 {
1587 /* nothing to flip in a pseudo reply */
1592 /*
1593 * If an established stream will do, use it, else
1594 * build one unless we have an array of msgno's...
1595 *
1596 * I was just mimicking what was already here. I don't really
1597 * understand why we use strcmp instead of same_stream_and_mailbox().
1598 * Or sp_stream_get(reply->mailbox, SP_MATCH).
1599 * Hubert 2003-07-09
1600 */
1606 }
1611 /*
1612 * This is here only for people who ran pine4.42 and are
1613 * processing postponed mail from 4.42 now. Pine4.42 saved the
1614 * original mailbox name in the canonical name's position in
1615 * the postponed-msgs folder so it won't match the canonical
1616 * name from the stream.
1617 */
1623 /* TRANSLATORS: program is busy updating the Answered flags so warns user */
1631 ourstream++;
1632 }
1638 }
1639 }
1646 }
1651 }
1654 /*
1655 * $Forwarded is a regular keyword so we only try to
1656 * set it if the stream allows keywords.
1657 * We could mess up if the stream has keywords but just
1658 * isn't allowing anymore and $Forwarded already exists,
1659 * but what are the odds?
1660 */
1663 FORWARDED_FLAG,
1665 }
1666 else
1673 }
1680 }
1681 }
1684 /*
1685 * phone_home_from - make phone home request's from address IMpersonal.
1686 * Doesn't include user's personal name.
1687 */
1688 ADDRESS *
1690 {
1694 /* garble up mailbox name */
1700 }
1703 /*
1704 * one-way-hash a username into an 8-digit decimal number
1705 *
1706 * Corey Satten, corey@cac.washington.edu, 7/15/98
1707 */
1708 unsigned int
1710 {
1716 else
1720 }
1723 }
1726 /*----------------------------------------------------------------------
1727 Call the mailer, SMTP, sendmail or whatever
1729 Args: header -- full header (envelope and local parts) of message to send
1730 body -- The full body of the message including text
1731 alt_smtp_servers --
1732 verbosefile -- non-null means caller wants verbose interaction and the resulting
1733 output file name to be returned
1735 Returns: -1 if failed, 1 if succeeded
1736 ----*/
1737 int
1741 {
1754 /* Check for any recipients */
1763 }
1765 #ifdef SMIME
1777 }
1779 /* need to free new body from encrypt if sign fails? */
1787 }
1788 #endif
1790 /* set up counts and such to keep track sent percentage */
1798 #ifndef _WINDOWS
1800 /* try posting via local "<mta> <-t>" if specified */
1806 }
1808 #endif
1810 /*
1811 * If the user's asked for it, and we find that the first text
1812 * part (attachments all get b64'd) is non-7bit, ask for 8BITMIME.
1813 */
1817 #ifdef DEBUG
1818 #ifndef DEBUGJOURNAL
1820 #endif
1822 #endif
1832 /*
1833 * If it isn't Never, then we're always going to let them
1834 * know about failures. This means we don't allow for the
1835 * possibility of setting delay or success without failure.
1836 */
1841 }
1842 }
1845 /*
1846 * Set global header pointer so post_rfc822_output can get at it when
1847 * it's called back from c-client's sending routine...
1848 */
1851 /*
1852 * Fabricate a fake ENVELOPE to hand c-client's SMTP engine.
1853 * The purpose is to give smtp_mail the list for SMTP RCPT when
1854 * there are recipients in pine's METAENV that are outside c-client's
1855 * envelope.
1856 *
1857 * NOTE: If there aren't any, don't bother. Dealt with it below.
1858 */
1877 }
1878 }
1880 /*
1881 * Install our rfc822 output routine
1882 */
1886 /*
1887 * Allow for verbose posting
1888 */
1892 /*
1893 * We do this because we want mm_log to put the error message into
1894 * c_client_error instead of showing it itself.
1895 */
1898 /*
1899 * OK, who posts what? We tried an mta_handoff above, but there
1900 * was either none specified or we decided not to use it. So,
1901 * if there's an smtp-server defined anywhere,
1902 */
1904 /*---------- SMTP ----------*/
1909 }
1912 /*---------- SMTP ----------*/
1916 }
1917 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
1920 /*----- Send via LOCAL SMTP agent ------*/
1929 /* BUG: should provide separate stderr output! */
1930 }
1954 }
1955 }
1961 }
1962 }
1967 }
1970 }
1972 /*
1973 * Before we actually send data, see if we have to protect
1974 * the first text body part from getting encoded. We protect
1975 * it from getting encoded in "pine_rfc822_output_body" by
1976 * temporarily inventing a synonym for ENC8BIT...
1977 * This works like so:
1978 * Suppose bp->encoding is set to ENC8BIT.
1979 * We change that here to some unused value (added_encoding) and
1980 * set body_encodings[added_encoding] to "8BIT".
1981 * Then post_rfc822_output is called which calls
1982 * pine_rfc822_output_body. Inside that routine
1983 * pine_write_body_header writes out the encoding for the
1984 * part. Normally it would see encoding == ENC8BIT and it would
1985 * change that to QUOTED-PRINTABLE, but since encoding has been
1986 * set to added_encoding it uses body_encodings[added_encoding]
1987 * which is "8BIT" instead. Then the actual body is written by
1988 * pine_write_body_header which does not do the gf_8bit_qp
1989 * filtering because encoding != ENC8BIT (instead it's equal
1990 * to added_encoding).
1991 */
1997 ;
2001 }
2007 #ifdef SMIME
2016 body->nested.part->next->body.contents.text.data = body->nested.part->next->body.mime.text.data;
2018 }
2020 }
2021 }
2046 /*
2047 * Too complicated to figure out which header line
2048 * has the error in the fake_env case, so just
2049 * leave cursor at default.
2050 */
2059 }
2063 }
2064 }
2078 }
2082 }
2083 }
2087 }
2089 /* repair modified "body_encodings" array? */
2094 }
2100 }
2106 }
2119 }
2122 }
2124 /*
2125 * Restore original 822 emitter...
2126 */
2132 done:
2134 #ifdef SMIME
2135 /* Free replacement encrypted body */
2139 /* Just get rid of first part, it's actually origBody */
2145 }
2148 }
2149 #endif
2155 /*-------- Did message make it ? ----------*/
2157 /*---- Error sending mail -----*/
2164 }
2167 }
2171 }
2172 }
2175 /*
2176 * write_postponed - exported method to write the given message
2177 * to the postponed folder
2178 */
2179 int
2181 {
2193 }
2202 /* BUG: writem sufficient ? */
2209 }
2211 /*
2212 * Work around c-client reply-to bug. C-client will
2213 * return a reply_to in an envelope even if there is
2214 * no reply-to header field. We want to note here whether
2215 * the reply-to is real or not.
2216 */
2224 else
2226 }
2228 /*
2229 * Write the list of custom headers to the
2230 * X-Our-Headers header so that we can recover the
2231 * list in redraft.
2232 */
2242 ;
2249 /* note: "pf" overloaded */
2254 r--;
2256 }
2259 }
2260 }
2267 }
2273 }
2277 }
2280 int
2282 {
2287 }
2288 else
2292 }
2295 int
2297 {
2309 }
2312 }
2315 }
2318 }
2321 }
2324 /*----------------------------------------------------------------------
2325 Checks to make sure the fcc is available and can be opened
2327 Args: fcc -- the name of the fcc to create. It can't be NULL.
2328 fcc_cntxt -- Returns the context the fcc is in.
2329 force -- supress user option prompt
2331 Returns allocated storage object on success, NULL on failure
2332 ----*/
2333 STORE_S *
2335 {
2340 /*
2341 * check for fcc's existance...
2342 */
2348 /*
2349 * Don't want to preclude a user from Fcc'ing a .name'd folder
2350 */
2354 }
2356 /*
2357 * We only want to set the "context" if fcc is an ambiguous
2358 * name. Otherwise, our "relativeness" rules for contexts
2359 * (implemented in context.c) might cause the name to be
2360 * interpreted in the wrong context...
2361 */
2368 || (pith_opt_save_create_prompt
2374 ok++;
2377 }
2378 else
2380 }
2381 else
2388 }
2391 ok++;
2392 }
2395 || (pith_opt_save_create_prompt
2404 }
2405 else
2407 }
2408 }
2413 }
2433 s1,
2437 s2);
2440 }
2441 else
2443 }
2444 else
2448 }
2451 }
2454 /*----------------------------------------------------------------------
2455 mail_append() the fcc accumulated in temp_storage to proper destination
2457 Args: fcc -- name of folder
2458 fcc_cntxt -- context for folder
2459 temp_storage -- String of file where Fcc has been accumulated
2461 This copies the string of file to the actual folder, which might be IMAP
2462 or a disk folder. The temp_storage is freed after it is written.
2463 An error message is produced if this fails.
2464 ----*/
2465 int
2468 {
2469 STRING msg;
2485 }
2486 else
2491 /*
2492 * Before changing this note that these lines depend on the
2493 * definition of FCC_SOURCE.
2494 */
2510 }
2518 }
2521 /*
2522 * first_text_8bit - return TRUE if somewhere in the body 8BIT data's
2523 * contained.
2524 */
2525 BODY *
2527 {
2533 }
2536 /*
2537 * Build and return the "From:" address for outbound messages from
2538 * global data...
2539 */
2540 ADDRESS *
2542 {
2549 }
2556 }
2559 /*
2560 * set_mime_type_by_grope - sniff the given storage object to determine its
2561 * type, subtype, encoding, and charset
2562 *
2563 * "Type" and "encoding" must be set before calling this routine.
2564 * If "type" is set to something other than TYPEOTHER on entry,
2565 * then that is the "type" we wish to use. Same for "encoding"
2566 * using ENCOTHER instead of TYPEOTHER. Otherwise, we
2567 * figure them out here. If "type" is already set, we also
2568 * leave subtype alone. If not, we figure out subtype here.
2569 * There is a chance that we will upgrade encoding to a "higher"
2570 * level. For example, if it comes in as 7BIT we may change
2571 * that to 8BIT if we find a From_ we want to escape.
2572 * We may also set the charset attribute if the type is TEXT.
2573 *
2574 * NOTE: this is rather inefficient if the store object is a CharStar
2575 * but the win is all types are handled the same
2576 */
2577 void
2579 {
2580 #define RBUFSZ (8193)
2590 #ifdef ENCODE_FROMS
2593 #endif
2601 ;
2610 }
2616 }
2621 }
2626 }
2630 }
2634 }
2639 }
2644 }
2646 /*
2647 * if type was set above, but no encoding specified, go
2648 * ahead and make it BASE64...
2649 */
2652 }
2653 }
2655 /* PROBLEM !!! */
2661 }
2662 }
2668 #endif
2673 /* Some people don't like quoted-printable caused by leading Froms */
2674 #ifdef ENCODE_FROMS
2676 #endif
2681 #if defined(DOS) || defined(OS2)
2682 /* LF with no CR!! */
2685 #endif
2686 }
2688 eight_bit_chars++;
2689 }
2691 /* NULL found. Unless we're told otherwise, must be binary */
2695 }
2697 /*
2698 * The "TYPETEXT" here handles the case that the NULL
2699 * comes from imported text generated by some external
2700 * editor that permits or inserts NULLS. Otherwise,
2701 * assume it's a binary segment...
2702 */
2705 /*
2706 * Since we've already set encoding, count this as a
2707 * hi bit char and continue. The reason is that if this
2708 * is text, there may be a high percentage of encoded
2709 * characters, so base64 may get set below...
2710 */
2712 eight_bit_chars++;
2713 else
2715 }
2720 #endif
2722 /* read another buffer in */
2728 ;
2732 }
2733 else
2734 p++;
2736 /*
2737 * If there's no beginning-of-line pointer, then we must
2738 * have seen an end-of-line. Set bol to the start of the
2739 * new line...
2740 */
2745 /* either a lone \r or lone \n indicate binary file */
2751 }
2755 }
2756 }
2757 #endif
2758 }
2759 }
2761 /* stash away for later */
2765 /*
2766 * Since the type or encoding aren't set yet, fall thru a
2767 * series of tests to make sure an adequate type and
2768 * encoding are set...
2769 */
2773 /*
2774 * Since the types not set, then we didn't find a NULL.
2775 * If there's no NULL, then this is likely text. However,
2776 * since we can't be *completely* sure, we set it to
2777 * the generic type.
2778 */
2781 }
2784 /*
2785 * As with NULL handling, if we're told it's text,
2786 * qp-encode it, else it gets base 64...
2787 */
2789 }
2797 }
2799 /*
2800 * The 30% threshold is based on qp encoded readability
2801 * on non-MIME UA's.
2802 */
2808 }
2813 }
2815 /*
2816 * Apply maximal encoding regardless of previous
2817 * setting. This segment's either not text, or is
2818 * unlikely to be readable with > 30% of the
2819 * text encoded anyway, so we might as well save space...
2820 */
2822 }
2823 }
2825 #ifdef ENCODE_FROMS
2826 /* If there were From_'s at the beginning of a line or standalone dots */
2829 #endif
2831 /* Set the subtype */
2842 }
2845 /*
2846 * Call this to set the charset of an attachment we have
2847 * created. If the attachment contains any non-ascii characters
2848 * then we'll set the charset to the passed in charset, otherwise
2849 * we'll make it us-ascii.
2850 */
2851 void
2853 {
2868 can_be_ascii--;
2875 /*
2876 * Else we don't know. There are non ascii characters but we either
2877 * don't have a charset to set it to or that charset is just us_ascii,
2878 * which is impossible. So we label it unknown. An alternative would
2879 * have been to strip the high bits instead and label it ascii.
2880 */
2882 }
2886 }
2889 /*
2890 * since encoding happens on the way out the door, this is basically
2891 * just needed to handle TYPEMULTIPART
2892 */
2893 void
2895 {
2910 }
2921 /*
2922 * If the part is text we edited, then it is UTF-8.
2923 * The user may be asking us to send it as something else
2924 * or we may want to downconvert to a more-specific characterset.
2925 * Mark it for conversion here so the right MIME header's written.
2926 * Do conversion pine_rfc822_output_body.
2927 * Attachments are left as is.
2928 */
2939 /*
2940 * Fix iso-2022-jp encoding to ENC7BIT since it's escape based
2941 * and doesn't use anything but ASCII characters.
2942 * Why is it not ENC7BIT already? Because when we set the encoding
2943 * in set_mime_type_by_grope we were groping through UTF-8 text
2944 * not 2022 text. Not only that, but we didn't know at that point
2945 * that it wouldn't stay UTF-8 when we sent it, which would require
2946 * encoding.
2947 */
2952 }
2956 }
2961 /* Encapsulated messages are always treated as text objects at this point.
2962 This means that you must replace body->contents.msg with
2963 body->contents.text, which probably involves copying
2964 body->contents.msg.text to body->contents.text */
2966 /*
2967 * but we'll delay encoding it until the message is on the way
2968 * into the mail slot...
2969 */
2971 }
2972 }
2975 /*
2976 * pine_header_line - simple wrapper around c-client call to contain
2977 * repeated code, and to write fcc if required.
2978 */
2979 int
2982 {
2997 else
3016 /*
3017 * We were folding everything except message-id, but that wasn't
3018 * sufficient. Since 822 only allows folding where linear-white-space
3019 * is allowed we'd need a smarter folder than "fold" to do it. So,
3020 * instead of inventing that smarter folder (which would have to
3021 * know 822 syntax)
3022 *
3023 * We could just alloc space and copy the actual_field followed by
3024 * the value into it, but since that's what fold does anyway we'll
3025 * waste some cpu time and use fold with a big fold parameter.
3026 *
3027 * We upped the references folding from 75 to 256 because we were
3028 * encountering longer-than-75 message ids, and to break one line
3029 * in references is to break them all.
3030 *
3031 * Also, some users are adding long text without spaces to the subject
3032 * line (e.g. URLs) so we up that number too. For the moment this is
3033 * going to 512 (a url that is about 6 lines long.)
3034 */
3039 }
3042 else
3049 }
3051 RFC822BUFFER rbuf;
3054 /*
3055 * rfc1522_encode already inserted continuation lines and did
3056 * the necessary folding so we don't have to do it. Let
3057 * rfc822_header_line add the trailing crlf and the resent- if
3058 * necessary. The 20 could actually be a 12.
3059 */
3071 }
3079 }
3086 }
3087 else
3091 }
3094 /*
3095 * Do appropriate encoding of text header lines.
3096 * For some field types (those that consist of 822 *text) we just encode
3097 * the whole thing. For structured fields we encode only within comments
3098 * if possible.
3099 *
3100 * Args d -- Destination buffer if needed. (tmp_20k_buf)
3101 * s -- Source string.
3102 * charset -- Charset to encode with.
3103 * encode_all -- If set, encode the whole string. If not, try to encode
3104 * only within comments if possible.
3105 *
3106 * Returns S is returned if no encoding is done. D is returned if encoding
3107 * was needed.
3108 */
3111 {
3122 /*
3123 * We don't have to worry about keeping track of quoted-strings because
3124 * none of these fields which aren't addresses contain quoted-strings.
3125 * We do keep track of escaped parens inside of comments and comment
3126 * nesting.
3127 */
3139 /* encode the comment, excluding the outer parens */
3146 charset);
3157 }
3162 }
3171 }
3172 }
3181 }
3182 }
3185 /* Unterminated comment (wasn't really a comment) */
3190 }
3191 }
3193 /*
3194 * We have to check if there is anything that needs to be encoded that
3195 * wasn't in a comment. If there is, we'd better just start over and
3196 * encode the whole thing. So, if no encoding has been done within
3197 * comments, or if encoding is needed both within and outside of
3198 * comments, then we encode the whole thing. Otherwise, go with
3199 * the version that has only comments encoded.
3200 */
3208 }
3209 }
3212 /*
3213 * pine_address_line - write a header field containing addresses,
3214 * one by one (so there's no buffer limit), and
3215 * wrapping where necessary.
3216 * Note: we use c-client functions to properly build the text string,
3217 * but have to screw around with pointers to fool c-client functions
3218 * into not blatting all the text into a single buffer. Yeah, I know.
3219 */
3220 int
3223 {
3231 RFC822BUFFER rbuf;
3234 #define no_comma (&comma[1])
3240 in_group++;
3241 was_start_of_group++;
3242 /* encode mailbox of group */
3253 }
3255 failed++;
3257 }
3258 }
3259 }
3260 else
3264 /* make sure personal name is encoded */
3274 }
3276 failed++;
3278 }
3279 }
3284 /* use automatic buffer unless it isn't big enough */
3288 }
3292 }
3315 }
3320 }
3322 /*
3323 * If there is no sending_stream and we are writing the Lcc header,
3324 * then we are piping it to sendmail -t which expects it to be a bcc,
3325 * not lcc.
3326 *
3327 * When we write it to the fcc or postponed (the lmc.so),
3328 * we want it to be lcc, not bcc, so we put it back.
3329 */
3343 }
3351 /* account for c-client's representation of group names */
3356 /*
3357 * Rfc822_write_address no longer writes out the end of group
3358 * unless the whole group address is passed to it, so we do
3359 * it ourselves.
3360 */
3362 }
3365 }
3366 /* start of new group, print phrase below */
3368 in_group++;
3369 was_start_of_group++;
3370 }
3372 /* no comma before first address in group syntax */
3376 }
3378 /* write delimiter */
3393 }
3395 failed++;
3397 }
3405 }
3408 /* make sure we don't write out group end with rfc822_write_address */
3417 }
3426 /*
3427 * BUG
3428 * With group syntax addresses we no longer have two identical
3429 * streams of output. Instead, for the fcc/postpone copy we include
3430 * all of the addresses inside the :; of the group, and for the
3431 * mail we're sending we don't include them. That means we aren't
3432 * correctly keeping track of the column to wrap in, below. That is,
3433 * we are keeping track of the fcc copy but we aren't keeping track
3434 * of the regular copy. It could result in too long or too short
3435 * lines. Should almost never come up since group addresses are almost
3436 * never followed by other addresses in the same header, and even
3437 * when they are, you have to go out of your way to get the headers
3438 * messed up.
3439 */
3446 }
3447 else
3455 }
3457 bail_out:
3467 }
3470 /*
3471 * mutated pine version of c-client's rfc822_header() function.
3472 * changed to call pine-wrapped header and address functions
3473 * so we don't have to limit the header size to a fixed buffer.
3474 * This function also calls pine's body_header write function
3475 * because encoding is delayed until output_body() is called.
3476 */
3477 long
3479 {
3492 }
3497 /*
3498 * Warning: This is confusing. The 2nd to last argument used to
3499 * be just pf->writehdr. We want Bcc lines to be written out
3500 * if we are handing off to a sendmail temp file but not if we
3501 * are talking smtp, so bcc's writehdr is set to 0 and
3502 * pine_address_line was sending if writehdr OR !sending_stream.
3503 * That works as long as we want to write everything when
3504 * !sending_stream (an mta handoff to sendmail). But then we
3505 * added the undisclosed recipients line which should only get
3506 * written if writehdr is set, and not when we pass to a
3507 * sendmail temp file. So pine_address_line has been changed
3508 * so it bases its decision solely on the writehdr passed to it,
3509 * and the logic that worries about Bcc and sending_stream
3510 * was moved up to the caller (here) to decide when to set it.
3511 *
3512 * So we have:
3513 * undisclosed recipients:; This will just be written
3514 * if writehdr was set and not
3515 * otherwise, nothing magical.
3516 *** We may want to change this, because sendmail -t doesn't handle
3517 *** the empty group syntax well unless it has been configured to
3518 *** do so. It isn't configured by default, or in any of the
3519 *** sendmail v8 configs. So we may want to not write this line
3520 *** if we're doing an mta_handoff (!sending_stream).
3521 *
3522 * !sending_stream (which means a handoff to a sendmail -t)
3523 * bcc or lcc both set the arg so they'll get written
3524 * (There is also Lcc hocus pocus in pine_address_line
3525 * which converts the Lcc: to Bcc: for sendmail
3526 * processing.)
3527 * sending_stream (which means an smtp handoff)
3528 * bcc and lcc will never have writehdr set, so
3529 * will never be written (They both do have rcptto set,
3530 * so they both do cause RCPT TO commands.)
3531 *
3532 * The localcopy is independent of sending_stream and is just
3533 * written if it is set for all of these.
3534 */
3537 header,
3539 f,
3540 s,
3543 ? !sending_stream
3564 }
3565 }
3568 #if (defined(DOS) || defined(OS2)) && !defined(NOAUTH)
3569 /*
3570 * Add comforting "X-" header line indicating what sort of
3571 * authenticity the receiver can expect...
3572 */
3574 NETMBX netmbox;
3585 }
3600 }
3605 }
3609 }
3610 #endif
3617 }
3622 }
3625 }
3628 /*
3629 * pine_rfc822_output - pine's version of c-client call. Necessary here
3630 * since we're not using its structures as intended!
3631 */
3632 long
3634 {
3642 /* build and output RFC822 header, output body */
3650 }
3653 /*
3654 * post_rfc822_output - cloak for pine's 822 output routine. Since
3655 * we can't pass opaque envelope thru c-client posting
3656 * logic, we need to wrap the real output inside
3657 * something that c-client knows how to call.
3658 */
3659 long
3663 soutr_t f,
3666 {
3668 }
3671 /*
3672 * posting_characterset- determine what transliteration is reasonable
3673 * for posting the given non-ascii messsage data.
3674 *
3675 * preferred_charset is the charset the original data was labeled in.
3676 * If we can keep that we do.
3677 *
3678 * Returns: always returns the preferred character set.
3679 */
3682 {
3698 /* convert text in header to UCS characters */
3705 /*
3706 * After the while loop is done the validbitmap has
3707 * a 1 bit for all the character sets that can
3708 * represent all of the characters of this header.
3709 */
3720 }
3723 }
3732 }
3738 UCS ucs;
3739 CBUF_S cbuf;
3765 /*
3766 * Read a stream of UTF-8 characters from the_text
3767 * and convert them to UCS-4 characters for the translatable
3768 * test.
3769 */
3772 /* got a ucs character */
3777 }
3778 }
3785 }
3787 /* user chooses something other than UTF-8 */
3789 /*
3790 * If we're to post in other than UTF-8, and it can be
3791 * transliterated without losing fidelity, do it.
3792 * Else, use UTF-8.
3793 */
3795 /* if ascii works, always use that */
3799 /* does the user's posting character set work? */
3803 /* this is the charset the message we are replying to was in */
3809 /* else, use UTF-8 */
3811 }
3812 /* user chooses nothing, going with the default */
3818 /*
3819 * In this case the user didn't specify a posting character set
3820 * and we will choose the most-specific one from our list.
3821 */
3823 /* ascii is best */
3827 /* Can we keep the original from the message we're replying to? */
3833 /* choose the best of the rest */
3838 /*
3839 * If the text we're labeling contains something like
3840 * smart quotes but no CJK characters, then instead of
3841 * labeling it as ISO-2022-JP we want to use UTF-8.
3842 */
3853 }
3856 }
3857 /* user explicitly chooses UTF-8 */
3859 /* if ascii works, always use that */
3863 /* else, use UTF-8 */
3865 }
3866 }
3869 }
3891 "EUC-KR"
3892 };
3897 {
3902 /*
3903 * When user doesn't set a posting character set posting_charmap ends up
3904 * set to UTF-8. That also happens if user sets UTF-8 explicitly.
3905 * That's where the strange set of if-else's come from.
3906 */
3908 /* user chooses something other than UTF-8 */
3912 reset++;
3914 /* if posting_charmap is valid, include it in list */
3919 count++;
3923 reset++;
3924 }
3930 count++;
3934 reset++;
3935 }
3938 reset++;
3963 }
3964 }
3965 /* user chooses nothing, going with the default */
3971 /* does preferred_charset have to be added to the list? */
3977 }
3980 /* existing list is right size already */
3982 /* just check to see if last list item is the preferred_charset */
3984 /* no, fix it */
3985 reset++;
3988 }
3989 }
3991 reset++;
4003 }
4004 }
4006 /* if list is same size as downgrades, consider it good */
4008 reset++;
4021 }
4022 }
4023 }
4024 /* user explicitly chooses UTF-8 */
4026 /* include possibility of ascii even if they explicitly ask for UTF-8 */
4029 reset++;
4032 reset++;
4038 /* the list is just ascii and nothing else */
4045 }
4046 }
4055 }
4058 }
4061 /* total reset */
4062 void
4064 {
4072 }
4075 int
4077 {
4091 done++;
4094 }
4095 }
4098 }
4103 {
4111 /* careful, find_rightmost_bit modifies the bitmap */
4117 }
4120 /*
4121 * Set parameter to new value.
4122 */
4123 void
4125 {
4134 }
4147 }
4148 /* else pm is existing paramname parameter */
4149 }
4158 }
4159 }
4160 }
4163 /*----------------------------------------------------------------------
4164 Remove the leading digits from SMTP error messages
4165 -----*/
4168 {
4171 error++;
4176 }
4179 /*
4180 * Local globals pine's body output routine needs
4181 */
4186 /*
4187 * def to make our pipe write's more friendly
4188 */
4189 #ifdef PIPE_MAX
4190 #if PIPE_MAX > 20000
4191 #undef PIPE_MAX
4192 #endif
4193 #endif
4195 #ifndef PIPE_MAX
4196 #define PIPE_MAX 1024
4197 #endif
4200 /*
4201 * l_flust_net - empties gf_io terminal function's buffer
4202 */
4203 int
4205 {
4211 /*
4212 * The start of each write is expected to be the start of a
4213 * "record" (i.e., a CRLF terminated line). Make sure that is true
4214 * else we might screw up SMTP dot quoting...
4215 */
4219 ;
4226 ;
4229 /* snippet remains */
4232 }
4233 }
4242 if(lp && lp >= tmp_20k_buf && lp < tmp_20k_buf + SIZEOF_20KBUF && (*lp = c)) /* Shift text left? */
4245 }
4248 }
4251 /*
4252 * l_putc - gf_io terminal function that calls smtp's soutr_t function.
4253 *
4254 */
4255 int
4257 {
4262 }
4266 /*
4267 * pine_rfc822_output_body - pine's version of c-client call. Again,
4268 * necessary since c-client doesn't know about how
4269 * we're treating attachments
4270 */
4271 long
4273 {
4280 LOC_2022_JP ljp;
4281 gf_io_t gc;
4290 /* find cookie */
4295 /*
4296 * Output a bit of text before the first multipart delimiter
4297 * to warn unsuspecting users of non-mime-aware ua's that
4298 * they should expect weirdness. We do not add this when signing a
4299 * message, though...
4300 */
4301 #ifdef SMIME
4303 #endif
4304 if(f && !(*f)(s, " This message is in MIME format. The first part should be readable text,\015\012 while the remaining parts are likely unreadable without MIME-aware tools.\015\012\015\012"))
4308 /* build cookie */
4311 /* append cookie,mini-hdr,contents */
4318 /* output trailing cookie */
4321 #ifdef SMIME
4325 #endif
4329 }
4332 }
4342 else
4345 /*
4346 * Don't add trailing line if it is ExternalText, which already guarantees
4347 * a trailing newline.
4348 */
4364 }
4371 }
4373 /* else, just send it? */
4375 }
4376 }
4377 }
4380 }
4382 /*
4383 * Convert text pieces to canonical form
4384 * BEFORE applying any encoding (rfc1341: appendix G)...
4385 * NOTE: almost all filters expect CRLF newlines
4386 */
4391 }
4404 }
4405 }
4411 }
4430 /*
4431 * BUG: If this name is not ascii it's going to cause trouble.
4432 */
4448 }
4453 }
4458 else
4460 }
4464 {
4472 }
4474 /*
4475 * pine_write_body_header - another c-client clone. This time
4476 * so the final encoding labels get set
4477 * correctly since it hasn't happened yet,
4478 * and to be paranoid about line lengths.
4479 *
4480 * Returns: TRUE/nonzero on success, zero on error
4481 */
4482 int
4484 {
4486 RFC822BUFFER rbuf;
4505 }
4515 ? ENCBASE64
4517 ? ENCQUOTEDPRINTABLE
4522 /*
4523 * If requested, strip Content-ID headers that don't look like they
4524 * are needed. Microsoft's Outlook XP has a bug that causes it to
4525 * not show that there is an attachment when there is a Content-ID
4526 * header present on that attachment.
4527 *
4528 * If user has quell-content-id turned on, don't output content-id
4529 * unless it is of type message/external-body.
4530 * Since this code doesn't look inside messages being forwarded
4531 * type message content-ids will remain as is and type multipart
4532 * alternative will remain as is. We don't create those on our
4533 * own. If we did, we'd have to worry about getting this right.
4534 */
4570 }
4575 }
4587 }
4589 /* copy out of so, a line at a time (or less than a K)
4590 * and send it down the pike
4591 */
4602 }
4604 /* Finally, write blank line */
4609 }
4612 }
4615 /*
4616 * pine_write_header - convert, encode (if needed) and
4617 * write "header-name: field-body"
4618 */
4619 int
4621 {
4637 }
4640 /*
4641 * pine_write_param - convert, encode and write MIME header-field parameters
4642 */
4643 int
4645 {
4661 }
4664 }
4668 int
4670 {
4676 /*
4677 * "comment out" the real values since our comment isn't
4678 * likely the same type, disposition nor encoding...
4679 */
4682 }
4685 }
4688 }
4691 int
4693 {
4700 }
4703 }
4707 int
4709 {
4714 }
4717 /*
4718 * pine_free_body - c-client call wrapper so the body data pointer we
4719 * we're using in a way c-client doesn't know about
4720 * gets free'd appropriately.
4721 */
4722 void
4724 {
4725 /*
4726 * Preempt c-client's contents.text.data clean up since we've
4727 * usurped it's meaning for our own purposes...
4728 */
4731 /* Then let c-client handle the rest... */
4733 }
4736 /*
4737 * pine_free_body_data - free pine's interpretations of the body part's
4738 * data pointer.
4739 */
4740 void
4742 {
4749 }
4752 }
4753 }
4756 long
4758 {
4768 }
4771 }
4774 int
4776 {
4780 }
4783 /*
4784 * pine_smtp_verbose_out - write
4785 */
4786 void
4788 {
4789 #ifdef _WINDOWS
4790 LPTSTR slpt;
4791 #endif
4798 else
4801 #ifdef _WINDOWS
4802 /*
4803 * The stream is opened in Unicode mode, so we need to fix the
4804 * argument to fputs.
4805 */
4810 }
4814 #else
4818 #endif
4819 }
4821 }
4824 /*
4825 * pine_header_forbidden - is this name a "forbidden" header?
4826 *
4827 * name - the header name to check
4828 * We don't allow user to change these.
4829 */
4830 int
4832 {
4860 NULL
4861 };
4868 }
4871 /*
4872 * hdr_is_in_list - is there a custom value for this header?
4873 *
4874 * hdr - the header name to check
4875 * custom - the list to check in
4876 * Returns 1 if there is a custom value, 0 otherwise.
4877 */
4878 int
4880 {
4888 }
4891 /*
4892 * count_custom_hdrs_pf - returns number of custom headers in arg
4893 * custom -- the list to be counted
4894 * only_nonstandard -- only count headers which aren't standard pine headers
4895 */
4896 int
4898 {
4903 ret++;
4906 }
4909 /*
4910 * count_custom_hdrs_list - returns number of custom headers in arg
4911 */
4912 int
4914 {
4925 /* remove leading whitespace */
4928 /* look for colon or space or end */
4936 ret++;
4939 }
4940 }
4941 }
4944 }
4947 /*
4948 * set_default_hdrval - put the user's default value for this header
4949 * into pf->textbuf.
4950 * setthis - the pinefield to be set
4951 * custom - where to look for the default
4952 */
4953 CustomType
4955 {
4962 }
4972 /* turn on editing */
4978 }
4984 }
4987 /*
4988 * pine_header_standard - is this name a "standard" header?
4989 *
4990 * name - the header name to check
4991 */
4992 FieldType
4994 {
4997 /* check to see if this is a standard header */
5003 }
5006 /*
5007 * customized_hdr_setup - setup the PINEFIELDS for all the customized headers
5008 * Allocates space for each name and addr ptr.
5009 * Allocates space for default in textbuf, even if empty.
5010 *
5011 * head - the first PINEFIELD to fill in
5012 * list - the list to parse
5013 */
5014 void
5016 {
5027 /* anything after leading whitespace? */
5031 /* look for colon or space or end */
5036 /* if there is a space in the field-name, skip it */
5040 name);
5042 }
5047 /* Don't allow any of the forbidden headers. */
5051 name);
5055 }
5066 #ifdef OLDWAY
5067 /*
5068 * Some mailers apparently break if we change
5069 * user@domain into Fred <user@domain> for
5070 * return-receipt-to,
5071 * so we'll just call this a FreeText field, too.
5072 */
5073 /*
5074 * For now, all custom headers are FreeText except for
5075 * this one that we happen to know about. We might
5076 * have to add some syntax to the config option so that
5077 * people can tell us their custom header takes addresses.
5078 */
5083 }
5088 /* remove space between name and colon */
5091 /* give them an alloc'd default, even if empty */
5097 pf++;
5098 }
5099 else
5101 }
5102 }
5103 }
5105 /* fix last next pointer */
5108 }
5111 /*
5112 * add_defaults_from_list - the PINEFIELDS list given by "head" is already
5113 * setup except that it doesn't have default values.
5114 * Add those defaults if they exist in "list".
5115 *
5116 * head - the first PINEFIELD to add a default to
5117 * list - the list to get the defaults from
5118 */
5119 void
5121 {
5133 /* anything after leading whitespace? */
5137 /* look for colon or space or end */
5142 /* if there is a space in the field-name, skip it */
5152 }
5156 /*
5157 * Found the right header. See if it has a default
5158 * value set.
5159 */
5161 /* remove space between name and colon */
5173 }
5174 }
5177 }
5178 }
5179 }
5180 }
5183 /*
5184 * parse_custom_hdrs - allocate PINEFIELDS for custom headers
5185 * fill in the defaults
5186 * Args - list -- The list to parse.
5187 * cstmtype -- Fill the in cstmtype field with this value
5188 */
5189 PINEFIELD *
5191 {
5195 /*
5196 * add one for possible use by fcc
5197 * What is this "possible use"? I don't see it. I don't
5198 * think it exists anymore. I think +1 would be ok. hubert 2000-08-02
5199 */
5204 /* set up the custom header pfields */
5208 }
5211 /*
5212 * Combine the two lists of headers into one list which is allocated here
5213 * and freed by the caller. Eliminate duplicates with values from the role
5214 * taking precedence over values from the default.
5215 */
5216 PINEFIELD *
5218 {
5237 pf++;
5238 }
5240 /* if these aren't already there, add them */
5242 /* check for already there */
5245 i++)
5246 ;
5256 pf++;
5257 }
5258 }
5260 /* fix last next pointer */
5265 }
5268 /*
5269 * free_customs - free misc. resources associated with custom header fields
5270 *
5271 * pf - pointer to first custom field
5272 */
5273 void
5275 {
5285 /* only true for FreeText */
5289 /* only true for Address */
5292 }
5295 }
5298 /*
5299 * encode_whole_header
5300 *
5301 * Returns 1 if whole value should be encoded
5302 * 0 to encode only within comments
5303 */
5304 int
5306 {
5313 retval++;
5318 retval++;
5320 }
5321 }
5322 }
5325 }
5328 /*----------------------------------------------------------------------
5329 Post news via NNTP or inews
5331 Args: env -- envelope of message to post
5332 body -- body of message to post
5334 Returns: -1 if failed or cancelled, 1 if succeeded
5336 WARNING: This call function has the side effect of writing the message
5337 to the lmc.so object.
5338 ----*/
5339 int
5342 {
5359 /*---------- NNTP server defined ----------*/
5365 /*
5366 * Install our rfc822 output routine
5367 */
5379 #ifdef DEBUG
5381 #else
5383 #endif
5389 /*
5390 * Fake that we've got clearance from the transport agent
5391 * for 8bit transport for the benefit of our output routines...
5392 */
5398 ;
5402 }
5408 }
5409 }
5411 /*
5412 * Set global header pointer so we can get at it later...
5413 */
5424 }
5433 }
5436 /*---- Open of NNTP connection failed ------ */
5442 }
5443 server_no++;
5444 }
5448 /*----- Post via local mechanism -------*/
5449 #ifdef _WINDOWS
5454 pipecb_f);
5455 #endif
5456 }
5467 }
5471 }
5474 /* ----------------------------------------------------------------------
5475 Figure out command to start local SMTP agent
5477 Args: errbuf -- buffer for reporting errors (assumed non-NULL)
5479 Returns an alloc'd copy of the local SMTP agent invocation or NULL
5481 ----*/
5484 {
5485 #ifdef _WINDOWS
5492 # if defined(SENDMAIL) && defined(SENDMAILFLAGS)
5493 #define SENDTMPLEN 256
5495 /* SENDTMPLEN == sizeof(tmp) */
5499 # else
5502 # endif
5503 #endif
5506 }
5510 #ifndef _WINDOWS
5511 /*----------------------------------------------------------------------
5512 Hand off given message to local posting agent
5514 Args: envelope -- The envelope for the BCC and debugging
5515 header -- The text of the message header
5516 errbuf -- buffer for reporting errors (assumed non-NULL)
5517 len -- Length of errbuf
5519 ----*/
5520 int
5525 {
5526 #ifdef DF_SENDMAIL_PATH
5528 #endif
5531 /*
5532 * A bit of complicated policy implemented here.
5533 * There are two posting variables sendmail-path and smtp-server.
5534 * Precedence is in that order.
5535 * They can be set one of 4 ways: fixed, command-line, user, or globally.
5536 * Precedence is in that order.
5537 * Said differently, the order goes something like what's below.
5538 *
5539 * NOTE: the fixed/command-line/user precendence handling is also
5540 * indicated by what's pointed to by ps_global->VAR_*, but since
5541 * that also includes the global defaults, it's not sufficient.
5542 */
5547 }
5553 }
5563 else
5565 }
5573 }
5574 #ifdef DF_SENDMAIL_PATH
5575 /*
5576 * This defines the default method of posting. So,
5577 * unless we're told otherwise use it...
5578 */
5583 }
5584 #endif
5585 }
5586 }
5587 }
5595 }
5596 else
5598 }
5602 /*----------------------------------------------------------------------
5603 Hand off given message to local posting agent
5605 Args: envelope -- The envelope for the BCC and debugging
5606 header -- The text of the message header
5607 errbuf -- buffer for reporting errors (assumed non-NULL)
5608 errbuflen -- Length of errbuf
5610 Fork off mailer process and pipe the message into it
5611 Called to post news via Inews when NNTP is unavailable
5613 ----*/
5619 {
5621 #ifdef SENDNEWS
5633 }
5643 }
5647 /*----------------------------------------------------------------------
5648 Hand off message to local MTA; it parses recipients from 822 header
5650 Args: header -- struct containing header data
5651 body -- struct containing message body data
5652 cmd -- command to use for handoff (%s says where file should go)
5653 errs -- pointer to buf to hold errors
5655 ----*/
5660 {
5673 }
5679 }
5680 }
5681 else
5687 }
5690 }
5693 /*
5694 * pine_pipe_soutr - Replacement for tcp_soutr that writes one of our
5695 * pipes rather than a tcp stream
5696 */
5697 long
5699 {
5711 }
5712 }
5716 }
5717 }
5725 }
5726 }
5727 else
5729 }
5732 }
5733 #endif
5736 /**************** "PIPE" READING POSTING I/O ROUTINES ****************/
5739 /*
5740 * helpful def's
5741 */
5742 #define S(X) ((PIPE_S *)(X))
5743 #define GETBUFLEN (4 * MAILTMPLEN)
5748 {
5754 /* MAILTMPLEN = sizeof(tmp) */
5759 }
5760 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
5765 }
5766 else
5770 }
5775 {
5777 }
5780 /*
5781 * piped_soutr - Replacement for tcp_soutr that writes one of our
5782 * pipes rather than a tcp stream
5783 */
5784 long
5786 {
5788 }
5791 /*
5792 * piped_sout - Replacement for tcp_soutr that writes one of our
5793 * pipes rather than a tcp stream
5794 */
5795 long
5797 {
5809 }
5810 }
5814 }
5815 }
5818 }
5821 /*
5822 * piped_getline - Replacement for tcp_getline that reads one
5823 * of our pipes rather than a tcp pipe
5824 *
5825 * C-client expects that the \r\n will be stripped off.
5826 */
5829 {
5839 /* alloc space to collect input (freed in close_system_pipe) */
5843 }
5850 }
5855 }
5858 }
5869 }
5871 n++;
5873 }
5874 /* copy partial string from buffer */
5876 /* get more data */
5884 }
5892 }
5893 }
5896 }
5899 ptr++;
5900 cnt--;
5902 }
5910 }
5913 }
5916 /*
5917 * piped_close - Replacement for tcp_close that closes pipes to our
5918 * child rather than a tcp connection
5919 */
5920 void
5922 {
5923 /*
5924 * Uninstall our hooks into smtp_send since it's being used by
5925 * the nntp driver as well...
5926 */
5928 }
5931 /*
5932 * piped_abort - close down the pipe we were using to post
5933 */
5934 void
5936 {
5940 }
5945 }
5946 }
5951 {
5953 }
5956 unsigned long
5958 {
5960 }