| blob | 4768a7e55916b1484c9977c445b8380d6a91f27b |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2013-2018 Eduardo Chappa
8 * Copyright 2006-2008 University of Washington
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * ========================================================================
17 */
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 */
2176 }
2226 }
2227 }
2231 }
2236 /* if no value, use default */
2240 }
2246 }
2248 /* If there is a newsgroup, we'd better show it */
2256 }
2261 }
2266 }
2271 }
2276 }
2281 }
2287 }
2293 }
2299 }
2305 }
2311 }
2317 }
2323 }
2329 }
2335 }
2341 }
2345 }
2349 /* can't do a default for this one */
2351 /* If there is an attachment already, we'd better show them */
2364 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
2369 }
2370 }
2378 /* If already set, make it act like we typed it in */
2395 }
2400 SIZEOF_20KBUF,
2406 }
2418 /* if bcc exists, make sure it's exposed so nothing's
2419 * sent by mistake...
2420 */
2436 }
2450 }
2454 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2459 #endif
2465 }
2467 /*
2468 * If this is a reply to news, don't show the regular email
2469 * recipient headers (unless they are non-empty).
2470 */
2485 }
2486 else
2488 }
2490 /*
2491 * If this address doesn't already have a value, then we check
2492 * for a default value assigned by the user.
2493 */
2504 /*
2505 * Try to set To based on Lcc. Don't attempt Fcc.
2506 */
2544 }
2545 }
2552 }
2556 }
2566 }
2567 }
2569 /* if we still don't have a from */
2572 }
2574 /*
2575 * Addr is already set in the rest of the cases.
2576 */
2580 /*
2581 * We get to this case of the ifelse if the from or reply-to
2582 * addr was set by a role above.
2583 */
2585 /* figure out the default value */
2594 }
2596 /* if value set by role is different from default, show it */
2600 /* malformed */
2604 }
2608 }
2613 /*
2614 * These three are different from the others because we
2615 * might add the addresses to what is already there instead
2616 * of replacing.
2617 */
2641 ;
2647 }
2654 }
2657 }
2676 }
2679 }
2684 }
2689 /* outgoing2strings will alloc the string pf->scratch below */
2698 else
2704 }
2736 /* if no value, use default */
2739 }
2743 }
2746 }
2757 }
2759 /*
2760 * We may or may not want to give the user the chance to edit
2761 * the From and Reply-To lines. If they are listed in either
2762 * Default-composer-hdrs or Customized-hdrs, then they can edit
2763 * them, else no.
2764 * If canedit is not set, that means that this header is not in
2765 * the user's customized-hdrs. If rich_header is set, that
2766 * means that this header is not in the user's
2767 * default-composer-hdrs (since From and Reply-To are rich
2768 * by default). So, don't give it an he to edit with in that case.
2769 *
2770 * For other types, just not setting canedit will cause it to be
2771 * uneditable, regardless of what the user does.
2772 */
2775 /* to allow it, we let this fall through to the reply-to case below */
2786 }
2792 }
2795 he++;
2796 }
2804 }
2805 else
2806 he++;
2809 }
2810 }
2812 /*
2813 * This is so the builder can tell the composer to fill the affected
2814 * field based on the value in the field on the left.
2815 *
2816 * Note that this mechanism isn't completely general. Each entry has
2817 * only a single next_affected, so if some other entry points an
2818 * affected entry at an entry with a next_affected, they all inherit
2819 * that next_affected. Since this isn't used much a careful ordering
2820 * of the affected fields should make it a sufficient mechanism.
2821 */
2830 /*
2831 * Set up headerentries for custom fields.
2832 * NOTE: "i" is assumed to now index first custom field in sending
2833 * order.
2834 */
2852 /* change default text into an ADDRESS */
2853 /* strip quotes around whole default */
2865 }
2884 }
2888 /* use first 8 characters for prompt */
2893 he++;
2894 }
2896 /*
2897 * Make sure at least *one* field is displayable...
2898 */
2903 }
2905 /*
2906 * None displayable!!! Warn and display defaults.
2907 */
2915 }
2917 /*
2918 * Save information about body which set_mime_type_by_grope might change.
2919 * Then, if we get an error sending, we reset these things so that
2920 * grope can do it's thing again after we edit some more.
2921 */
2924 else
2930 /*----------------------------------------------------------------------
2931 Loop calling the editor until everything goes well
2932 ----*/
2936 /* Reset body to what it was when we started. */
2939 else
2941 /*
2942 * set initial cursor position based on how many times we've been
2943 * thru the loop...
2944 */
2947 }
2951 }
2954 /* set the start_here bit in correct header */
2960 }
2962 /* If didn't find it, we start in body. */
2965 }
2968 }
2970 /* in case these were turned on in previous pass through loop */
2974 }
2979 /*
2980 * If a sending attempt failed after we passed the message text
2981 * thru a user-defined filter, "orig_so" points to the original
2982 * text. Replace the body's encoded data with the original...
2983 */
2991 }
2993 /*
2994 * Convert the envelope and body to the string format that
2995 * pico can edit
2996 */
3000 /*
3001 * If this isn't the first time through this loop, we may have
3002 * freed some of the FreeText headers below so that they wouldn't
3003 * show up as empty headers in the finished message. Need to
3004 * alloc them again here so they can be edited.
3005 */
3011 }
3013 /*
3014 * If From is exposed, probably by a role, then start the cursor
3015 * on the first line which isn't filled in. If it isn't, then we
3016 * don't move the cursor, mostly for back-compat.
3017 */
3028 }
3029 }
3031 #ifdef _WINDOWS
3033 #endif
3038 /* turn off user input timeout when in composer */
3046 #ifdef _WINDOWS
3048 #endif
3051 /*
3052 * Only reinitialize signals if we didn't receive an interesting
3053 * one while in pico, since pico's return is part of processing that
3054 * signal and it should continue to be ignored.
3055 */
3059 /*
3060 * We're going to save in DEADLETTER. Dump attachments first.
3061 */
3065 /* Turn strings back into structures */
3068 /* Make newsgroups NULL if it is "" (so won't show up in headers) */
3073 }
3075 /* Make subject NULL if it is "" (so won't show up in headers) */
3079 /* remove custom fields that are empty */
3085 }
3086 }
3087 }
3091 /*-------- Stamp it with a current date -------*/
3104 /* Set return_path based on From which is going to be used */
3110 /*
3111 * Don't ever believe the sender that is there.
3112 * If From doesn't look quite right, generate our own sender.
3113 */
3117 /*
3118 * If the LHS of the address doesn't match, or the RHS
3119 * doesn't match one of localdomain or hostname,
3120 * then add a sender line (really X-X-Sender).
3121 *
3122 * Don't add a personal_name since the user can change that.
3123 */
3125 &&
3136 }
3141 }
3143 /*----- Message is edited, now decide what to do with it ----*/
3145 /*=========== Postpone or Interrupted message ============*/
3163 }
3165 /*
3166 * The idea here is to use the Fcc: writing facility
3167 * to append to the special postponed message folder...
3168 *
3169 * NOTE: the strategy now is to write the message and
3170 * all attachments as they exist at composition time.
3171 * In other words, attachments are postponed by value
3172 * and not reference. This may change later, but we'll
3173 * need a local "message/external-body" type that
3174 * outgoing2strings knows how to properly set up for
3175 * the composer. Maybe later...
3176 */
3183 /*--- Addresses didn't check out---*/
3187 }
3189 /*
3190 * Build the local message copy so.
3191 *
3192 * In the HUP case, we'll write the bezerk delimiter by
3193 * hand and output the message directly into the folder.
3194 * It's not only faster, we don't have to worry about
3195 * c-client reentrance and less hands paw over the data so
3196 * there's less chance of a problem.
3197 *
3198 * In the Postpone case, just create it if the user wants to
3199 * and create a temporary storage object to write into. */
3200 fake_hup:
3206 #if defined(DOS) || defined(OS2)
3207 /*
3208 * we can't assume anything about root or home dirs, so
3209 * just plunk it down in the same place as the pinerc
3210 */
3218 }
3223 }
3224 else
3225 #endif
3227 ps_global->VAR_OPER_DIR
3249 }
3257 }
3260 }
3261 else
3276 else
3280 }
3281 }
3282 }
3283 }
3290 }
3292 /*
3293 * Store the cursor position
3294 *
3295 * First find the header entry with the start_here
3296 * bit set, if any. This means the editor is telling
3297 * us to start on this header field next time.
3298 */
3304 }
3306 /* If there wasn't one, ":" means we start in the body. */
3318 }
3325 }
3328 }
3334 /* copy fcc line to postponed or interrupted folder */
3338 /* plug error into header for later display to user */
3343 }
3345 /*
3346 * if reply, write (UID)folder header field so we can
3347 * later flag the replied-to message \\ANSWERED
3348 * DON'T save MSGNO's.
3349 */
3359 }
3375 /*
3376 * Logically, this ought to be part of pf_uid, but this
3377 * was added later and so had to be in a separate header
3378 * for backwards compatibility.
3379 */
3385 }
3387 /* Save cursor position */
3397 }
3399 /*
3400 * Work around c-client reply-to bug. C-client will
3401 * return a reply_to in an envelope even if there is
3402 * no reply-to header field. We want to note here whether
3403 * the reply-to is real or not.
3404 */
3410 else
3412 }
3414 /* Save the role-specific smtp server */
3420 /*
3421 * Turn the list of smtp servers into a space-
3422 * delimited list in a single string.
3423 */
3435 }
3438 }
3444 else
3446 }
3448 /* Save the role-specific nntp server */
3456 /*
3457 * Turn the list of nntp servers into a space-
3458 * delimited list in a single string.
3459 */
3471 }
3474 }
3475 }
3476 else
3483 else
3485 }
3487 /*
3488 * Write the list of custom headers to the
3489 * X-Our-Headers header so that we can recover the
3490 * list in redraft.
3491 */
3509 }
3512 }
3514 /*
3515 * We need to make sure any header values that got cleared
3516 * get written to the postponed message (they won't if
3517 * pf->text is NULL). Otherwise, we can't tell previously
3518 * non-existent custom headers or default values from
3519 * custom (or other) headers that got blanked in the
3520 * composer...
3521 */
3526 /*
3527 * We're saving the message for use later. It may be that the
3528 * characters in the message are not all convertible to the
3529 * user's posting_charmap. We'll save it as UTF-8 instead
3530 * and worry about that the next time they try to send it.
3531 * Use a different save pointer just to be sure we don't
3532 * mess up the other stuff. We should probably make the
3533 * charset an argument.
3534 *
3535 * We also need to fix the charset of the body part
3536 * the user is editing so that we can read it back
3537 * successfully when we resume the composition.
3538 */
3541 {
3546 else
3552 ;
3559 }
3560 }
3574 }
3591 }
3592 else
3599 }
3600 else
3603 }
3605 /* discontinue coerced UTF-8 posting */
3609 }
3610 else
3615 /*
3616 * Special Hack #291: if any hi-byte bits are set in
3617 * editor's result, we put them there.
3618 */
3625 }
3632 else
3637 }
3650 }
3656 }
3657 }
3659 /*------ Must be sending mail or posting ! -----*/
3666 /* --- If posting, confirm with user ----*/
3673 }
3683 continue_with_only_fcc++;
3684 }
3690 }
3691 }
3694 /*--- Addresses didn't check out---*/
3697 }
3700 && !continue_with_only_fcc
3709 local_redraft_pos
3714 }
3722 local_redraft_pos
3727 }
3735 local_redraft_pos
3740 }
3744 /*---- Check out fcc -----*/
3746 /*
3747 * If special name "inbox" then replace it with the
3748 * real inbox path.
3749 */
3757 }
3760 /* lmc.text_only set on command line */
3762 /* ---- Open or allocation of fcc failed ----- */
3765 /*
3766 * Find field entry associated with fcc, and start
3767 * composer on it...
3768 */
3774 }
3775 else
3777 }
3778 else
3781 /*---- Take care of any requested prefiltering ----*/
3789 }
3791 /*------ Actually post -------*/
3806 }
3807 }
3816 }
3817 else
3819 }
3821 /*
3822 * BUG: IF we've posted the message *and* an fcc was specified
3823 * then we've already got a neatly formatted message in the
3824 * lmc.so. It'd be nice not to have to re-encode everything
3825 * to insert it into the smtp slot...
3826 */
3828 /*
3829 * Turn on "undisclosed recipients" header if no To or cc.
3830 */
3835 }
3840 }
3842 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
3843 /*
3844 * If requested, launch backgroud posting...
3845 */
3853 /*
3854 * Put us in new process group...
3855 */
3858 /* BUG: should fix argv[0] to indicate what we're up to */
3860 /*
3861 * If there are any live streams, pretend we never
3862 * knew them. Problem is two processes writing
3863 * same server process.
3864 * This is not clean but we're just going to exit
3865 * right away anyway. We just want to be sure to leave
3866 * the stuff that the parent is going to use alone.
3867 * The next three lines will disable the re-use of the
3868 * existing streams and cause us to open a new one if
3869 * needed.
3870 */
3875 /* quell any display output */
3878 /*------- Actually mail the message ------*/
3887 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3888 else
3890 }
3893 call_mailer_flags,
3894 call_mailer_file_result,
3900 }
3902 /*----- Was there an fcc involved? -----*/
3904 /*------ Write it if at least something worked ------*/
3916 }
3918 /*-- Now actually copy to fcc folder and close --*/
3924 }
3931 }
3934 }
3937 /*
3938 * Encode child's result in hi-byte of
3939 * editor's result
3940 */
3943 }
3946 }
3952 }
3961 }
3972 }
3975 /*------- Actually mail the message ------*/
3983 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3984 else
3986 }
3989 call_mailer_flags,
3990 call_mailer_file_result,
3996 }
3998 /*----- Was there an fcc involved? -----*/
4000 /*------ Write it if at least something worked ------*/
4011 }
4013 /*-- Now actually copy to fcc folder and close --*/
4018 }
4024 }
4027 }
4029 /*----- Mail Post FAILED, back to composer -----*/
4034 /*
4035 * Find field entry associated with fcc, and start
4036 * composer on it...
4037 */
4045 }
4053 }
4055 /*
4056 * If message sent *completely* successfully, there's a
4057 * reply struct AND we're allowed to write back state, do it.
4058 * But also protect against shifted message numbers due
4059 * to new mail arrival. Since the number passed is based
4060 * on the real imap msg no, AND we're sure no expunge has
4061 * been done, just fix up the sorted number...
4062 */
4065 /*----- Signed, sealed, delivered! ------*/
4070 }
4071 }
4090 }
4115 }
4118 /*
4119 * Check for subject in outgoing message.
4120 *
4121 * Asks user whether to proceed with no subject.
4122 */
4123 int
4125 {
4137 else
4139 }
4142 }
4146 }
4149 /*
4150 * Check for fcc in outgoing message.
4151 *
4152 * Asks user whether to proceed with no fcc.
4153 */
4154 int
4156 {
4164 else
4166 }
4169 }
4172 /*
4173 * Confirm that the user wants to send to MAILER-DAEMON
4174 */
4175 int
4177 {
4180 }
4183 void
4185 {
4191 }
4192 }
4195 int
4197 {
4204 }
4207 /*
4208 * call__mailer_file_result - some results from call_mailer might be in a file.
4209 * dislplay that file.
4210 */
4211 void
4213 {
4217 }
4220 }
4221 }
4222 }
4224 void
4226 {
4242 }
4243 }
4247 /*
4248 * This is specialized routine. It assumes that the only things that we
4249 * care about restoring are the body type, subtype, encoding and the
4250 * state of the charset parameter. It also assumes that if the charset
4251 * parameter exists when we save it, it won't be removed later.
4252 */
4253 BODY_PARTICULARS_S *
4255 {
4273 }
4277 }
4280 }
4283 void
4285 {
4307 }
4311 else
4315 }
4316 }
4319 /*
4320 * This can't happen because grope never removes
4321 * the charset parameter.
4322 */
4325 }
4326 /*
4327 else{
4328 ok, still no parameter
4329 }
4330 */
4331 }
4332 }
4338 }
4339 }
4342 void
4344 {
4353 }
4354 }
4357 /*----------------------------------------------------------------------
4358 Build a status message suitable for framing
4360 Returns: pointer to resulting buffer
4361 ---*/
4364 {
4403 /* dots on end of fixed, no fcc */
4407 }
4409 /* include whole fixed part, quotes and dots at end of fcc name */
4419 }
4421 /* whole thing */
4427 }
4433 }
4435 /* Callback from Pico to set the conditions for Alpine to start a new thread
4436 */
4438 void
4440 {
4442 }
4446 /*----------------------------------------------------------------------
4447 Call back for pico to insert the specified message's text
4449 Args: n -- message number to format
4450 f -- function to use to output the formatted message
4453 Returns: returns msg number formatted on success, zero on error.
4454 ----*/
4455 long
4457 {
4469 }
4471 /* temporarily assign a new quote string */
4475 /* build separator line */
4478 /* actually write message text */
4484 }
4489 }
4492 /*----------------------------------------------------------------------
4493 Call back for pico to prompt the user for exit confirmation
4495 Args: dflt -- default answer for confirmation prompt
4497 Returns: either NULL if the user accepts exit, or string containing
4498 reason why the user declined.
4499 ----*/
4500 int
4503 {
4530 }
4537 }
4544 /*
4545 * Build list of available filters...
4546 */
4550 ;
4558 }
4564 }
4569 }
4570 else
4579 }
4586 }
4587 }
4601 /* set global_filter_pointer to desired filter or NULL if none */
4602 /* prepare two keymenu slots for selecting filter */
4615 }
4618 /* setup keymenu slot to toggle verbose mode */
4623 }
4626 /* setup keymenu slot to toggle flowed mode */
4632 }
4635 /* setup keymenu slot to toggle attacment on fcc */
4640 }
4642 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
4648 }
4649 #endif
4656 #ifdef SMIME
4671 }
4672 }
4673 #endif
4678 /* setup keymenu slots to toggle dsn bits */
4696 }
4708 }
4717 else
4733 lparen++;
4734 }
4735 else
4737 }
4740 }
4747 lparen++;
4748 }
4752 }
4753 }
4760 }
4761 else
4763 }
4770 lparen++;
4771 }
4772 else
4774 }
4784 }
4791 lparen++;
4792 }
4793 else
4795 }
4800 }
4807 lparen++;
4808 }
4812 }
4813 }
4816 }
4818 #ifdef SMIME
4824 lparen++;
4825 }
4829 }
4830 }
4833 }
4840 lparen++;
4841 }
4845 }
4846 }
4849 }
4850 #endif
4888 }
4889 }
4900 h_send_prompt,
4901 RB_NORM);
4902 else
4913 h_send_prompt,
4914 RB_NORM);
4918 }
4922 }
4926 }
4929 }
4932 }
4935 }
4939 else
4944 }
4947 }
4952 }
4956 /* turn off related bits */
4959 }
4962 /* turn off related bits */
4965 }
4968 /* turn off related bits */
4971 }
4974 }
4975 }
4977 /*
4978 * When you turn on DSN, the default is to notify on
4979 * failure, success, or delay; and to return the whole
4980 * body on failure.
4981 */
4983 }
4991 }
4999 else
5001 }
5002 }
5003 #ifdef SMIME
5007 }
5011 }
5012 #endif
5026 }
5028 /* remember selection */
5041 }
5042 }
5053 }
5056 /*
5057 * Allow user to choose a priority for sending.
5058 *
5059 * Returns an allocated priority on success, NULL otherwise.
5060 */
5063 {
5072 cnt++;
5083 lp++;
5084 }
5091 /* TRANSLATORS: SELECT A PRIORITY is a screen title
5092 TRANSLATORS: Print something1 using something2.
5093 "priorities" is something1 */
5097 starting_val);
5107 }
5110 int
5112 {
5114 }
5117 /*----------------------------------------------------------------------
5118 Call back for pico to display mime type of attachment
5120 Args: file -- filename being attached
5122 Returns: returns 1 on success (message queued), zero otherwise (don't know
5123 type so nothing queued).
5124 ----*/
5125 int
5127 {
5136 /* don't know where the cursor's been, reset it */
5142 }
5143 }
5151 }
5152 else
5157 }
5160 /*----------------------------------------------------------------------
5161 Call back for pico to receive an uploaded message
5163 Args: fname -- name for uploaded file (empty if they want us to assign it)
5164 size -- pointer to long to hold the attachment's size
5166 Notes: the attachment is uploaded to a temp file, and
5168 Returns: TRUE on success, FALSE otherwise
5169 ----*/
5170 int
5172 {
5190 }
5191 }
5192 else
5209 }
5217 }
5218 else
5225 }
5230 {
5241 };
5252 }
5256 }
5257 else
5259 }
5263 }
5266 /*----------------------------------------------------------------------
5267 Pass the first text segment of the message thru the "send filter"
5269 Args: body pointer and address for storage object of old data
5271 Returns: returns 1 on success, zero on error.
5272 ----*/
5273 int
5276 {
5285 #define DO_HEADERS 1
5291 /*
5292 * We need WRITE_TO_LOCALE here because the user is going to
5293 * be operating on tmpf. We need to change it back after they
5294 * are done.
5295 */
5300 }
5302 /*
5303 * If the headers are wanted for filtering, we can just
5304 * stick them in the tmpf file that is already there before
5305 * putting the body in.
5306 */
5313 }
5323 }
5324 else
5326 }
5328 /*
5329 * Gf_filter wants a single storage object to read from.
5330 * If headers are wanted for filtering we'll have to put them
5331 * and the body into a temp file first and then use that
5332 * as the storage object for gf_filter.
5333 * We don't use WRITE_TO_LOCALE in this case because gf_filter
5334 * takes care of that.
5335 */
5337 /* put headers in our_tmpf_so */
5344 /* put body in our_tmpf_so */
5353 /* tell gf_filter to read from our_tmpf_so instead of *so */
5355 }
5356 else
5358 }
5359 else
5377 /* now we undo the WRITE_FROM_LOCALE change in tmpf */
5384 }
5385 else
5387 }
5388 else
5390 }
5391 else
5393 }
5394 else
5397 pipe_callback);
5404 #ifdef _WINDOWS
5406 /*
5407 * Can't really be using stdout, so don't print message that
5408 * gets printed in the else. Ideally the program being called
5409 * will wait after showing the message, we might want to look
5410 * into doing the waiting in console based apps... or not.
5411 */
5412 #else
5421 }
5431 /*
5432 * If the command said it would return new MIME
5433 * mime type data, check it out...
5434 */
5446 ;
5464 }
5467 }
5470 }
5471 }
5473 /*
5474 * Reevaluate the encoding in case form's changed...
5475 */
5478 }
5482 }
5483 else
5485 }
5488 }
5489 else
5495 }
5500 }
5507 }
5513 errstr);
5516 }
5519 }
5522 /*----------------------------------------------------------------------
5523 Copy the newsgroup name of the given mailbox into the given buffer
5525 Args:
5527 Returns:
5528 ----*/
5529 void
5531 {
5532 NETMBX mb;
5537 }
5540 }
5541 else
5543 }
5546 /*----------------------------------------------------------------------
5547 Generate and send a message back to the pine development team
5549 Args: none
5551 Returns: none
5552 ----*/
5553 void
5555 {
5564 }
5592 }
5593 else
5600 }
5603 /*----------------------------------------------------------------------
5604 Set up fields for passing to pico. Assumes first text part is
5605 intended to be passed along for editing, and is in the form of
5606 of a storage object brought into existence sometime before pico_send().
5607 -----*/
5608 void
5611 {
5614 /*
5615 * SIMPLIFYING ASSUMPTION #37: the first TEXT part's storage object
5616 * is guaranteed to be of type PicoText!
5617 */
5621 /* mark storage object as user edited */
5624 }
5631 /*
5632 * We used to jump out the window if the first part wasn't text,
5633 * but that may not be the case when bouncing a message with
5634 * a leading non-text segment. So, IT'S UNDERSTOOD that the
5635 * contents of the first part to send is still ALWAYS in a
5636 * PicoText storage object, *AND* if that object doesn't contain
5637 * data of type text, then it must contain THE ENCODED NON-TEXT
5638 * DATA of the piece being sent.
5639 *
5640 * It's up to the programmer to make sure that such a message is
5641 * sent via pine_simple_send and never get to the composer via
5642 * pine_send.
5643 *
5644 * Make sense?
5645 */
5648 /* mark storage object as user edited */
5652 /*
5653 * If we already had a list, blast it now, so we can build a new
5654 * attachment list that reflects what's really there...
5655 */
5660 /* Simplifyihg assumption #28e. (see cross reference)
5661 All parts in the body passed in here that are not already
5662 in the attachments list are added to the end of the attachments
5663 list. Attachment items not in the body list will be taken care
5664 of in strings2outgoing, but they are unlikey to occur
5665 */
5668 /* Already in list? */
5672 ;
5686 }
5690 }
5691 }
5692 else
5698 /*
5699 * If we can find a "name" parm, display that too...
5700 */
5702 /* Convert any [ or ]'s the name contained */
5710 }
5711 else
5731 }
5732 }
5733 }
5734 }
5737 /*------------------------------------------------------------------
5738 Malloc strings to pass to composer editor because it expects
5739 such strings so it can realloc them
5740 -----------------------------------------------------------------*/
5741 /*
5742 * turn any address fields into text strings
5743 */
5744 /*
5745 * SIMPLIFYING ASSUMPTION #116: all header strings are understood
5746 * NOT to be RFC1522 decoded. Said differently, they're understood
5747 * to be RFC1522 ENCODED as necessary. The intent is to preserve
5748 * original charset tagging as far into the compose/send pipe as
5749 * we can.
5750 */
5761 /*
5762 * Scan for and fix-up patently bogus fields.
5763 *
5764 * NOTE: collaboration with this code and what's done in
5765 * reply.c:reply_cp_addr to package up the bogus stuff
5766 * is required.
5767 */
5773 /*
5774 * Rfc822_cat has been changed so that it now quotes
5775 * this sometimes. So we have to look out for quotes
5776 * which confuse the decoder. It was only quoting
5777 * because we were putting \r \n in the input, I think.
5778 */
5801 }
5809 /*
5810 * Replace control characters with ^C notation, unless
5811 * some conditions are met (see istrncpy).
5812 * If user doesn't edit, then we switch back to the
5813 * original version. If user does edit, then all bets
5814 * are off.
5815 */
5821 }
5824 }
5825 }
5844 }
5849 }
5854 /*
5855 * Replace control characters with ^C notation, unless
5856 * some conditions are met (see istrncpy).
5857 * If user doesn't edit, then we switch back to the
5858 * original version. If user does edit, then all bets
5859 * are off.
5860 */
5866 }
5869 }
5870 }
5876 }
5877 }
5880 /*----------------------------------------------------------------------
5881 Restore fields returned from pico to form useful to sending
5882 routines.
5883 -----*/
5884 void
5886 {
5892 /*
5893 * turn any local address strings into address lists
5894 */
5915 }
5927 }
5933 }
5936 }
5942 }
5945 /*----------------------------------------------------------------------
5947 The head of the body list here is always either TEXT or MULTIPART. It may be
5948 changed from TEXT to MULTIPART if there are attachments to be added
5949 and it is not already multipart.
5950 ----*/
5951 void
5953 {
5962 /*
5963 * if conditions are met short circuit MIME wrapping
5964 */
5967 /* only override assigned encoding if it might need upgrading */
5978 }
5981 }
5984 /*-- Current type is text, but there are attachments to add --*/
5985 /*-- Upgrade to a TYPEMULTIPART --*/
5990 /*
5991 * Why do we do this?
5992 * The problem is that base64 or quoted-printable encoding is
5993 * sensitive to having random data appended to it's end. If
5994 * we use a single part TEXT message and something in between
5995 * us and the end appends advertising without adjusting for
5996 * the encoding, the message is screwed up. So we wrap the
5997 * text part inside a multipart and then the appended data
5998 * will come after the boundary.
5999 *
6000 * We wish we could do this on the way out the door in a
6001 * child of post_rfc822_output because at that point we know
6002 * the character set and the encoding being used. For example,
6003 * iso-2022-jp is an encoding that is not sensitive to data
6004 * appended to the end, so it wouldn't need to be wrapped.
6005 * We could conceivably have post_rfc822_body inspect the
6006 * body and change it before doing the output. It would work
6007 * but would be very fragile. We'd be passed a body from
6008 * c-client to output and instead of just doing the output
6009 * we'd change the body and then output it. Not worth it
6010 * since the multipart wrapping is completely correct for
6011 * MIME-aware mailers.
6012 */
6014 /* move contents which were NOT copied */
6017 }
6024 }
6028 }
6031 /*-- Now type must be MULTIPART with first part text --*/
6034 }
6036 /*------ Go through the parts list remove those to be deleted -----*/
6039 /* already existed? */
6043 /*
6044 * decode original to see if it matches what was decoded
6045 * when we sent it in.
6046 */
6057 /* encoding happens as msg text is written */
6059 }
6065 }
6074 }
6075 else
6077 }
6079 /*---------- Now add any new attachments ---------*/
6085 /*
6086 * the idea is handle ALL attachments as open FILE *'s. Actual
6087 * encoding and such is handled at the time the message
6088 * is shoved into the mail slot or written to disk...
6089 *
6090 * Also, we never unlink a file, so it's up to whoever opens
6091 * it to deal with tmpfile issues.
6092 */
6100 }
6107 /*
6108 * Set type to unknown and let set_mime_type_by_* figure it out.
6109 * Always encode attachments we add as BINARY.
6110 */
6117 }
6124 /* Add name attribute for backward compatibility */
6133 }
6134 else
6138 pa->filename
6142 /* Then set the Content-Disposition ala RFC1806 */
6153 }
6154 else
6158 pa->filename
6161 }
6165 }
6167 /*
6168 * Now, if this multipart has but one text piece (that is, no
6169 * attachments), then downgrade from a composite type to a discrete
6170 * text/plain message if CTE is not 8bit.
6171 */
6177 /* Clone the interesting body part */
6180 /* and rub out what we don't want cleaned up when it's free'd */
6184 }
6188 }
6191 /*
6192 * Fill in text BODY part's structure
6193 *
6194 */
6195 void
6197 {
6205 }
6208 /*
6209 * free_attachment_list - free attachments in given list
6210 */
6211 void
6213 {
6229 }
6240 }
6241 }
6244 void
6246 {
6258 }
6261 /*
6262 * view_as_rich - set the rich_header flag
6263 *
6264 * name - name of the header field
6265 * deflt - default value to return if user didn't set it
6266 *
6267 * Note: if the user tries to turn them all off with "", then
6268 * we take that to mean default, since otherwise there is no
6269 * way to get to the headers.
6270 */
6271 int
6273 {
6283 }
6286 }
6288 }
6291 /*
6292 * background_posting - return whether or not we're already in the process
6293 * of posting
6294 */
6295 int
6297 {
6303 }
6306 }
6309 /*----------------------------------------------------------------------
6310 Validate the given subject relative to any news groups.
6312 Args: none
6314 Returns: always returns 1, but also returns error if
6315 ----*/
6316 int
6318 {
6325 /*
6326 * Now look for any header entry we passed to pico that has to do
6327 * with news. If there's no subject, gripe.
6328 */
6336 }
6337 }
6340 }
6343 /*
6344 * This is the build_address used by the composer to check for an address
6345 * in the addrbook.
6346 *
6347 * Args: to -- the passed in line to parse
6348 * full_to -- Address of a pointer to return the full address in.
6349 * This will be allocated here and freed by the caller.
6350 * error -- Address of a pointer to return an error message in.
6351 * This will be allocated here and freed by the caller.
6352 * barg -- Address of a pointer to return the fcc in is in
6353 * fcc->tptr. It will have already been allocated by the
6354 * caller but we may free it and reallocate if we wish.
6355 * Caller will free it.
6356 *
6357 * Result: 0 is returned if address was OK,
6358 * -1 if address wasn't OK.
6359 *
6360 * Side effect: Can flush addrbook entry cache entries so they need to be
6361 * re-fetched afterwords.
6362 */
6363 int
6365 {
6368 BuildTo bldto;
6376 /* check to see if to string is empty to avoid work */
6385 }
6393 /* No guarantee cursor or status line is how we saved it */
6401 /*
6402 * If we end up jumping back here because somebody else changed one of
6403 * our addrbooks out from underneath us, we may well leak some memory.
6404 * That's probably ok since this will be very rare.
6405 *
6406 * The reason for the memcpy of the jmp_buf is that we may actually
6407 * be indirectly calling this function from within the address book.
6408 * For example, we may be in the address book screen and then run
6409 * the ComposeTo command which puts us in the composer, then we call
6410 * build_address from there which resets addrbook_changed_unexpectedly.
6411 * Once we leave build_address we need to reset addrbook_changed_un...
6412 * because this position on the stack will no longer be valid.
6413 * Same is true of the other setjmp's in this file which are wrapped
6414 * in memcpy calls.
6415 */
6434 }
6436 ab_nesting_level++;
6443 ab_nesting_level--;
6447 /*
6448 * Have to rfc1522_decode the full_to string before sending it back.
6449 */
6458 /* p == q means that decoding happened, p is decoded *full_to */
6462 }
6463 else
6465 }
6470 /* Pt will point to headents[Fcc].bldr_private */
6475 /*
6476 * If *barg->aff is set, that means fcc was set from a list
6477 * during some previous builder call.
6478 * If the current To line contains the old expansion as a prefix, then
6479 * we should leave things as they are. In order to decide that,
6480 * we look at a hash value computed from the strings.
6481 */
6493 }
6494 else
6496 }
6502 /* replace fcc value */
6513 }
6526 }
6528 /*
6529 * If result is reproducible, we don't keep track here.
6530 */
6533 }
6534 }
6535 }
6536 else
6538 }
6540 /* This is so pico will erase the old message */
6547 }
6550 /*
6551 * This is the builder used by the composer for the Lcc line.
6552 *
6553 * Args: lcc -- the passed in Lcc line to parse
6554 * full_lcc -- Address of a pointer to return the full address in.
6555 * This will be allocated here and freed by the caller.
6556 * error -- Address of a pointer to return an error message in.
6557 * This is not allocated so should not be freed by the caller.
6558 * barg -- This is a pointer to text for affected entries which
6559 * we may be changing. The first one in the list is the
6560 * To entry. We may put the name of the list in empty
6561 * group syntax form there (like List Name: ;).
6562 * The second one in the list is the fcc field.
6563 * The tptr members already point to text allocated in the
6564 * caller. We may free and reallocate here, caller will
6565 * free the result in any case.
6566 *
6567 * Result: 0 is returned if address was OK,
6568 * -1 if address wasn't OK.
6569 *
6570 * Side effect: Can flush addrbook entry cache entries so they need to be
6571 * re-fetched afterwords.
6572 */
6573 int
6575 {
6579 BuildTo bldlcc;
6590 /* check to see if to string is empty to avoid work */
6599 }
6608 /*
6609 * If we end up jumping back here because somebody else changed one of
6610 * our addrbooks out from underneath us, we may well leak some memory.
6611 * That's probably ok since this will be very rare.
6612 */
6632 }
6634 ab_nesting_level++;
6638 /*
6639 * To is first affected_entry and Fcc is second.
6640 * The conditional stuff for the fcc argument says to only change the
6641 * fcc if the fcc pointer is passed in non-null, and the To pointer
6642 * is also non-null. If they are null, that means they've already been
6643 * entered (are sticky). We don't affect fcc if either fcc or To has
6644 * been typed in.
6645 */
6647 full_lcc,
6648 error,
6655 ab_nesting_level--;
6659 /* full_lcc is what ends up in the Lcc: line */
6663 /*
6664 * Have to rfc1522_decode the full_lcc string before sending it back.
6665 */
6671 }
6672 else
6674 }
6676 /* to is what ends up in the To: line */
6681 /*
6682 * Have to rfc1522_decode the full_to string before sending it back.
6683 */
6688 /*
6689 * If the caller wants us to try to preserve the charset
6690 * information (they set aff) we copy it into encoded->etext.
6691 * We don't have to worry about pasting together pieces of
6692 * etext like we do in build_address because whenever the
6693 * Lcc line is setting the To line it will be setting the
6694 * whole line, not modifying it.
6695 * Pt will point to headents[To].bldr_private.
6696 */
6704 }
6705 }
6709 }
6710 else
6717 /*
6718 * This part is recording the fact that the To line was set to
6719 * what it is by entering something on the Lcc line. In particular,
6720 * if a list alias was entered here then the fullname of the list
6721 * goes in the To line. We save this affector information so that
6722 * we can tell it shouldn't be modified if we call build_addr_lcc
6723 * again unless we actually modified what's in the Lcc line so that
6724 * it doesn't start with the same thing. The problem we're solving
6725 * is that the contents of the Lcc line no longer look like the
6726 * list they were derived from.
6727 * Pt will point to headents[To].bldr_private.
6728 */
6743 }
6744 else
6746 }
6753 /* replace to value */
6769 }
6775 }
6782 }
6795 }
6797 /*
6798 * If result is reproducible, we don't keep track here.
6799 */
6802 }
6803 }
6804 }
6805 else
6807 }
6812 /*
6813 * If *barg->next->aff is set, that means fcc was set from a list
6814 * during some previous builder call. If the current Lcc line
6815 * contains the old expansion as a prefix, then we should leave
6816 * things as they are. In order to decide that we look at a hash
6817 * value computed from the strings.
6818 * Pt will point to headents[Fcc].bldr_private
6819 */
6835 }
6836 else
6838 }
6845 /* replace fcc value */
6856 }
6869 }
6871 /*
6872 * If result is reproducible, we don't keep track here.
6873 */
6876 }
6877 }
6878 }
6879 else
6881 }
6890 }
6893 /*----------------------------------------------------------------------
6894 Verify and canonicalize news groups names.
6895 Called from the message composer
6897 Args: given_group -- List of groups typed by user
6898 expanded_group -- pointer to point to expanded list, which will be
6899 allocated here and freed in caller. If this is
6900 NULL, don't attempt to validate.
6901 error -- pointer to store error message
6902 fcc -- pointer to point to fcc, which will be
6903 allocated here and freed in caller
6905 Returns: 0 if all is OK
6906 -1 if addresses weren't valid
6908 Test the given list of newstroups against those recognized by our nntp
6909 servers. Testing by actually trying to open the list is much cheaper, both
6910 in bandwidth and memory, than yanking the whole list across the wire.
6911 ----*/
6912 int
6913 news_build(char *given_group, char **expanded_group, char **error, BUILDER_ARG *fcc, int *mangled)
6914 {
6925 /* assign any new fcc to the BUILDER_ARG */
6928 /* it changed */
6933 }
6934 }
6938 }
6940 /* deal with any busy indicator */
6948 }
6952 }
6955 void
6957 {
6959 }
6962 #if defined(DOS) || defined(OS2)
6964 /*----------------------------------------------------------------------
6965 Verify that the necessary pieces are around to allow for
6966 message sending under DOS
6968 Args: strict -- tells us if a remote stream is required before
6969 sending is permitted.
6971 The idea is to make sure pine knows enough to put together a valid
6972 from line. The things we MUST know are a user-id, user-domain and
6973 smtp server to dump the message off on. Typically these are
6974 provided in pine's configuration file, but if not, the user is
6975 queried here.
6976 ----*/
6977 int
6979 {
6982 HelpType help;
6984 /*
6985 * query for user name portion of address, use IMAP login
6986 * name as default
6987 */
6989 NETMBX mb;
6997 }
6999 /* no user-id prompting if set */
7010 }
7011 else
7013 }
7014 else
7018 /* No prompt, just assume mailbox login is user-id */
7021 }
7037 }
7041 }
7047 }
7049 /* save the name */
7054 && !no_prompt_user_id
7057 }
7061 }
7062 }
7064 /* query for personal name */
7082 }
7086 }
7095 }
7099 }
7100 }
7101 }
7103 /*
7104 * query for host/domain portion of address, using IMAP
7105 * host as default
7106 */
7116 }
7117 else
7134 }
7138 }
7144 }
7146 /* save the name */
7156 }
7161 }
7162 }
7164 /* check for smtp server */
7176 }
7177 else
7194 }
7198 }
7204 }
7206 /* save the name */
7213 }
7216 }