| blob | ef9cdf49e349132d658be12dfb4c2906ba2e46bd |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2013-2017 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 */
19 /*======================================================================
20 Functions for composing and sending mail
22 ====*/
78 /*
79 * macro to bind pico's headerentry pointer to PINEFIELD "extdata" hook
80 */
81 #define HE(PF) ((struct headerentry *)((PF)->extdata))
84 /*
85 * Internal Prototypes
86 */
97 BODY_PARTICULARS_S
120 #if defined(DOS) || defined(OS2)
125 /*
126 * Pointer to buffer to hold pointers into pine data that's needed by pico.
127 */
139 /* local global to save busy_cue state */
143 /*
144 * Various useful strings
145 */
146 #define INTRPT_PMT \
148 #define PSTPND_PMT \
150 #define FORM_PMT \
152 #define PSTPN_FORM_PMT \
154 #define POST_PMT \
156 #define INTR_DEL_PMT \
160 /*
161 * Macros to help sort out posting results
162 */
163 #define P_MAIL_WIN 0x01
164 #define P_MAIL_LOSE 0x02
165 #define P_MAIL_BITS 0x03
166 #define P_NEWS_WIN 0x04
167 #define P_NEWS_LOSE 0x08
168 #define P_NEWS_BITS 0x0C
169 #define P_FCC_WIN 0x10
170 #define P_FCC_LOSE 0x20
171 #define P_FCC_BITS 0x30
177 /*
178 * For check_for_subject and check_for_fcc
179 */
180 #define CF_OK 0x1
181 #define CF_MISSING 0x2
184 /*----------------------------------------------------------------------
185 Compose screen (not forward or reply). Set up envelope, call composer
187 Args: pine_state -- The usual pine structure
189 Little front end for the compose screen
190 ---*/
191 void
193 {
203 }
206 /*----------------------------------------------------------------------
207 Alternate compose screen. Set up role and call regular compose.
209 Args: pine_state -- The usual pine structure
210 ---*/
211 void
213 {
222 /* Setup role */
228 }
230 /*
231 * If default role was selected (NULL) we need to make up a role which
232 * won't do anything, but will cause compose_mail to think there's
233 * already a role so that it won't try to confirm the default.
234 */
241 }
248 }
251 /*----------------------------------------------------------------------
252 Format envelope for outgoing message and call editor
254 Args: given_to -- An address to send mail to (usually from command line
255 invocation)
256 fcc_arg -- The fcc that goes with this address.
258 If a "To" line is given format that into the envelope and get ready to call
259 the composer
260 If there's a message postponed, offer to continue it, and set it up,
261 otherwise just fill in the outgoing envelope as blank.
263 NOTE: we ignore postponed and interrupted messages in nr mode
264 ----*/
265 void
268 {
289 /*-- Check for INTERRUPTED mail --*/
293 /* build filename and see if it exists. build_path creates
294 * an explicit local path name, so all c-client access is thru
295 * local drivers.
296 */
303 /* check to see if the folder exists, the user wants to continue
304 * and that we can actually read something in...
305 */
308 }
310 /*-- Check for postponed mail --*/
318 /*-- Check for form letter folder --*/
352 }
359 }
366 }
386 }
390 }
418 }
437 {
448 }
454 }
469 }
470 }
494 }
496 to_is_sticky++;
498 /* redraft() may or may not have closed stream */
503 }
510 }
511 }
512 }
516 file_path);
519 }
520 }
521 }
535 done++;
537 /* stream may or may not be closed in redraft() */
541 to_is_sticky++;
543 }
551 done++;
552 }
553 }
554 }
556 done++;
560 }
573 done++;
575 /* stream may or may not be closed in redraft() */
579 to_is_sticky++;
581 }
589 done++;
590 }
591 }
592 }
598 }
599 }
603 }
605 /*-- normal composition --*/
609 PAT_STATE dummy;
611 /*================= Compose new message ===============*/
620 /*
621 * Setup possible role
622 */
627 /* Setup possible compose role */
629 /*
630 * setup default role
631 * Msgno = -1 means there is no msg.
632 * This will match roles which have the Compose Use turned
633 * on, and have no patterns set, and match the Current
634 * Folder Type.
635 */
644 }
645 }
646 }
652 /*
653 * The type of storage object allocated below is vitally
654 * important. See SIMPLIFYING ASSUMPTION #37
655 */
664 }
665 }
666 }
671 }
683 }
686 }
687 }
688 else
699 }
705 }
711 /*
712 * check whether a build_address-produced fcc is different from
713 * fcc. If same, do nothing, if different, set sticky bit in pine_send.
714 */
723 }
726 /* not sticky */
727 }
728 else
729 fcc_is_sticky++;
733 }
749 }
761 }
764 /*----------------------------------------------------------------------
765 Args: stream -- This is where we get the postponed messages from
766 We'll expunge and close it here unless it is mail_stream.
768 These are all return values:
769 ================
770 outgoing --
771 body --
772 fcc --
773 lcc --
774 reply --
775 redraft_pos --
776 custom --
777 role --
778 ================
780 flags --
782 ----*/
783 int
787 {
797 /*
798 * If we're manipulating the current folder, don't bother
799 * with index
800 */
804 else
808 }
811 /*
812 * Since the user's got this folder already opened and they're
813 * on a selected message, pick that one rather than rebuild
814 * another index screen...
815 */
817 }
825 }
828 }
843 q_status_message(SM_ORDER, 3, 3, _("Undelete messages to remain postponed, and then continue message"));
844 else
845 q_status_message(SM_ORDER, 3, 3, _("Undelete form letters you want to keep, and then continue message"));
848 }
851 }
868 }
874 }
877 }
878 }
884 else
886 }
889 int
891 {
895 type);
897 }
900 }
903 /* this is for initializing the fixed header elements in pine_send() */
904 /*
905 prompt::name::help::prwid::maxlen::realaddr::
906 builder::affected_entry::next_affected::selector::key_label::fileedit::
907 display_it::break_on_comma::is_attach::rich_header::only_file_chars::
908 single_space::sticky::dirty::start_here::blank::sticky_special::KS_ODATAVAR
909 */
989 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
993 #endif
994 };
1008 /*----------------------------------------------------------------------
1009 Get addressee for message, then post message
1011 Args: outgoing -- Partially formatted outgoing ENVELOPE
1012 body -- Body of outgoing message
1013 prmpt_who -- Optional prompt for optionally_enter call
1014 prmpt_cnf -- Optional prompt for confirmation call
1015 used_tobufval -- The string that the to was eventually set equal to.
1016 This gets passed back if non-NULL on entry.
1017 flagsarg -- SS_PROMPTFORTO - Allow user to change recipient
1018 SS_NULLRP - Use null return-path so we'll send an
1019 SMTP MAIL FROM: <>
1021 Result: message "To: " field is provided and message is sent or cancelled.
1023 Fields:
1024 remail -
1025 return_path -
1026 date added here
1027 from added here
1028 sender -
1029 reply_to -
1030 subject passed in, NOT edited but maybe canonized here
1031 to possibly passed in, edited and canonized here
1032 cc -
1033 bcc -
1034 in_reply_to -
1035 message_id -
1037 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1038 with the first part TYPETEXT! All newlines in the text here also end with
1039 CRLF.
1041 Returns 0 on success, -1 on failure.
1042 ----*/
1043 int
1051 {
1057 HelpType help;
1060 BUILDER_ARG ba_fcc;
1063 PAT_STATE pstate;
1073 /*----- Fill in a few general parts of the envelope ----*/
1083 }
1088 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
1089 else
1091 }
1092 else
1094 }
1109 }
1116 }
1134 /*----------------------------------------------------------------------
1135 Loop editing the "To: " field until everything goes well
1136 ----*/
1144 snprintf(tmp, sizeof(tmp), _("BOUNCE (redirect) message using role \"%s\" to : "), role->nick);
1145 else
1148 }
1151 og2s_done++;
1153 }
1168 }
1174 }
1180 prmpt_who
1181 ? prmpt_who
1184 }
1185 else
1193 done++;
1215 }
1216 }
1228 }
1230 }
1237 }
1238 else
1247 }
1248 else
1265 /*
1266 * Just make it look like user typed this list in.
1267 */
1269 got_something++;
1273 }
1278 }
1288 }
1298 /*
1299 * If role has an fcc, use it instead of what build_address
1300 * tells us.
1301 */
1307 }
1319 }
1326 /* confirm address */
1338 ps_global))))
1339 /*--- Addresses didn't check out---*/
1355 /* setup keymenu slot to toggle verbose mode */
1365 }
1366 }
1368 /* clear DSN flags */
1371 /* setup keymenu slots to toggle dsn bits */
1389 }
1411 ? addr
1428 /* TRANSLATORS: several possible key labels follow */
1448 }
1449 }
1457 }
1460 }
1463 }
1467 else
1469 }
1473 /* turn off related bits */
1476 }
1479 /* turn off related bits */
1482 }
1485 /* turn off related bits */
1488 }
1491 }
1492 }
1495 }
1509 }
1510 }
1525 /*
1526 * If special name "inbox" then replace it with the
1527 * real inbox path.
1528 */
1536 }
1537 }
1539 /*---- Check out fcc -----*/
1549 }
1550 else
1552 }
1553 else
1555 }
1556 else
1563 }
1571 q_status_message(SM_ORDER | SM_DING, 5, 5, _("Use of a role-defined smtp-server is administratively prohibited"));
1572 else
1574 }
1577 call_mailer_flags,
1578 call_mailer_file_result,
1579 pipe_callback);
1581 }
1582 else
1588 /*----- Was there an fcc involved? -----*/
1600 }
1602 /* Now actually copy to fcc folder and close */
1603 fcc_result =
1605 label,
1608 }
1614 }
1617 }
1623 else
1625 }
1649 SIZEOF_20KBUF,
1651 }
1652 }
1656 }
1660 }
1661 }
1670 else
1672 }
1674 }
1679 }
1680 }
1682 done++;
1687 done++;
1694 ? h_anon_forward
1712 }
1716 }
1719 }
1723 }
1730 }
1731 }
1733 finish:
1740 }
1743 /*
1744 * pine_simple_send_header - generate header suitable for simple_sending
1745 */
1746 METAENV *
1748 {
1755 /* assign he_dummy to "To:" field "he" for strings2outgoing */
1762 }
1765 }
1769 /*----------------------------------------------------------------------
1770 Prepare data structures for pico, call pico, then post message
1772 Args: outgoing -- Partially formatted outgoing ENVELOPE
1773 body -- Body of outgoing message
1774 editor_title -- Title for anchor line in composer
1775 fcc_arg -- The file carbon copy field
1776 reply -- Struct describing set of msgs being replied-to
1777 lcc_arg --
1778 custom -- custom header list.
1779 sticky_fcc --
1781 Result: message is edited, then postponed, cancelled or sent.
1783 Fields:
1784 remail -
1785 return_path -
1786 date added here
1787 from added here
1788 sender -
1789 reply_to -
1790 subject passed in, edited and cannonized here
1791 to possibly passed in, edited and cannonized here
1792 cc possibly passed in, edited and cannonized here
1793 bcc edited and cannonized here
1794 in_reply_to generated in reply() and passed in
1795 message_id -
1797 Storage for these fields comes from anywhere outside. It is remalloced
1798 here so the composer can realloc them if needed. The copies here are also
1799 freed here.
1801 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1802 with the first part TYPETEXT! All newlines in the text here also end with
1803 CRLF.
1805 There's a further assumption that the text in the TYPETEXT part is
1806 stored in a storage object (see filter.c).
1807 ----*/
1808 void
1813 {
1826 METAENV header;
1832 CustomType ct;
1841 /*
1842 * Cancel any pending initial commands since pico uses a different
1843 * input routine. If we didn't cancel them, they would happen after
1844 * we returned from the editor, which would be confusing.
1845 */
1855 }
1858 }
1860 #if defined(DOS) || defined(OS2)
1864 }
1867 #else
1871 #endif
1881 #ifdef _WINDOWS
1895 /* We actually want to set this only if message we're sending is flowed */
1909 #if defined(DOS) || defined(OS2)
1912 }
1913 #endif
1918 /* NOTE: initial cursor position set below */
1922 /*
1923 * When user runs compose and the current folder is a newsgroup,
1924 * offer to post to the current newsgroup.
1925 */
1933 /*
1934 * Replies don't get this far because To or Newsgroups will already
1935 * be filled in. So must be either ordinary compose or forward.
1936 * Forward sets subject, so use that to tell the difference.
1937 */
1949 }
1960 }
1970 }
1975 }
1981 }
1984 }
1999 }
2000 }
2001 }
2005 NETMBX news_mb;
2013 suggested_nntp_server =
2019 /* take out /nntp, which gets added in nntp_open */
2026 else
2027 p++;
2035 }
2037 }
2038 }
2039 }
2040 else
2042 }
2043 }
2045 /*
2046 * If we don't already have custom headers set and the role has custom
2047 * headers, then incorporate those custom headers into "custom".
2048 */
2053 /*
2054 * If we allow the Combine argument here, we're saying that we want to
2055 * combine the values from the envelope and the role for the fields To,
2056 * Cc, Bcc, and Newsgroups. For example, if we are replying to a message
2057 * we'll have a To in the envelope because we're replying. If our role also
2058 * has a To action, then Combine would combine those two and offer both
2059 * to the user. We've decided against doing this. Instead, we always use
2060 * Replace, and the role's header value replaces the value from the
2061 * envelope. It might also make sense in some cases to do the opposite,
2062 * which would be treating the role headers as defaults, just like
2063 * customized-hdrs.
2064 */
2065 #ifdef WANT_TO_COMBINE_ADDRESSES
2068 #else
2071 #endif
2078 }
2083 }
2084 }
2085 else
2087 }
2091 /* how many fixed fields are there? */
2093 ;
2097 /* the fixed part of the PINEFIELDs */
2102 /* temporary headerentry array for pico */
2116 /* custom part of PINEFIELDs */
2122 /*
2123 * For Address types, pf->addr points to an ADDRESS *.
2124 * If that address is in the "outgoing" envelope, it will
2125 * be freed by the caller, otherwise, it should be freed here.
2126 * Pf->textbuf for an Address is used a little to set up a default,
2127 * but then is freed right away below. Pf->scratch is used for a
2128 * pointer to some alloced space for pico to edit in. Addresses in
2129 * the custom area are freed by free_customs().
2130 *
2131 * For FreeText types, pf->addr is not used. Pf->text points to a
2132 * pointer that points to the text. Pf->textbuf points to a copy of
2133 * the text that must be freed before we leave, otherwise, it is
2134 * probably a pointer into the envelope and that gets freed by the
2135 * caller.
2136 *
2137 * He->realaddr is the pointer to the text that pico actually edits.
2138 */
2140 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2141 # define NN 4
2142 #else
2143 # define NN 3
2144 #endif
2147 use_news_order++;
2149 /* initialize the fixed header elements of the two temp arrays */
2156 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2157 , N_SENDER
2158 #endif
2159 };
2162 /* slightly different editing order if sending to news */
2167 /* copy the templates */
2172 /* slide string over so it is Sender instead of X-X-Sender */
2225 }
2226 }
2230 }
2235 /* if no value, use default */
2239 }
2245 }
2247 /* If there is a newsgroup, we'd better show it */
2255 }
2260 }
2265 }
2270 }
2275 }
2280 }
2286 }
2292 }
2298 }
2304 }
2310 }
2316 }
2322 }
2328 }
2334 }
2340 }
2344 }
2348 /* can't do a default for this one */
2350 /* If there is an attachment already, we'd better show them */
2363 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
2368 }
2369 }
2377 /* If already set, make it act like we typed it in */
2394 }
2399 SIZEOF_20KBUF,
2405 }
2417 /* if bcc exists, make sure it's exposed so nothing's
2418 * sent by mistake...
2419 */
2435 }
2449 }
2453 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2458 #endif
2464 }
2466 /*
2467 * If this is a reply to news, don't show the regular email
2468 * recipient headers (unless they are non-empty).
2469 */
2484 }
2485 else
2487 }
2489 /*
2490 * If this address doesn't already have a value, then we check
2491 * for a default value assigned by the user.
2492 */
2503 /*
2504 * Try to set To based on Lcc. Don't attempt Fcc.
2505 */
2543 }
2544 }
2551 }
2555 }
2565 }
2566 }
2568 /* if we still don't have a from */
2571 }
2573 /*
2574 * Addr is already set in the rest of the cases.
2575 */
2579 /*
2580 * We get to this case of the ifelse if the from or reply-to
2581 * addr was set by a role above.
2582 */
2584 /* figure out the default value */
2593 }
2595 /* if value set by role is different from default, show it */
2599 /* malformed */
2603 }
2607 }
2612 /*
2613 * These three are different from the others because we
2614 * might add the addresses to what is already there instead
2615 * of replacing.
2616 */
2640 ;
2646 }
2653 }
2656 }
2675 }
2678 }
2683 }
2688 /* outgoing2strings will alloc the string pf->scratch below */
2697 else
2703 }
2735 /* if no value, use default */
2738 }
2742 }
2745 }
2756 }
2758 /*
2759 * We may or may not want to give the user the chance to edit
2760 * the From and Reply-To lines. If they are listed in either
2761 * Default-composer-hdrs or Customized-hdrs, then they can edit
2762 * them, else no.
2763 * If canedit is not set, that means that this header is not in
2764 * the user's customized-hdrs. If rich_header is set, that
2765 * means that this header is not in the user's
2766 * default-composer-hdrs (since From and Reply-To are rich
2767 * by default). So, don't give it an he to edit with in that case.
2768 *
2769 * For other types, just not setting canedit will cause it to be
2770 * uneditable, regardless of what the user does.
2771 */
2774 /* to allow it, we let this fall through to the reply-to case below */
2785 }
2791 }
2794 he++;
2795 }
2803 }
2804 else
2805 he++;
2808 }
2809 }
2811 /*
2812 * This is so the builder can tell the composer to fill the affected
2813 * field based on the value in the field on the left.
2814 *
2815 * Note that this mechanism isn't completely general. Each entry has
2816 * only a single next_affected, so if some other entry points an
2817 * affected entry at an entry with a next_affected, they all inherit
2818 * that next_affected. Since this isn't used much a careful ordering
2819 * of the affected fields should make it a sufficient mechanism.
2820 */
2829 /*
2830 * Set up headerentries for custom fields.
2831 * NOTE: "i" is assumed to now index first custom field in sending
2832 * order.
2833 */
2851 /* change default text into an ADDRESS */
2852 /* strip quotes around whole default */
2864 }
2883 }
2887 /* use first 8 characters for prompt */
2892 he++;
2893 }
2895 /*
2896 * Make sure at least *one* field is displayable...
2897 */
2902 }
2904 /*
2905 * None displayable!!! Warn and display defaults.
2906 */
2914 }
2916 /*
2917 * Save information about body which set_mime_type_by_grope might change.
2918 * Then, if we get an error sending, we reset these things so that
2919 * grope can do it's thing again after we edit some more.
2920 */
2923 else
2929 /*----------------------------------------------------------------------
2930 Loop calling the editor until everything goes well
2931 ----*/
2935 /* Reset body to what it was when we started. */
2938 else
2940 /*
2941 * set initial cursor position based on how many times we've been
2942 * thru the loop...
2943 */
2946 }
2950 }
2953 /* set the start_here bit in correct header */
2959 }
2961 /* If didn't find it, we start in body. */
2964 }
2967 }
2969 /* in case these were turned on in previous pass through loop */
2973 }
2978 /*
2979 * If a sending attempt failed after we passed the message text
2980 * thru a user-defined filter, "orig_so" points to the original
2981 * text. Replace the body's encoded data with the original...
2982 */
2990 }
2992 /*
2993 * Convert the envelope and body to the string format that
2994 * pico can edit
2995 */
2999 /*
3000 * If this isn't the first time through this loop, we may have
3001 * freed some of the FreeText headers below so that they wouldn't
3002 * show up as empty headers in the finished message. Need to
3003 * alloc them again here so they can be edited.
3004 */
3010 }
3012 /*
3013 * If From is exposed, probably by a role, then start the cursor
3014 * on the first line which isn't filled in. If it isn't, then we
3015 * don't move the cursor, mostly for back-compat.
3016 */
3027 }
3028 }
3030 #ifdef _WINDOWS
3032 #endif
3037 /* turn off user input timeout when in composer */
3045 #ifdef _WINDOWS
3047 #endif
3050 /*
3051 * Only reinitialize signals if we didn't receive an interesting
3052 * one while in pico, since pico's return is part of processing that
3053 * signal and it should continue to be ignored.
3054 */
3058 /*
3059 * We're going to save in DEADLETTER. Dump attachments first.
3060 */
3064 /* Turn strings back into structures */
3067 /* Make newsgroups NULL if it is "" (so won't show up in headers) */
3072 }
3074 /* Make subject NULL if it is "" (so won't show up in headers) */
3078 /* remove custom fields that are empty */
3084 }
3085 }
3086 }
3090 /*-------- Stamp it with a current date -------*/
3103 /* Set return_path based on From which is going to be used */
3109 /*
3110 * Don't ever believe the sender that is there.
3111 * If From doesn't look quite right, generate our own sender.
3112 */
3116 /*
3117 * If the LHS of the address doesn't match, or the RHS
3118 * doesn't match one of localdomain or hostname,
3119 * then add a sender line (really X-X-Sender).
3120 *
3121 * Don't add a personal_name since the user can change that.
3122 */
3124 &&
3135 }
3140 }
3142 /*----- Message is edited, now decide what to do with it ----*/
3144 /*=========== Postpone or Interrupted message ============*/
3162 }
3164 /*
3165 * The idea here is to use the Fcc: writing facility
3166 * to append to the special postponed message folder...
3167 *
3168 * NOTE: the strategy now is to write the message and
3169 * all attachments as they exist at composition time.
3170 * In other words, attachments are postponed by value
3171 * and not reference. This may change later, but we'll
3172 * need a local "message/external-body" type that
3173 * outgoing2strings knows how to properly set up for
3174 * the composer. Maybe later...
3175 */
3182 /*--- Addresses didn't check out---*/
3186 }
3188 /*
3189 * Build the local message copy so.
3190 *
3191 * In the HUP case, we'll write the bezerk delimiter by
3192 * hand and output the message directly into the folder.
3193 * It's not only faster, we don't have to worry about
3194 * c-client reentrance and less hands paw over the data so
3195 * there's less chance of a problem.
3196 *
3197 * In the Postpone case, just create it if the user wants to
3198 * and create a temporary storage object to write into. */
3199 fake_hup:
3205 #if defined(DOS) || defined(OS2)
3206 /*
3207 * we can't assume anything about root or home dirs, so
3208 * just plunk it down in the same place as the pinerc
3209 */
3217 }
3222 }
3223 else
3224 #endif
3226 ps_global->VAR_OPER_DIR
3248 }
3256 }
3259 }
3260 else
3275 else
3279 }
3280 }
3281 }
3282 }
3289 }
3291 /*
3292 * Store the cursor position
3293 *
3294 * First find the header entry with the start_here
3295 * bit set, if any. This means the editor is telling
3296 * us to start on this header field next time.
3297 */
3303 }
3305 /* If there wasn't one, ":" means we start in the body. */
3317 }
3324 }
3327 }
3333 /* copy fcc line to postponed or interrupted folder */
3337 /* plug error into header for later display to user */
3342 }
3344 /*
3345 * if reply, write (UID)folder header field so we can
3346 * later flag the replied-to message \\ANSWERED
3347 * DON'T save MSGNO's.
3348 */
3358 }
3374 /*
3375 * Logically, this ought to be part of pf_uid, but this
3376 * was added later and so had to be in a separate header
3377 * for backwards compatibility.
3378 */
3384 }
3386 /* Save cursor position */
3396 }
3398 /*
3399 * Work around c-client reply-to bug. C-client will
3400 * return a reply_to in an envelope even if there is
3401 * no reply-to header field. We want to note here whether
3402 * the reply-to is real or not.
3403 */
3409 else
3411 }
3413 /* Save the role-specific smtp server */
3419 /*
3420 * Turn the list of smtp servers into a space-
3421 * delimited list in a single string.
3422 */
3434 }
3437 }
3443 else
3445 }
3447 /* Save the role-specific nntp server */
3455 /*
3456 * Turn the list of nntp servers into a space-
3457 * delimited list in a single string.
3458 */
3470 }
3473 }
3474 }
3475 else
3482 else
3484 }
3486 /*
3487 * Write the list of custom headers to the
3488 * X-Our-Headers header so that we can recover the
3489 * list in redraft.
3490 */
3508 }
3511 }
3513 /*
3514 * We need to make sure any header values that got cleared
3515 * get written to the postponed message (they won't if
3516 * pf->text is NULL). Otherwise, we can't tell previously
3517 * non-existent custom headers or default values from
3518 * custom (or other) headers that got blanked in the
3519 * composer...
3520 */
3525 /*
3526 * We're saving the message for use later. It may be that the
3527 * characters in the message are not all convertible to the
3528 * user's posting_charmap. We'll save it as UTF-8 instead
3529 * and worry about that the next time they try to send it.
3530 * Use a different save pointer just to be sure we don't
3531 * mess up the other stuff. We should probably make the
3532 * charset an argument.
3533 *
3534 * We also need to fix the charset of the body part
3535 * the user is editing so that we can read it back
3536 * successfully when we resume the composition.
3537 */
3540 {
3545 else
3551 ;
3558 }
3559 }
3573 }
3590 }
3591 else
3598 }
3599 else
3602 }
3604 /* discontinue coerced UTF-8 posting */
3608 }
3609 else
3614 /*
3615 * Special Hack #291: if any hi-byte bits are set in
3616 * editor's result, we put them there.
3617 */
3624 }
3631 else
3636 }
3649 }
3655 }
3656 }
3658 /*------ Must be sending mail or posting ! -----*/
3665 /* --- If posting, confirm with user ----*/
3672 }
3682 continue_with_only_fcc++;
3683 }
3689 }
3690 }
3693 /*--- Addresses didn't check out---*/
3696 }
3699 && !continue_with_only_fcc
3708 local_redraft_pos
3713 }
3721 local_redraft_pos
3726 }
3734 local_redraft_pos
3739 }
3743 /*---- Check out fcc -----*/
3745 /*
3746 * If special name "inbox" then replace it with the
3747 * real inbox path.
3748 */
3756 }
3759 /* lmc.text_only set on command line */
3761 /* ---- Open or allocation of fcc failed ----- */
3764 /*
3765 * Find field entry associated with fcc, and start
3766 * composer on it...
3767 */
3773 }
3774 else
3776 }
3777 else
3780 /*---- Take care of any requested prefiltering ----*/
3788 }
3790 /*------ Actually post -------*/
3805 }
3806 }
3815 }
3816 else
3818 }
3820 /*
3821 * BUG: IF we've posted the message *and* an fcc was specified
3822 * then we've already got a neatly formatted message in the
3823 * lmc.so. It'd be nice not to have to re-encode everything
3824 * to insert it into the smtp slot...
3825 */
3827 /*
3828 * Turn on "undisclosed recipients" header if no To or cc.
3829 */
3834 }
3839 }
3841 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
3842 /*
3843 * If requested, launch backgroud posting...
3844 */
3852 /*
3853 * Put us in new process group...
3854 */
3857 /* BUG: should fix argv[0] to indicate what we're up to */
3859 /*
3860 * If there are any live streams, pretend we never
3861 * knew them. Problem is two processes writing
3862 * same server process.
3863 * This is not clean but we're just going to exit
3864 * right away anyway. We just want to be sure to leave
3865 * the stuff that the parent is going to use alone.
3866 * The next three lines will disable the re-use of the
3867 * existing streams and cause us to open a new one if
3868 * needed.
3869 */
3874 /* quell any display output */
3877 /*------- Actually mail the message ------*/
3886 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3887 else
3889 }
3892 call_mailer_flags,
3893 call_mailer_file_result,
3899 }
3901 /*----- Was there an fcc involved? -----*/
3903 /*------ Write it if at least something worked ------*/
3915 }
3917 /*-- Now actually copy to fcc folder and close --*/
3923 }
3930 }
3933 }
3936 /*
3937 * Encode child's result in hi-byte of
3938 * editor's result
3939 */
3942 }
3945 }
3951 }
3960 }
3971 }
3974 /*------- Actually mail the message ------*/
3982 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3983 else
3985 }
3988 call_mailer_flags,
3989 call_mailer_file_result,
3995 }
3997 /*----- Was there an fcc involved? -----*/
3999 /*------ Write it if at least something worked ------*/
4010 }
4012 /*-- Now actually copy to fcc folder and close --*/
4017 }
4023 }
4026 }
4028 /*----- Mail Post FAILED, back to composer -----*/
4033 /*
4034 * Find field entry associated with fcc, and start
4035 * composer on it...
4036 */
4044 }
4052 }
4054 /*
4055 * If message sent *completely* successfully, there's a
4056 * reply struct AND we're allowed to write back state, do it.
4057 * But also protect against shifted message numbers due
4058 * to new mail arrival. Since the number passed is based
4059 * on the real imap msg no, AND we're sure no expunge has
4060 * been done, just fix up the sorted number...
4061 */
4064 /*----- Signed, sealed, delivered! ------*/
4069 }
4070 }
4089 }
4114 }
4117 /*
4118 * Check for subject in outgoing message.
4119 *
4120 * Asks user whether to proceed with no subject.
4121 */
4122 int
4124 {
4136 else
4138 }
4141 }
4145 }
4148 /*
4149 * Check for fcc in outgoing message.
4150 *
4151 * Asks user whether to proceed with no fcc.
4152 */
4153 int
4155 {
4163 else
4165 }
4168 }
4171 /*
4172 * Confirm that the user wants to send to MAILER-DAEMON
4173 */
4174 int
4176 {
4179 }
4182 void
4184 {
4190 }
4191 }
4194 int
4196 {
4203 }
4206 /*
4207 * call__mailer_file_result - some results from call_mailer might be in a file.
4208 * dislplay that file.
4209 */
4210 void
4212 {
4216 }
4219 }
4220 }
4221 }
4223 void
4225 {
4241 }
4242 }
4246 /*
4247 * This is specialized routine. It assumes that the only things that we
4248 * care about restoring are the body type, subtype, encoding and the
4249 * state of the charset parameter. It also assumes that if the charset
4250 * parameter exists when we save it, it won't be removed later.
4251 */
4252 BODY_PARTICULARS_S *
4254 {
4272 }
4276 }
4279 }
4282 void
4284 {
4306 }
4310 else
4314 }
4315 }
4318 /*
4319 * This can't happen because grope never removes
4320 * the charset parameter.
4321 */
4324 }
4325 /*
4326 else{
4327 ok, still no parameter
4328 }
4329 */
4330 }
4331 }
4337 }
4338 }
4341 void
4343 {
4352 }
4353 }
4356 /*----------------------------------------------------------------------
4357 Build a status message suitable for framing
4359 Returns: pointer to resulting buffer
4360 ---*/
4363 {
4402 /* dots on end of fixed, no fcc */
4406 }
4408 /* include whole fixed part, quotes and dots at end of fcc name */
4418 }
4420 /* whole thing */
4426 }
4432 }
4434 /* Callback from Pico to set the conditions for Alpine to start a new thread
4435 */
4437 void
4439 {
4441 }
4445 /*----------------------------------------------------------------------
4446 Call back for pico to insert the specified message's text
4448 Args: n -- message number to format
4449 f -- function to use to output the formatted message
4452 Returns: returns msg number formatted on success, zero on error.
4453 ----*/
4454 long
4456 {
4468 }
4470 /* temporarily assign a new quote string */
4474 /* build separator line */
4477 /* actually write message text */
4483 }
4488 }
4491 /*----------------------------------------------------------------------
4492 Call back for pico to prompt the user for exit confirmation
4494 Args: dflt -- default answer for confirmation prompt
4496 Returns: either NULL if the user accepts exit, or string containing
4497 reason why the user declined.
4498 ----*/
4499 int
4502 {
4529 }
4536 }
4543 /*
4544 * Build list of available filters...
4545 */
4549 ;
4557 }
4563 }
4568 }
4569 else
4578 }
4585 }
4586 }
4600 /* set global_filter_pointer to desired filter or NULL if none */
4601 /* prepare two keymenu slots for selecting filter */
4614 }
4617 /* setup keymenu slot to toggle verbose mode */
4622 }
4625 /* setup keymenu slot to toggle flowed mode */
4631 }
4634 /* setup keymenu slot to toggle attacment on fcc */
4639 }
4641 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
4647 }
4648 #endif
4655 #ifdef SMIME
4670 }
4671 }
4672 #endif
4677 /* setup keymenu slots to toggle dsn bits */
4695 }
4707 }
4716 else
4732 lparen++;
4733 }
4734 else
4736 }
4739 }
4746 lparen++;
4747 }
4751 }
4752 }
4759 }
4760 else
4762 }
4769 lparen++;
4770 }
4771 else
4773 }
4783 }
4790 lparen++;
4791 }
4792 else
4794 }
4799 }
4806 lparen++;
4807 }
4811 }
4812 }
4815 }
4817 #ifdef SMIME
4823 lparen++;
4824 }
4828 }
4829 }
4832 }
4839 lparen++;
4840 }
4844 }
4845 }
4848 }
4849 #endif
4887 }
4888 }
4899 h_send_prompt,
4900 RB_NORM);
4901 else
4912 h_send_prompt,
4913 RB_NORM);
4917 }
4921 }
4925 }
4928 }
4931 }
4934 }
4938 else
4943 }
4946 }
4951 }
4955 /* turn off related bits */
4958 }
4961 /* turn off related bits */
4964 }
4967 /* turn off related bits */
4970 }
4973 }
4974 }
4976 /*
4977 * When you turn on DSN, the default is to notify on
4978 * failure, success, or delay; and to return the whole
4979 * body on failure.
4980 */
4982 }
4990 }
4998 else
5000 }
5001 }
5002 #ifdef SMIME
5006 }
5010 }
5011 #endif
5025 }
5027 /* remember selection */
5040 }
5041 }
5052 }
5055 /*
5056 * Allow user to choose a priority for sending.
5057 *
5058 * Returns an allocated priority on success, NULL otherwise.
5059 */
5062 {
5071 cnt++;
5082 lp++;
5083 }
5090 /* TRANSLATORS: SELECT A PRIORITY is a screen title
5091 TRANSLATORS: Print something1 using something2.
5092 "priorities" is something1 */
5096 starting_val);
5106 }
5109 int
5111 {
5113 }
5116 /*----------------------------------------------------------------------
5117 Call back for pico to display mime type of attachment
5119 Args: file -- filename being attached
5121 Returns: returns 1 on success (message queued), zero otherwise (don't know
5122 type so nothing queued).
5123 ----*/
5124 int
5126 {
5135 /* don't know where the cursor's been, reset it */
5141 }
5142 }
5150 }
5151 else
5156 }
5159 /*----------------------------------------------------------------------
5160 Call back for pico to receive an uploaded message
5162 Args: fname -- name for uploaded file (empty if they want us to assign it)
5163 size -- pointer to long to hold the attachment's size
5165 Notes: the attachment is uploaded to a temp file, and
5167 Returns: TRUE on success, FALSE otherwise
5168 ----*/
5169 int
5171 {
5189 }
5190 }
5191 else
5208 }
5216 }
5217 else
5224 }
5229 {
5240 };
5251 }
5255 }
5256 else
5258 }
5262 }
5265 /*----------------------------------------------------------------------
5266 Pass the first text segment of the message thru the "send filter"
5268 Args: body pointer and address for storage object of old data
5270 Returns: returns 1 on success, zero on error.
5271 ----*/
5272 int
5275 {
5284 #define DO_HEADERS 1
5290 /*
5291 * We need WRITE_TO_LOCALE here because the user is going to
5292 * be operating on tmpf. We need to change it back after they
5293 * are done.
5294 */
5299 }
5301 /*
5302 * If the headers are wanted for filtering, we can just
5303 * stick them in the tmpf file that is already there before
5304 * putting the body in.
5305 */
5312 }
5322 }
5323 else
5325 }
5327 /*
5328 * Gf_filter wants a single storage object to read from.
5329 * If headers are wanted for filtering we'll have to put them
5330 * and the body into a temp file first and then use that
5331 * as the storage object for gf_filter.
5332 * We don't use WRITE_TO_LOCALE in this case because gf_filter
5333 * takes care of that.
5334 */
5336 /* put headers in our_tmpf_so */
5343 /* put body in our_tmpf_so */
5352 /* tell gf_filter to read from our_tmpf_so instead of *so */
5354 }
5355 else
5357 }
5358 else
5376 /* now we undo the WRITE_FROM_LOCALE change in tmpf */
5383 }
5384 else
5386 }
5387 else
5389 }
5390 else
5392 }
5393 else
5396 pipe_callback);
5403 #ifdef _WINDOWS
5405 /*
5406 * Can't really be using stdout, so don't print message that
5407 * gets printed in the else. Ideally the program being called
5408 * will wait after showing the message, we might want to look
5409 * into doing the waiting in console based apps... or not.
5410 */
5411 #else
5420 }
5430 /*
5431 * If the command said it would return new MIME
5432 * mime type data, check it out...
5433 */
5445 ;
5463 }
5466 }
5469 }
5470 }
5472 /*
5473 * Reevaluate the encoding in case form's changed...
5474 */
5477 }
5481 }
5482 else
5484 }
5487 }
5488 else
5494 }
5499 }
5506 }
5512 errstr);
5515 }
5518 }
5521 /*----------------------------------------------------------------------
5522 Copy the newsgroup name of the given mailbox into the given buffer
5524 Args:
5526 Returns:
5527 ----*/
5528 void
5530 {
5531 NETMBX mb;
5536 }
5539 }
5540 else
5542 }
5545 /*----------------------------------------------------------------------
5546 Generate and send a message back to the pine development team
5548 Args: none
5550 Returns: none
5551 ----*/
5552 void
5554 {
5563 }
5591 }
5592 else
5599 }
5602 /*----------------------------------------------------------------------
5603 Set up fields for passing to pico. Assumes first text part is
5604 intended to be passed along for editing, and is in the form of
5605 of a storage object brought into existence sometime before pico_send().
5606 -----*/
5607 void
5610 {
5613 /*
5614 * SIMPLIFYING ASSUMPTION #37: the first TEXT part's storage object
5615 * is guaranteed to be of type PicoText!
5616 */
5620 /* mark storage object as user edited */
5623 }
5630 /*
5631 * We used to jump out the window if the first part wasn't text,
5632 * but that may not be the case when bouncing a message with
5633 * a leading non-text segment. So, IT'S UNDERSTOOD that the
5634 * contents of the first part to send is still ALWAYS in a
5635 * PicoText storage object, *AND* if that object doesn't contain
5636 * data of type text, then it must contain THE ENCODED NON-TEXT
5637 * DATA of the piece being sent.
5638 *
5639 * It's up to the programmer to make sure that such a message is
5640 * sent via pine_simple_send and never get to the composer via
5641 * pine_send.
5642 *
5643 * Make sense?
5644 */
5647 /* mark storage object as user edited */
5651 /*
5652 * If we already had a list, blast it now, so we can build a new
5653 * attachment list that reflects what's really there...
5654 */
5659 /* Simplifyihg assumption #28e. (see cross reference)
5660 All parts in the body passed in here that are not already
5661 in the attachments list are added to the end of the attachments
5662 list. Attachment items not in the body list will be taken care
5663 of in strings2outgoing, but they are unlikey to occur
5664 */
5667 /* Already in list? */
5671 ;
5685 }
5689 }
5690 }
5691 else
5697 /*
5698 * If we can find a "name" parm, display that too...
5699 */
5701 /* Convert any [ or ]'s the name contained */
5709 }
5710 else
5730 }
5731 }
5732 }
5733 }
5736 /*------------------------------------------------------------------
5737 Malloc strings to pass to composer editor because it expects
5738 such strings so it can realloc them
5739 -----------------------------------------------------------------*/
5740 /*
5741 * turn any address fields into text strings
5742 */
5743 /*
5744 * SIMPLIFYING ASSUMPTION #116: all header strings are understood
5745 * NOT to be RFC1522 decoded. Said differently, they're understood
5746 * to be RFC1522 ENCODED as necessary. The intent is to preserve
5747 * original charset tagging as far into the compose/send pipe as
5748 * we can.
5749 */
5760 /*
5761 * Scan for and fix-up patently bogus fields.
5762 *
5763 * NOTE: collaboration with this code and what's done in
5764 * reply.c:reply_cp_addr to package up the bogus stuff
5765 * is required.
5766 */
5772 /*
5773 * Rfc822_cat has been changed so that it now quotes
5774 * this sometimes. So we have to look out for quotes
5775 * which confuse the decoder. It was only quoting
5776 * because we were putting \r \n in the input, I think.
5777 */
5800 }
5808 /*
5809 * Replace control characters with ^C notation, unless
5810 * some conditions are met (see istrncpy).
5811 * If user doesn't edit, then we switch back to the
5812 * original version. If user does edit, then all bets
5813 * are off.
5814 */
5820 }
5823 }
5824 }
5843 }
5848 }
5853 /*
5854 * Replace control characters with ^C notation, unless
5855 * some conditions are met (see istrncpy).
5856 * If user doesn't edit, then we switch back to the
5857 * original version. If user does edit, then all bets
5858 * are off.
5859 */
5865 }
5868 }
5869 }
5875 }
5876 }
5879 /*----------------------------------------------------------------------
5880 Restore fields returned from pico to form useful to sending
5881 routines.
5882 -----*/
5883 void
5885 {
5891 /*
5892 * turn any local address strings into address lists
5893 */
5914 }
5926 }
5932 }
5935 }
5941 }
5944 /*----------------------------------------------------------------------
5946 The head of the body list here is always either TEXT or MULTIPART. It may be
5947 changed from TEXT to MULTIPART if there are attachments to be added
5948 and it is not already multipart.
5949 ----*/
5950 void
5952 {
5961 /*
5962 * if conditions are met short circuit MIME wrapping
5963 */
5966 /* only override assigned encoding if it might need upgrading */
5977 }
5980 }
5983 /*-- Current type is text, but there are attachments to add --*/
5984 /*-- Upgrade to a TYPEMULTIPART --*/
5989 /*
5990 * Why do we do this?
5991 * The problem is that base64 or quoted-printable encoding is
5992 * sensitive to having random data appended to it's end. If
5993 * we use a single part TEXT message and something in between
5994 * us and the end appends advertising without adjusting for
5995 * the encoding, the message is screwed up. So we wrap the
5996 * text part inside a multipart and then the appended data
5997 * will come after the boundary.
5998 *
5999 * We wish we could do this on the way out the door in a
6000 * child of post_rfc822_output because at that point we know
6001 * the character set and the encoding being used. For example,
6002 * iso-2022-jp is an encoding that is not sensitive to data
6003 * appended to the end, so it wouldn't need to be wrapped.
6004 * We could conceivably have post_rfc822_body inspect the
6005 * body and change it before doing the output. It would work
6006 * but would be very fragile. We'd be passed a body from
6007 * c-client to output and instead of just doing the output
6008 * we'd change the body and then output it. Not worth it
6009 * since the multipart wrapping is completely correct for
6010 * MIME-aware mailers.
6011 */
6013 /* move contents which were NOT copied */
6016 }
6023 }
6027 }
6030 /*-- Now type must be MULTIPART with first part text --*/
6033 }
6035 /*------ Go through the parts list remove those to be deleted -----*/
6038 /* already existed? */
6042 /*
6043 * decode original to see if it matches what was decoded
6044 * when we sent it in.
6045 */
6056 /* encoding happens as msg text is written */
6058 }
6064 }
6073 }
6074 else
6076 }
6078 /*---------- Now add any new attachments ---------*/
6084 /*
6085 * the idea is handle ALL attachments as open FILE *'s. Actual
6086 * encoding and such is handled at the time the message
6087 * is shoved into the mail slot or written to disk...
6088 *
6089 * Also, we never unlink a file, so it's up to whoever opens
6090 * it to deal with tmpfile issues.
6091 */
6099 }
6106 /*
6107 * Set type to unknown and let set_mime_type_by_* figure it out.
6108 * Always encode attachments we add as BINARY.
6109 */
6116 }
6123 /* Add name attribute for backward compatibility */
6132 }
6133 else
6137 pa->filename
6141 /* Then set the Content-Disposition ala RFC1806 */
6152 }
6153 else
6157 pa->filename
6160 }
6164 }
6166 /*
6167 * Now, if this multipart has but one text piece (that is, no
6168 * attachments), then downgrade from a composite type to a discrete
6169 * text/plain message if CTE is not 8bit.
6170 */
6176 /* Clone the interesting body part */
6179 /* and rub out what we don't want cleaned up when it's free'd */
6183 }
6187 }
6190 /*
6191 * Fill in text BODY part's structure
6192 *
6193 */
6194 void
6196 {
6204 }
6207 /*
6208 * free_attachment_list - free attachments in given list
6209 */
6210 void
6212 {
6228 }
6239 }
6240 }
6243 void
6245 {
6257 }
6260 /*
6261 * view_as_rich - set the rich_header flag
6262 *
6263 * name - name of the header field
6264 * deflt - default value to return if user didn't set it
6265 *
6266 * Note: if the user tries to turn them all off with "", then
6267 * we take that to mean default, since otherwise there is no
6268 * way to get to the headers.
6269 */
6270 int
6272 {
6282 }
6285 }
6287 }
6290 /*
6291 * background_posting - return whether or not we're already in the process
6292 * of posting
6293 */
6294 int
6296 {
6302 }
6305 }
6308 /*----------------------------------------------------------------------
6309 Validate the given subject relative to any news groups.
6311 Args: none
6313 Returns: always returns 1, but also returns error if
6314 ----*/
6315 int
6317 {
6324 /*
6325 * Now look for any header entry we passed to pico that has to do
6326 * with news. If there's no subject, gripe.
6327 */
6335 }
6336 }
6339 }
6342 /*
6343 * This is the build_address used by the composer to check for an address
6344 * in the addrbook.
6345 *
6346 * Args: to -- the passed in line to parse
6347 * full_to -- Address of a pointer to return the full address in.
6348 * This will be allocated here and freed by the caller.
6349 * error -- Address of a pointer to return an error message in.
6350 * This will be allocated here and freed by the caller.
6351 * barg -- Address of a pointer to return the fcc in is in
6352 * fcc->tptr. It will have already been allocated by the
6353 * caller but we may free it and reallocate if we wish.
6354 * Caller will free it.
6355 *
6356 * Result: 0 is returned if address was OK,
6357 * -1 if address wasn't OK.
6358 *
6359 * Side effect: Can flush addrbook entry cache entries so they need to be
6360 * re-fetched afterwords.
6361 */
6362 int
6364 {
6367 BuildTo bldto;
6375 /* check to see if to string is empty to avoid work */
6384 }
6392 /* No guarantee cursor or status line is how we saved it */
6400 /*
6401 * If we end up jumping back here because somebody else changed one of
6402 * our addrbooks out from underneath us, we may well leak some memory.
6403 * That's probably ok since this will be very rare.
6404 *
6405 * The reason for the memcpy of the jmp_buf is that we may actually
6406 * be indirectly calling this function from within the address book.
6407 * For example, we may be in the address book screen and then run
6408 * the ComposeTo command which puts us in the composer, then we call
6409 * build_address from there which resets addrbook_changed_unexpectedly.
6410 * Once we leave build_address we need to reset addrbook_changed_un...
6411 * because this position on the stack will no longer be valid.
6412 * Same is true of the other setjmp's in this file which are wrapped
6413 * in memcpy calls.
6414 */
6433 }
6435 ab_nesting_level++;
6442 ab_nesting_level--;
6446 /*
6447 * Have to rfc1522_decode the full_to string before sending it back.
6448 */
6457 /* p == q means that decoding happened, p is decoded *full_to */
6461 }
6462 else
6464 }
6469 /* Pt will point to headents[Fcc].bldr_private */
6474 /*
6475 * If *barg->aff is set, that means fcc was set from a list
6476 * during some previous builder call.
6477 * If the current To line contains the old expansion as a prefix, then
6478 * we should leave things as they are. In order to decide that,
6479 * we look at a hash value computed from the strings.
6480 */
6492 }
6493 else
6495 }
6501 /* replace fcc value */
6512 }
6525 }
6527 /*
6528 * If result is reproducible, we don't keep track here.
6529 */
6532 }
6533 }
6534 }
6535 else
6537 }
6539 /* This is so pico will erase the old message */
6546 }
6549 /*
6550 * This is the builder used by the composer for the Lcc line.
6551 *
6552 * Args: lcc -- the passed in Lcc line to parse
6553 * full_lcc -- Address of a pointer to return the full address in.
6554 * This will be allocated here and freed by the caller.
6555 * error -- Address of a pointer to return an error message in.
6556 * This is not allocated so should not be freed by the caller.
6557 * barg -- This is a pointer to text for affected entries which
6558 * we may be changing. The first one in the list is the
6559 * To entry. We may put the name of the list in empty
6560 * group syntax form there (like List Name: ;).
6561 * The second one in the list is the fcc field.
6562 * The tptr members already point to text allocated in the
6563 * caller. We may free and reallocate here, caller will
6564 * free the result in any case.
6565 *
6566 * Result: 0 is returned if address was OK,
6567 * -1 if address wasn't OK.
6568 *
6569 * Side effect: Can flush addrbook entry cache entries so they need to be
6570 * re-fetched afterwords.
6571 */
6572 int
6574 {
6578 BuildTo bldlcc;
6589 /* check to see if to string is empty to avoid work */
6598 }
6607 /*
6608 * If we end up jumping back here because somebody else changed one of
6609 * our addrbooks out from underneath us, we may well leak some memory.
6610 * That's probably ok since this will be very rare.
6611 */
6631 }
6633 ab_nesting_level++;
6637 /*
6638 * To is first affected_entry and Fcc is second.
6639 * The conditional stuff for the fcc argument says to only change the
6640 * fcc if the fcc pointer is passed in non-null, and the To pointer
6641 * is also non-null. If they are null, that means they've already been
6642 * entered (are sticky). We don't affect fcc if either fcc or To has
6643 * been typed in.
6644 */
6646 full_lcc,
6647 error,
6654 ab_nesting_level--;
6658 /* full_lcc is what ends up in the Lcc: line */
6662 /*
6663 * Have to rfc1522_decode the full_lcc string before sending it back.
6664 */
6670 }
6671 else
6673 }
6675 /* to is what ends up in the To: line */
6680 /*
6681 * Have to rfc1522_decode the full_to string before sending it back.
6682 */
6687 /*
6688 * If the caller wants us to try to preserve the charset
6689 * information (they set aff) we copy it into encoded->etext.
6690 * We don't have to worry about pasting together pieces of
6691 * etext like we do in build_address because whenever the
6692 * Lcc line is setting the To line it will be setting the
6693 * whole line, not modifying it.
6694 * Pt will point to headents[To].bldr_private.
6695 */
6703 }
6704 }
6708 }
6709 else
6716 /*
6717 * This part is recording the fact that the To line was set to
6718 * what it is by entering something on the Lcc line. In particular,
6719 * if a list alias was entered here then the fullname of the list
6720 * goes in the To line. We save this affector information so that
6721 * we can tell it shouldn't be modified if we call build_addr_lcc
6722 * again unless we actually modified what's in the Lcc line so that
6723 * it doesn't start with the same thing. The problem we're solving
6724 * is that the contents of the Lcc line no longer look like the
6725 * list they were derived from.
6726 * Pt will point to headents[To].bldr_private.
6727 */
6742 }
6743 else
6745 }
6752 /* replace to value */
6768 }
6774 }
6781 }
6794 }
6796 /*
6797 * If result is reproducible, we don't keep track here.
6798 */
6801 }
6802 }
6803 }
6804 else
6806 }
6811 /*
6812 * If *barg->next->aff is set, that means fcc was set from a list
6813 * during some previous builder call. If the current Lcc line
6814 * contains the old expansion as a prefix, then we should leave
6815 * things as they are. In order to decide that we look at a hash
6816 * value computed from the strings.
6817 * Pt will point to headents[Fcc].bldr_private
6818 */
6834 }
6835 else
6837 }
6844 /* replace fcc value */
6855 }
6868 }
6870 /*
6871 * If result is reproducible, we don't keep track here.
6872 */
6875 }
6876 }
6877 }
6878 else
6880 }
6889 }
6892 /*----------------------------------------------------------------------
6893 Verify and canonicalize news groups names.
6894 Called from the message composer
6896 Args: given_group -- List of groups typed by user
6897 expanded_group -- pointer to point to expanded list, which will be
6898 allocated here and freed in caller. If this is
6899 NULL, don't attempt to validate.
6900 error -- pointer to store error message
6901 fcc -- pointer to point to fcc, which will be
6902 allocated here and freed in caller
6904 Returns: 0 if all is OK
6905 -1 if addresses weren't valid
6907 Test the given list of newstroups against those recognized by our nntp
6908 servers. Testing by actually trying to open the list is much cheaper, both
6909 in bandwidth and memory, than yanking the whole list across the wire.
6910 ----*/
6911 int
6912 news_build(char *given_group, char **expanded_group, char **error, BUILDER_ARG *fcc, int *mangled)
6913 {
6924 /* assign any new fcc to the BUILDER_ARG */
6927 /* it changed */
6932 }
6933 }
6937 }
6939 /* deal with any busy indicator */
6947 }
6951 }
6954 void
6956 {
6958 }
6961 #if defined(DOS) || defined(OS2)
6963 /*----------------------------------------------------------------------
6964 Verify that the necessary pieces are around to allow for
6965 message sending under DOS
6967 Args: strict -- tells us if a remote stream is required before
6968 sending is permitted.
6970 The idea is to make sure pine knows enough to put together a valid
6971 from line. The things we MUST know are a user-id, user-domain and
6972 smtp server to dump the message off on. Typically these are
6973 provided in pine's configuration file, but if not, the user is
6974 queried here.
6975 ----*/
6976 int
6978 {
6981 HelpType help;
6983 /*
6984 * query for user name portion of address, use IMAP login
6985 * name as default
6986 */
6988 NETMBX mb;
6996 }
6998 /* no user-id prompting if set */
7009 }
7010 else
7012 }
7013 else
7017 /* No prompt, just assume mailbox login is user-id */
7020 }
7036 }
7040 }
7046 }
7048 /* save the name */
7053 && !no_prompt_user_id
7056 }
7060 }
7061 }
7063 /* query for personal name */
7081 }
7085 }
7094 }
7098 }
7099 }
7100 }
7102 /*
7103 * query for host/domain portion of address, using IMAP
7104 * host as default
7105 */
7115 }
7116 else
7133 }
7137 }
7143 }
7145 /* save the name */
7155 }
7160 }
7161 }
7163 /* check for smtp server */
7175 }
7176 else
7193 }
7197 }
7203 }
7205 /* save the name */
7212 }
7215 }