| blob | 4620d1aa271c9fb2947107fd78fb5c2997e26c3a |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2013-2014 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 }
897 /* let outgoing routines decide on charset */
906 }
907 else
909 }
910 }
917 }
921 /* We have what we want, blast this message... */
926 }
927 else
931 }
934 /*----------------------------------------------------------------------
935 Clear deleted messages from given stream and expunge if necessary
937 Args: stream --
938 problem --
940 ----*/
941 int
943 {
954 }
965 }
967 /* if it is current, we have to change folders */
969 do_the_broach++;
971 /*
972 * This is the stream to the empty postponed-msgs folder.
973 * We are going to delete the folder in a second. It is
974 * probably preferable to unselect the mailbox and leave
975 * this stream open for re-use instead of actually closing it,
976 * so we do that if possible.
977 */
979 /*
980 * This does the UNSELECT on the stream. A NULL
981 * return should mean that something went wrong and
982 * a mail_close already happened, so that should have
983 * cleaned things up in the callback.
984 */
987 /* now close it so it is put into the stream cache */
990 }
991 }
992 else
999 }
1003 /* TRANSLATORS: Arg is a mailbox name */
1008 }
1009 }
1012 }
1015 /*----------------------------------------------------------------------
1016 Parse the given header text for any given fields
1018 Args: text -- Text to parse for fcc and attachments refs
1019 fields -- array of field names to look for
1020 values -- array of pointer to save values to, returned NULL if
1021 fields isn't in text.
1023 This function simply looks for the given fields in the given header
1024 text string.
1025 NOTE: newlines are expected CRLF, and we'll ignore continuations
1026 ----*/
1027 void
1029 {
1036 /*---- Loop until the end of the header ----*/
1047 }
1052 }
1061 }
1062 else
1064 }
1067 }
1070 }
1073 }
1075 /* Skip to end of line, what ever it was */
1080 }
1081 }
1082 }
1085 /*----------------------------------------------------------------------
1086 build a fresh REPLY_S from the given string (see pine_send for format)
1088 Args: s -- "X-Reply-UID" header value
1090 Returns: filled in REPLY_S or NULL on parse error
1091 ----*/
1092 REPLY_S *
1094 {
1099 /* FORMAT: (n prefix)(n validity uidlist)mailbox */
1100 /* if 'n prefix' is empty, uid list represents forwarded msgs */
1104 }
1107 ;
1115 }
1116 }
1117 else
1119 }
1123 ;
1128 ;
1143 else
1145 }
1148 i++;
1151 }
1160 else
1166 }
1167 else
1169 }
1170 }
1171 }
1172 }
1173 }
1176 }
1179 /*
1180 * pine_new_env - allocate a new METAENV and fill it in.
1181 */
1182 METAENV *
1184 {
1192 /* how many fields are there? */
1194 ;
1199 cnt++;
1201 /* temporary PINEFIELD array */
1215 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
1216 # define NN 4
1217 #else
1218 # define NN 3
1219 #endif
1221 /* initialize pfield */
1227 /* slide string over so it is Sender instead of X-X-Sender */
1316 }
1357 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
1362 #endif
1372 }
1389 }
1390 }
1393 i--;
1395 /*
1396 * NOTE: "i" is assumed to now index first custom field in sending
1397 * order.
1398 */
1412 BuildTo bldto;
1418 /* change default text into an ADDRESS */
1419 /* strip quotes around whole default */
1427 }
1440 }
1441 }
1442 }
1446 }
1449 void
1451 {
1457 ;
1464 }
1467 }
1473 }
1476 /*----------------------------------------------------------------------
1477 Check for addresses the user is not permitted to send to, or probably
1478 doesn't want to send to
1480 Returns: 0 if OK
1481 1 if there are only empty groups
1482 -1 if the message shouldn't be sent
1484 Queues a message indicating what happened
1485 ---*/
1486 int
1488 {
1493 /*---- Is he/she trying to send mail to the mailer-daemon ----*/
1501 /* TRANSLATORS: First arg is the address we can't
1502 send to, second arg is "not in addressbook". */
1509 }
1515 }
1519 }
1522 }
1523 }
1526 }
1529 /*
1530 * If this isn't general enough we can modify it. The value passed in
1531 * is expected to be one of the desc settings from the priorities array,
1532 * like "High". The header value is X-Priority: 2 (High)
1533 * or something similar. If value doesn't match any of the values then
1534 * the actual value is used instead.
1535 */
1536 PINEFIELD *
1538 {
1561 }
1562 else
1564 }
1565 }
1567 }
1570 /*----------------------------------------------------------------------
1571 Set answered flags for messages specified by reply structure
1573 Args: reply --
1575 Returns: with appropriate flags set and index cache entries suitably tweeked
1576 ----*/
1577 void
1579 {
1584 /* nothing to flip in a pseudo reply */
1589 /*
1590 * If an established stream will do, use it, else
1591 * build one unless we have an array of msgno's...
1592 *
1593 * I was just mimicking what was already here. I don't really
1594 * understand why we use strcmp instead of same_stream_and_mailbox().
1595 * Or sp_stream_get(reply->mailbox, SP_MATCH).
1596 * Hubert 2003-07-09
1597 */
1603 }
1608 /*
1609 * This is here only for people who ran pine4.42 and are
1610 * processing postponed mail from 4.42 now. Pine4.42 saved the
1611 * original mailbox name in the canonical name's position in
1612 * the postponed-msgs folder so it won't match the canonical
1613 * name from the stream.
1614 */
1620 /* TRANSLATORS: program is busy updating the Answered flags so warns user */
1628 ourstream++;
1629 }
1635 }
1636 }
1643 }
1648 }
1651 /*
1652 * $Forwarded is a regular keyword so we only try to
1653 * set it if the stream allows keywords.
1654 * We could mess up if the stream has keywords but just
1655 * isn't allowing anymore and $Forwarded already exists,
1656 * but what are the odds?
1657 */
1660 FORWARDED_FLAG,
1662 }
1663 else
1670 }
1677 }
1678 }
1681 /*
1682 * phone_home_from - make phone home request's from address IMpersonal.
1683 * Doesn't include user's personal name.
1684 */
1685 ADDRESS *
1687 {
1691 /* garble up mailbox name */
1697 }
1700 /*
1701 * one-way-hash a username into an 8-digit decimal number
1702 *
1703 * Corey Satten, corey@cac.washington.edu, 7/15/98
1704 */
1705 unsigned int
1707 {
1713 else
1717 }
1720 }
1723 /*----------------------------------------------------------------------
1724 Call the mailer, SMTP, sendmail or whatever
1726 Args: header -- full header (envelope and local parts) of message to send
1727 body -- The full body of the message including text
1728 alt_smtp_servers --
1729 verbosefile -- non-null means caller wants verbose interaction and the resulting
1730 output file name to be returned
1732 Returns: -1 if failed, 1 if succeeded
1733 ----*/
1734 int
1738 {
1751 /* Check for any recipients */
1760 }
1762 #ifdef SMIME
1774 /* need to free new body from encrypt if sign fails? */
1782 }
1783 #endif
1785 /* set up counts and such to keep track sent percentage */
1793 #ifndef _WINDOWS
1795 /* try posting via local "<mta> <-t>" if specified */
1801 }
1803 #endif
1805 /*
1806 * If the user's asked for it, and we find that the first text
1807 * part (attachments all get b64'd) is non-7bit, ask for 8BITMIME.
1808 */
1812 #ifdef DEBUG
1813 #ifndef DEBUGJOURNAL
1815 #endif
1817 #endif
1827 /*
1828 * If it isn't Never, then we're always going to let them
1829 * know about failures. This means we don't allow for the
1830 * possibility of setting delay or success without failure.
1831 */
1836 }
1837 }
1840 /*
1841 * Set global header pointer so post_rfc822_output can get at it when
1842 * it's called back from c-client's sending routine...
1843 */
1846 /*
1847 * Fabricate a fake ENVELOPE to hand c-client's SMTP engine.
1848 * The purpose is to give smtp_mail the list for SMTP RCPT when
1849 * there are recipients in pine's METAENV that are outside c-client's
1850 * envelope.
1851 *
1852 * NOTE: If there aren't any, don't bother. Dealt with it below.
1853 */
1872 }
1873 }
1875 /*
1876 * Install our rfc822 output routine
1877 */
1881 /*
1882 * Allow for verbose posting
1883 */
1887 /*
1888 * We do this because we want mm_log to put the error message into
1889 * c_client_error instead of showing it itself.
1890 */
1893 /*
1894 * OK, who posts what? We tried an mta_handoff above, but there
1895 * was either none specified or we decided not to use it. So,
1896 * if there's an smtp-server defined anywhere,
1897 */
1899 /*---------- SMTP ----------*/
1904 }
1907 /*---------- SMTP ----------*/
1911 }
1912 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
1915 /*----- Send via LOCAL SMTP agent ------*/
1924 /* BUG: should provide separate stderr output! */
1925 }
1949 }
1950 }
1956 }
1957 }
1962 }
1965 }
1967 /*
1968 * Before we actually send data, see if we have to protect
1969 * the first text body part from getting encoded. We protect
1970 * it from getting encoded in "pine_rfc822_output_body" by
1971 * temporarily inventing a synonym for ENC8BIT...
1972 * This works like so:
1973 * Suppose bp->encoding is set to ENC8BIT.
1974 * We change that here to some unused value (added_encoding) and
1975 * set body_encodings[added_encoding] to "8BIT".
1976 * Then post_rfc822_output is called which calls
1977 * pine_rfc822_output_body. Inside that routine
1978 * pine_write_body_header writes out the encoding for the
1979 * part. Normally it would see encoding == ENC8BIT and it would
1980 * change that to QUOTED-PRINTABLE, but since encoding has been
1981 * set to added_encoding it uses body_encodings[added_encoding]
1982 * which is "8BIT" instead. Then the actual body is written by
1983 * pine_write_body_header which does not do the gf_8bit_qp
1984 * filtering because encoding != ENC8BIT (instead it's equal
1985 * to added_encoding).
1986 */
1992 ;
1996 }
2002 }
2003 }
2028 /*
2029 * Too complicated to figure out which header line
2030 * has the error in the fake_env case, so just
2031 * leave cursor at default.
2032 */
2041 }
2045 }
2046 }
2060 }
2064 }
2065 }
2069 }
2071 /* repair modified "body_encodings" array? */
2076 }
2082 }
2088 }
2101 }
2104 }
2106 /*
2107 * Restore original 822 emitter...
2108 */
2114 done:
2116 #ifdef SMIME
2117 /* Free replacement encrypted body */
2121 /* Just get rid of first part, it's actually origBody */
2127 }
2130 }
2131 #endif
2137 /*-------- Did message make it ? ----------*/
2139 /*---- Error sending mail -----*/
2146 }
2149 }
2153 }
2154 }
2157 /*
2158 * write_postponed - exported method to write the given message
2159 * to the postponed folder
2160 */
2161 int
2163 {
2175 }
2184 /* BUG: writem sufficient ? */
2191 }
2193 /*
2194 * Work around c-client reply-to bug. C-client will
2195 * return a reply_to in an envelope even if there is
2196 * no reply-to header field. We want to note here whether
2197 * the reply-to is real or not.
2198 */
2206 else
2208 }
2210 /*
2211 * Write the list of custom headers to the
2212 * X-Our-Headers header so that we can recover the
2213 * list in redraft.
2214 */
2224 ;
2231 /* note: "pf" overloaded */
2236 r--;
2238 }
2241 }
2242 }
2249 }
2255 }
2259 }
2262 int
2264 {
2269 }
2270 else
2274 }
2277 int
2279 {
2291 }
2294 }
2297 }
2300 }
2303 }
2306 /*----------------------------------------------------------------------
2307 Checks to make sure the fcc is available and can be opened
2309 Args: fcc -- the name of the fcc to create. It can't be NULL.
2310 fcc_cntxt -- Returns the context the fcc is in.
2311 force -- supress user option prompt
2313 Returns allocated storage object on success, NULL on failure
2314 ----*/
2315 STORE_S *
2317 {
2322 /*
2323 * check for fcc's existance...
2324 */
2330 /*
2331 * Don't want to preclude a user from Fcc'ing a .name'd folder
2332 */
2336 }
2338 /*
2339 * We only want to set the "context" if fcc is an ambiguous
2340 * name. Otherwise, our "relativeness" rules for contexts
2341 * (implemented in context.c) might cause the name to be
2342 * interpreted in the wrong context...
2343 */
2350 || (pith_opt_save_create_prompt
2356 ok++;
2359 }
2360 else
2362 }
2363 else
2370 }
2373 ok++;
2374 }
2377 || (pith_opt_save_create_prompt
2386 }
2387 else
2389 }
2390 }
2395 }
2415 s1,
2419 s2);
2422 }
2423 else
2425 }
2426 else
2430 }
2433 }
2436 /*----------------------------------------------------------------------
2437 mail_append() the fcc accumulated in temp_storage to proper destination
2439 Args: fcc -- name of folder
2440 fcc_cntxt -- context for folder
2441 temp_storage -- String of file where Fcc has been accumulated
2443 This copies the string of file to the actual folder, which might be IMAP
2444 or a disk folder. The temp_storage is freed after it is written.
2445 An error message is produced if this fails.
2446 ----*/
2447 int
2450 {
2451 STRING msg;
2467 }
2468 else
2473 /*
2474 * Before changing this note that these lines depend on the
2475 * definition of FCC_SOURCE.
2476 */
2492 }
2500 }
2503 /*
2504 * first_text_8bit - return TRUE if somewhere in the body 8BIT data's
2505 * contained.
2506 */
2507 BODY *
2509 {
2515 }
2518 /*
2519 * Build and return the "From:" address for outbound messages from
2520 * global data...
2521 */
2522 ADDRESS *
2524 {
2531 }
2538 }
2541 /*
2542 * set_mime_type_by_grope - sniff the given storage object to determine its
2543 * type, subtype, encoding, and charset
2544 *
2545 * "Type" and "encoding" must be set before calling this routine.
2546 * If "type" is set to something other than TYPEOTHER on entry,
2547 * then that is the "type" we wish to use. Same for "encoding"
2548 * using ENCOTHER instead of TYPEOTHER. Otherwise, we
2549 * figure them out here. If "type" is already set, we also
2550 * leave subtype alone. If not, we figure out subtype here.
2551 * There is a chance that we will upgrade encoding to a "higher"
2552 * level. For example, if it comes in as 7BIT we may change
2553 * that to 8BIT if we find a From_ we want to escape.
2554 * We may also set the charset attribute if the type is TEXT.
2555 *
2556 * NOTE: this is rather inefficient if the store object is a CharStar
2557 * but the win is all types are handled the same
2558 */
2559 void
2561 {
2562 #define RBUFSZ (8193)
2572 #ifdef ENCODE_FROMS
2575 #endif
2583 ;
2592 }
2598 }
2603 }
2608 }
2612 }
2616 }
2621 }
2626 }
2628 /*
2629 * if type was set above, but no encoding specified, go
2630 * ahead and make it BASE64...
2631 */
2634 }
2635 }
2637 /* PROBLEM !!! */
2643 }
2644 }
2650 #endif
2655 /* Some people don't like quoted-printable caused by leading Froms */
2656 #ifdef ENCODE_FROMS
2658 #endif
2663 #if defined(DOS) || defined(OS2)
2664 /* LF with no CR!! */
2667 #endif
2668 }
2670 eight_bit_chars++;
2671 }
2673 /* NULL found. Unless we're told otherwise, must be binary */
2677 }
2679 /*
2680 * The "TYPETEXT" here handles the case that the NULL
2681 * comes from imported text generated by some external
2682 * editor that permits or inserts NULLS. Otherwise,
2683 * assume it's a binary segment...
2684 */
2687 /*
2688 * Since we've already set encoding, count this as a
2689 * hi bit char and continue. The reason is that if this
2690 * is text, there may be a high percentage of encoded
2691 * characters, so base64 may get set below...
2692 */
2694 eight_bit_chars++;
2695 else
2697 }
2702 #endif
2704 /* read another buffer in */
2710 ;
2714 }
2715 else
2716 p++;
2718 /*
2719 * If there's no beginning-of-line pointer, then we must
2720 * have seen an end-of-line. Set bol to the start of the
2721 * new line...
2722 */
2727 /* either a lone \r or lone \n indicate binary file */
2733 }
2737 }
2738 }
2739 #endif
2740 }
2741 }
2743 /* stash away for later */
2747 /*
2748 * Since the type or encoding aren't set yet, fall thru a
2749 * series of tests to make sure an adequate type and
2750 * encoding are set...
2751 */
2755 /*
2756 * Since the types not set, then we didn't find a NULL.
2757 * If there's no NULL, then this is likely text. However,
2758 * since we can't be *completely* sure, we set it to
2759 * the generic type.
2760 */
2763 }
2766 /*
2767 * As with NULL handling, if we're told it's text,
2768 * qp-encode it, else it gets base 64...
2769 */
2771 }
2779 }
2781 /*
2782 * The 30% threshold is based on qp encoded readability
2783 * on non-MIME UA's.
2784 */
2790 }
2795 }
2797 /*
2798 * Apply maximal encoding regardless of previous
2799 * setting. This segment's either not text, or is
2800 * unlikely to be readable with > 30% of the
2801 * text encoded anyway, so we might as well save space...
2802 */
2804 }
2805 }
2807 #ifdef ENCODE_FROMS
2808 /* If there were From_'s at the beginning of a line or standalone dots */
2811 #endif
2813 /* Set the subtype */
2824 }
2827 /*
2828 * Call this to set the charset of an attachment we have
2829 * created. If the attachment contains any non-ascii characters
2830 * then we'll set the charset to the passed in charset, otherwise
2831 * we'll make it us-ascii.
2832 */
2833 void
2835 {
2850 can_be_ascii--;
2857 /*
2858 * Else we don't know. There are non ascii characters but we either
2859 * don't have a charset to set it to or that charset is just us_ascii,
2860 * which is impossible. So we label it unknown. An alternative would
2861 * have been to strip the high bits instead and label it ascii.
2862 */
2864 }
2868 }
2871 /*
2872 * since encoding happens on the way out the door, this is basically
2873 * just needed to handle TYPEMULTIPART
2874 */
2875 void
2877 {
2892 }
2903 /*
2904 * If the part is text we edited, then it is UTF-8.
2905 * The user may be asking us to send it as something else
2906 * or we may want to downconvert to a more-specific characterset.
2907 * Mark it for conversion here so the right MIME header's written.
2908 * Do conversion pine_rfc822_output_body.
2909 * Attachments are left as is.
2910 */
2921 /*
2922 * Fix iso-2022-jp encoding to ENC7BIT since it's escape based
2923 * and doesn't use anything but ASCII characters.
2924 * Why is it not ENC7BIT already? Because when we set the encoding
2925 * in set_mime_type_by_grope we were groping through UTF-8 text
2926 * not 2022 text. Not only that, but we didn't know at that point
2927 * that it wouldn't stay UTF-8 when we sent it, which would require
2928 * encoding.
2929 */
2934 }
2938 }
2943 /* Encapsulated messages are always treated as text objects at this point.
2944 This means that you must replace body->contents.msg with
2945 body->contents.text, which probably involves copying
2946 body->contents.msg.text to body->contents.text */
2948 /*
2949 * but we'll delay encoding it until the message is on the way
2950 * into the mail slot...
2951 */
2953 }
2954 }
2957 /*
2958 * pine_header_line - simple wrapper around c-client call to contain
2959 * repeated code, and to write fcc if required.
2960 */
2961 int
2964 {
2978 else
2997 /*
2998 * We were folding everything except message-id, but that wasn't
2999 * sufficient. Since 822 only allows folding where linear-white-space
3000 * is allowed we'd need a smarter folder than "fold" to do it. So,
3001 * instead of inventing that smarter folder (which would have to
3002 * know 822 syntax)
3003 *
3004 * We could just alloc space and copy the actual_field followed by
3005 * the value into it, but since that's what fold does anyway we'll
3006 * waste some cpu time and use fold with a big fold parameter.
3007 *
3008 * We upped the references folding from 75 to 256 because we were
3009 * encountering longer-than-75 message ids, and to break one line
3010 * in references is to break them all.
3011 */
3016 else
3023 }
3025 RFC822BUFFER rbuf;
3028 /*
3029 * rfc1522_encode already inserted continuation lines and did
3030 * the necessary folding so we don't have to do it. Let
3031 * rfc822_header_line add the trailing crlf and the resent- if
3032 * necessary. The 20 could actually be a 12.
3033 */
3045 }
3053 }
3060 }
3061 else
3065 }
3068 /*
3069 * Do appropriate encoding of text header lines.
3070 * For some field types (those that consist of 822 *text) we just encode
3071 * the whole thing. For structured fields we encode only within comments
3072 * if possible.
3073 *
3074 * Args d -- Destination buffer if needed. (tmp_20k_buf)
3075 * s -- Source string.
3076 * charset -- Charset to encode with.
3077 * encode_all -- If set, encode the whole string. If not, try to encode
3078 * only within comments if possible.
3079 *
3080 * Returns S is returned if no encoding is done. D is returned if encoding
3081 * was needed.
3082 */
3085 {
3096 /*
3097 * We don't have to worry about keeping track of quoted-strings because
3098 * none of these fields which aren't addresses contain quoted-strings.
3099 * We do keep track of escaped parens inside of comments and comment
3100 * nesting.
3101 */
3113 /* encode the comment, excluding the outer parens */
3120 charset);
3131 }
3136 }
3145 }
3146 }
3155 }
3156 }
3159 /* Unterminated comment (wasn't really a comment) */
3164 }
3165 }
3167 /*
3168 * We have to check if there is anything that needs to be encoded that
3169 * wasn't in a comment. If there is, we'd better just start over and
3170 * encode the whole thing. So, if no encoding has been done within
3171 * comments, or if encoding is needed both within and outside of
3172 * comments, then we encode the whole thing. Otherwise, go with
3173 * the version that has only comments encoded.
3174 */
3182 }
3183 }
3186 /*
3187 * pine_address_line - write a header field containing addresses,
3188 * one by one (so there's no buffer limit), and
3189 * wrapping where necessary.
3190 * Note: we use c-client functions to properly build the text string,
3191 * but have to screw around with pointers to fool c-client functions
3192 * into not blatting all the text into a single buffer. Yeah, I know.
3193 */
3194 int
3197 {
3205 RFC822BUFFER rbuf;
3208 #define no_comma (&comma[1])
3214 in_group++;
3215 was_start_of_group++;
3216 /* encode mailbox of group */
3227 }
3229 failed++;
3231 }
3232 }
3233 }
3234 else
3238 /* make sure personal name is encoded */
3248 }
3250 failed++;
3252 }
3253 }
3258 /* use automatic buffer unless it isn't big enough */
3262 }
3266 }
3289 }
3294 }
3296 /*
3297 * If there is no sending_stream and we are writing the Lcc header,
3298 * then we are piping it to sendmail -t which expects it to be a bcc,
3299 * not lcc.
3300 *
3301 * When we write it to the fcc or postponed (the lmc.so),
3302 * we want it to be lcc, not bcc, so we put it back.
3303 */
3317 }
3325 /* account for c-client's representation of group names */
3330 /*
3331 * Rfc822_write_address no longer writes out the end of group
3332 * unless the whole group address is passed to it, so we do
3333 * it ourselves.
3334 */
3336 }
3339 }
3340 /* start of new group, print phrase below */
3342 in_group++;
3343 was_start_of_group++;
3344 }
3346 /* no comma before first address in group syntax */
3350 }
3352 /* write delimiter */
3367 }
3369 failed++;
3371 }
3379 }
3382 /* make sure we don't write out group end with rfc822_write_address */
3391 }
3400 /*
3401 * BUG
3402 * With group syntax addresses we no longer have two identical
3403 * streams of output. Instead, for the fcc/postpone copy we include
3404 * all of the addresses inside the :; of the group, and for the
3405 * mail we're sending we don't include them. That means we aren't
3406 * correctly keeping track of the column to wrap in, below. That is,
3407 * we are keeping track of the fcc copy but we aren't keeping track
3408 * of the regular copy. It could result in too long or too short
3409 * lines. Should almost never come up since group addresses are almost
3410 * never followed by other addresses in the same header, and even
3411 * when they are, you have to go out of your way to get the headers
3412 * messed up.
3413 */
3420 }
3421 else
3429 }
3431 bail_out:
3441 }
3444 /*
3445 * mutated pine version of c-client's rfc822_header() function.
3446 * changed to call pine-wrapped header and address functions
3447 * so we don't have to limit the header size to a fixed buffer.
3448 * This function also calls pine's body_header write function
3449 * because encoding is delayed until output_body() is called.
3450 */
3451 long
3453 {
3466 }
3471 /*
3472 * Warning: This is confusing. The 2nd to last argument used to
3473 * be just pf->writehdr. We want Bcc lines to be written out
3474 * if we are handing off to a sendmail temp file but not if we
3475 * are talking smtp, so bcc's writehdr is set to 0 and
3476 * pine_address_line was sending if writehdr OR !sending_stream.
3477 * That works as long as we want to write everything when
3478 * !sending_stream (an mta handoff to sendmail). But then we
3479 * added the undisclosed recipients line which should only get
3480 * written if writehdr is set, and not when we pass to a
3481 * sendmail temp file. So pine_address_line has been changed
3482 * so it bases its decision solely on the writehdr passed to it,
3483 * and the logic that worries about Bcc and sending_stream
3484 * was moved up to the caller (here) to decide when to set it.
3485 *
3486 * So we have:
3487 * undisclosed recipients:; This will just be written
3488 * if writehdr was set and not
3489 * otherwise, nothing magical.
3490 *** We may want to change this, because sendmail -t doesn't handle
3491 *** the empty group syntax well unless it has been configured to
3492 *** do so. It isn't configured by default, or in any of the
3493 *** sendmail v8 configs. So we may want to not write this line
3494 *** if we're doing an mta_handoff (!sending_stream).
3495 *
3496 * !sending_stream (which means a handoff to a sendmail -t)
3497 * bcc or lcc both set the arg so they'll get written
3498 * (There is also Lcc hocus pocus in pine_address_line
3499 * which converts the Lcc: to Bcc: for sendmail
3500 * processing.)
3501 * sending_stream (which means an smtp handoff)
3502 * bcc and lcc will never have writehdr set, so
3503 * will never be written (They both do have rcptto set,
3504 * so they both do cause RCPT TO commands.)
3505 *
3506 * The localcopy is independent of sending_stream and is just
3507 * written if it is set for all of these.
3508 */
3511 header,
3513 f,
3514 s,
3517 ? !sending_stream
3538 }
3539 }
3542 #if (defined(DOS) || defined(OS2)) && !defined(NOAUTH)
3543 /*
3544 * Add comforting "X-" header line indicating what sort of
3545 * authenticity the receiver can expect...
3546 */
3548 NETMBX netmbox;
3559 }
3574 }
3579 }
3583 }
3584 #endif
3591 }
3596 }
3599 }
3602 /*
3603 * pine_rfc822_output - pine's version of c-client call. Necessary here
3604 * since we're not using its structures as intended!
3605 */
3606 long
3608 {
3616 /* build and output RFC822 header, output body */
3624 }
3627 /*
3628 * post_rfc822_output - cloak for pine's 822 output routine. Since
3629 * we can't pass opaque envelope thru c-client posting
3630 * logic, we need to wrap the real output inside
3631 * something that c-client knows how to call.
3632 */
3633 long
3637 soutr_t f,
3640 {
3642 }
3645 /*
3646 * posting_characterset- determine what transliteration is reasonable
3647 * for posting the given non-ascii messsage data.
3648 *
3649 * preferred_charset is the charset the original data was labeled in.
3650 * If we can keep that we do.
3651 *
3652 * Returns: always returns the preferred character set.
3653 */
3656 {
3672 /* convert text in header to UCS characters */
3679 /*
3680 * After the while loop is done the validbitmap has
3681 * a 1 bit for all the character sets that can
3682 * represent all of the characters of this header.
3683 */
3694 }
3697 }
3706 }
3712 UCS ucs;
3713 CBUF_S cbuf;
3739 /*
3740 * Read a stream of UTF-8 characters from the_text
3741 * and convert them to UCS-4 characters for the translatable
3742 * test.
3743 */
3746 /* got a ucs character */
3751 }
3752 }
3759 }
3761 /* user chooses something other than UTF-8 */
3763 /*
3764 * If we're to post in other than UTF-8, and it can be
3765 * transliterated without losing fidelity, do it.
3766 * Else, use UTF-8.
3767 */
3769 /* if ascii works, always use that */
3773 /* does the user's posting character set work? */
3777 /* this is the charset the message we are replying to was in */
3783 /* else, use UTF-8 */
3785 }
3786 /* user chooses nothing, going with the default */
3792 /*
3793 * In this case the user didn't specify a posting character set
3794 * and we will choose the most-specific one from our list.
3795 */
3797 /* ascii is best */
3801 /* Can we keep the original from the message we're replying to? */
3807 /* choose the best of the rest */
3812 /*
3813 * If the text we're labeling contains something like
3814 * smart quotes but no CJK characters, then instead of
3815 * labeling it as ISO-2022-JP we want to use UTF-8.
3816 */
3827 }
3830 }
3831 /* user explicitly chooses UTF-8 */
3833 /* if ascii works, always use that */
3837 /* else, use UTF-8 */
3839 }
3840 }
3843 }
3865 "EUC-KR"
3866 };
3871 {
3876 /*
3877 * When user doesn't set a posting character set posting_charmap ends up
3878 * set to UTF-8. That also happens if user sets UTF-8 explicitly.
3879 * That's where the strange set of if-else's come from.
3880 */
3882 /* user chooses something other than UTF-8 */
3886 reset++;
3888 /* if posting_charmap is valid, include it in list */
3893 count++;
3897 reset++;
3898 }
3904 count++;
3908 reset++;
3909 }
3912 reset++;
3937 }
3938 }
3939 /* user chooses nothing, going with the default */
3945 /* does preferred_charset have to be added to the list? */
3951 }
3954 /* existing list is right size already */
3956 /* just check to see if last list item is the preferred_charset */
3958 /* no, fix it */
3959 reset++;
3962 }
3963 }
3965 reset++;
3977 }
3978 }
3980 /* if list is same size as downgrades, consider it good */
3982 reset++;
3995 }
3996 }
3997 }
3998 /* user explicitly chooses UTF-8 */
4000 /* include possibility of ascii even if they explicitly ask for UTF-8 */
4003 reset++;
4006 reset++;
4012 /* the list is just ascii and nothing else */
4019 }
4020 }
4029 }
4032 }
4035 /* total reset */
4036 void
4038 {
4046 }
4049 int
4051 {
4065 done++;
4068 }
4069 }
4072 }
4077 {
4085 /* careful, find_rightmost_bit modifies the bitmap */
4091 }
4094 /*
4095 * Set parameter to new value.
4096 */
4097 void
4099 {
4108 }
4121 }
4122 /* else pm is existing paramname parameter */
4123 }
4132 }
4133 }
4134 }
4137 /*----------------------------------------------------------------------
4138 Remove the leading digits from SMTP error messages
4139 -----*/
4142 {
4145 error++;
4150 }
4153 /*
4154 * Local globals pine's body output routine needs
4155 */
4160 /*
4161 * def to make our pipe write's more friendly
4162 */
4163 #ifdef PIPE_MAX
4164 #if PIPE_MAX > 20000
4165 #undef PIPE_MAX
4166 #endif
4167 #endif
4169 #ifndef PIPE_MAX
4170 #define PIPE_MAX 1024
4171 #endif
4174 /*
4175 * l_flust_net - empties gf_io terminal function's buffer
4176 */
4177 int
4179 {
4185 /*
4186 * The start of each write is expected to be the start of a
4187 * "record" (i.e., a CRLF terminated line). Make sure that is true
4188 * else we might screw up SMTP dot quoting...
4189 */
4193 ;
4200 ;
4203 /* snippet remains */
4206 }
4207 }
4216 if(lp && lp >= tmp_20k_buf && lp < tmp_20k_buf + SIZEOF_20KBUF && (*lp = c)) /* Shift text left? */
4219 }
4222 }
4225 /*
4226 * l_putc - gf_io terminal function that calls smtp's soutr_t function.
4227 *
4228 */
4229 int
4231 {
4236 }
4240 /*
4241 * pine_rfc822_output_body - pine's version of c-client call. Again,
4242 * necessary since c-client doesn't know about how
4243 * we're treating attachments
4244 */
4245 long
4247 {
4253 LOC_2022_JP ljp;
4254 gf_io_t gc;
4260 /* find cookie */
4265 /*
4266 * Output a bit of text before the first multipart delimiter
4267 * to warn unsuspecting users of non-mime-aware ua's that
4268 * they should expect weirdness. We do not add this when signing a
4269 * message, though...
4270 */
4271 #ifdef SMIME
4273 #endif
4274 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"))
4278 /* build cookie */
4281 /* append cookie,mini-hdr,contents */
4288 /* output trailing cookie */
4291 #ifdef SMIME
4295 #endif
4299 }
4302 }
4312 else
4315 /*
4316 * Don't add trailing line if it is ExternalText, which already guarantees
4317 * a trailing newline.
4318 */
4334 }
4341 }
4343 /* else, just send it? */
4345 }
4346 }
4347 }
4350 }
4352 /*
4353 * Convert text pieces to canonical form
4354 * BEFORE applying any encoding (rfc1341: appendix G)...
4355 * NOTE: almost all filters expect CRLF newlines
4356 */
4361 }
4374 }
4375 }
4381 }
4400 /*
4401 * BUG: If this name is not ascii it's going to cause trouble.
4402 */
4418 }
4423 }
4428 else
4430 }
4434 {
4442 }
4444 /*
4445 * pine_write_body_header - another c-client clone. This time
4446 * so the final encoding labels get set
4447 * correctly since it hasn't happened yet,
4448 * and to be paranoid about line lengths.
4449 *
4450 * Returns: TRUE/nonzero on success, zero on error
4451 */
4452 int
4454 {
4456 RFC822BUFFER rbuf;
4475 }
4485 ? ENCBASE64
4487 ? ENCQUOTEDPRINTABLE
4492 /*
4493 * If requested, strip Content-ID headers that don't look like they
4494 * are needed. Microsoft's Outlook XP has a bug that causes it to
4495 * not show that there is an attachment when there is a Content-ID
4496 * header present on that attachment.
4497 *
4498 * If user has quell-content-id turned on, don't output content-id
4499 * unless it is of type message/external-body.
4500 * Since this code doesn't look inside messages being forwarded
4501 * type message content-ids will remain as is and type multipart
4502 * alternative will remain as is. We don't create those on our
4503 * own. If we did, we'd have to worry about getting this right.
4504 */
4540 }
4545 }
4557 }
4559 /* copy out of so, a line at a time (or less than a K)
4560 * and send it down the pike
4561 */
4572 }
4574 /* Finally, write blank line */
4579 }
4582 }
4585 /*
4586 * pine_write_header - convert, encode (if needed) and
4587 * write "header-name: field-body"
4588 */
4589 int
4591 {
4607 }
4610 /*
4611 * pine_write_param - convert, encode and write MIME header-field parameters
4612 */
4613 int
4615 {
4631 }
4634 }
4638 int
4640 {
4646 /*
4647 * "comment out" the real values since our comment isn't
4648 * likely the same type, disposition nor encoding...
4649 */
4652 }
4655 }
4658 }
4661 int
4663 {
4670 }
4673 }
4677 int
4679 {
4684 }
4687 /*
4688 * pine_free_body - c-client call wrapper so the body data pointer we
4689 * we're using in a way c-client doesn't know about
4690 * gets free'd appropriately.
4691 */
4692 void
4694 {
4695 /*
4696 * Preempt c-client's contents.text.data clean up since we've
4697 * usurped it's meaning for our own purposes...
4698 */
4701 /* Then let c-client handle the rest... */
4703 }
4706 /*
4707 * pine_free_body_data - free pine's interpretations of the body part's
4708 * data pointer.
4709 */
4710 void
4712 {
4719 }
4722 }
4723 }
4726 long
4728 {
4738 }
4741 }
4744 int
4746 {
4750 }
4753 /*
4754 * pine_smtp_verbose_out - write
4755 */
4756 void
4758 {
4759 #ifdef _WINDOWS
4760 LPTSTR slpt;
4761 #endif
4768 else
4771 #ifdef _WINDOWS
4772 /*
4773 * The stream is opened in Unicode mode, so we need to fix the
4774 * argument to fputs.
4775 */
4780 }
4784 #else
4788 #endif
4789 }
4791 }
4794 /*
4795 * pine_header_forbidden - is this name a "forbidden" header?
4796 *
4797 * name - the header name to check
4798 * We don't allow user to change these.
4799 */
4800 int
4802 {
4830 NULL
4831 };
4838 }
4841 /*
4842 * hdr_is_in_list - is there a custom value for this header?
4843 *
4844 * hdr - the header name to check
4845 * custom - the list to check in
4846 * Returns 1 if there is a custom value, 0 otherwise.
4847 */
4848 int
4850 {
4858 }
4861 /*
4862 * count_custom_hdrs_pf - returns number of custom headers in arg
4863 * custom -- the list to be counted
4864 * only_nonstandard -- only count headers which aren't standard pine headers
4865 */
4866 int
4868 {
4873 ret++;
4876 }
4879 /*
4880 * count_custom_hdrs_list - returns number of custom headers in arg
4881 */
4882 int
4884 {
4895 /* remove leading whitespace */
4898 /* look for colon or space or end */
4906 ret++;
4909 }
4910 }
4911 }
4914 }
4917 /*
4918 * set_default_hdrval - put the user's default value for this header
4919 * into pf->textbuf.
4920 * setthis - the pinefield to be set
4921 * custom - where to look for the default
4922 */
4923 CustomType
4925 {
4932 }
4942 /* turn on editing */
4948 }
4954 }
4957 /*
4958 * pine_header_standard - is this name a "standard" header?
4959 *
4960 * name - the header name to check
4961 */
4962 FieldType
4964 {
4967 /* check to see if this is a standard header */
4973 }
4976 /*
4977 * customized_hdr_setup - setup the PINEFIELDS for all the customized headers
4978 * Allocates space for each name and addr ptr.
4979 * Allocates space for default in textbuf, even if empty.
4980 *
4981 * head - the first PINEFIELD to fill in
4982 * list - the list to parse
4983 */
4984 void
4986 {
4997 /* anything after leading whitespace? */
5001 /* look for colon or space or end */
5006 /* if there is a space in the field-name, skip it */
5010 name);
5012 }
5017 /* Don't allow any of the forbidden headers. */
5021 name);
5025 }
5036 #ifdef OLDWAY
5037 /*
5038 * Some mailers apparently break if we change
5039 * user@domain into Fred <user@domain> for
5040 * return-receipt-to,
5041 * so we'll just call this a FreeText field, too.
5042 */
5043 /*
5044 * For now, all custom headers are FreeText except for
5045 * this one that we happen to know about. We might
5046 * have to add some syntax to the config option so that
5047 * people can tell us their custom header takes addresses.
5048 */
5053 }
5058 /* remove space between name and colon */
5061 /* give them an alloc'd default, even if empty */
5067 pf++;
5068 }
5069 else
5071 }
5072 }
5073 }
5075 /* fix last next pointer */
5078 }
5081 /*
5082 * add_defaults_from_list - the PINEFIELDS list given by "head" is already
5083 * setup except that it doesn't have default values.
5084 * Add those defaults if they exist in "list".
5085 *
5086 * head - the first PINEFIELD to add a default to
5087 * list - the list to get the defaults from
5088 */
5089 void
5091 {
5103 /* anything after leading whitespace? */
5107 /* look for colon or space or end */
5112 /* if there is a space in the field-name, skip it */
5122 }
5126 /*
5127 * Found the right header. See if it has a default
5128 * value set.
5129 */
5131 /* remove space between name and colon */
5143 }
5144 }
5147 }
5148 }
5149 }
5150 }
5153 /*
5154 * parse_custom_hdrs - allocate PINEFIELDS for custom headers
5155 * fill in the defaults
5156 * Args - list -- The list to parse.
5157 * cstmtype -- Fill the in cstmtype field with this value
5158 */
5159 PINEFIELD *
5161 {
5165 /*
5166 * add one for possible use by fcc
5167 * What is this "possible use"? I don't see it. I don't
5168 * think it exists anymore. I think +1 would be ok. hubert 2000-08-02
5169 */
5174 /* set up the custom header pfields */
5178 }
5181 /*
5182 * Combine the two lists of headers into one list which is allocated here
5183 * and freed by the caller. Eliminate duplicates with values from the role
5184 * taking precedence over values from the default.
5185 */
5186 PINEFIELD *
5188 {
5207 pf++;
5208 }
5210 /* if these aren't already there, add them */
5212 /* check for already there */
5215 i++)
5216 ;
5226 pf++;
5227 }
5228 }
5230 /* fix last next pointer */
5235 }
5238 /*
5239 * free_customs - free misc. resources associated with custom header fields
5240 *
5241 * pf - pointer to first custom field
5242 */
5243 void
5245 {
5255 /* only true for FreeText */
5259 /* only true for Address */
5262 }
5265 }
5268 /*
5269 * encode_whole_header
5270 *
5271 * Returns 1 if whole value should be encoded
5272 * 0 to encode only within comments
5273 */
5274 int
5276 {
5283 retval++;
5288 retval++;
5290 }
5291 }
5292 }
5295 }
5298 /*----------------------------------------------------------------------
5299 Post news via NNTP or inews
5301 Args: env -- envelope of message to post
5302 body -- body of message to post
5304 Returns: -1 if failed or cancelled, 1 if succeeded
5306 WARNING: This call function has the side effect of writing the message
5307 to the lmc.so object.
5308 ----*/
5309 int
5312 {
5329 /*---------- NNTP server defined ----------*/
5335 /*
5336 * Install our rfc822 output routine
5337 */
5349 #ifdef DEBUG
5351 #else
5353 #endif
5359 /*
5360 * Fake that we've got clearance from the transport agent
5361 * for 8bit transport for the benefit of our output routines...
5362 */
5368 ;
5372 }
5378 }
5379 }
5381 /*
5382 * Set global header pointer so we can get at it later...
5383 */
5394 }
5403 }
5406 /*---- Open of NNTP connection failed ------ */
5412 }
5413 server_no++;
5414 }
5418 /*----- Post via local mechanism -------*/
5419 #ifdef _WINDOWS
5424 pipecb_f);
5425 #endif
5426 }
5437 }
5441 }
5444 /* ----------------------------------------------------------------------
5445 Figure out command to start local SMTP agent
5447 Args: errbuf -- buffer for reporting errors (assumed non-NULL)
5449 Returns an alloc'd copy of the local SMTP agent invocation or NULL
5451 ----*/
5454 {
5455 #ifdef _WINDOWS
5462 # if defined(SENDMAIL) && defined(SENDMAILFLAGS)
5468 # else
5471 # endif
5472 #endif
5475 }
5479 #ifndef _WINDOWS
5480 /*----------------------------------------------------------------------
5481 Hand off given message to local posting agent
5483 Args: envelope -- The envelope for the BCC and debugging
5484 header -- The text of the message header
5485 errbuf -- buffer for reporting errors (assumed non-NULL)
5486 len -- Length of errbuf
5488 ----*/
5489 int
5494 {
5495 #ifdef DF_SENDMAIL_PATH
5497 #endif
5500 /*
5501 * A bit of complicated policy implemented here.
5502 * There are two posting variables sendmail-path and smtp-server.
5503 * Precedence is in that order.
5504 * They can be set one of 4 ways: fixed, command-line, user, or globally.
5505 * Precedence is in that order.
5506 * Said differently, the order goes something like what's below.
5507 *
5508 * NOTE: the fixed/command-line/user precendence handling is also
5509 * indicated by what's pointed to by ps_global->VAR_*, but since
5510 * that also includes the global defaults, it's not sufficient.
5511 */
5516 }
5522 }
5532 else
5534 }
5542 }
5543 #ifdef DF_SENDMAIL_PATH
5544 /*
5545 * This defines the default method of posting. So,
5546 * unless we're told otherwise use it...
5547 */
5552 }
5553 #endif
5554 }
5555 }
5556 }
5564 }
5565 else
5567 }
5571 /*----------------------------------------------------------------------
5572 Hand off given message to local posting agent
5574 Args: envelope -- The envelope for the BCC and debugging
5575 header -- The text of the message header
5576 errbuf -- buffer for reporting errors (assumed non-NULL)
5577 errbuflen -- Length of errbuf
5579 Fork off mailer process and pipe the message into it
5580 Called to post news via Inews when NNTP is unavailable
5582 ----*/
5588 {
5590 #ifdef SENDNEWS
5602 }
5612 }
5616 /*----------------------------------------------------------------------
5617 Hand off message to local MTA; it parses recipients from 822 header
5619 Args: header -- struct containing header data
5620 body -- struct containing message body data
5621 cmd -- command to use for handoff (%s says where file should go)
5622 errs -- pointer to buf to hold errors
5624 ----*/
5629 {
5642 }
5648 }
5649 }
5650 else
5656 }
5659 }
5662 /*
5663 * pine_pipe_soutr - Replacement for tcp_soutr that writes one of our
5664 * pipes rather than a tcp stream
5665 */
5666 long
5668 {
5680 }
5681 }
5685 }
5693 }
5694 }
5695 else
5697 }
5700 }
5701 #endif
5704 /**************** "PIPE" READING POSTING I/O ROUTINES ****************/
5707 /*
5708 * helpful def's
5709 */
5710 #define S(X) ((PIPE_S *)(X))
5711 #define GETBUFLEN (4 * MAILTMPLEN)
5716 {
5727 }
5728 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
5733 }
5734 else
5738 }
5743 {
5745 }
5748 /*
5749 * piped_soutr - Replacement for tcp_soutr that writes one of our
5750 * pipes rather than a tcp stream
5751 */
5752 long
5754 {
5756 }
5759 /*
5760 * piped_sout - Replacement for tcp_soutr that writes one of our
5761 * pipes rather than a tcp stream
5762 */
5763 long
5765 {
5777 }
5778 }
5782 }
5783 }
5786 }
5789 /*
5790 * piped_getline - Replacement for tcp_getline that reads one
5791 * of our pipes rather than a tcp pipe
5792 *
5793 * C-client expects that the \r\n will be stripped off.
5794 */
5797 {
5807 /* alloc space to collect input (freed in close_system_pipe) */
5811 }
5818 }
5823 }
5826 }
5837 }
5839 n++;
5841 }
5842 /* copy partial string from buffer */
5844 /* get more data */
5852 }
5860 }
5861 }
5864 }
5867 ptr++;
5868 cnt--;
5870 }
5878 }
5881 }
5884 /*
5885 * piped_close - Replacement for tcp_close that closes pipes to our
5886 * child rather than a tcp connection
5887 */
5888 void
5890 {
5891 /*
5892 * Uninstall our hooks into smtp_send since it's being used by
5893 * the nntp driver as well...
5894 */
5896 }
5899 /*
5900 * piped_abort - close down the pipe we were using to post
5901 */
5902 void
5904 {
5908 }
5913 }
5914 }
5919 {
5921 }
5924 unsigned long
5926 {
5928 }