| blob | 4af84ebe46533a01b2986443e2bd1e12330d1f11 |
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 }
1566 }
1569 /*----------------------------------------------------------------------
1570 Set answered flags for messages specified by reply structure
1572 Args: reply --
1574 Returns: with appropriate flags set and index cache entries suitably tweeked
1575 ----*/
1576 void
1578 {
1583 /* nothing to flip in a pseudo reply */
1588 /*
1589 * If an established stream will do, use it, else
1590 * build one unless we have an array of msgno's...
1591 *
1592 * I was just mimicking what was already here. I don't really
1593 * understand why we use strcmp instead of same_stream_and_mailbox().
1594 * Or sp_stream_get(reply->mailbox, SP_MATCH).
1595 * Hubert 2003-07-09
1596 */
1602 }
1607 /*
1608 * This is here only for people who ran pine4.42 and are
1609 * processing postponed mail from 4.42 now. Pine4.42 saved the
1610 * original mailbox name in the canonical name's position in
1611 * the postponed-msgs folder so it won't match the canonical
1612 * name from the stream.
1613 */
1619 /* TRANSLATORS: program is busy updating the Answered flags so warns user */
1627 ourstream++;
1628 }
1634 }
1635 }
1642 }
1647 }
1650 /*
1651 * $Forwarded is a regular keyword so we only try to
1652 * set it if the stream allows keywords.
1653 * We could mess up if the stream has keywords but just
1654 * isn't allowing anymore and $Forwarded already exists,
1655 * but what are the odds?
1656 */
1659 FORWARDED_FLAG,
1661 }
1662 else
1669 }
1676 }
1677 }
1680 /*
1681 * phone_home_from - make phone home request's from address IMpersonal.
1682 * Doesn't include user's personal name.
1683 */
1684 ADDRESS *
1686 {
1690 /* garble up mailbox name */
1696 }
1699 /*
1700 * one-way-hash a username into an 8-digit decimal number
1701 *
1702 * Corey Satten, corey@cac.washington.edu, 7/15/98
1703 */
1704 unsigned int
1706 {
1712 else
1716 }
1719 }
1722 /*----------------------------------------------------------------------
1723 Call the mailer, SMTP, sendmail or whatever
1725 Args: header -- full header (envelope and local parts) of message to send
1726 body -- The full body of the message including text
1727 alt_smtp_servers --
1728 verbosefile -- non-null means caller wants verbose interaction and the resulting
1729 output file name to be returned
1731 Returns: -1 if failed, 1 if succeeded
1732 ----*/
1733 int
1737 {
1750 /* Check for any recipients */
1759 }
1761 #ifdef SMIME
1773 /* need to free new body from encrypt if sign fails? */
1781 }
1782 #endif
1784 /* set up counts and such to keep track sent percentage */
1792 #ifndef _WINDOWS
1794 /* try posting via local "<mta> <-t>" if specified */
1800 }
1802 #endif
1804 /*
1805 * If the user's asked for it, and we find that the first text
1806 * part (attachments all get b64'd) is non-7bit, ask for 8BITMIME.
1807 */
1811 #ifdef DEBUG
1812 #ifndef DEBUGJOURNAL
1814 #endif
1816 #endif
1826 /*
1827 * If it isn't Never, then we're always going to let them
1828 * know about failures. This means we don't allow for the
1829 * possibility of setting delay or success without failure.
1830 */
1835 }
1836 }
1839 /*
1840 * Set global header pointer so post_rfc822_output can get at it when
1841 * it's called back from c-client's sending routine...
1842 */
1845 /*
1846 * Fabricate a fake ENVELOPE to hand c-client's SMTP engine.
1847 * The purpose is to give smtp_mail the list for SMTP RCPT when
1848 * there are recipients in pine's METAENV that are outside c-client's
1849 * envelope.
1850 *
1851 * NOTE: If there aren't any, don't bother. Dealt with it below.
1852 */
1871 }
1872 }
1874 /*
1875 * Install our rfc822 output routine
1876 */
1880 /*
1881 * Allow for verbose posting
1882 */
1886 /*
1887 * We do this because we want mm_log to put the error message into
1888 * c_client_error instead of showing it itself.
1889 */
1892 /*
1893 * OK, who posts what? We tried an mta_handoff above, but there
1894 * was either none specified or we decided not to use it. So,
1895 * if there's an smtp-server defined anywhere,
1896 */
1898 /*---------- SMTP ----------*/
1903 }
1906 /*---------- SMTP ----------*/
1910 }
1911 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
1914 /*----- Send via LOCAL SMTP agent ------*/
1923 /* BUG: should provide separate stderr output! */
1924 }
1948 }
1949 }
1955 }
1956 }
1961 }
1964 }
1966 /*
1967 * Before we actually send data, see if we have to protect
1968 * the first text body part from getting encoded. We protect
1969 * it from getting encoded in "pine_rfc822_output_body" by
1970 * temporarily inventing a synonym for ENC8BIT...
1971 * This works like so:
1972 * Suppose bp->encoding is set to ENC8BIT.
1973 * We change that here to some unused value (added_encoding) and
1974 * set body_encodings[added_encoding] to "8BIT".
1975 * Then post_rfc822_output is called which calls
1976 * pine_rfc822_output_body. Inside that routine
1977 * pine_write_body_header writes out the encoding for the
1978 * part. Normally it would see encoding == ENC8BIT and it would
1979 * change that to QUOTED-PRINTABLE, but since encoding has been
1980 * set to added_encoding it uses body_encodings[added_encoding]
1981 * which is "8BIT" instead. Then the actual body is written by
1982 * pine_write_body_header which does not do the gf_8bit_qp
1983 * filtering because encoding != ENC8BIT (instead it's equal
1984 * to added_encoding).
1985 */
1991 ;
1995 }
2001 }
2002 }
2027 /*
2028 * Too complicated to figure out which header line
2029 * has the error in the fake_env case, so just
2030 * leave cursor at default.
2031 */
2040 }
2044 }
2045 }
2059 }
2063 }
2064 }
2068 }
2070 /* repair modified "body_encodings" array? */
2075 }
2081 }
2087 }
2100 }
2103 }
2105 /*
2106 * Restore original 822 emitter...
2107 */
2113 done:
2115 #ifdef SMIME
2116 /* Free replacement encrypted body */
2120 /* Just get rid of first part, it's actually origBody */
2126 }
2129 }
2130 #endif
2136 /*-------- Did message make it ? ----------*/
2138 /*---- Error sending mail -----*/
2145 }
2148 }
2152 }
2153 }
2156 /*
2157 * write_postponed - exported method to write the given message
2158 * to the postponed folder
2159 */
2160 int
2162 {
2174 }
2183 /* BUG: writem sufficient ? */
2190 }
2192 /*
2193 * Work around c-client reply-to bug. C-client will
2194 * return a reply_to in an envelope even if there is
2195 * no reply-to header field. We want to note here whether
2196 * the reply-to is real or not.
2197 */
2205 else
2207 }
2209 /*
2210 * Write the list of custom headers to the
2211 * X-Our-Headers header so that we can recover the
2212 * list in redraft.
2213 */
2223 ;
2230 /* note: "pf" overloaded */
2235 r--;
2237 }
2240 }
2241 }
2248 }
2254 }
2258 }
2261 int
2263 {
2268 }
2269 else
2273 }
2276 int
2278 {
2290 }
2293 }
2296 }
2299 }
2302 }
2305 /*----------------------------------------------------------------------
2306 Checks to make sure the fcc is available and can be opened
2308 Args: fcc -- the name of the fcc to create. It can't be NULL.
2309 fcc_cntxt -- Returns the context the fcc is in.
2310 force -- supress user option prompt
2312 Returns allocated storage object on success, NULL on failure
2313 ----*/
2314 STORE_S *
2316 {
2321 /*
2322 * check for fcc's existance...
2323 */
2329 /*
2330 * Don't want to preclude a user from Fcc'ing a .name'd folder
2331 */
2335 }
2337 /*
2338 * We only want to set the "context" if fcc is an ambiguous
2339 * name. Otherwise, our "relativeness" rules for contexts
2340 * (implemented in context.c) might cause the name to be
2341 * interpreted in the wrong context...
2342 */
2349 || (pith_opt_save_create_prompt
2355 ok++;
2358 }
2359 else
2361 }
2362 else
2369 }
2372 ok++;
2373 }
2376 || (pith_opt_save_create_prompt
2385 }
2386 else
2388 }
2389 }
2394 }
2414 s1,
2418 s2);
2421 }
2422 else
2424 }
2425 else
2429 }
2432 }
2435 /*----------------------------------------------------------------------
2436 mail_append() the fcc accumulated in temp_storage to proper destination
2438 Args: fcc -- name of folder
2439 fcc_cntxt -- context for folder
2440 temp_storage -- String of file where Fcc has been accumulated
2442 This copies the string of file to the actual folder, which might be IMAP
2443 or a disk folder. The temp_storage is freed after it is written.
2444 An error message is produced if this fails.
2445 ----*/
2446 int
2449 {
2450 STRING msg;
2466 }
2467 else
2472 /*
2473 * Before changing this note that these lines depend on the
2474 * definition of FCC_SOURCE.
2475 */
2491 }
2499 }
2502 /*
2503 * first_text_8bit - return TRUE if somewhere in the body 8BIT data's
2504 * contained.
2505 */
2506 BODY *
2508 {
2514 }
2517 /*
2518 * Build and return the "From:" address for outbound messages from
2519 * global data...
2520 */
2521 ADDRESS *
2523 {
2530 }
2537 }
2540 /*
2541 * set_mime_type_by_grope - sniff the given storage object to determine its
2542 * type, subtype, encoding, and charset
2543 *
2544 * "Type" and "encoding" must be set before calling this routine.
2545 * If "type" is set to something other than TYPEOTHER on entry,
2546 * then that is the "type" we wish to use. Same for "encoding"
2547 * using ENCOTHER instead of TYPEOTHER. Otherwise, we
2548 * figure them out here. If "type" is already set, we also
2549 * leave subtype alone. If not, we figure out subtype here.
2550 * There is a chance that we will upgrade encoding to a "higher"
2551 * level. For example, if it comes in as 7BIT we may change
2552 * that to 8BIT if we find a From_ we want to escape.
2553 * We may also set the charset attribute if the type is TEXT.
2554 *
2555 * NOTE: this is rather inefficient if the store object is a CharStar
2556 * but the win is all types are handled the same
2557 */
2558 void
2560 {
2561 #define RBUFSZ (8193)
2571 #ifdef ENCODE_FROMS
2574 #endif
2582 ;
2591 }
2597 }
2602 }
2607 }
2611 }
2615 }
2620 }
2625 }
2627 /*
2628 * if type was set above, but no encoding specified, go
2629 * ahead and make it BASE64...
2630 */
2633 }
2634 }
2636 /* PROBLEM !!! */
2642 }
2643 }
2649 #endif
2654 /* Some people don't like quoted-printable caused by leading Froms */
2655 #ifdef ENCODE_FROMS
2657 #endif
2662 #if defined(DOS) || defined(OS2)
2663 /* LF with no CR!! */
2666 #endif
2667 }
2669 eight_bit_chars++;
2670 }
2672 /* NULL found. Unless we're told otherwise, must be binary */
2676 }
2678 /*
2679 * The "TYPETEXT" here handles the case that the NULL
2680 * comes from imported text generated by some external
2681 * editor that permits or inserts NULLS. Otherwise,
2682 * assume it's a binary segment...
2683 */
2686 /*
2687 * Since we've already set encoding, count this as a
2688 * hi bit char and continue. The reason is that if this
2689 * is text, there may be a high percentage of encoded
2690 * characters, so base64 may get set below...
2691 */
2693 eight_bit_chars++;
2694 else
2696 }
2701 #endif
2703 /* read another buffer in */
2709 ;
2713 }
2714 else
2715 p++;
2717 /*
2718 * If there's no beginning-of-line pointer, then we must
2719 * have seen an end-of-line. Set bol to the start of the
2720 * new line...
2721 */
2726 /* either a lone \r or lone \n indicate binary file */
2732 }
2736 }
2737 }
2738 #endif
2739 }
2740 }
2742 /* stash away for later */
2746 /*
2747 * Since the type or encoding aren't set yet, fall thru a
2748 * series of tests to make sure an adequate type and
2749 * encoding are set...
2750 */
2754 /*
2755 * Since the types not set, then we didn't find a NULL.
2756 * If there's no NULL, then this is likely text. However,
2757 * since we can't be *completely* sure, we set it to
2758 * the generic type.
2759 */
2762 }
2765 /*
2766 * As with NULL handling, if we're told it's text,
2767 * qp-encode it, else it gets base 64...
2768 */
2770 }
2778 }
2780 /*
2781 * The 30% threshold is based on qp encoded readability
2782 * on non-MIME UA's.
2783 */
2789 }
2794 }
2796 /*
2797 * Apply maximal encoding regardless of previous
2798 * setting. This segment's either not text, or is
2799 * unlikely to be readable with > 30% of the
2800 * text encoded anyway, so we might as well save space...
2801 */
2803 }
2804 }
2806 #ifdef ENCODE_FROMS
2807 /* If there were From_'s at the beginning of a line or standalone dots */
2810 #endif
2812 /* Set the subtype */
2823 }
2826 /*
2827 * Call this to set the charset of an attachment we have
2828 * created. If the attachment contains any non-ascii characters
2829 * then we'll set the charset to the passed in charset, otherwise
2830 * we'll make it us-ascii.
2831 */
2832 void
2834 {
2849 can_be_ascii--;
2856 /*
2857 * Else we don't know. There are non ascii characters but we either
2858 * don't have a charset to set it to or that charset is just us_ascii,
2859 * which is impossible. So we label it unknown. An alternative would
2860 * have been to strip the high bits instead and label it ascii.
2861 */
2863 }
2867 }
2870 /*
2871 * since encoding happens on the way out the door, this is basically
2872 * just needed to handle TYPEMULTIPART
2873 */
2874 void
2876 {
2891 }
2902 /*
2903 * If the part is text we edited, then it is UTF-8.
2904 * The user may be asking us to send it as something else
2905 * or we may want to downconvert to a more-specific characterset.
2906 * Mark it for conversion here so the right MIME header's written.
2907 * Do conversion pine_rfc822_output_body.
2908 * Attachments are left as is.
2909 */
2920 /*
2921 * Fix iso-2022-jp encoding to ENC7BIT since it's escape based
2922 * and doesn't use anything but ASCII characters.
2923 * Why is it not ENC7BIT already? Because when we set the encoding
2924 * in set_mime_type_by_grope we were groping through UTF-8 text
2925 * not 2022 text. Not only that, but we didn't know at that point
2926 * that it wouldn't stay UTF-8 when we sent it, which would require
2927 * encoding.
2928 */
2933 }
2937 }
2942 /* Encapsulated messages are always treated as text objects at this point.
2943 This means that you must replace body->contents.msg with
2944 body->contents.text, which probably involves copying
2945 body->contents.msg.text to body->contents.text */
2947 /*
2948 * but we'll delay encoding it until the message is on the way
2949 * into the mail slot...
2950 */
2952 }
2953 }
2956 /*
2957 * pine_header_line - simple wrapper around c-client call to contain
2958 * repeated code, and to write fcc if required.
2959 */
2960 int
2963 {
2977 else
2996 /*
2997 * We were folding everything except message-id, but that wasn't
2998 * sufficient. Since 822 only allows folding where linear-white-space
2999 * is allowed we'd need a smarter folder than "fold" to do it. So,
3000 * instead of inventing that smarter folder (which would have to
3001 * know 822 syntax)
3002 *
3003 * We could just alloc space and copy the actual_field followed by
3004 * the value into it, but since that's what fold does anyway we'll
3005 * waste some cpu time and use fold with a big fold parameter.
3006 *
3007 * We upped the references folding from 75 to 256 because we were
3008 * encountering longer-than-75 message ids, and to break one line
3009 * in references is to break them all.
3010 */
3015 else
3022 }
3024 RFC822BUFFER rbuf;
3027 /*
3028 * rfc1522_encode already inserted continuation lines and did
3029 * the necessary folding so we don't have to do it. Let
3030 * rfc822_header_line add the trailing crlf and the resent- if
3031 * necessary. The 20 could actually be a 12.
3032 */
3044 }
3052 }
3059 }
3060 else
3064 }
3067 /*
3068 * Do appropriate encoding of text header lines.
3069 * For some field types (those that consist of 822 *text) we just encode
3070 * the whole thing. For structured fields we encode only within comments
3071 * if possible.
3072 *
3073 * Args d -- Destination buffer if needed. (tmp_20k_buf)
3074 * s -- Source string.
3075 * charset -- Charset to encode with.
3076 * encode_all -- If set, encode the whole string. If not, try to encode
3077 * only within comments if possible.
3078 *
3079 * Returns S is returned if no encoding is done. D is returned if encoding
3080 * was needed.
3081 */
3084 {
3095 /*
3096 * We don't have to worry about keeping track of quoted-strings because
3097 * none of these fields which aren't addresses contain quoted-strings.
3098 * We do keep track of escaped parens inside of comments and comment
3099 * nesting.
3100 */
3112 /* encode the comment, excluding the outer parens */
3119 charset);
3130 }
3135 }
3144 }
3145 }
3154 }
3155 }
3158 /* Unterminated comment (wasn't really a comment) */
3163 }
3164 }
3166 /*
3167 * We have to check if there is anything that needs to be encoded that
3168 * wasn't in a comment. If there is, we'd better just start over and
3169 * encode the whole thing. So, if no encoding has been done within
3170 * comments, or if encoding is needed both within and outside of
3171 * comments, then we encode the whole thing. Otherwise, go with
3172 * the version that has only comments encoded.
3173 */
3181 }
3182 }
3185 /*
3186 * pine_address_line - write a header field containing addresses,
3187 * one by one (so there's no buffer limit), and
3188 * wrapping where necessary.
3189 * Note: we use c-client functions to properly build the text string,
3190 * but have to screw around with pointers to fool c-client functions
3191 * into not blatting all the text into a single buffer. Yeah, I know.
3192 */
3193 int
3196 {
3204 RFC822BUFFER rbuf;
3207 #define no_comma (&comma[1])
3213 in_group++;
3214 was_start_of_group++;
3215 /* encode mailbox of group */
3226 }
3228 failed++;
3230 }
3231 }
3232 }
3233 else
3237 /* make sure personal name is encoded */
3247 }
3249 failed++;
3251 }
3252 }
3257 /* use automatic buffer unless it isn't big enough */
3261 }
3265 }
3288 }
3293 }
3295 /*
3296 * If there is no sending_stream and we are writing the Lcc header,
3297 * then we are piping it to sendmail -t which expects it to be a bcc,
3298 * not lcc.
3299 *
3300 * When we write it to the fcc or postponed (the lmc.so),
3301 * we want it to be lcc, not bcc, so we put it back.
3302 */
3316 }
3324 /* account for c-client's representation of group names */
3329 /*
3330 * Rfc822_write_address no longer writes out the end of group
3331 * unless the whole group address is passed to it, so we do
3332 * it ourselves.
3333 */
3335 }
3338 }
3339 /* start of new group, print phrase below */
3341 in_group++;
3342 was_start_of_group++;
3343 }
3345 /* no comma before first address in group syntax */
3349 }
3351 /* write delimiter */
3366 }
3368 failed++;
3370 }
3378 }
3381 /* make sure we don't write out group end with rfc822_write_address */
3390 }
3399 /*
3400 * BUG
3401 * With group syntax addresses we no longer have two identical
3402 * streams of output. Instead, for the fcc/postpone copy we include
3403 * all of the addresses inside the :; of the group, and for the
3404 * mail we're sending we don't include them. That means we aren't
3405 * correctly keeping track of the column to wrap in, below. That is,
3406 * we are keeping track of the fcc copy but we aren't keeping track
3407 * of the regular copy. It could result in too long or too short
3408 * lines. Should almost never come up since group addresses are almost
3409 * never followed by other addresses in the same header, and even
3410 * when they are, you have to go out of your way to get the headers
3411 * messed up.
3412 */
3419 }
3420 else
3428 }
3430 bail_out:
3440 }
3443 /*
3444 * mutated pine version of c-client's rfc822_header() function.
3445 * changed to call pine-wrapped header and address functions
3446 * so we don't have to limit the header size to a fixed buffer.
3447 * This function also calls pine's body_header write function
3448 * because encoding is delayed until output_body() is called.
3449 */
3450 long
3452 {
3465 }
3470 /*
3471 * Warning: This is confusing. The 2nd to last argument used to
3472 * be just pf->writehdr. We want Bcc lines to be written out
3473 * if we are handing off to a sendmail temp file but not if we
3474 * are talking smtp, so bcc's writehdr is set to 0 and
3475 * pine_address_line was sending if writehdr OR !sending_stream.
3476 * That works as long as we want to write everything when
3477 * !sending_stream (an mta handoff to sendmail). But then we
3478 * added the undisclosed recipients line which should only get
3479 * written if writehdr is set, and not when we pass to a
3480 * sendmail temp file. So pine_address_line has been changed
3481 * so it bases its decision solely on the writehdr passed to it,
3482 * and the logic that worries about Bcc and sending_stream
3483 * was moved up to the caller (here) to decide when to set it.
3484 *
3485 * So we have:
3486 * undisclosed recipients:; This will just be written
3487 * if writehdr was set and not
3488 * otherwise, nothing magical.
3489 *** We may want to change this, because sendmail -t doesn't handle
3490 *** the empty group syntax well unless it has been configured to
3491 *** do so. It isn't configured by default, or in any of the
3492 *** sendmail v8 configs. So we may want to not write this line
3493 *** if we're doing an mta_handoff (!sending_stream).
3494 *
3495 * !sending_stream (which means a handoff to a sendmail -t)
3496 * bcc or lcc both set the arg so they'll get written
3497 * (There is also Lcc hocus pocus in pine_address_line
3498 * which converts the Lcc: to Bcc: for sendmail
3499 * processing.)
3500 * sending_stream (which means an smtp handoff)
3501 * bcc and lcc will never have writehdr set, so
3502 * will never be written (They both do have rcptto set,
3503 * so they both do cause RCPT TO commands.)
3504 *
3505 * The localcopy is independent of sending_stream and is just
3506 * written if it is set for all of these.
3507 */
3510 header,
3512 f,
3513 s,
3516 ? !sending_stream
3537 }
3538 }
3541 #if (defined(DOS) || defined(OS2)) && !defined(NOAUTH)
3542 /*
3543 * Add comforting "X-" header line indicating what sort of
3544 * authenticity the receiver can expect...
3545 */
3547 NETMBX netmbox;
3558 }
3573 }
3578 }
3582 }
3583 #endif
3590 }
3595 }
3598 }
3601 /*
3602 * pine_rfc822_output - pine's version of c-client call. Necessary here
3603 * since we're not using its structures as intended!
3604 */
3605 long
3607 {
3615 /* build and output RFC822 header, output body */
3623 }
3626 /*
3627 * post_rfc822_output - cloak for pine's 822 output routine. Since
3628 * we can't pass opaque envelope thru c-client posting
3629 * logic, we need to wrap the real output inside
3630 * something that c-client knows how to call.
3631 */
3632 long
3636 soutr_t f,
3639 {
3641 }
3644 /*
3645 * posting_characterset- determine what transliteration is reasonable
3646 * for posting the given non-ascii messsage data.
3647 *
3648 * preferred_charset is the charset the original data was labeled in.
3649 * If we can keep that we do.
3650 *
3651 * Returns: always returns the preferred character set.
3652 */
3655 {
3671 /* convert text in header to UCS characters */
3678 /*
3679 * After the while loop is done the validbitmap has
3680 * a 1 bit for all the character sets that can
3681 * represent all of the characters of this header.
3682 */
3693 }
3696 }
3705 }
3711 UCS ucs;
3712 CBUF_S cbuf;
3738 /*
3739 * Read a stream of UTF-8 characters from the_text
3740 * and convert them to UCS-4 characters for the translatable
3741 * test.
3742 */
3745 /* got a ucs character */
3750 }
3751 }
3758 }
3760 /* user chooses something other than UTF-8 */
3762 /*
3763 * If we're to post in other than UTF-8, and it can be
3764 * transliterated without losing fidelity, do it.
3765 * Else, use UTF-8.
3766 */
3768 /* if ascii works, always use that */
3772 /* does the user's posting character set work? */
3776 /* this is the charset the message we are replying to was in */
3782 /* else, use UTF-8 */
3784 }
3785 /* user chooses nothing, going with the default */
3791 /*
3792 * In this case the user didn't specify a posting character set
3793 * and we will choose the most-specific one from our list.
3794 */
3796 /* ascii is best */
3800 /* Can we keep the original from the message we're replying to? */
3806 /* choose the best of the rest */
3811 /*
3812 * If the text we're labeling contains something like
3813 * smart quotes but no CJK characters, then instead of
3814 * labeling it as ISO-2022-JP we want to use UTF-8.
3815 */
3826 }
3829 }
3830 /* user explicitly chooses UTF-8 */
3832 /* if ascii works, always use that */
3836 /* else, use UTF-8 */
3838 }
3839 }
3842 }
3864 "EUC-KR"
3865 };
3870 {
3875 /*
3876 * When user doesn't set a posting character set posting_charmap ends up
3877 * set to UTF-8. That also happens if user sets UTF-8 explicitly.
3878 * That's where the strange set of if-else's come from.
3879 */
3881 /* user chooses something other than UTF-8 */
3885 reset++;
3887 /* if posting_charmap is valid, include it in list */
3892 count++;
3896 reset++;
3897 }
3903 count++;
3907 reset++;
3908 }
3911 reset++;
3936 }
3937 }
3938 /* user chooses nothing, going with the default */
3944 /* does preferred_charset have to be added to the list? */
3950 }
3953 /* existing list is right size already */
3955 /* just check to see if last list item is the preferred_charset */
3957 /* no, fix it */
3958 reset++;
3961 }
3962 }
3964 reset++;
3976 }
3977 }
3979 /* if list is same size as downgrades, consider it good */
3981 reset++;
3994 }
3995 }
3996 }
3997 /* user explicitly chooses UTF-8 */
3999 /* include possibility of ascii even if they explicitly ask for UTF-8 */
4002 reset++;
4005 reset++;
4011 /* the list is just ascii and nothing else */
4018 }
4019 }
4028 }
4031 }
4034 /* total reset */
4035 void
4037 {
4045 }
4048 int
4050 {
4064 done++;
4067 }
4068 }
4071 }
4076 {
4084 /* careful, find_rightmost_bit modifies the bitmap */
4090 }
4093 /*
4094 * Set parameter to new value.
4095 */
4096 void
4098 {
4107 }
4120 }
4121 /* else pm is existing paramname parameter */
4122 }
4131 }
4132 }
4133 }
4136 /*----------------------------------------------------------------------
4137 Remove the leading digits from SMTP error messages
4138 -----*/
4141 {
4144 error++;
4149 }
4152 /*
4153 * Local globals pine's body output routine needs
4154 */
4159 /*
4160 * def to make our pipe write's more friendly
4161 */
4162 #ifdef PIPE_MAX
4163 #if PIPE_MAX > 20000
4164 #undef PIPE_MAX
4165 #endif
4166 #endif
4168 #ifndef PIPE_MAX
4169 #define PIPE_MAX 1024
4170 #endif
4173 /*
4174 * l_flust_net - empties gf_io terminal function's buffer
4175 */
4176 int
4178 {
4184 /*
4185 * The start of each write is expected to be the start of a
4186 * "record" (i.e., a CRLF terminated line). Make sure that is true
4187 * else we might screw up SMTP dot quoting...
4188 */
4192 ;
4199 ;
4202 /* snippet remains */
4205 }
4206 }
4215 if(lp && lp >= tmp_20k_buf && lp < tmp_20k_buf + SIZEOF_20KBUF && (*lp = c)) /* Shift text left? */
4218 }
4221 }
4224 /*
4225 * l_putc - gf_io terminal function that calls smtp's soutr_t function.
4226 *
4227 */
4228 int
4230 {
4235 }
4239 /*
4240 * pine_rfc822_output_body - pine's version of c-client call. Again,
4241 * necessary since c-client doesn't know about how
4242 * we're treating attachments
4243 */
4244 long
4246 {
4252 LOC_2022_JP ljp;
4253 gf_io_t gc;
4259 /* find cookie */
4264 /*
4265 * Output a bit of text before the first multipart delimiter
4266 * to warn unsuspecting users of non-mime-aware ua's that
4267 * they should expect weirdness. We do not add this when signing a
4268 * message, though...
4269 */
4270 #ifdef SMIME
4272 #endif
4273 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"))
4277 /* build cookie */
4280 /* append cookie,mini-hdr,contents */
4287 /* output trailing cookie */
4293 }
4296 }
4306 else
4309 /*
4310 * Don't add trailing line if it is ExternalText, which already guarantees
4311 * a trailing newline.
4312 */
4328 }
4335 }
4337 /* else, just send it? */
4339 }
4340 }
4341 }
4344 }
4346 /*
4347 * Convert text pieces to canonical form
4348 * BEFORE applying any encoding (rfc1341: appendix G)...
4349 * NOTE: almost all filters expect CRLF newlines
4350 */
4355 }
4368 }
4369 }
4375 }
4394 /*
4395 * BUG: If this name is not ascii it's going to cause trouble.
4396 */
4412 }
4417 }
4422 else
4424 }
4428 {
4436 }
4438 /*
4439 * pine_write_body_header - another c-client clone. This time
4440 * so the final encoding labels get set
4441 * correctly since it hasn't happened yet,
4442 * and to be paranoid about line lengths.
4443 *
4444 * Returns: TRUE/nonzero on success, zero on error
4445 */
4446 int
4448 {
4450 RFC822BUFFER rbuf;
4469 }
4479 ? ENCBASE64
4481 ? ENCQUOTEDPRINTABLE
4486 /*
4487 * If requested, strip Content-ID headers that don't look like they
4488 * are needed. Microsoft's Outlook XP has a bug that causes it to
4489 * not show that there is an attachment when there is a Content-ID
4490 * header present on that attachment.
4491 *
4492 * If user has quell-content-id turned on, don't output content-id
4493 * unless it is of type message/external-body.
4494 * Since this code doesn't look inside messages being forwarded
4495 * type message content-ids will remain as is and type multipart
4496 * alternative will remain as is. We don't create those on our
4497 * own. If we did, we'd have to worry about getting this right.
4498 */
4534 }
4539 }
4551 }
4553 /* copy out of so, a line at a time (or less than a K)
4554 * and send it down the pike
4555 */
4566 }
4568 /* Finally, write blank line */
4573 }
4576 }
4579 /*
4580 * pine_write_header - convert, encode (if needed) and
4581 * write "header-name: field-body"
4582 */
4583 int
4585 {
4601 }
4604 /*
4605 * pine_write_param - convert, encode and write MIME header-field parameters
4606 */
4607 int
4609 {
4625 }
4628 }
4632 int
4634 {
4640 /*
4641 * "comment out" the real values since our comment isn't
4642 * likely the same type, disposition nor encoding...
4643 */
4646 }
4649 }
4652 }
4655 int
4657 {
4664 }
4667 }
4671 int
4673 {
4678 }
4681 /*
4682 * pine_free_body - c-client call wrapper so the body data pointer we
4683 * we're using in a way c-client doesn't know about
4684 * gets free'd appropriately.
4685 */
4686 void
4688 {
4689 /*
4690 * Preempt c-client's contents.text.data clean up since we've
4691 * usurped it's meaning for our own purposes...
4692 */
4695 /* Then let c-client handle the rest... */
4697 }
4700 /*
4701 * pine_free_body_data - free pine's interpretations of the body part's
4702 * data pointer.
4703 */
4704 void
4706 {
4713 }
4716 }
4717 }
4720 long
4722 {
4732 }
4735 }
4738 int
4740 {
4744 }
4747 /*
4748 * pine_smtp_verbose_out - write
4749 */
4750 void
4752 {
4753 #ifdef _WINDOWS
4754 LPTSTR slpt;
4755 #endif
4762 else
4765 #ifdef _WINDOWS
4766 /*
4767 * The stream is opened in Unicode mode, so we need to fix the
4768 * argument to fputs.
4769 */
4774 }
4778 #else
4782 #endif
4783 }
4785 }
4788 /*
4789 * pine_header_forbidden - is this name a "forbidden" header?
4790 *
4791 * name - the header name to check
4792 * We don't allow user to change these.
4793 */
4794 int
4796 {
4824 NULL
4825 };
4832 }
4835 /*
4836 * hdr_is_in_list - is there a custom value for this header?
4837 *
4838 * hdr - the header name to check
4839 * custom - the list to check in
4840 * Returns 1 if there is a custom value, 0 otherwise.
4841 */
4842 int
4844 {
4852 }
4855 /*
4856 * count_custom_hdrs_pf - returns number of custom headers in arg
4857 * custom -- the list to be counted
4858 * only_nonstandard -- only count headers which aren't standard pine headers
4859 */
4860 int
4862 {
4867 ret++;
4870 }
4873 /*
4874 * count_custom_hdrs_list - returns number of custom headers in arg
4875 */
4876 int
4878 {
4889 /* remove leading whitespace */
4892 /* look for colon or space or end */
4900 ret++;
4903 }
4904 }
4905 }
4908 }
4911 /*
4912 * set_default_hdrval - put the user's default value for this header
4913 * into pf->textbuf.
4914 * setthis - the pinefield to be set
4915 * custom - where to look for the default
4916 */
4917 CustomType
4919 {
4926 }
4936 /* turn on editing */
4942 }
4948 }
4951 /*
4952 * pine_header_standard - is this name a "standard" header?
4953 *
4954 * name - the header name to check
4955 */
4956 FieldType
4958 {
4961 /* check to see if this is a standard header */
4967 }
4970 /*
4971 * customized_hdr_setup - setup the PINEFIELDS for all the customized headers
4972 * Allocates space for each name and addr ptr.
4973 * Allocates space for default in textbuf, even if empty.
4974 *
4975 * head - the first PINEFIELD to fill in
4976 * list - the list to parse
4977 */
4978 void
4980 {
4991 /* anything after leading whitespace? */
4995 /* look for colon or space or end */
5000 /* if there is a space in the field-name, skip it */
5004 name);
5006 }
5011 /* Don't allow any of the forbidden headers. */
5015 name);
5019 }
5030 #ifdef OLDWAY
5031 /*
5032 * Some mailers apparently break if we change
5033 * user@domain into Fred <user@domain> for
5034 * return-receipt-to,
5035 * so we'll just call this a FreeText field, too.
5036 */
5037 /*
5038 * For now, all custom headers are FreeText except for
5039 * this one that we happen to know about. We might
5040 * have to add some syntax to the config option so that
5041 * people can tell us their custom header takes addresses.
5042 */
5047 }
5052 /* remove space between name and colon */
5055 /* give them an alloc'd default, even if empty */
5061 pf++;
5062 }
5063 else
5065 }
5066 }
5067 }
5069 /* fix last next pointer */
5072 }
5075 /*
5076 * add_defaults_from_list - the PINEFIELDS list given by "head" is already
5077 * setup except that it doesn't have default values.
5078 * Add those defaults if they exist in "list".
5079 *
5080 * head - the first PINEFIELD to add a default to
5081 * list - the list to get the defaults from
5082 */
5083 void
5085 {
5097 /* anything after leading whitespace? */
5101 /* look for colon or space or end */
5106 /* if there is a space in the field-name, skip it */
5116 }
5120 /*
5121 * Found the right header. See if it has a default
5122 * value set.
5123 */
5125 /* remove space between name and colon */
5137 }
5138 }
5141 }
5142 }
5143 }
5144 }
5147 /*
5148 * parse_custom_hdrs - allocate PINEFIELDS for custom headers
5149 * fill in the defaults
5150 * Args - list -- The list to parse.
5151 * cstmtype -- Fill the in cstmtype field with this value
5152 */
5153 PINEFIELD *
5155 {
5159 /*
5160 * add one for possible use by fcc
5161 * What is this "possible use"? I don't see it. I don't
5162 * think it exists anymore. I think +1 would be ok. hubert 2000-08-02
5163 */
5168 /* set up the custom header pfields */
5172 }
5175 /*
5176 * Combine the two lists of headers into one list which is allocated here
5177 * and freed by the caller. Eliminate duplicates with values from the role
5178 * taking precedence over values from the default.
5179 */
5180 PINEFIELD *
5182 {
5201 pf++;
5202 }
5204 /* if these aren't already there, add them */
5206 /* check for already there */
5209 i++)
5210 ;
5220 pf++;
5221 }
5222 }
5224 /* fix last next pointer */
5229 }
5232 /*
5233 * free_customs - free misc. resources associated with custom header fields
5234 *
5235 * pf - pointer to first custom field
5236 */
5237 void
5239 {
5249 /* only true for FreeText */
5253 /* only true for Address */
5256 }
5259 }
5262 /*
5263 * encode_whole_header
5264 *
5265 * Returns 1 if whole value should be encoded
5266 * 0 to encode only within comments
5267 */
5268 int
5270 {
5277 retval++;
5282 retval++;
5284 }
5285 }
5286 }
5289 }
5292 /*----------------------------------------------------------------------
5293 Post news via NNTP or inews
5295 Args: env -- envelope of message to post
5296 body -- body of message to post
5298 Returns: -1 if failed or cancelled, 1 if succeeded
5300 WARNING: This call function has the side effect of writing the message
5301 to the lmc.so object.
5302 ----*/
5303 int
5306 {
5323 /*---------- NNTP server defined ----------*/
5329 /*
5330 * Install our rfc822 output routine
5331 */
5343 #ifdef DEBUG
5345 #else
5347 #endif
5353 /*
5354 * Fake that we've got clearance from the transport agent
5355 * for 8bit transport for the benefit of our output routines...
5356 */
5362 ;
5366 }
5372 }
5373 }
5375 /*
5376 * Set global header pointer so we can get at it later...
5377 */
5388 }
5397 }
5400 /*---- Open of NNTP connection failed ------ */
5406 }
5407 server_no++;
5408 }
5412 /*----- Post via local mechanism -------*/
5413 #ifdef _WINDOWS
5418 pipecb_f);
5419 #endif
5420 }
5431 }
5435 }
5438 /* ----------------------------------------------------------------------
5439 Figure out command to start local SMTP agent
5441 Args: errbuf -- buffer for reporting errors (assumed non-NULL)
5443 Returns an alloc'd copy of the local SMTP agent invocation or NULL
5445 ----*/
5448 {
5449 #ifdef _WINDOWS
5456 # if defined(SENDMAIL) && defined(SENDMAILFLAGS)
5462 # else
5465 # endif
5466 #endif
5469 }
5473 #ifndef _WINDOWS
5474 /*----------------------------------------------------------------------
5475 Hand off given message to local posting agent
5477 Args: envelope -- The envelope for the BCC and debugging
5478 header -- The text of the message header
5479 errbuf -- buffer for reporting errors (assumed non-NULL)
5480 len -- Length of errbuf
5482 ----*/
5483 int
5488 {
5489 #ifdef DF_SENDMAIL_PATH
5491 #endif
5494 /*
5495 * A bit of complicated policy implemented here.
5496 * There are two posting variables sendmail-path and smtp-server.
5497 * Precedence is in that order.
5498 * They can be set one of 4 ways: fixed, command-line, user, or globally.
5499 * Precedence is in that order.
5500 * Said differently, the order goes something like what's below.
5501 *
5502 * NOTE: the fixed/command-line/user precendence handling is also
5503 * indicated by what's pointed to by ps_global->VAR_*, but since
5504 * that also includes the global defaults, it's not sufficient.
5505 */
5510 }
5516 }
5526 else
5528 }
5536 }
5537 #ifdef DF_SENDMAIL_PATH
5538 /*
5539 * This defines the default method of posting. So,
5540 * unless we're told otherwise use it...
5541 */
5546 }
5547 #endif
5548 }
5549 }
5550 }
5558 }
5559 else
5561 }
5565 /*----------------------------------------------------------------------
5566 Hand off given message to local posting agent
5568 Args: envelope -- The envelope for the BCC and debugging
5569 header -- The text of the message header
5570 errbuf -- buffer for reporting errors (assumed non-NULL)
5571 errbuflen -- Length of errbuf
5573 Fork off mailer process and pipe the message into it
5574 Called to post news via Inews when NNTP is unavailable
5576 ----*/
5582 {
5584 #ifdef SENDNEWS
5596 }
5606 }
5610 /*----------------------------------------------------------------------
5611 Hand off message to local MTA; it parses recipients from 822 header
5613 Args: header -- struct containing header data
5614 body -- struct containing message body data
5615 cmd -- command to use for handoff (%s says where file should go)
5616 errs -- pointer to buf to hold errors
5618 ----*/
5623 {
5636 }
5642 }
5643 }
5644 else
5650 }
5653 }
5656 /*
5657 * pine_pipe_soutr - Replacement for tcp_soutr that writes one of our
5658 * pipes rather than a tcp stream
5659 */
5660 long
5662 {
5674 }
5675 }
5679 }
5687 }
5688 }
5689 else
5691 }
5694 }
5695 #endif
5698 /**************** "PIPE" READING POSTING I/O ROUTINES ****************/
5701 /*
5702 * helpful def's
5703 */
5704 #define S(X) ((PIPE_S *)(X))
5705 #define GETBUFLEN (4 * MAILTMPLEN)
5710 {
5721 }
5722 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
5727 }
5728 else
5732 }
5737 {
5739 }
5742 /*
5743 * piped_soutr - Replacement for tcp_soutr that writes one of our
5744 * pipes rather than a tcp stream
5745 */
5746 long
5748 {
5750 }
5753 /*
5754 * piped_sout - Replacement for tcp_soutr that writes one of our
5755 * pipes rather than a tcp stream
5756 */
5757 long
5759 {
5771 }
5772 }
5776 }
5777 }
5780 }
5783 /*
5784 * piped_getline - Replacement for tcp_getline that reads one
5785 * of our pipes rather than a tcp pipe
5786 *
5787 * C-client expects that the \r\n will be stripped off.
5788 */
5791 {
5801 /* alloc space to collect input (freed in close_system_pipe) */
5805 }
5812 }
5817 }
5820 }
5831 }
5833 n++;
5835 }
5836 /* copy partial string from buffer */
5838 /* get more data */
5846 }
5854 }
5855 }
5858 }
5861 ptr++;
5862 cnt--;
5864 }
5872 }
5875 }
5878 /*
5879 * piped_close - Replacement for tcp_close that closes pipes to our
5880 * child rather than a tcp connection
5881 */
5882 void
5884 {
5885 /*
5886 * Uninstall our hooks into smtp_send since it's being used by
5887 * the nntp driver as well...
5888 */
5890 }
5893 /*
5894 * piped_abort - close down the pipe we were using to post
5895 */
5896 void
5898 {
5902 }
5907 }
5908 }
5913 {
5915 }
5918 unsigned long
5920 {
5922 }