| blob | dc5a500f107e3349a7f18c59bd597c4ea4070a36 |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2013-2018 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 */
1234 }
1321 }
1362 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
1367 #endif
1377 }
1394 }
1395 }
1398 i--;
1400 /*
1401 * NOTE: "i" is assumed to now index first custom field in sending
1402 * order.
1403 */
1417 BuildTo bldto;
1423 /* change default text into an ADDRESS */
1424 /* strip quotes around whole default */
1432 }
1445 }
1446 }
1447 }
1451 }
1454 void
1456 {
1462 ;
1469 }
1472 }
1478 }
1481 /*----------------------------------------------------------------------
1482 Check for addresses the user is not permitted to send to, or probably
1483 doesn't want to send to
1485 Returns: 0 if OK
1486 1 if there are only empty groups
1487 -1 if the message shouldn't be sent
1489 Queues a message indicating what happened
1490 ---*/
1491 int
1493 {
1498 /*---- Is he/she trying to send mail to the mailer-daemon ----*/
1506 /* TRANSLATORS: First arg is the address we can't
1507 send to, second arg is "not in addressbook". */
1514 }
1520 }
1524 }
1527 }
1528 }
1531 }
1534 /*
1535 * If this isn't general enough we can modify it. The value passed in
1536 * is expected to be one of the desc settings from the priorities array,
1537 * like "High". The header value is X-Priority: 2 (High)
1538 * or something similar. If value doesn't match any of the values then
1539 * the actual value is used instead.
1540 */
1541 PINEFIELD *
1543 {
1566 }
1567 else
1569 }
1570 }
1572 }
1575 /*----------------------------------------------------------------------
1576 Set answered flags for messages specified by reply structure
1578 Args: reply --
1580 Returns: with appropriate flags set and index cache entries suitably tweeked
1581 ----*/
1582 void
1584 {
1589 /* nothing to flip in a pseudo reply */
1594 /*
1595 * If an established stream will do, use it, else
1596 * build one unless we have an array of msgno's...
1597 *
1598 * I was just mimicking what was already here. I don't really
1599 * understand why we use strcmp instead of same_stream_and_mailbox().
1600 * Or sp_stream_get(reply->mailbox, SP_MATCH).
1601 * Hubert 2003-07-09
1602 */
1608 }
1613 /*
1614 * This is here only for people who ran pine4.42 and are
1615 * processing postponed mail from 4.42 now. Pine4.42 saved the
1616 * original mailbox name in the canonical name's position in
1617 * the postponed-msgs folder so it won't match the canonical
1618 * name from the stream.
1619 */
1625 /* TRANSLATORS: program is busy updating the Answered flags so warns user */
1633 ourstream++;
1634 }
1640 }
1641 }
1648 }
1653 }
1656 /*
1657 * $Forwarded is a regular keyword so we only try to
1658 * set it if the stream allows keywords.
1659 * We could mess up if the stream has keywords but just
1660 * isn't allowing anymore and $Forwarded already exists,
1661 * but what are the odds?
1662 */
1665 FORWARDED_FLAG,
1667 }
1668 else
1675 }
1682 }
1683 }
1686 /*
1687 * phone_home_from - make phone home request's from address IMpersonal.
1688 * Doesn't include user's personal name.
1689 */
1690 ADDRESS *
1692 {
1696 /* garble up mailbox name */
1702 }
1705 /*
1706 * one-way-hash a username into an 8-digit decimal number
1707 *
1708 * Corey Satten, corey@cac.washington.edu, 7/15/98
1709 */
1710 unsigned int
1712 {
1718 else
1722 }
1725 }
1728 /*----------------------------------------------------------------------
1729 Call the mailer, SMTP, sendmail or whatever
1731 Args: header -- full header (envelope and local parts) of message to send
1732 body -- The full body of the message including text
1733 alt_smtp_servers --
1734 verbosefile -- non-null means caller wants verbose interaction and the resulting
1735 output file name to be returned
1737 Returns: -1 if failed, 1 if succeeded
1738 ----*/
1739 int
1743 {
1756 /* Check for any recipients */
1765 }
1767 #ifdef SMIME
1779 }
1781 /* need to free new body from encrypt if sign fails? */
1789 }
1790 #endif
1792 /* set up counts and such to keep track sent percentage */
1800 #ifndef _WINDOWS
1802 /* try posting via local "<mta> <-t>" if specified */
1808 }
1810 #endif
1812 /*
1813 * If the user's asked for it, and we find that the first text
1814 * part (attachments all get b64'd) is non-7bit, ask for 8BITMIME.
1815 */
1819 #ifdef DEBUG
1820 #ifndef DEBUGJOURNAL
1822 #endif
1824 #endif
1834 /*
1835 * If it isn't Never, then we're always going to let them
1836 * know about failures. This means we don't allow for the
1837 * possibility of setting delay or success without failure.
1838 */
1843 }
1844 }
1847 /*
1848 * Set global header pointer so post_rfc822_output can get at it when
1849 * it's called back from c-client's sending routine...
1850 */
1853 /*
1854 * Fabricate a fake ENVELOPE to hand c-client's SMTP engine.
1855 * The purpose is to give smtp_mail the list for SMTP RCPT when
1856 * there are recipients in pine's METAENV that are outside c-client's
1857 * envelope.
1858 *
1859 * NOTE: If there aren't any, don't bother. Dealt with it below.
1860 */
1879 }
1880 }
1882 /*
1883 * Install our rfc822 output routine
1884 */
1888 /*
1889 * Allow for verbose posting
1890 */
1894 /*
1895 * We do this because we want mm_log to put the error message into
1896 * c_client_error instead of showing it itself.
1897 */
1900 /*
1901 * OK, who posts what? We tried an mta_handoff above, but there
1902 * was either none specified or we decided not to use it. So,
1903 * if there's an smtp-server defined anywhere,
1904 */
1906 /*---------- SMTP ----------*/
1911 }
1914 /*---------- SMTP ----------*/
1918 }
1919 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
1922 /*----- Send via LOCAL SMTP agent ------*/
1931 /* BUG: should provide separate stderr output! */
1932 }
1956 }
1957 }
1963 }
1964 }
1969 }
1972 }
1974 /*
1975 * Before we actually send data, see if we have to protect
1976 * the first text body part from getting encoded. We protect
1977 * it from getting encoded in "pine_rfc822_output_body" by
1978 * temporarily inventing a synonym for ENC8BIT...
1979 * This works like so:
1980 * Suppose bp->encoding is set to ENC8BIT.
1981 * We change that here to some unused value (added_encoding) and
1982 * set body_encodings[added_encoding] to "8BIT".
1983 * Then post_rfc822_output is called which calls
1984 * pine_rfc822_output_body. Inside that routine
1985 * pine_write_body_header writes out the encoding for the
1986 * part. Normally it would see encoding == ENC8BIT and it would
1987 * change that to QUOTED-PRINTABLE, but since encoding has been
1988 * set to added_encoding it uses body_encodings[added_encoding]
1989 * which is "8BIT" instead. Then the actual body is written by
1990 * pine_write_body_header which does not do the gf_8bit_qp
1991 * filtering because encoding != ENC8BIT (instead it's equal
1992 * to added_encoding).
1993 */
1999 ;
2003 }
2009 #ifdef SMIME
2018 body->nested.part->next->body.contents.text.data = body->nested.part->next->body.mime.text.data;
2020 }
2022 }
2023 }
2048 /*
2049 * Too complicated to figure out which header line
2050 * has the error in the fake_env case, so just
2051 * leave cursor at default.
2052 */
2061 }
2065 }
2066 }
2080 }
2084 }
2085 }
2089 }
2091 /* repair modified "body_encodings" array? */
2096 }
2102 }
2108 }
2121 }
2124 }
2126 /*
2127 * Restore original 822 emitter...
2128 */
2134 done:
2136 #ifdef SMIME
2137 /* Free replacement encrypted body */
2141 /* Just get rid of first part, it's actually origBody */
2147 }
2150 }
2151 #endif
2157 /*-------- Did message make it ? ----------*/
2159 /*---- Error sending mail -----*/
2166 }
2169 }
2173 }
2174 }
2177 /*
2178 * write_postponed - exported method to write the given message
2179 * to the postponed folder
2180 */
2181 int
2183 {
2195 }
2204 /* BUG: writem sufficient ? */
2211 }
2213 /*
2214 * Work around c-client reply-to bug. C-client will
2215 * return a reply_to in an envelope even if there is
2216 * no reply-to header field. We want to note here whether
2217 * the reply-to is real or not.
2218 */
2226 else
2228 }
2230 /*
2231 * Write the list of custom headers to the
2232 * X-Our-Headers header so that we can recover the
2233 * list in redraft.
2234 */
2244 ;
2251 /* note: "pf" overloaded */
2256 r--;
2258 }
2261 }
2262 }
2269 }
2275 }
2279 }
2282 int
2284 {
2289 }
2290 else
2294 }
2297 int
2299 {
2311 }
2314 }
2317 }
2320 }
2323 }
2326 /*----------------------------------------------------------------------
2327 Checks to make sure the fcc is available and can be opened
2329 Args: fcc -- the name of the fcc to create. It can't be NULL.
2330 fcc_cntxt -- Returns the context the fcc is in.
2331 force -- supress user option prompt
2333 Returns allocated storage object on success, NULL on failure
2334 ----*/
2335 STORE_S *
2337 {
2342 /*
2343 * check for fcc's existance...
2344 */
2350 /*
2351 * Don't want to preclude a user from Fcc'ing a .name'd folder
2352 */
2356 }
2358 /*
2359 * We only want to set the "context" if fcc is an ambiguous
2360 * name. Otherwise, our "relativeness" rules for contexts
2361 * (implemented in context.c) might cause the name to be
2362 * interpreted in the wrong context...
2363 */
2370 || (pith_opt_save_create_prompt
2376 ok++;
2379 }
2380 else
2382 }
2383 else
2390 }
2393 ok++;
2394 }
2397 || (pith_opt_save_create_prompt
2406 }
2407 else
2409 }
2410 }
2415 }
2435 s1,
2439 s2);
2442 }
2443 else
2445 }
2446 else
2450 }
2453 }
2456 /*----------------------------------------------------------------------
2457 mail_append() the fcc accumulated in temp_storage to proper destination
2459 Args: fcc -- name of folder
2460 fcc_cntxt -- context for folder
2461 temp_storage -- String of file where Fcc has been accumulated
2463 This copies the string of file to the actual folder, which might be IMAP
2464 or a disk folder. The temp_storage is freed after it is written.
2465 An error message is produced if this fails.
2466 ----*/
2467 int
2470 {
2471 STRING msg;
2487 }
2488 else
2493 /*
2494 * Before changing this note that these lines depend on the
2495 * definition of FCC_SOURCE.
2496 */
2512 }
2520 }
2523 /*
2524 * first_text_8bit - return TRUE if somewhere in the body 8BIT data's
2525 * contained.
2526 */
2527 BODY *
2529 {
2535 }
2538 /*
2539 * Build and return the "From:" address for outbound messages from
2540 * global data...
2541 */
2542 ADDRESS *
2544 {
2551 }
2558 }
2561 /*
2562 * set_mime_type_by_grope - sniff the given storage object to determine its
2563 * type, subtype, encoding, and charset
2564 *
2565 * "Type" and "encoding" must be set before calling this routine.
2566 * If "type" is set to something other than TYPEOTHER on entry,
2567 * then that is the "type" we wish to use. Same for "encoding"
2568 * using ENCOTHER instead of TYPEOTHER. Otherwise, we
2569 * figure them out here. If "type" is already set, we also
2570 * leave subtype alone. If not, we figure out subtype here.
2571 * There is a chance that we will upgrade encoding to a "higher"
2572 * level. For example, if it comes in as 7BIT we may change
2573 * that to 8BIT if we find a From_ we want to escape.
2574 * We may also set the charset attribute if the type is TEXT.
2575 *
2576 * NOTE: this is rather inefficient if the store object is a CharStar
2577 * but the win is all types are handled the same
2578 */
2579 void
2581 {
2582 #define RBUFSZ (8193)
2592 #ifdef ENCODE_FROMS
2595 #endif
2603 ;
2612 }
2618 }
2623 }
2628 }
2632 }
2636 }
2641 }
2646 }
2648 /*
2649 * if type was set above, but no encoding specified, go
2650 * ahead and make it BASE64...
2651 */
2654 }
2655 }
2657 /* PROBLEM !!! */
2663 }
2664 }
2670 #endif
2675 /* Some people don't like quoted-printable caused by leading Froms */
2676 #ifdef ENCODE_FROMS
2678 #endif
2683 #if defined(DOS) || defined(OS2)
2684 /* LF with no CR!! */
2687 #endif
2688 }
2690 eight_bit_chars++;
2691 }
2693 /* NULL found. Unless we're told otherwise, must be binary */
2697 }
2699 /*
2700 * The "TYPETEXT" here handles the case that the NULL
2701 * comes from imported text generated by some external
2702 * editor that permits or inserts NULLS. Otherwise,
2703 * assume it's a binary segment...
2704 */
2707 /*
2708 * Since we've already set encoding, count this as a
2709 * hi bit char and continue. The reason is that if this
2710 * is text, there may be a high percentage of encoded
2711 * characters, so base64 may get set below...
2712 */
2714 eight_bit_chars++;
2715 else
2717 }
2722 #endif
2724 /* read another buffer in */
2730 ;
2734 }
2735 else
2736 p++;
2738 /*
2739 * If there's no beginning-of-line pointer, then we must
2740 * have seen an end-of-line. Set bol to the start of the
2741 * new line...
2742 */
2747 /* either a lone \r or lone \n indicate binary file */
2753 }
2757 }
2758 }
2759 #endif
2760 }
2761 }
2763 /* stash away for later */
2767 /*
2768 * Since the type or encoding aren't set yet, fall thru a
2769 * series of tests to make sure an adequate type and
2770 * encoding are set...
2771 */
2775 /*
2776 * Since the types not set, then we didn't find a NULL.
2777 * If there's no NULL, then this is likely text. However,
2778 * since we can't be *completely* sure, we set it to
2779 * the generic type.
2780 */
2783 }
2786 /*
2787 * As with NULL handling, if we're told it's text,
2788 * qp-encode it, else it gets base 64...
2789 */
2791 }
2799 }
2801 /*
2802 * The 30% threshold is based on qp encoded readability
2803 * on non-MIME UA's.
2804 */
2810 }
2815 }
2817 /*
2818 * Apply maximal encoding regardless of previous
2819 * setting. This segment's either not text, or is
2820 * unlikely to be readable with > 30% of the
2821 * text encoded anyway, so we might as well save space...
2822 */
2824 }
2825 }
2827 #ifdef ENCODE_FROMS
2828 /* If there were From_'s at the beginning of a line or standalone dots */
2831 #endif
2833 /* Set the subtype */
2844 }
2847 /*
2848 * Call this to set the charset of an attachment we have
2849 * created. If the attachment contains any non-ascii characters
2850 * then we'll set the charset to the passed in charset, otherwise
2851 * we'll make it us-ascii.
2852 */
2853 void
2855 {
2870 can_be_ascii--;
2877 /*
2878 * Else we don't know. There are non ascii characters but we either
2879 * don't have a charset to set it to or that charset is just us_ascii,
2880 * which is impossible. So we label it unknown. An alternative would
2881 * have been to strip the high bits instead and label it ascii.
2882 */
2884 }
2888 }
2891 /*
2892 * since encoding happens on the way out the door, this is basically
2893 * just needed to handle TYPEMULTIPART
2894 */
2895 void
2897 {
2912 }
2923 /*
2924 * If the part is text we edited, then it is UTF-8.
2925 * The user may be asking us to send it as something else
2926 * or we may want to downconvert to a more-specific characterset.
2927 * Mark it for conversion here so the right MIME header's written.
2928 * Do conversion pine_rfc822_output_body.
2929 * Attachments are left as is.
2930 */
2941 /*
2942 * Fix iso-2022-jp encoding to ENC7BIT since it's escape based
2943 * and doesn't use anything but ASCII characters.
2944 * Why is it not ENC7BIT already? Because when we set the encoding
2945 * in set_mime_type_by_grope we were groping through UTF-8 text
2946 * not 2022 text. Not only that, but we didn't know at that point
2947 * that it wouldn't stay UTF-8 when we sent it, which would require
2948 * encoding.
2949 */
2954 }
2958 }
2963 /* Encapsulated messages are always treated as text objects at this point.
2964 This means that you must replace body->contents.msg with
2965 body->contents.text, which probably involves copying
2966 body->contents.msg.text to body->contents.text */
2968 /*
2969 * but we'll delay encoding it until the message is on the way
2970 * into the mail slot...
2971 */
2973 }
2974 }
2977 /*
2978 * pine_header_line - simple wrapper around c-client call to contain
2979 * repeated code, and to write fcc if required.
2980 */
2981 int
2984 {
2999 else
3018 /*
3019 * We were folding everything except message-id, but that wasn't
3020 * sufficient. Since 822 only allows folding where linear-white-space
3021 * is allowed we'd need a smarter folder than "fold" to do it. So,
3022 * instead of inventing that smarter folder (which would have to
3023 * know 822 syntax)
3024 *
3025 * We could just alloc space and copy the actual_field followed by
3026 * the value into it, but since that's what fold does anyway we'll
3027 * waste some cpu time and use fold with a big fold parameter.
3028 *
3029 * We upped the references folding from 75 to 256 because we were
3030 * encountering longer-than-75 message ids, and to break one line
3031 * in references is to break them all.
3032 *
3033 * Also, some users are adding long text without spaces to the subject
3034 * line (e.g. URLs) so we up that number too. For the moment this is
3035 * going to 512 (a url that is about 6 lines long.)
3036 */
3041 }
3044 else
3051 }
3053 RFC822BUFFER rbuf;
3056 /*
3057 * rfc1522_encode already inserted continuation lines and did
3058 * the necessary folding so we don't have to do it. Let
3059 * rfc822_header_line add the trailing crlf and the resent- if
3060 * necessary. The 20 could actually be a 12.
3061 */
3073 }
3081 }
3088 }
3089 else
3093 }
3096 /*
3097 * Do appropriate encoding of text header lines.
3098 * For some field types (those that consist of 822 *text) we just encode
3099 * the whole thing. For structured fields we encode only within comments
3100 * if possible.
3101 *
3102 * Args d -- Destination buffer if needed. (tmp_20k_buf)
3103 * s -- Source string.
3104 * charset -- Charset to encode with.
3105 * encode_all -- If set, encode the whole string. If not, try to encode
3106 * only within comments if possible.
3107 *
3108 * Returns S is returned if no encoding is done. D is returned if encoding
3109 * was needed.
3110 */
3113 {
3124 /*
3125 * We don't have to worry about keeping track of quoted-strings because
3126 * none of these fields which aren't addresses contain quoted-strings.
3127 * We do keep track of escaped parens inside of comments and comment
3128 * nesting.
3129 */
3141 /* encode the comment, excluding the outer parens */
3148 charset);
3159 }
3164 }
3173 }
3174 }
3183 }
3184 }
3187 /* Unterminated comment (wasn't really a comment) */
3192 }
3193 }
3195 /*
3196 * We have to check if there is anything that needs to be encoded that
3197 * wasn't in a comment. If there is, we'd better just start over and
3198 * encode the whole thing. So, if no encoding has been done within
3199 * comments, or if encoding is needed both within and outside of
3200 * comments, then we encode the whole thing. Otherwise, go with
3201 * the version that has only comments encoded.
3202 */
3210 }
3211 }
3214 /*
3215 * pine_address_line - write a header field containing addresses,
3216 * one by one (so there's no buffer limit), and
3217 * wrapping where necessary.
3218 * Note: we use c-client functions to properly build the text string,
3219 * but have to screw around with pointers to fool c-client functions
3220 * into not blatting all the text into a single buffer. Yeah, I know.
3221 */
3222 int
3225 {
3233 RFC822BUFFER rbuf;
3236 #define no_comma (&comma[1])
3242 in_group++;
3243 was_start_of_group++;
3244 /* encode mailbox of group */
3255 }
3257 failed++;
3259 }
3260 }
3261 }
3262 else
3266 /* make sure personal name is encoded */
3276 }
3278 failed++;
3280 }
3281 }
3286 /* use automatic buffer unless it isn't big enough */
3290 }
3294 }
3317 }
3322 }
3324 /*
3325 * If there is no sending_stream and we are writing the Lcc header,
3326 * then we are piping it to sendmail -t which expects it to be a bcc,
3327 * not lcc.
3328 *
3329 * When we write it to the fcc or postponed (the lmc.so),
3330 * we want it to be lcc, not bcc, so we put it back.
3331 */
3345 }
3353 /* account for c-client's representation of group names */
3358 /*
3359 * Rfc822_write_address no longer writes out the end of group
3360 * unless the whole group address is passed to it, so we do
3361 * it ourselves.
3362 */
3364 }
3367 }
3368 /* start of new group, print phrase below */
3370 in_group++;
3371 was_start_of_group++;
3372 }
3374 /* no comma before first address in group syntax */
3378 }
3380 /* write delimiter */
3395 }
3397 failed++;
3399 }
3407 }
3410 /* make sure we don't write out group end with rfc822_write_address */
3419 }
3428 /*
3429 * BUG
3430 * With group syntax addresses we no longer have two identical
3431 * streams of output. Instead, for the fcc/postpone copy we include
3432 * all of the addresses inside the :; of the group, and for the
3433 * mail we're sending we don't include them. That means we aren't
3434 * correctly keeping track of the column to wrap in, below. That is,
3435 * we are keeping track of the fcc copy but we aren't keeping track
3436 * of the regular copy. It could result in too long or too short
3437 * lines. Should almost never come up since group addresses are almost
3438 * never followed by other addresses in the same header, and even
3439 * when they are, you have to go out of your way to get the headers
3440 * messed up.
3441 */
3448 }
3449 else
3457 }
3459 bail_out:
3469 }
3472 /*
3473 * mutated pine version of c-client's rfc822_header() function.
3474 * changed to call pine-wrapped header and address functions
3475 * so we don't have to limit the header size to a fixed buffer.
3476 * This function also calls pine's body_header write function
3477 * because encoding is delayed until output_body() is called.
3478 */
3479 long
3481 {
3494 }
3499 /*
3500 * Warning: This is confusing. The 2nd to last argument used to
3501 * be just pf->writehdr. We want Bcc lines to be written out
3502 * if we are handing off to a sendmail temp file but not if we
3503 * are talking smtp, so bcc's writehdr is set to 0 and
3504 * pine_address_line was sending if writehdr OR !sending_stream.
3505 * That works as long as we want to write everything when
3506 * !sending_stream (an mta handoff to sendmail). But then we
3507 * added the undisclosed recipients line which should only get
3508 * written if writehdr is set, and not when we pass to a
3509 * sendmail temp file. So pine_address_line has been changed
3510 * so it bases its decision solely on the writehdr passed to it,
3511 * and the logic that worries about Bcc and sending_stream
3512 * was moved up to the caller (here) to decide when to set it.
3513 *
3514 * So we have:
3515 * undisclosed recipients:; This will just be written
3516 * if writehdr was set and not
3517 * otherwise, nothing magical.
3518 *** We may want to change this, because sendmail -t doesn't handle
3519 *** the empty group syntax well unless it has been configured to
3520 *** do so. It isn't configured by default, or in any of the
3521 *** sendmail v8 configs. So we may want to not write this line
3522 *** if we're doing an mta_handoff (!sending_stream).
3523 *
3524 * !sending_stream (which means a handoff to a sendmail -t)
3525 * bcc or lcc both set the arg so they'll get written
3526 * (There is also Lcc hocus pocus in pine_address_line
3527 * which converts the Lcc: to Bcc: for sendmail
3528 * processing.)
3529 * sending_stream (which means an smtp handoff)
3530 * bcc and lcc will never have writehdr set, so
3531 * will never be written (They both do have rcptto set,
3532 * so they both do cause RCPT TO commands.)
3533 *
3534 * The localcopy is independent of sending_stream and is just
3535 * written if it is set for all of these.
3536 */
3539 header,
3541 f,
3542 s,
3545 ? !sending_stream
3566 }
3567 }
3570 #if (defined(DOS) || defined(OS2)) && !defined(NOAUTH)
3571 /*
3572 * Add comforting "X-" header line indicating what sort of
3573 * authenticity the receiver can expect...
3574 */
3576 NETMBX netmbox;
3587 }
3602 }
3607 }
3611 }
3612 #endif
3619 }
3624 }
3627 }
3630 /*
3631 * pine_rfc822_output - pine's version of c-client call. Necessary here
3632 * since we're not using its structures as intended!
3633 */
3634 long
3636 {
3644 /* build and output RFC822 header, output body */
3652 }
3655 /*
3656 * post_rfc822_output - cloak for pine's 822 output routine. Since
3657 * we can't pass opaque envelope thru c-client posting
3658 * logic, we need to wrap the real output inside
3659 * something that c-client knows how to call.
3660 */
3661 long
3665 soutr_t f,
3668 {
3670 }
3673 /*
3674 * posting_characterset- determine what transliteration is reasonable
3675 * for posting the given non-ascii messsage data.
3676 *
3677 * preferred_charset is the charset the original data was labeled in.
3678 * If we can keep that we do.
3679 *
3680 * Returns: always returns the preferred character set.
3681 */
3684 {
3700 /* convert text in header to UCS characters */
3707 /*
3708 * After the while loop is done the validbitmap has
3709 * a 1 bit for all the character sets that can
3710 * represent all of the characters of this header.
3711 */
3717 }
3724 }
3727 }
3736 }
3742 UCS ucs;
3743 CBUF_S cbuf;
3769 /*
3770 * Read a stream of UTF-8 characters from the_text
3771 * and convert them to UCS-4 characters for the translatable
3772 * test.
3773 */
3776 /* got a ucs character */
3781 }
3782 }
3789 }
3791 /* user chooses something other than UTF-8 */
3793 /*
3794 * If we're to post in other than UTF-8, and it can be
3795 * transliterated without losing fidelity, do it.
3796 * Else, use UTF-8.
3797 */
3799 /* if ascii works, always use that */
3803 /* does the user's posting character set work? */
3807 /* this is the charset the message we are replying to was in */
3813 /* else, use UTF-8 */
3815 }
3816 /* user chooses nothing, going with the default */
3822 /*
3823 * In this case the user didn't specify a posting character set
3824 * and we will choose the most-specific one from our list.
3825 */
3827 /* ascii is best */
3831 /* Can we keep the original from the message we're replying to? */
3837 /* choose the best of the rest */
3842 /*
3843 * If the text we're labeling contains something like
3844 * smart quotes but no CJK characters, then instead of
3845 * labeling it as ISO-2022-JP we want to use UTF-8.
3846 */
3857 }
3860 }
3861 /* user explicitly chooses UTF-8 */
3863 /* if ascii works, always use that */
3867 /* else, use UTF-8 */
3869 }
3870 }
3873 }
3895 "EUC-KR"
3896 };
3901 {
3906 /*
3907 * When user doesn't set a posting character set posting_charmap ends up
3908 * set to UTF-8. That also happens if user sets UTF-8 explicitly.
3909 * That's where the strange set of if-else's come from.
3910 */
3912 /* user chooses something other than UTF-8 */
3916 reset++;
3918 /* if posting_charmap is valid, include it in list */
3923 count++;
3927 reset++;
3928 }
3934 count++;
3938 reset++;
3939 }
3942 reset++;
3967 }
3968 }
3969 /* user chooses nothing, going with the default */
3975 /* does preferred_charset have to be added to the list? */
3981 }
3984 /* existing list is right size already */
3986 /* just check to see if last list item is the preferred_charset */
3988 /* no, fix it */
3989 reset++;
3992 }
3993 }
3995 reset++;
4007 }
4008 }
4010 /* if list is same size as downgrades, consider it good */
4012 reset++;
4025 }
4026 }
4027 }
4028 /* user explicitly chooses UTF-8 */
4030 /* include possibility of ascii even if they explicitly ask for UTF-8 */
4033 reset++;
4036 reset++;
4042 /* the list is just ascii and nothing else */
4049 }
4050 }
4059 }
4062 }
4065 /* total reset */
4066 void
4068 {
4076 }
4079 int
4081 {
4095 done++;
4098 }
4099 }
4102 }
4107 {
4115 /* careful, find_rightmost_bit modifies the bitmap */
4121 }
4124 /*
4125 * Set parameter to new value.
4126 */
4127 void
4129 {
4138 }
4151 }
4152 /* else pm is existing paramname parameter */
4153 }
4162 }
4163 }
4164 }
4167 /*----------------------------------------------------------------------
4168 Remove the leading digits from SMTP error messages
4169 -----*/
4172 {
4175 error++;
4180 }
4183 /*
4184 * Local globals pine's body output routine needs
4185 */
4190 /*
4191 * def to make our pipe write's more friendly
4192 */
4193 #ifdef PIPE_MAX
4194 #if PIPE_MAX > 20000
4195 #undef PIPE_MAX
4196 #endif
4197 #endif
4199 #ifndef PIPE_MAX
4200 #define PIPE_MAX 1024
4201 #endif
4204 /*
4205 * l_flust_net - empties gf_io terminal function's buffer
4206 */
4207 int
4209 {
4215 /*
4216 * The start of each write is expected to be the start of a
4217 * "record" (i.e., a CRLF terminated line). Make sure that is true
4218 * else we might screw up SMTP dot quoting...
4219 */
4223 ;
4230 ;
4233 /* snippet remains */
4236 }
4237 }
4246 if(lp && lp >= tmp_20k_buf && lp < tmp_20k_buf + SIZEOF_20KBUF && (*lp = c)) /* Shift text left? */
4249 }
4252 }
4255 /*
4256 * l_putc - gf_io terminal function that calls smtp's soutr_t function.
4257 *
4258 */
4259 int
4261 {
4266 }
4270 /*
4271 * pine_rfc822_output_body - pine's version of c-client call. Again,
4272 * necessary since c-client doesn't know about how
4273 * we're treating attachments
4274 */
4275 long
4277 {
4284 LOC_2022_JP ljp;
4285 gf_io_t gc;
4294 /* find cookie */
4299 /*
4300 * Output a bit of text before the first multipart delimiter
4301 * to warn unsuspecting users of non-mime-aware ua's that
4302 * they should expect weirdness. We do not add this when signing a
4303 * message, though...
4304 */
4305 #ifdef SMIME
4307 #endif
4308 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"))
4312 /* build cookie */
4315 /* append cookie,mini-hdr,contents */
4322 /* output trailing cookie */
4325 #ifdef SMIME
4329 #endif
4333 }
4336 }
4346 else
4349 /*
4350 * Don't add trailing line if it is ExternalText, which already guarantees
4351 * a trailing newline.
4352 */
4368 }
4375 }
4377 /* else, just send it? */
4379 }
4380 }
4381 }
4384 }
4386 /*
4387 * Convert text pieces to canonical form
4388 * BEFORE applying any encoding (rfc1341: appendix G)...
4389 * NOTE: almost all filters expect CRLF newlines
4390 */
4395 }
4408 }
4409 }
4415 }
4434 /*
4435 * BUG: If this name is not ascii it's going to cause trouble.
4436 */
4452 }
4457 }
4462 else
4464 }
4468 {
4476 }
4478 /*
4479 * pine_write_body_header - another c-client clone. This time
4480 * so the final encoding labels get set
4481 * correctly since it hasn't happened yet,
4482 * and to be paranoid about line lengths.
4483 *
4484 * Returns: TRUE/nonzero on success, zero on error
4485 */
4486 int
4488 {
4490 RFC822BUFFER rbuf;
4509 }
4519 ? ENCBASE64
4521 ? ENCQUOTEDPRINTABLE
4526 /*
4527 * If requested, strip Content-ID headers that don't look like they
4528 * are needed. Microsoft's Outlook XP has a bug that causes it to
4529 * not show that there is an attachment when there is a Content-ID
4530 * header present on that attachment.
4531 *
4532 * If user has quell-content-id turned on, don't output content-id
4533 * unless it is of type message/external-body.
4534 * Since this code doesn't look inside messages being forwarded
4535 * type message content-ids will remain as is and type multipart
4536 * alternative will remain as is. We don't create those on our
4537 * own. If we did, we'd have to worry about getting this right.
4538 */
4574 }
4579 }
4591 }
4593 /* copy out of so, a line at a time (or less than a K)
4594 * and send it down the pike
4595 */
4606 }
4608 /* Finally, write blank line */
4613 }
4616 }
4619 /*
4620 * pine_write_header - convert, encode (if needed) and
4621 * write "header-name: field-body"
4622 */
4623 int
4625 {
4641 }
4644 /*
4645 * pine_write_param - convert, encode and write MIME header-field parameters
4646 */
4647 int
4649 {
4665 }
4668 }
4672 int
4674 {
4680 /*
4681 * "comment out" the real values since our comment isn't
4682 * likely the same type, disposition nor encoding...
4683 */
4686 }
4689 }
4692 }
4695 int
4697 {
4704 }
4707 }
4711 int
4713 {
4718 }
4721 /*
4722 * pine_free_body - c-client call wrapper so the body data pointer we
4723 * we're using in a way c-client doesn't know about
4724 * gets free'd appropriately.
4725 */
4726 void
4728 {
4729 /*
4730 * Preempt c-client's contents.text.data clean up since we've
4731 * usurped it's meaning for our own purposes...
4732 */
4735 /* Then let c-client handle the rest... */
4737 }
4740 /*
4741 * pine_free_body_data - free pine's interpretations of the body part's
4742 * data pointer.
4743 */
4744 void
4746 {
4753 }
4756 }
4757 }
4760 long
4762 {
4772 }
4775 }
4778 int
4780 {
4784 }
4787 /*
4788 * pine_smtp_verbose_out - write
4789 */
4790 void
4792 {
4793 #ifdef _WINDOWS
4794 LPTSTR slpt;
4795 #endif
4802 else
4805 #ifdef _WINDOWS
4806 /*
4807 * The stream is opened in Unicode mode, so we need to fix the
4808 * argument to fputs.
4809 */
4814 }
4818 #else
4822 #endif
4823 }
4825 }
4828 /*
4829 * pine_header_forbidden - is this name a "forbidden" header?
4830 *
4831 * name - the header name to check
4832 * We don't allow user to change these.
4833 */
4834 int
4836 {
4864 NULL
4865 };
4872 }
4875 /*
4876 * hdr_is_in_list - is there a custom value for this header?
4877 *
4878 * hdr - the header name to check
4879 * custom - the list to check in
4880 * Returns 1 if there is a custom value, 0 otherwise.
4881 */
4882 int
4884 {
4892 }
4895 /*
4896 * count_custom_hdrs_pf - returns number of custom headers in arg
4897 * custom -- the list to be counted
4898 * only_nonstandard -- only count headers which aren't standard pine headers
4899 */
4900 int
4902 {
4907 ret++;
4910 }
4913 /*
4914 * count_custom_hdrs_list - returns number of custom headers in arg
4915 */
4916 int
4918 {
4929 /* remove leading whitespace */
4932 /* look for colon or space or end */
4940 ret++;
4943 }
4944 }
4945 }
4948 }
4951 /*
4952 * set_default_hdrval - put the user's default value for this header
4953 * into pf->textbuf.
4954 * setthis - the pinefield to be set
4955 * custom - where to look for the default
4956 */
4957 CustomType
4959 {
4966 }
4976 /* turn on editing */
4982 }
4988 }
4991 /*
4992 * pine_header_standard - is this name a "standard" header?
4993 *
4994 * name - the header name to check
4995 */
4996 FieldType
4998 {
5001 /* check to see if this is a standard header */
5007 }
5010 /*
5011 * customized_hdr_setup - setup the PINEFIELDS for all the customized headers
5012 * Allocates space for each name and addr ptr.
5013 * Allocates space for default in textbuf, even if empty.
5014 *
5015 * head - the first PINEFIELD to fill in
5016 * list - the list to parse
5017 */
5018 void
5020 {
5031 /* anything after leading whitespace? */
5035 /* look for colon or space or end */
5040 /* if there is a space in the field-name, skip it */
5044 name);
5046 }
5051 /* Don't allow any of the forbidden headers. */
5055 name);
5059 }
5070 #ifdef OLDWAY
5071 /*
5072 * Some mailers apparently break if we change
5073 * user@domain into Fred <user@domain> for
5074 * return-receipt-to,
5075 * so we'll just call this a FreeText field, too.
5076 */
5077 /*
5078 * For now, all custom headers are FreeText except for
5079 * this one that we happen to know about. We might
5080 * have to add some syntax to the config option so that
5081 * people can tell us their custom header takes addresses.
5082 */
5087 }
5092 /* remove space between name and colon */
5095 /* give them an alloc'd default, even if empty */
5101 pf++;
5102 }
5103 else
5105 }
5106 }
5107 }
5109 /* fix last next pointer */
5112 }
5115 /*
5116 * add_defaults_from_list - the PINEFIELDS list given by "head" is already
5117 * setup except that it doesn't have default values.
5118 * Add those defaults if they exist in "list".
5119 *
5120 * head - the first PINEFIELD to add a default to
5121 * list - the list to get the defaults from
5122 */
5123 void
5125 {
5137 /* anything after leading whitespace? */
5141 /* look for colon or space or end */
5146 /* if there is a space in the field-name, skip it */
5156 }
5160 /*
5161 * Found the right header. See if it has a default
5162 * value set.
5163 */
5165 /* remove space between name and colon */
5177 }
5178 }
5181 }
5182 }
5183 }
5184 }
5187 /*
5188 * parse_custom_hdrs - allocate PINEFIELDS for custom headers
5189 * fill in the defaults
5190 * Args - list -- The list to parse.
5191 * cstmtype -- Fill the in cstmtype field with this value
5192 */
5193 PINEFIELD *
5195 {
5199 /*
5200 * add one for possible use by fcc
5201 * What is this "possible use"? I don't see it. I don't
5202 * think it exists anymore. I think +1 would be ok. hubert 2000-08-02
5203 */
5208 /* set up the custom header pfields */
5212 }
5215 /*
5216 * Combine the two lists of headers into one list which is allocated here
5217 * and freed by the caller. Eliminate duplicates with values from the role
5218 * taking precedence over values from the default.
5219 */
5220 PINEFIELD *
5222 {
5241 pf++;
5242 }
5244 /* if these aren't already there, add them */
5246 /* check for already there */
5249 i++)
5250 ;
5260 pf++;
5261 }
5262 }
5264 /* fix last next pointer */
5269 }
5272 /*
5273 * free_customs - free misc. resources associated with custom header fields
5274 *
5275 * pf - pointer to first custom field
5276 */
5277 void
5279 {
5289 /* only true for FreeText */
5293 /* only true for Address */
5296 }
5299 }
5302 /*
5303 * encode_whole_header
5304 *
5305 * Returns 1 if whole value should be encoded
5306 * 0 to encode only within comments
5307 */
5308 int
5310 {
5317 retval++;
5322 retval++;
5324 }
5325 }
5326 }
5329 }
5332 /*----------------------------------------------------------------------
5333 Post news via NNTP or inews
5335 Args: env -- envelope of message to post
5336 body -- body of message to post
5338 Returns: -1 if failed or cancelled, 1 if succeeded
5340 WARNING: This call function has the side effect of writing the message
5341 to the lmc.so object.
5342 ----*/
5343 int
5346 {
5363 /*---------- NNTP server defined ----------*/
5369 /*
5370 * Install our rfc822 output routine
5371 */
5383 #ifdef DEBUG
5385 #else
5387 #endif
5393 /*
5394 * Fake that we've got clearance from the transport agent
5395 * for 8bit transport for the benefit of our output routines...
5396 */
5402 ;
5406 }
5412 }
5413 }
5415 /*
5416 * Set global header pointer so we can get at it later...
5417 */
5428 }
5437 }
5440 /*---- Open of NNTP connection failed ------ */
5446 }
5447 server_no++;
5448 }
5452 /*----- Post via local mechanism -------*/
5453 #ifdef _WINDOWS
5458 pipecb_f);
5459 #endif
5460 }
5471 }
5475 }
5478 /* ----------------------------------------------------------------------
5479 Figure out command to start local SMTP agent
5481 Args: errbuf -- buffer for reporting errors (assumed non-NULL)
5483 Returns an alloc'd copy of the local SMTP agent invocation or NULL
5485 ----*/
5488 {
5489 #ifdef _WINDOWS
5496 # if defined(SENDMAIL) && defined(SENDMAILFLAGS)
5497 #define SENDTMPLEN 256
5499 /* SENDTMPLEN == sizeof(tmp) */
5503 # else
5506 # endif
5507 #endif
5510 }
5514 #ifndef _WINDOWS
5515 /*----------------------------------------------------------------------
5516 Hand off given message to local posting agent
5518 Args: envelope -- The envelope for the BCC and debugging
5519 header -- The text of the message header
5520 errbuf -- buffer for reporting errors (assumed non-NULL)
5521 len -- Length of errbuf
5523 ----*/
5524 int
5529 {
5530 #ifdef DF_SENDMAIL_PATH
5532 #endif
5535 /*
5536 * A bit of complicated policy implemented here.
5537 * There are two posting variables sendmail-path and smtp-server.
5538 * Precedence is in that order.
5539 * They can be set one of 4 ways: fixed, command-line, user, or globally.
5540 * Precedence is in that order.
5541 * Said differently, the order goes something like what's below.
5542 *
5543 * NOTE: the fixed/command-line/user precendence handling is also
5544 * indicated by what's pointed to by ps_global->VAR_*, but since
5545 * that also includes the global defaults, it's not sufficient.
5546 */
5551 }
5557 }
5567 else
5569 }
5577 }
5578 #ifdef DF_SENDMAIL_PATH
5579 /*
5580 * This defines the default method of posting. So,
5581 * unless we're told otherwise use it...
5582 */
5587 }
5588 #endif
5589 }
5590 }
5591 }
5599 }
5600 else
5602 }
5606 /*----------------------------------------------------------------------
5607 Hand off given message to local posting agent
5609 Args: envelope -- The envelope for the BCC and debugging
5610 header -- The text of the message header
5611 errbuf -- buffer for reporting errors (assumed non-NULL)
5612 errbuflen -- Length of errbuf
5614 Fork off mailer process and pipe the message into it
5615 Called to post news via Inews when NNTP is unavailable
5617 ----*/
5623 {
5625 #ifdef SENDNEWS
5637 }
5647 }
5651 /*----------------------------------------------------------------------
5652 Hand off message to local MTA; it parses recipients from 822 header
5654 Args: header -- struct containing header data
5655 body -- struct containing message body data
5656 cmd -- command to use for handoff (%s says where file should go)
5657 errs -- pointer to buf to hold errors
5659 ----*/
5664 {
5677 }
5683 }
5684 }
5685 else
5691 }
5694 }
5697 /*
5698 * pine_pipe_soutr - Replacement for tcp_soutr that writes one of our
5699 * pipes rather than a tcp stream
5700 */
5701 long
5703 {
5715 }
5716 }
5720 }
5721 }
5729 }
5730 }
5731 else
5733 }
5736 }
5737 #endif
5740 /**************** "PIPE" READING POSTING I/O ROUTINES ****************/
5743 /*
5744 * helpful def's
5745 */
5746 #define S(X) ((PIPE_S *)(X))
5747 #define GETBUFLEN (4 * MAILTMPLEN)
5752 {
5758 /* MAILTMPLEN = sizeof(tmp) */
5763 }
5764 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
5769 }
5770 else
5774 }
5779 {
5781 }
5784 /*
5785 * piped_soutr - Replacement for tcp_soutr that writes one of our
5786 * pipes rather than a tcp stream
5787 */
5788 long
5790 {
5792 }
5795 /*
5796 * piped_sout - Replacement for tcp_soutr that writes one of our
5797 * pipes rather than a tcp stream
5798 */
5799 long
5801 {
5813 }
5814 }
5818 }
5819 }
5822 }
5825 /*
5826 * piped_getline - Replacement for tcp_getline that reads one
5827 * of our pipes rather than a tcp pipe
5828 *
5829 * C-client expects that the \r\n will be stripped off.
5830 */
5833 {
5843 /* alloc space to collect input (freed in close_system_pipe) */
5847 }
5854 }
5859 }
5862 }
5873 }
5875 n++;
5877 }
5878 /* copy partial string from buffer */
5880 /* get more data */
5888 }
5896 }
5897 }
5900 }
5903 ptr++;
5904 cnt--;
5906 }
5914 }
5917 }
5920 /*
5921 * piped_close - Replacement for tcp_close that closes pipes to our
5922 * child rather than a tcp connection
5923 */
5924 void
5926 {
5927 /*
5928 * Uninstall our hooks into smtp_send since it's being used by
5929 * the nntp driver as well...
5930 */
5932 }
5935 /*
5936 * piped_abort - close down the pipe we were using to post
5937 */
5938 void
5940 {
5944 }
5949 }
5950 }
5955 {
5957 }
5960 unsigned long
5962 {
5964 }