| blob | b01ff7e53616a85111f87ab450db1f164dab4781 |
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 }
1776 /* need to free new body from encrypt if sign fails? */
1784 }
1785 #endif
1787 /* set up counts and such to keep track sent percentage */
1795 #ifndef _WINDOWS
1797 /* try posting via local "<mta> <-t>" if specified */
1803 }
1805 #endif
1807 /*
1808 * If the user's asked for it, and we find that the first text
1809 * part (attachments all get b64'd) is non-7bit, ask for 8BITMIME.
1810 */
1814 #ifdef DEBUG
1815 #ifndef DEBUGJOURNAL
1817 #endif
1819 #endif
1829 /*
1830 * If it isn't Never, then we're always going to let them
1831 * know about failures. This means we don't allow for the
1832 * possibility of setting delay or success without failure.
1833 */
1838 }
1839 }
1842 /*
1843 * Set global header pointer so post_rfc822_output can get at it when
1844 * it's called back from c-client's sending routine...
1845 */
1848 /*
1849 * Fabricate a fake ENVELOPE to hand c-client's SMTP engine.
1850 * The purpose is to give smtp_mail the list for SMTP RCPT when
1851 * there are recipients in pine's METAENV that are outside c-client's
1852 * envelope.
1853 *
1854 * NOTE: If there aren't any, don't bother. Dealt with it below.
1855 */
1874 }
1875 }
1877 /*
1878 * Install our rfc822 output routine
1879 */
1883 /*
1884 * Allow for verbose posting
1885 */
1889 /*
1890 * We do this because we want mm_log to put the error message into
1891 * c_client_error instead of showing it itself.
1892 */
1895 /*
1896 * OK, who posts what? We tried an mta_handoff above, but there
1897 * was either none specified or we decided not to use it. So,
1898 * if there's an smtp-server defined anywhere,
1899 */
1901 /*---------- SMTP ----------*/
1906 }
1909 /*---------- SMTP ----------*/
1913 }
1914 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
1917 /*----- Send via LOCAL SMTP agent ------*/
1926 /* BUG: should provide separate stderr output! */
1927 }
1951 }
1952 }
1958 }
1959 }
1964 }
1967 }
1969 /*
1970 * Before we actually send data, see if we have to protect
1971 * the first text body part from getting encoded. We protect
1972 * it from getting encoded in "pine_rfc822_output_body" by
1973 * temporarily inventing a synonym for ENC8BIT...
1974 * This works like so:
1975 * Suppose bp->encoding is set to ENC8BIT.
1976 * We change that here to some unused value (added_encoding) and
1977 * set body_encodings[added_encoding] to "8BIT".
1978 * Then post_rfc822_output is called which calls
1979 * pine_rfc822_output_body. Inside that routine
1980 * pine_write_body_header writes out the encoding for the
1981 * part. Normally it would see encoding == ENC8BIT and it would
1982 * change that to QUOTED-PRINTABLE, but since encoding has been
1983 * set to added_encoding it uses body_encodings[added_encoding]
1984 * which is "8BIT" instead. Then the actual body is written by
1985 * pine_write_body_header which does not do the gf_8bit_qp
1986 * filtering because encoding != ENC8BIT (instead it's equal
1987 * to added_encoding).
1988 */
1994 ;
1998 }
2004 #ifdef SMIME
2013 body->nested.part->next->body.contents.text.data = body->nested.part->next->body.mime.text.data;
2015 }
2017 }
2018 }
2043 /*
2044 * Too complicated to figure out which header line
2045 * has the error in the fake_env case, so just
2046 * leave cursor at default.
2047 */
2056 }
2060 }
2061 }
2075 }
2079 }
2080 }
2084 }
2086 /* repair modified "body_encodings" array? */
2091 }
2097 }
2103 }
2116 }
2119 }
2121 /*
2122 * Restore original 822 emitter...
2123 */
2129 done:
2131 #ifdef SMIME
2132 /* Free replacement encrypted body */
2136 /* Just get rid of first part, it's actually origBody */
2142 }
2145 }
2146 #endif
2152 /*-------- Did message make it ? ----------*/
2154 /*---- Error sending mail -----*/
2161 }
2164 }
2168 }
2169 }
2172 /*
2173 * write_postponed - exported method to write the given message
2174 * to the postponed folder
2175 */
2176 int
2178 {
2190 }
2199 /* BUG: writem sufficient ? */
2206 }
2208 /*
2209 * Work around c-client reply-to bug. C-client will
2210 * return a reply_to in an envelope even if there is
2211 * no reply-to header field. We want to note here whether
2212 * the reply-to is real or not.
2213 */
2221 else
2223 }
2225 /*
2226 * Write the list of custom headers to the
2227 * X-Our-Headers header so that we can recover the
2228 * list in redraft.
2229 */
2239 ;
2246 /* note: "pf" overloaded */
2251 r--;
2253 }
2256 }
2257 }
2264 }
2270 }
2274 }
2277 int
2279 {
2284 }
2285 else
2289 }
2292 int
2294 {
2306 }
2309 }
2312 }
2315 }
2318 }
2321 /*----------------------------------------------------------------------
2322 Checks to make sure the fcc is available and can be opened
2324 Args: fcc -- the name of the fcc to create. It can't be NULL.
2325 fcc_cntxt -- Returns the context the fcc is in.
2326 force -- supress user option prompt
2328 Returns allocated storage object on success, NULL on failure
2329 ----*/
2330 STORE_S *
2332 {
2337 /*
2338 * check for fcc's existance...
2339 */
2345 /*
2346 * Don't want to preclude a user from Fcc'ing a .name'd folder
2347 */
2351 }
2353 /*
2354 * We only want to set the "context" if fcc is an ambiguous
2355 * name. Otherwise, our "relativeness" rules for contexts
2356 * (implemented in context.c) might cause the name to be
2357 * interpreted in the wrong context...
2358 */
2365 || (pith_opt_save_create_prompt
2371 ok++;
2374 }
2375 else
2377 }
2378 else
2385 }
2388 ok++;
2389 }
2392 || (pith_opt_save_create_prompt
2401 }
2402 else
2404 }
2405 }
2410 }
2430 s1,
2434 s2);
2437 }
2438 else
2440 }
2441 else
2445 }
2448 }
2451 /*----------------------------------------------------------------------
2452 mail_append() the fcc accumulated in temp_storage to proper destination
2454 Args: fcc -- name of folder
2455 fcc_cntxt -- context for folder
2456 temp_storage -- String of file where Fcc has been accumulated
2458 This copies the string of file to the actual folder, which might be IMAP
2459 or a disk folder. The temp_storage is freed after it is written.
2460 An error message is produced if this fails.
2461 ----*/
2462 int
2465 {
2466 STRING msg;
2482 }
2483 else
2488 /*
2489 * Before changing this note that these lines depend on the
2490 * definition of FCC_SOURCE.
2491 */
2507 }
2515 }
2518 /*
2519 * first_text_8bit - return TRUE if somewhere in the body 8BIT data's
2520 * contained.
2521 */
2522 BODY *
2524 {
2530 }
2533 /*
2534 * Build and return the "From:" address for outbound messages from
2535 * global data...
2536 */
2537 ADDRESS *
2539 {
2546 }
2553 }
2556 /*
2557 * set_mime_type_by_grope - sniff the given storage object to determine its
2558 * type, subtype, encoding, and charset
2559 *
2560 * "Type" and "encoding" must be set before calling this routine.
2561 * If "type" is set to something other than TYPEOTHER on entry,
2562 * then that is the "type" we wish to use. Same for "encoding"
2563 * using ENCOTHER instead of TYPEOTHER. Otherwise, we
2564 * figure them out here. If "type" is already set, we also
2565 * leave subtype alone. If not, we figure out subtype here.
2566 * There is a chance that we will upgrade encoding to a "higher"
2567 * level. For example, if it comes in as 7BIT we may change
2568 * that to 8BIT if we find a From_ we want to escape.
2569 * We may also set the charset attribute if the type is TEXT.
2570 *
2571 * NOTE: this is rather inefficient if the store object is a CharStar
2572 * but the win is all types are handled the same
2573 */
2574 void
2576 {
2577 #define RBUFSZ (8193)
2587 #ifdef ENCODE_FROMS
2590 #endif
2598 ;
2607 }
2613 }
2618 }
2623 }
2627 }
2631 }
2636 }
2641 }
2643 /*
2644 * if type was set above, but no encoding specified, go
2645 * ahead and make it BASE64...
2646 */
2649 }
2650 }
2652 /* PROBLEM !!! */
2658 }
2659 }
2665 #endif
2670 /* Some people don't like quoted-printable caused by leading Froms */
2671 #ifdef ENCODE_FROMS
2673 #endif
2678 #if defined(DOS) || defined(OS2)
2679 /* LF with no CR!! */
2682 #endif
2683 }
2685 eight_bit_chars++;
2686 }
2688 /* NULL found. Unless we're told otherwise, must be binary */
2692 }
2694 /*
2695 * The "TYPETEXT" here handles the case that the NULL
2696 * comes from imported text generated by some external
2697 * editor that permits or inserts NULLS. Otherwise,
2698 * assume it's a binary segment...
2699 */
2702 /*
2703 * Since we've already set encoding, count this as a
2704 * hi bit char and continue. The reason is that if this
2705 * is text, there may be a high percentage of encoded
2706 * characters, so base64 may get set below...
2707 */
2709 eight_bit_chars++;
2710 else
2712 }
2717 #endif
2719 /* read another buffer in */
2725 ;
2729 }
2730 else
2731 p++;
2733 /*
2734 * If there's no beginning-of-line pointer, then we must
2735 * have seen an end-of-line. Set bol to the start of the
2736 * new line...
2737 */
2742 /* either a lone \r or lone \n indicate binary file */
2748 }
2752 }
2753 }
2754 #endif
2755 }
2756 }
2758 /* stash away for later */
2762 /*
2763 * Since the type or encoding aren't set yet, fall thru a
2764 * series of tests to make sure an adequate type and
2765 * encoding are set...
2766 */
2770 /*
2771 * Since the types not set, then we didn't find a NULL.
2772 * If there's no NULL, then this is likely text. However,
2773 * since we can't be *completely* sure, we set it to
2774 * the generic type.
2775 */
2778 }
2781 /*
2782 * As with NULL handling, if we're told it's text,
2783 * qp-encode it, else it gets base 64...
2784 */
2786 }
2794 }
2796 /*
2797 * The 30% threshold is based on qp encoded readability
2798 * on non-MIME UA's.
2799 */
2805 }
2810 }
2812 /*
2813 * Apply maximal encoding regardless of previous
2814 * setting. This segment's either not text, or is
2815 * unlikely to be readable with > 30% of the
2816 * text encoded anyway, so we might as well save space...
2817 */
2819 }
2820 }
2822 #ifdef ENCODE_FROMS
2823 /* If there were From_'s at the beginning of a line or standalone dots */
2826 #endif
2828 /* Set the subtype */
2839 }
2842 /*
2843 * Call this to set the charset of an attachment we have
2844 * created. If the attachment contains any non-ascii characters
2845 * then we'll set the charset to the passed in charset, otherwise
2846 * we'll make it us-ascii.
2847 */
2848 void
2850 {
2865 can_be_ascii--;
2872 /*
2873 * Else we don't know. There are non ascii characters but we either
2874 * don't have a charset to set it to or that charset is just us_ascii,
2875 * which is impossible. So we label it unknown. An alternative would
2876 * have been to strip the high bits instead and label it ascii.
2877 */
2879 }
2883 }
2886 /*
2887 * since encoding happens on the way out the door, this is basically
2888 * just needed to handle TYPEMULTIPART
2889 */
2890 void
2892 {
2907 }
2918 /*
2919 * If the part is text we edited, then it is UTF-8.
2920 * The user may be asking us to send it as something else
2921 * or we may want to downconvert to a more-specific characterset.
2922 * Mark it for conversion here so the right MIME header's written.
2923 * Do conversion pine_rfc822_output_body.
2924 * Attachments are left as is.
2925 */
2936 /*
2937 * Fix iso-2022-jp encoding to ENC7BIT since it's escape based
2938 * and doesn't use anything but ASCII characters.
2939 * Why is it not ENC7BIT already? Because when we set the encoding
2940 * in set_mime_type_by_grope we were groping through UTF-8 text
2941 * not 2022 text. Not only that, but we didn't know at that point
2942 * that it wouldn't stay UTF-8 when we sent it, which would require
2943 * encoding.
2944 */
2949 }
2953 }
2958 /* Encapsulated messages are always treated as text objects at this point.
2959 This means that you must replace body->contents.msg with
2960 body->contents.text, which probably involves copying
2961 body->contents.msg.text to body->contents.text */
2963 /*
2964 * but we'll delay encoding it until the message is on the way
2965 * into the mail slot...
2966 */
2968 }
2969 }
2972 /*
2973 * pine_header_line - simple wrapper around c-client call to contain
2974 * repeated code, and to write fcc if required.
2975 */
2976 int
2979 {
2993 else
3012 /*
3013 * We were folding everything except message-id, but that wasn't
3014 * sufficient. Since 822 only allows folding where linear-white-space
3015 * is allowed we'd need a smarter folder than "fold" to do it. So,
3016 * instead of inventing that smarter folder (which would have to
3017 * know 822 syntax)
3018 *
3019 * We could just alloc space and copy the actual_field followed by
3020 * the value into it, but since that's what fold does anyway we'll
3021 * waste some cpu time and use fold with a big fold parameter.
3022 *
3023 * We upped the references folding from 75 to 256 because we were
3024 * encountering longer-than-75 message ids, and to break one line
3025 * in references is to break them all.
3026 */
3031 else
3038 }
3040 RFC822BUFFER rbuf;
3043 /*
3044 * rfc1522_encode already inserted continuation lines and did
3045 * the necessary folding so we don't have to do it. Let
3046 * rfc822_header_line add the trailing crlf and the resent- if
3047 * necessary. The 20 could actually be a 12.
3048 */
3060 }
3068 }
3075 }
3076 else
3080 }
3083 /*
3084 * Do appropriate encoding of text header lines.
3085 * For some field types (those that consist of 822 *text) we just encode
3086 * the whole thing. For structured fields we encode only within comments
3087 * if possible.
3088 *
3089 * Args d -- Destination buffer if needed. (tmp_20k_buf)
3090 * s -- Source string.
3091 * charset -- Charset to encode with.
3092 * encode_all -- If set, encode the whole string. If not, try to encode
3093 * only within comments if possible.
3094 *
3095 * Returns S is returned if no encoding is done. D is returned if encoding
3096 * was needed.
3097 */
3100 {
3111 /*
3112 * We don't have to worry about keeping track of quoted-strings because
3113 * none of these fields which aren't addresses contain quoted-strings.
3114 * We do keep track of escaped parens inside of comments and comment
3115 * nesting.
3116 */
3128 /* encode the comment, excluding the outer parens */
3135 charset);
3146 }
3151 }
3160 }
3161 }
3170 }
3171 }
3174 /* Unterminated comment (wasn't really a comment) */
3179 }
3180 }
3182 /*
3183 * We have to check if there is anything that needs to be encoded that
3184 * wasn't in a comment. If there is, we'd better just start over and
3185 * encode the whole thing. So, if no encoding has been done within
3186 * comments, or if encoding is needed both within and outside of
3187 * comments, then we encode the whole thing. Otherwise, go with
3188 * the version that has only comments encoded.
3189 */
3197 }
3198 }
3201 /*
3202 * pine_address_line - write a header field containing addresses,
3203 * one by one (so there's no buffer limit), and
3204 * wrapping where necessary.
3205 * Note: we use c-client functions to properly build the text string,
3206 * but have to screw around with pointers to fool c-client functions
3207 * into not blatting all the text into a single buffer. Yeah, I know.
3208 */
3209 int
3212 {
3220 RFC822BUFFER rbuf;
3223 #define no_comma (&comma[1])
3229 in_group++;
3230 was_start_of_group++;
3231 /* encode mailbox of group */
3242 }
3244 failed++;
3246 }
3247 }
3248 }
3249 else
3253 /* make sure personal name is encoded */
3263 }
3265 failed++;
3267 }
3268 }
3273 /* use automatic buffer unless it isn't big enough */
3277 }
3281 }
3304 }
3309 }
3311 /*
3312 * If there is no sending_stream and we are writing the Lcc header,
3313 * then we are piping it to sendmail -t which expects it to be a bcc,
3314 * not lcc.
3315 *
3316 * When we write it to the fcc or postponed (the lmc.so),
3317 * we want it to be lcc, not bcc, so we put it back.
3318 */
3332 }
3340 /* account for c-client's representation of group names */
3345 /*
3346 * Rfc822_write_address no longer writes out the end of group
3347 * unless the whole group address is passed to it, so we do
3348 * it ourselves.
3349 */
3351 }
3354 }
3355 /* start of new group, print phrase below */
3357 in_group++;
3358 was_start_of_group++;
3359 }
3361 /* no comma before first address in group syntax */
3365 }
3367 /* write delimiter */
3382 }
3384 failed++;
3386 }
3394 }
3397 /* make sure we don't write out group end with rfc822_write_address */
3406 }
3415 /*
3416 * BUG
3417 * With group syntax addresses we no longer have two identical
3418 * streams of output. Instead, for the fcc/postpone copy we include
3419 * all of the addresses inside the :; of the group, and for the
3420 * mail we're sending we don't include them. That means we aren't
3421 * correctly keeping track of the column to wrap in, below. That is,
3422 * we are keeping track of the fcc copy but we aren't keeping track
3423 * of the regular copy. It could result in too long or too short
3424 * lines. Should almost never come up since group addresses are almost
3425 * never followed by other addresses in the same header, and even
3426 * when they are, you have to go out of your way to get the headers
3427 * messed up.
3428 */
3435 }
3436 else
3444 }
3446 bail_out:
3456 }
3459 /*
3460 * mutated pine version of c-client's rfc822_header() function.
3461 * changed to call pine-wrapped header and address functions
3462 * so we don't have to limit the header size to a fixed buffer.
3463 * This function also calls pine's body_header write function
3464 * because encoding is delayed until output_body() is called.
3465 */
3466 long
3468 {
3481 }
3486 /*
3487 * Warning: This is confusing. The 2nd to last argument used to
3488 * be just pf->writehdr. We want Bcc lines to be written out
3489 * if we are handing off to a sendmail temp file but not if we
3490 * are talking smtp, so bcc's writehdr is set to 0 and
3491 * pine_address_line was sending if writehdr OR !sending_stream.
3492 * That works as long as we want to write everything when
3493 * !sending_stream (an mta handoff to sendmail). But then we
3494 * added the undisclosed recipients line which should only get
3495 * written if writehdr is set, and not when we pass to a
3496 * sendmail temp file. So pine_address_line has been changed
3497 * so it bases its decision solely on the writehdr passed to it,
3498 * and the logic that worries about Bcc and sending_stream
3499 * was moved up to the caller (here) to decide when to set it.
3500 *
3501 * So we have:
3502 * undisclosed recipients:; This will just be written
3503 * if writehdr was set and not
3504 * otherwise, nothing magical.
3505 *** We may want to change this, because sendmail -t doesn't handle
3506 *** the empty group syntax well unless it has been configured to
3507 *** do so. It isn't configured by default, or in any of the
3508 *** sendmail v8 configs. So we may want to not write this line
3509 *** if we're doing an mta_handoff (!sending_stream).
3510 *
3511 * !sending_stream (which means a handoff to a sendmail -t)
3512 * bcc or lcc both set the arg so they'll get written
3513 * (There is also Lcc hocus pocus in pine_address_line
3514 * which converts the Lcc: to Bcc: for sendmail
3515 * processing.)
3516 * sending_stream (which means an smtp handoff)
3517 * bcc and lcc will never have writehdr set, so
3518 * will never be written (They both do have rcptto set,
3519 * so they both do cause RCPT TO commands.)
3520 *
3521 * The localcopy is independent of sending_stream and is just
3522 * written if it is set for all of these.
3523 */
3526 header,
3528 f,
3529 s,
3532 ? !sending_stream
3553 }
3554 }
3557 #if (defined(DOS) || defined(OS2)) && !defined(NOAUTH)
3558 /*
3559 * Add comforting "X-" header line indicating what sort of
3560 * authenticity the receiver can expect...
3561 */
3563 NETMBX netmbox;
3574 }
3589 }
3594 }
3598 }
3599 #endif
3606 }
3611 }
3614 }
3617 /*
3618 * pine_rfc822_output - pine's version of c-client call. Necessary here
3619 * since we're not using its structures as intended!
3620 */
3621 long
3623 {
3631 /* build and output RFC822 header, output body */
3639 }
3642 /*
3643 * post_rfc822_output - cloak for pine's 822 output routine. Since
3644 * we can't pass opaque envelope thru c-client posting
3645 * logic, we need to wrap the real output inside
3646 * something that c-client knows how to call.
3647 */
3648 long
3652 soutr_t f,
3655 {
3657 }
3660 /*
3661 * posting_characterset- determine what transliteration is reasonable
3662 * for posting the given non-ascii messsage data.
3663 *
3664 * preferred_charset is the charset the original data was labeled in.
3665 * If we can keep that we do.
3666 *
3667 * Returns: always returns the preferred character set.
3668 */
3671 {
3687 /* convert text in header to UCS characters */
3694 /*
3695 * After the while loop is done the validbitmap has
3696 * a 1 bit for all the character sets that can
3697 * represent all of the characters of this header.
3698 */
3709 }
3712 }
3721 }
3727 UCS ucs;
3728 CBUF_S cbuf;
3754 /*
3755 * Read a stream of UTF-8 characters from the_text
3756 * and convert them to UCS-4 characters for the translatable
3757 * test.
3758 */
3761 /* got a ucs character */
3766 }
3767 }
3774 }
3776 /* user chooses something other than UTF-8 */
3778 /*
3779 * If we're to post in other than UTF-8, and it can be
3780 * transliterated without losing fidelity, do it.
3781 * Else, use UTF-8.
3782 */
3784 /* if ascii works, always use that */
3788 /* does the user's posting character set work? */
3792 /* this is the charset the message we are replying to was in */
3798 /* else, use UTF-8 */
3800 }
3801 /* user chooses nothing, going with the default */
3807 /*
3808 * In this case the user didn't specify a posting character set
3809 * and we will choose the most-specific one from our list.
3810 */
3812 /* ascii is best */
3816 /* Can we keep the original from the message we're replying to? */
3822 /* choose the best of the rest */
3827 /*
3828 * If the text we're labeling contains something like
3829 * smart quotes but no CJK characters, then instead of
3830 * labeling it as ISO-2022-JP we want to use UTF-8.
3831 */
3842 }
3845 }
3846 /* user explicitly chooses UTF-8 */
3848 /* if ascii works, always use that */
3852 /* else, use UTF-8 */
3854 }
3855 }
3858 }
3880 "EUC-KR"
3881 };
3886 {
3891 /*
3892 * When user doesn't set a posting character set posting_charmap ends up
3893 * set to UTF-8. That also happens if user sets UTF-8 explicitly.
3894 * That's where the strange set of if-else's come from.
3895 */
3897 /* user chooses something other than UTF-8 */
3901 reset++;
3903 /* if posting_charmap is valid, include it in list */
3908 count++;
3912 reset++;
3913 }
3919 count++;
3923 reset++;
3924 }
3927 reset++;
3952 }
3953 }
3954 /* user chooses nothing, going with the default */
3960 /* does preferred_charset have to be added to the list? */
3966 }
3969 /* existing list is right size already */
3971 /* just check to see if last list item is the preferred_charset */
3973 /* no, fix it */
3974 reset++;
3977 }
3978 }
3980 reset++;
3992 }
3993 }
3995 /* if list is same size as downgrades, consider it good */
3997 reset++;
4010 }
4011 }
4012 }
4013 /* user explicitly chooses UTF-8 */
4015 /* include possibility of ascii even if they explicitly ask for UTF-8 */
4018 reset++;
4021 reset++;
4027 /* the list is just ascii and nothing else */
4034 }
4035 }
4044 }
4047 }
4050 /* total reset */
4051 void
4053 {
4061 }
4064 int
4066 {
4080 done++;
4083 }
4084 }
4087 }
4092 {
4100 /* careful, find_rightmost_bit modifies the bitmap */
4106 }
4109 /*
4110 * Set parameter to new value.
4111 */
4112 void
4114 {
4123 }
4136 }
4137 /* else pm is existing paramname parameter */
4138 }
4147 }
4148 }
4149 }
4152 /*----------------------------------------------------------------------
4153 Remove the leading digits from SMTP error messages
4154 -----*/
4157 {
4160 error++;
4165 }
4168 /*
4169 * Local globals pine's body output routine needs
4170 */
4175 /*
4176 * def to make our pipe write's more friendly
4177 */
4178 #ifdef PIPE_MAX
4179 #if PIPE_MAX > 20000
4180 #undef PIPE_MAX
4181 #endif
4182 #endif
4184 #ifndef PIPE_MAX
4185 #define PIPE_MAX 1024
4186 #endif
4189 /*
4190 * l_flust_net - empties gf_io terminal function's buffer
4191 */
4192 int
4194 {
4200 /*
4201 * The start of each write is expected to be the start of a
4202 * "record" (i.e., a CRLF terminated line). Make sure that is true
4203 * else we might screw up SMTP dot quoting...
4204 */
4208 ;
4215 ;
4218 /* snippet remains */
4221 }
4222 }
4231 if(lp && lp >= tmp_20k_buf && lp < tmp_20k_buf + SIZEOF_20KBUF && (*lp = c)) /* Shift text left? */
4234 }
4237 }
4240 /*
4241 * l_putc - gf_io terminal function that calls smtp's soutr_t function.
4242 *
4243 */
4244 int
4246 {
4251 }
4255 /*
4256 * pine_rfc822_output_body - pine's version of c-client call. Again,
4257 * necessary since c-client doesn't know about how
4258 * we're treating attachments
4259 */
4260 long
4262 {
4269 LOC_2022_JP ljp;
4270 gf_io_t gc;
4279 /* find cookie */
4284 /*
4285 * Output a bit of text before the first multipart delimiter
4286 * to warn unsuspecting users of non-mime-aware ua's that
4287 * they should expect weirdness. We do not add this when signing a
4288 * message, though...
4289 */
4290 #ifdef SMIME
4292 #endif
4293 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"))
4297 /* build cookie */
4300 /* append cookie,mini-hdr,contents */
4307 /* output trailing cookie */
4310 #ifdef SMIME
4314 #endif
4318 }
4321 }
4331 else
4334 /*
4335 * Don't add trailing line if it is ExternalText, which already guarantees
4336 * a trailing newline.
4337 */
4353 }
4360 }
4362 /* else, just send it? */
4364 }
4365 }
4366 }
4369 }
4371 /*
4372 * Convert text pieces to canonical form
4373 * BEFORE applying any encoding (rfc1341: appendix G)...
4374 * NOTE: almost all filters expect CRLF newlines
4375 */
4380 }
4393 }
4394 }
4400 }
4419 /*
4420 * BUG: If this name is not ascii it's going to cause trouble.
4421 */
4437 }
4442 }
4447 else
4449 }
4453 {
4461 }
4463 /*
4464 * pine_write_body_header - another c-client clone. This time
4465 * so the final encoding labels get set
4466 * correctly since it hasn't happened yet,
4467 * and to be paranoid about line lengths.
4468 *
4469 * Returns: TRUE/nonzero on success, zero on error
4470 */
4471 int
4473 {
4475 RFC822BUFFER rbuf;
4494 }
4504 ? ENCBASE64
4506 ? ENCQUOTEDPRINTABLE
4511 /*
4512 * If requested, strip Content-ID headers that don't look like they
4513 * are needed. Microsoft's Outlook XP has a bug that causes it to
4514 * not show that there is an attachment when there is a Content-ID
4515 * header present on that attachment.
4516 *
4517 * If user has quell-content-id turned on, don't output content-id
4518 * unless it is of type message/external-body.
4519 * Since this code doesn't look inside messages being forwarded
4520 * type message content-ids will remain as is and type multipart
4521 * alternative will remain as is. We don't create those on our
4522 * own. If we did, we'd have to worry about getting this right.
4523 */
4559 }
4564 }
4576 }
4578 /* copy out of so, a line at a time (or less than a K)
4579 * and send it down the pike
4580 */
4591 }
4593 /* Finally, write blank line */
4598 }
4601 }
4604 /*
4605 * pine_write_header - convert, encode (if needed) and
4606 * write "header-name: field-body"
4607 */
4608 int
4610 {
4626 }
4629 /*
4630 * pine_write_param - convert, encode and write MIME header-field parameters
4631 */
4632 int
4634 {
4650 }
4653 }
4657 int
4659 {
4665 /*
4666 * "comment out" the real values since our comment isn't
4667 * likely the same type, disposition nor encoding...
4668 */
4671 }
4674 }
4677 }
4680 int
4682 {
4689 }
4692 }
4696 int
4698 {
4703 }
4706 /*
4707 * pine_free_body - c-client call wrapper so the body data pointer we
4708 * we're using in a way c-client doesn't know about
4709 * gets free'd appropriately.
4710 */
4711 void
4713 {
4714 /*
4715 * Preempt c-client's contents.text.data clean up since we've
4716 * usurped it's meaning for our own purposes...
4717 */
4720 /* Then let c-client handle the rest... */
4722 }
4725 /*
4726 * pine_free_body_data - free pine's interpretations of the body part's
4727 * data pointer.
4728 */
4729 void
4731 {
4738 }
4741 }
4742 }
4745 long
4747 {
4757 }
4760 }
4763 int
4765 {
4769 }
4772 /*
4773 * pine_smtp_verbose_out - write
4774 */
4775 void
4777 {
4778 #ifdef _WINDOWS
4779 LPTSTR slpt;
4780 #endif
4787 else
4790 #ifdef _WINDOWS
4791 /*
4792 * The stream is opened in Unicode mode, so we need to fix the
4793 * argument to fputs.
4794 */
4799 }
4803 #else
4807 #endif
4808 }
4810 }
4813 /*
4814 * pine_header_forbidden - is this name a "forbidden" header?
4815 *
4816 * name - the header name to check
4817 * We don't allow user to change these.
4818 */
4819 int
4821 {
4849 NULL
4850 };
4857 }
4860 /*
4861 * hdr_is_in_list - is there a custom value for this header?
4862 *
4863 * hdr - the header name to check
4864 * custom - the list to check in
4865 * Returns 1 if there is a custom value, 0 otherwise.
4866 */
4867 int
4869 {
4877 }
4880 /*
4881 * count_custom_hdrs_pf - returns number of custom headers in arg
4882 * custom -- the list to be counted
4883 * only_nonstandard -- only count headers which aren't standard pine headers
4884 */
4885 int
4887 {
4892 ret++;
4895 }
4898 /*
4899 * count_custom_hdrs_list - returns number of custom headers in arg
4900 */
4901 int
4903 {
4914 /* remove leading whitespace */
4917 /* look for colon or space or end */
4925 ret++;
4928 }
4929 }
4930 }
4933 }
4936 /*
4937 * set_default_hdrval - put the user's default value for this header
4938 * into pf->textbuf.
4939 * setthis - the pinefield to be set
4940 * custom - where to look for the default
4941 */
4942 CustomType
4944 {
4951 }
4961 /* turn on editing */
4967 }
4973 }
4976 /*
4977 * pine_header_standard - is this name a "standard" header?
4978 *
4979 * name - the header name to check
4980 */
4981 FieldType
4983 {
4986 /* check to see if this is a standard header */
4992 }
4995 /*
4996 * customized_hdr_setup - setup the PINEFIELDS for all the customized headers
4997 * Allocates space for each name and addr ptr.
4998 * Allocates space for default in textbuf, even if empty.
4999 *
5000 * head - the first PINEFIELD to fill in
5001 * list - the list to parse
5002 */
5003 void
5005 {
5016 /* anything after leading whitespace? */
5020 /* look for colon or space or end */
5025 /* if there is a space in the field-name, skip it */
5029 name);
5031 }
5036 /* Don't allow any of the forbidden headers. */
5040 name);
5044 }
5055 #ifdef OLDWAY
5056 /*
5057 * Some mailers apparently break if we change
5058 * user@domain into Fred <user@domain> for
5059 * return-receipt-to,
5060 * so we'll just call this a FreeText field, too.
5061 */
5062 /*
5063 * For now, all custom headers are FreeText except for
5064 * this one that we happen to know about. We might
5065 * have to add some syntax to the config option so that
5066 * people can tell us their custom header takes addresses.
5067 */
5072 }
5077 /* remove space between name and colon */
5080 /* give them an alloc'd default, even if empty */
5086 pf++;
5087 }
5088 else
5090 }
5091 }
5092 }
5094 /* fix last next pointer */
5097 }
5100 /*
5101 * add_defaults_from_list - the PINEFIELDS list given by "head" is already
5102 * setup except that it doesn't have default values.
5103 * Add those defaults if they exist in "list".
5104 *
5105 * head - the first PINEFIELD to add a default to
5106 * list - the list to get the defaults from
5107 */
5108 void
5110 {
5122 /* anything after leading whitespace? */
5126 /* look for colon or space or end */
5131 /* if there is a space in the field-name, skip it */
5141 }
5145 /*
5146 * Found the right header. See if it has a default
5147 * value set.
5148 */
5150 /* remove space between name and colon */
5162 }
5163 }
5166 }
5167 }
5168 }
5169 }
5172 /*
5173 * parse_custom_hdrs - allocate PINEFIELDS for custom headers
5174 * fill in the defaults
5175 * Args - list -- The list to parse.
5176 * cstmtype -- Fill the in cstmtype field with this value
5177 */
5178 PINEFIELD *
5180 {
5184 /*
5185 * add one for possible use by fcc
5186 * What is this "possible use"? I don't see it. I don't
5187 * think it exists anymore. I think +1 would be ok. hubert 2000-08-02
5188 */
5193 /* set up the custom header pfields */
5197 }
5200 /*
5201 * Combine the two lists of headers into one list which is allocated here
5202 * and freed by the caller. Eliminate duplicates with values from the role
5203 * taking precedence over values from the default.
5204 */
5205 PINEFIELD *
5207 {
5226 pf++;
5227 }
5229 /* if these aren't already there, add them */
5231 /* check for already there */
5234 i++)
5235 ;
5245 pf++;
5246 }
5247 }
5249 /* fix last next pointer */
5254 }
5257 /*
5258 * free_customs - free misc. resources associated with custom header fields
5259 *
5260 * pf - pointer to first custom field
5261 */
5262 void
5264 {
5274 /* only true for FreeText */
5278 /* only true for Address */
5281 }
5284 }
5287 /*
5288 * encode_whole_header
5289 *
5290 * Returns 1 if whole value should be encoded
5291 * 0 to encode only within comments
5292 */
5293 int
5295 {
5302 retval++;
5307 retval++;
5309 }
5310 }
5311 }
5314 }
5317 /*----------------------------------------------------------------------
5318 Post news via NNTP or inews
5320 Args: env -- envelope of message to post
5321 body -- body of message to post
5323 Returns: -1 if failed or cancelled, 1 if succeeded
5325 WARNING: This call function has the side effect of writing the message
5326 to the lmc.so object.
5327 ----*/
5328 int
5331 {
5348 /*---------- NNTP server defined ----------*/
5354 /*
5355 * Install our rfc822 output routine
5356 */
5368 #ifdef DEBUG
5370 #else
5372 #endif
5378 /*
5379 * Fake that we've got clearance from the transport agent
5380 * for 8bit transport for the benefit of our output routines...
5381 */
5387 ;
5391 }
5397 }
5398 }
5400 /*
5401 * Set global header pointer so we can get at it later...
5402 */
5413 }
5422 }
5425 /*---- Open of NNTP connection failed ------ */
5431 }
5432 server_no++;
5433 }
5437 /*----- Post via local mechanism -------*/
5438 #ifdef _WINDOWS
5443 pipecb_f);
5444 #endif
5445 }
5456 }
5460 }
5463 /* ----------------------------------------------------------------------
5464 Figure out command to start local SMTP agent
5466 Args: errbuf -- buffer for reporting errors (assumed non-NULL)
5468 Returns an alloc'd copy of the local SMTP agent invocation or NULL
5470 ----*/
5473 {
5474 #ifdef _WINDOWS
5481 # if defined(SENDMAIL) && defined(SENDMAILFLAGS)
5487 # else
5490 # endif
5491 #endif
5494 }
5498 #ifndef _WINDOWS
5499 /*----------------------------------------------------------------------
5500 Hand off given message to local posting agent
5502 Args: envelope -- The envelope for the BCC and debugging
5503 header -- The text of the message header
5504 errbuf -- buffer for reporting errors (assumed non-NULL)
5505 len -- Length of errbuf
5507 ----*/
5508 int
5513 {
5514 #ifdef DF_SENDMAIL_PATH
5516 #endif
5519 /*
5520 * A bit of complicated policy implemented here.
5521 * There are two posting variables sendmail-path and smtp-server.
5522 * Precedence is in that order.
5523 * They can be set one of 4 ways: fixed, command-line, user, or globally.
5524 * Precedence is in that order.
5525 * Said differently, the order goes something like what's below.
5526 *
5527 * NOTE: the fixed/command-line/user precendence handling is also
5528 * indicated by what's pointed to by ps_global->VAR_*, but since
5529 * that also includes the global defaults, it's not sufficient.
5530 */
5535 }
5541 }
5551 else
5553 }
5561 }
5562 #ifdef DF_SENDMAIL_PATH
5563 /*
5564 * This defines the default method of posting. So,
5565 * unless we're told otherwise use it...
5566 */
5571 }
5572 #endif
5573 }
5574 }
5575 }
5583 }
5584 else
5586 }
5590 /*----------------------------------------------------------------------
5591 Hand off given message to local posting agent
5593 Args: envelope -- The envelope for the BCC and debugging
5594 header -- The text of the message header
5595 errbuf -- buffer for reporting errors (assumed non-NULL)
5596 errbuflen -- Length of errbuf
5598 Fork off mailer process and pipe the message into it
5599 Called to post news via Inews when NNTP is unavailable
5601 ----*/
5607 {
5609 #ifdef SENDNEWS
5621 }
5631 }
5635 /*----------------------------------------------------------------------
5636 Hand off message to local MTA; it parses recipients from 822 header
5638 Args: header -- struct containing header data
5639 body -- struct containing message body data
5640 cmd -- command to use for handoff (%s says where file should go)
5641 errs -- pointer to buf to hold errors
5643 ----*/
5648 {
5661 }
5667 }
5668 }
5669 else
5675 }
5678 }
5681 /*
5682 * pine_pipe_soutr - Replacement for tcp_soutr that writes one of our
5683 * pipes rather than a tcp stream
5684 */
5685 long
5687 {
5699 }
5700 }
5704 }
5712 }
5713 }
5714 else
5716 }
5719 }
5720 #endif
5723 /**************** "PIPE" READING POSTING I/O ROUTINES ****************/
5726 /*
5727 * helpful def's
5728 */
5729 #define S(X) ((PIPE_S *)(X))
5730 #define GETBUFLEN (4 * MAILTMPLEN)
5735 {
5746 }
5747 else if((postcmd = smtp_command(ps_global->c_client_error, sizeof(ps_global->c_client_error))) != NULL){
5752 }
5753 else
5757 }
5762 {
5764 }
5767 /*
5768 * piped_soutr - Replacement for tcp_soutr that writes one of our
5769 * pipes rather than a tcp stream
5770 */
5771 long
5773 {
5775 }
5778 /*
5779 * piped_sout - Replacement for tcp_soutr that writes one of our
5780 * pipes rather than a tcp stream
5781 */
5782 long
5784 {
5796 }
5797 }
5801 }
5802 }
5805 }
5808 /*
5809 * piped_getline - Replacement for tcp_getline that reads one
5810 * of our pipes rather than a tcp pipe
5811 *
5812 * C-client expects that the \r\n will be stripped off.
5813 */
5816 {
5826 /* alloc space to collect input (freed in close_system_pipe) */
5830 }
5837 }
5842 }
5845 }
5856 }
5858 n++;
5860 }
5861 /* copy partial string from buffer */
5863 /* get more data */
5871 }
5879 }
5880 }
5883 }
5886 ptr++;
5887 cnt--;
5889 }
5897 }
5900 }
5903 /*
5904 * piped_close - Replacement for tcp_close that closes pipes to our
5905 * child rather than a tcp connection
5906 */
5907 void
5909 {
5910 /*
5911 * Uninstall our hooks into smtp_send since it's being used by
5912 * the nntp driver as well...
5913 */
5915 }
5918 /*
5919 * piped_abort - close down the pipe we were using to post
5920 */
5921 void
5923 {
5927 }
5932 }
5933 }
5938 {
5940 }
5943 unsigned long
5945 {
5947 }