| blob | bc70dadf85bb8f6cf6ea6cd04ec0b7f3a02dfa46 |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2013-2020 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 ====*/
74 /*
75 * macro to bind pico's headerentry pointer to PINEFIELD "extdata" hook
76 */
77 #define HE(PF) ((struct headerentry *)((PF)->extdata))
80 /*
81 * Internal Prototypes
82 */
93 BODY_PARTICULARS_S
116 #if defined(DOS) || defined(OS2)
121 /*
122 * Pointer to buffer to hold pointers into pine data that's needed by pico.
123 */
135 /* local global to save busy_cue state */
139 /*
140 * Various useful strings
141 */
142 #define INTRPT_PMT \
144 #define PSTPND_PMT \
146 #define FORM_PMT \
148 #define PSTPN_FORM_PMT \
150 #define POST_PMT \
152 #define INTR_DEL_PMT \
156 /*
157 * Macros to help sort out posting results
158 */
159 #define P_MAIL_WIN 0x01
160 #define P_MAIL_LOSE 0x02
161 #define P_MAIL_BITS 0x03
162 #define P_NEWS_WIN 0x04
163 #define P_NEWS_LOSE 0x08
164 #define P_NEWS_BITS 0x0C
165 #define P_FCC_WIN 0x10
166 #define P_FCC_LOSE 0x20
167 #define P_FCC_BITS 0x30
173 /*
174 * For check_for_subject and check_for_fcc
175 */
176 #define CF_OK 0x1
177 #define CF_MISSING 0x2
180 /*----------------------------------------------------------------------
181 Compose screen (not forward or reply). Set up envelope, call composer
183 Args: pine_state -- The usual pine structure
185 Little front end for the compose screen
186 ---*/
187 void
189 {
199 }
202 /*----------------------------------------------------------------------
203 Alternate compose screen. Set up role and call regular compose.
205 Args: pine_state -- The usual pine structure
206 ---*/
207 void
209 {
218 /* Setup role */
224 }
226 /*
227 * If default role was selected (NULL) we need to make up a role which
228 * won't do anything, but will cause compose_mail to think there's
229 * already a role so that it won't try to confirm the default.
230 */
237 }
244 }
247 /*----------------------------------------------------------------------
248 Format envelope for outgoing message and call editor
250 Args: given_to -- An address to send mail to (usually from command line
251 invocation)
252 fcc_arg -- The fcc that goes with this address.
254 If a "To" line is given format that into the envelope and get ready to call
255 the composer
256 If there's a message postponed, offer to continue it, and set it up,
257 otherwise just fill in the outgoing envelope as blank.
259 NOTE: we ignore postponed and interrupted messages in nr mode
260 ----*/
261 void
264 {
285 /*-- Check for INTERRUPTED mail --*/
289 /* build filename and see if it exists. build_path creates
290 * an explicit local path name, so all c-client access is thru
291 * local drivers.
292 */
299 /* check to see if the folder exists, the user wants to continue
300 * and that we can actually read something in...
301 */
304 }
306 /*-- Check for postponed mail --*/
314 /*-- Check for form letter folder --*/
348 }
355 }
362 }
382 }
386 }
414 }
433 {
444 }
450 }
465 }
466 }
490 }
492 to_is_sticky++;
494 /* redraft() may or may not have closed stream */
499 }
506 }
507 }
508 }
512 file_path);
515 }
516 }
517 }
531 done++;
533 /* stream may or may not be closed in redraft() */
537 to_is_sticky++;
539 }
547 done++;
548 }
549 }
550 }
552 done++;
556 }
569 done++;
571 /* stream may or may not be closed in redraft() */
575 to_is_sticky++;
577 }
585 done++;
586 }
587 }
588 }
594 }
595 }
599 }
601 /*-- normal composition --*/
605 PAT_STATE dummy;
607 /*================= Compose new message ===============*/
614 /*
615 * Setup possible role
616 */
621 /* Setup possible compose role */
623 /*
624 * setup default role
625 * Msgno = -1 means there is no msg.
626 * This will match roles which have the Compose Use turned
627 * on, and have no patterns set, and match the Current
628 * Folder Type.
629 */
638 }
639 }
640 }
647 /*
648 * The type of storage object allocated below is vitally
649 * important. See SIMPLIFYING ASSUMPTION #37
650 */
659 }
660 }
661 }
666 }
678 }
681 }
682 }
683 else
694 }
700 }
706 /*
707 * check whether a build_address-produced fcc is different from
708 * fcc. If same, do nothing, if different, set sticky bit in pine_send.
709 */
718 }
721 /* not sticky */
722 }
723 else
724 fcc_is_sticky++;
728 }
744 }
756 }
759 /*----------------------------------------------------------------------
760 Args: stream -- This is where we get the postponed messages from
761 We'll expunge and close it here unless it is mail_stream.
763 These are all return values:
764 ================
765 outgoing --
766 body --
767 fcc --
768 lcc --
769 reply --
770 redraft_pos --
771 custom --
772 role --
773 ================
775 flags --
777 ----*/
778 int
782 {
792 /*
793 * If we're manipulating the current folder, don't bother
794 * with index
795 */
799 else
803 }
806 /*
807 * Since the user's got this folder already opened and they're
808 * on a selected message, pick that one rather than rebuild
809 * another index screen...
810 */
812 }
820 }
823 }
838 q_status_message(SM_ORDER, 3, 3, _("Undelete messages to remain postponed, and then continue message"));
839 else
840 q_status_message(SM_ORDER, 3, 3, _("Undelete form letters you want to keep, and then continue message"));
843 }
846 }
863 }
869 }
872 }
873 }
879 else
881 }
884 int
886 {
890 type);
892 }
895 }
898 /* this is for initializing the fixed header elements in pine_send() */
899 /*
900 prompt::name::help::prwid::maxlen::realaddr::
901 builder::affected_entry::next_affected::selector::key_label::fileedit::
902 display_it::break_on_comma::is_attach::rich_header::only_file_chars::
903 single_space::sticky::dirty::start_here::blank::sticky_special::KS_ODATAVAR
904 */
984 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
988 #endif
989 };
1003 /*----------------------------------------------------------------------
1004 Get addressee for message, then post message
1006 Args: outgoing -- Partially formatted outgoing ENVELOPE
1007 body -- Body of outgoing message
1008 prmpt_who -- Optional prompt for optionally_enter call
1009 prmpt_cnf -- Optional prompt for confirmation call
1010 used_tobufval -- The string that the to was eventually set equal to.
1011 This gets passed back if non-NULL on entry.
1012 flagsarg -- SS_PROMPTFORTO - Allow user to change recipient
1013 SS_NULLRP - Use null return-path so we'll send an
1014 SMTP MAIL FROM: <>
1016 Result: message "To: " field is provided and message is sent or cancelled.
1018 Fields:
1019 remail -
1020 return_path -
1021 date added here
1022 from added here
1023 sender -
1024 reply_to -
1025 subject passed in, NOT edited but maybe canonized here
1026 to possibly passed in, edited and canonized here
1027 cc -
1028 bcc -
1029 in_reply_to -
1030 message_id -
1032 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1033 with the first part TYPETEXT! All newlines in the text here also end with
1034 CRLF.
1036 Returns 0 on success, -1 on failure.
1037 ----*/
1038 int
1046 {
1052 HelpType help;
1055 BUILDER_ARG ba_fcc;
1058 PAT_STATE pstate;
1068 /*----- Fill in a few general parts of the envelope ----*/
1078 }
1083 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
1084 else
1086 }
1087 else
1089 }
1104 }
1111 }
1129 /*----------------------------------------------------------------------
1130 Loop editing the "To: " field until everything goes well
1131 ----*/
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 }
1231 }
1232 }
1234 }
1241 }
1242 else
1251 }
1252 else
1269 /*
1270 * Just make it look like user typed this list in.
1271 */
1273 got_something++;
1277 }
1282 }
1292 }
1302 /*
1303 * If role has an fcc, use it instead of what build_address
1304 * tells us.
1305 */
1311 }
1323 }
1330 /* confirm address */
1342 ps_global))))
1343 /*--- Addresses didn't check out---*/
1359 /* setup keymenu slot to toggle verbose mode */
1369 }
1370 }
1372 /* clear DSN flags */
1375 /* setup keymenu slots to toggle dsn bits */
1393 }
1415 ? addr
1432 /* TRANSLATORS: several possible key labels follow */
1452 }
1453 }
1461 }
1464 }
1467 }
1471 else
1473 }
1477 /* turn off related bits */
1480 }
1483 /* turn off related bits */
1486 }
1489 /* turn off related bits */
1492 }
1495 }
1496 }
1499 }
1513 }
1514 }
1529 /*
1530 * If special name "inbox" then replace it with the
1531 * real inbox path.
1532 */
1540 }
1541 }
1543 /*---- Check out fcc -----*/
1553 }
1554 else
1556 }
1557 else
1559 }
1560 else
1567 }
1575 q_status_message(SM_ORDER | SM_DING, 5, 5, _("Use of a role-defined smtp-server is administratively prohibited"));
1576 else
1578 }
1581 call_mailer_flags,
1582 call_mailer_file_result,
1583 pipe_callback);
1585 }
1586 else
1592 /*----- Was there an fcc involved? -----*/
1604 }
1606 /* Now actually copy to fcc folder and close */
1607 fcc_result =
1609 label,
1612 }
1618 }
1621 }
1627 else
1629 }
1653 SIZEOF_20KBUF,
1655 }
1656 }
1660 }
1664 }
1665 }
1674 else
1676 }
1678 }
1683 }
1684 }
1686 done++;
1691 done++;
1698 ? h_anon_forward
1716 }
1720 }
1723 }
1727 }
1734 }
1735 }
1737 finish:
1744 }
1747 /*
1748 * pine_simple_send_header - generate header suitable for simple_sending
1749 */
1750 METAENV *
1752 {
1759 /* assign he_dummy to "To:" field "he" for strings2outgoing */
1766 }
1769 }
1773 /*----------------------------------------------------------------------
1774 Prepare data structures for pico, call pico, then post message
1776 Args: outgoing -- Partially formatted outgoing ENVELOPE
1777 body -- Body of outgoing message
1778 editor_title -- Title for anchor line in composer
1779 fcc_arg -- The file carbon copy field
1780 reply -- Struct describing set of msgs being replied-to
1781 lcc_arg --
1782 custom -- custom header list.
1783 sticky_fcc --
1785 Result: message is edited, then postponed, cancelled or sent.
1787 Fields:
1788 remail -
1789 return_path -
1790 date added here
1791 from added here
1792 sender -
1793 reply_to -
1794 subject passed in, edited and cannonized here
1795 to possibly passed in, edited and cannonized here
1796 cc possibly passed in, edited and cannonized here
1797 bcc edited and cannonized here
1798 in_reply_to generated in reply() and passed in
1799 message_id -
1801 Storage for these fields comes from anywhere outside. It is remalloced
1802 here so the composer can realloc them if needed. The copies here are also
1803 freed here.
1805 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1806 with the first part TYPETEXT! All newlines in the text here also end with
1807 CRLF.
1809 There's a further assumption that the text in the TYPETEXT part is
1810 stored in a storage object (see filter.c).
1811 ----*/
1812 void
1817 {
1830 METAENV header;
1836 CustomType ct;
1845 /*
1846 * Cancel any pending initial commands since pico uses a different
1847 * input routine. If we didn't cancel them, they would happen after
1848 * we returned from the editor, which would be confusing.
1849 */
1859 }
1862 }
1864 #if defined(DOS) || defined(OS2)
1868 }
1871 #else
1875 #endif
1885 #ifdef _WINDOWS
1899 /* We actually want to set this only if message we're sending is flowed */
1913 #if defined(DOS) || defined(OS2)
1916 }
1917 #endif
1922 /* NOTE: initial cursor position set below */
1926 /*
1927 * When user runs compose and the current folder is a newsgroup,
1928 * offer to post to the current newsgroup.
1929 */
1937 /*
1938 * Replies don't get this far because To or Newsgroups will already
1939 * be filled in. So must be either ordinary compose or forward.
1940 * Forward sets subject, so use that to tell the difference.
1941 */
1953 }
1964 }
1974 }
1979 }
1985 }
1988 }
2003 }
2004 }
2005 }
2009 NETMBX news_mb;
2017 suggested_nntp_server =
2023 /* take out /nntp, which gets added in nntp_open */
2030 else
2031 p++;
2039 }
2041 }
2042 }
2043 }
2044 else
2046 }
2047 }
2049 /*
2050 * If we don't already have custom headers set and the role has custom
2051 * headers, then incorporate those custom headers into "custom".
2052 */
2057 /*
2058 * If we allow the Combine argument here, we're saying that we want to
2059 * combine the values from the envelope and the role for the fields To,
2060 * Cc, Bcc, and Newsgroups. For example, if we are replying to a message
2061 * we'll have a To in the envelope because we're replying. If our role also
2062 * has a To action, then Combine would combine those two and offer both
2063 * to the user. We've decided against doing this. Instead, we always use
2064 * Replace, and the role's header value replaces the value from the
2065 * envelope. It might also make sense in some cases to do the opposite,
2066 * which would be treating the role headers as defaults, just like
2067 * customized-hdrs.
2068 */
2069 #ifdef WANT_TO_COMBINE_ADDRESSES
2072 #else
2075 #endif
2082 }
2087 }
2088 }
2089 else
2091 }
2095 /* how many fixed fields are there? */
2097 ;
2101 /* the fixed part of the PINEFIELDs */
2106 /* temporary headerentry array for pico */
2120 /* custom part of PINEFIELDs */
2126 /*
2127 * For Address types, pf->addr points to an ADDRESS *.
2128 * If that address is in the "outgoing" envelope, it will
2129 * be freed by the caller, otherwise, it should be freed here.
2130 * Pf->textbuf for an Address is used a little to set up a default,
2131 * but then is freed right away below. Pf->scratch is used for a
2132 * pointer to some alloced space for pico to edit in. Addresses in
2133 * the custom area are freed by free_customs().
2134 *
2135 * For FreeText types, pf->addr is not used. Pf->text points to a
2136 * pointer that points to the text. Pf->textbuf points to a copy of
2137 * the text that must be freed before we leave, otherwise, it is
2138 * probably a pointer into the envelope and that gets freed by the
2139 * caller.
2140 *
2141 * He->realaddr is the pointer to the text that pico actually edits.
2142 */
2144 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2145 # define NN 4
2146 #else
2147 # define NN 3
2148 #endif
2151 use_news_order++;
2153 /* initialize the fixed header elements of the two temp arrays */
2160 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2161 , N_SENDER
2162 #endif
2163 };
2166 /* slightly different editing order if sending to news */
2171 /* copy the templates */
2176 /* slide string over so it is Sender instead of X-X-Sender */
2180 }
2230 }
2231 }
2235 }
2240 /* if no value, use default */
2244 }
2250 }
2252 /* If there is a newsgroup, we'd better show it */
2260 }
2265 }
2270 }
2275 }
2280 }
2285 }
2291 }
2297 }
2303 }
2309 }
2315 }
2321 }
2327 }
2333 }
2339 }
2345 }
2349 }
2353 /* can't do a default for this one */
2355 /* If there is an attachment already, we'd better show them */
2368 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
2373 }
2374 }
2382 /* If already set, make it act like we typed it in */
2399 }
2404 SIZEOF_20KBUF,
2410 }
2422 /* if bcc exists, make sure it's exposed so nothing's
2423 * sent by mistake...
2424 */
2440 }
2454 }
2458 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2463 #endif
2469 }
2471 /*
2472 * If this is a reply to news, don't show the regular email
2473 * recipient headers (unless they are non-empty).
2474 */
2489 }
2490 else
2492 }
2494 /*
2495 * If this address doesn't already have a value, then we check
2496 * for a default value assigned by the user.
2497 */
2508 /*
2509 * Try to set To based on Lcc. Don't attempt Fcc.
2510 */
2548 }
2549 }
2556 }
2560 }
2570 }
2571 }
2573 /* if we still don't have a from */
2576 }
2578 /*
2579 * Addr is already set in the rest of the cases.
2580 */
2584 /*
2585 * We get to this case of the ifelse if the from or reply-to
2586 * addr was set by a role above.
2587 */
2589 /* figure out the default value */
2598 }
2600 /* if value set by role is different from default, show it */
2604 /* malformed */
2608 }
2612 }
2617 /*
2618 * These three are different from the others because we
2619 * might add the addresses to what is already there instead
2620 * of replacing.
2621 */
2645 ;
2651 }
2658 }
2661 }
2680 }
2683 }
2688 }
2693 /* outgoing2strings will alloc the string pf->scratch below */
2702 else
2708 }
2740 /* if no value, use default */
2743 }
2747 }
2750 }
2761 }
2763 /*
2764 * We may or may not want to give the user the chance to edit
2765 * the From and Reply-To lines. If they are listed in either
2766 * Default-composer-hdrs or Customized-hdrs, then they can edit
2767 * them, else no.
2768 * If canedit is not set, that means that this header is not in
2769 * the user's customized-hdrs. If rich_header is set, that
2770 * means that this header is not in the user's
2771 * default-composer-hdrs (since From and Reply-To are rich
2772 * by default). So, don't give it an he to edit with in that case.
2773 *
2774 * For other types, just not setting canedit will cause it to be
2775 * uneditable, regardless of what the user does.
2776 */
2779 /* to allow it, we let this fall through to the reply-to case below */
2790 }
2796 }
2799 he++;
2800 }
2808 }
2809 else
2810 he++;
2813 }
2814 }
2816 /*
2817 * This is so the builder can tell the composer to fill the affected
2818 * field based on the value in the field on the left.
2819 *
2820 * Note that this mechanism isn't completely general. Each entry has
2821 * only a single next_affected, so if some other entry points an
2822 * affected entry at an entry with a next_affected, they all inherit
2823 * that next_affected. Since this isn't used much a careful ordering
2824 * of the affected fields should make it a sufficient mechanism.
2825 */
2834 /*
2835 * Set up headerentries for custom fields.
2836 * NOTE: "i" is assumed to now index first custom field in sending
2837 * order.
2838 */
2856 /* change default text into an ADDRESS */
2857 /* strip quotes around whole default */
2869 }
2888 }
2892 /* use first 8 characters for prompt */
2897 he++;
2898 }
2900 /*
2901 * Make sure at least *one* field is displayable...
2902 */
2907 }
2909 /*
2910 * None displayable!!! Warn and display defaults.
2911 */
2919 }
2921 /*
2922 * Save information about body which set_mime_type_by_grope might change.
2923 * Then, if we get an error sending, we reset these things so that
2924 * grope can do it's thing again after we edit some more.
2925 */
2928 else
2934 /*----------------------------------------------------------------------
2935 Loop calling the editor until everything goes well
2936 ----*/
2940 /* Reset body to what it was when we started. */
2943 else
2945 /*
2946 * set initial cursor position based on how many times we've been
2947 * thru the loop...
2948 */
2951 }
2955 }
2958 /* set the start_here bit in correct header */
2964 }
2966 /* If didn't find it, we start in body. */
2969 }
2972 }
2974 /* in case these were turned on in previous pass through loop */
2978 }
2983 /*
2984 * If a sending attempt failed after we passed the message text
2985 * thru a user-defined filter, "orig_so" points to the original
2986 * text. Replace the body's encoded data with the original...
2987 */
2995 }
2997 /*
2998 * Convert the envelope and body to the string format that
2999 * pico can edit
3000 */
3004 /*
3005 * If this isn't the first time through this loop, we may have
3006 * freed some of the FreeText headers below so that they wouldn't
3007 * show up as empty headers in the finished message. Need to
3008 * alloc them again here so they can be edited.
3009 */
3015 }
3017 /*
3018 * If From is exposed, probably by a role, then start the cursor
3019 * on the first line which isn't filled in. If it isn't, then we
3020 * don't move the cursor, mostly for back-compat.
3021 */
3032 }
3033 }
3035 #ifdef _WINDOWS
3037 #endif
3042 /* turn off user input timeout when in composer */
3050 #ifdef _WINDOWS
3052 #endif
3055 /*
3056 * Only reinitialize signals if we didn't receive an interesting
3057 * one while in pico, since pico's return is part of processing that
3058 * signal and it should continue to be ignored.
3059 */
3063 /*
3064 * We're going to save in DEADLETTER. Dump attachments first.
3065 */
3069 /* Turn strings back into structures */
3072 /* Make newsgroups NULL if it is "" (so won't show up in headers) */
3077 }
3079 /* Make subject NULL if it is "" (so won't show up in headers) */
3083 /* remove custom fields that are empty */
3089 }
3090 }
3091 }
3095 /*-------- Stamp it with a current date -------*/
3108 /* Set return_path based on From which is going to be used */
3114 /*
3115 * Don't ever believe the sender that is there.
3116 * If From doesn't look quite right, generate our own sender.
3117 */
3121 /*
3122 * If the LHS of the address doesn't match, or the RHS
3123 * doesn't match one of localdomain or hostname,
3124 * then add a sender line (really X-X-Sender).
3125 *
3126 * Don't add a personal_name since the user can change that.
3127 */
3129 &&
3140 }
3145 }
3147 /*----- Message is edited, now decide what to do with it ----*/
3149 /*=========== Postpone or Interrupted message ============*/
3167 }
3169 /*
3170 * The idea here is to use the Fcc: writing facility
3171 * to append to the special postponed message folder...
3172 *
3173 * NOTE: the strategy now is to write the message and
3174 * all attachments as they exist at composition time.
3175 * In other words, attachments are postponed by value
3176 * and not reference. This may change later, but we'll
3177 * need a local "message/external-body" type that
3178 * outgoing2strings knows how to properly set up for
3179 * the composer. Maybe later...
3180 */
3187 /*--- Addresses didn't check out---*/
3191 }
3193 /*
3194 * Build the local message copy so.
3195 *
3196 * In the HUP case, we'll write the bezerk delimiter by
3197 * hand and output the message directly into the folder.
3198 * It's not only faster, we don't have to worry about
3199 * c-client reentrance and less hands paw over the data so
3200 * there's less chance of a problem.
3201 *
3202 * In the Postpone case, just create it if the user wants to
3203 * and create a temporary storage object to write into. */
3204 fake_hup:
3210 #if defined(DOS) || defined(OS2)
3211 /*
3212 * we can't assume anything about root or home dirs, so
3213 * just plunk it down in the same place as the pinerc
3214 */
3222 }
3227 }
3228 else
3229 #endif
3231 ps_global->VAR_OPER_DIR
3253 }
3261 }
3264 }
3265 else
3280 else
3284 }
3285 }
3286 }
3287 }
3294 }
3296 /*
3297 * Store the cursor position
3298 *
3299 * First find the header entry with the start_here
3300 * bit set, if any. This means the editor is telling
3301 * us to start on this header field next time.
3302 */
3308 }
3310 /* If there wasn't one, ":" means we start in the body. */
3322 }
3329 }
3332 }
3338 /* copy fcc line to postponed or interrupted folder */
3342 /* plug error into header for later display to user */
3347 }
3349 /*
3350 * if reply, write (UID)folder header field so we can
3351 * later flag the replied-to message \\ANSWERED
3352 * DON'T save MSGNO's.
3353 */
3363 }
3379 /*
3380 * Logically, this ought to be part of pf_uid, but this
3381 * was added later and so had to be in a separate header
3382 * for backwards compatibility.
3383 */
3389 }
3391 /* Save cursor position */
3401 }
3403 /*
3404 * Work around c-client reply-to bug. C-client will
3405 * return a reply_to in an envelope even if there is
3406 * no reply-to header field. We want to note here whether
3407 * the reply-to is real or not.
3408 */
3414 else
3416 }
3418 /* Save the role-specific smtp server */
3424 /*
3425 * Turn the list of smtp servers into a space-
3426 * delimited list in a single string.
3427 */
3439 }
3442 }
3448 else
3450 }
3452 /* Save the role-specific nntp server */
3460 /*
3461 * Turn the list of nntp servers into a space-
3462 * delimited list in a single string.
3463 */
3475 }
3478 }
3479 }
3480 else
3487 else
3489 }
3491 /*
3492 * Write the list of custom headers to the
3493 * X-Our-Headers header so that we can recover the
3494 * list in redraft.
3495 */
3513 }
3516 }
3518 /*
3519 * We need to make sure any header values that got cleared
3520 * get written to the postponed message (they won't if
3521 * pf->text is NULL). Otherwise, we can't tell previously
3522 * non-existent custom headers or default values from
3523 * custom (or other) headers that got blanked in the
3524 * composer...
3525 */
3530 /*
3531 * We're saving the message for use later. It may be that the
3532 * characters in the message are not all convertible to the
3533 * user's posting_charmap. We'll save it as UTF-8 instead
3534 * and worry about that the next time they try to send it.
3535 * Use a different save pointer just to be sure we don't
3536 * mess up the other stuff. We should probably make the
3537 * charset an argument.
3538 *
3539 * We also need to fix the charset of the body part
3540 * the user is editing so that we can read it back
3541 * successfully when we resume the composition.
3542 */
3545 {
3550 else
3556 ;
3563 }
3564 }
3578 }
3595 }
3596 else
3603 }
3604 else
3607 }
3609 /* discontinue coerced UTF-8 posting */
3613 }
3614 else
3619 /*
3620 * Special Hack #291: if any hi-byte bits are set in
3621 * editor's result, we put them there.
3622 */
3629 }
3636 else
3641 }
3654 }
3660 }
3661 }
3663 /*------ Must be sending mail or posting ! -----*/
3670 /* --- If posting, confirm with user ----*/
3677 }
3687 continue_with_only_fcc++;
3688 }
3694 }
3695 }
3698 /*--- Addresses didn't check out---*/
3701 }
3704 && !continue_with_only_fcc
3713 local_redraft_pos
3718 }
3726 local_redraft_pos
3731 }
3739 local_redraft_pos
3744 }
3748 /*---- Check out fcc -----*/
3750 /*
3751 * If special name "inbox" then replace it with the
3752 * real inbox path.
3753 */
3761 }
3764 /* lmc.text_only set on command line */
3766 /* ---- Open or allocation of fcc failed ----- */
3769 /*
3770 * Find field entry associated with fcc, and start
3771 * composer on it...
3772 */
3778 }
3779 else
3781 }
3782 else
3785 /*---- Take care of any requested prefiltering ----*/
3793 }
3795 /*------ Actually post -------*/
3810 }
3811 }
3820 }
3821 else
3823 }
3825 /*
3826 * BUG: IF we've posted the message *and* an fcc was specified
3827 * then we've already got a neatly formatted message in the
3828 * lmc.so. It'd be nice not to have to re-encode everything
3829 * to insert it into the smtp slot...
3830 */
3832 /*
3833 * Turn on "undisclosed recipients" header if no To or cc.
3834 */
3839 }
3844 }
3846 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
3847 /*
3848 * If requested, launch background posting...
3849 */
3857 /*
3858 * Put us in new process group...
3859 */
3862 /* BUG: should fix argv[0] to indicate what we're up to */
3864 /*
3865 * If there are any live streams, pretend we never
3866 * knew them. Problem is two processes writing
3867 * same server process.
3868 * This is not clean but we're just going to exit
3869 * right away anyway. We just want to be sure to leave
3870 * the stuff that the parent is going to use alone.
3871 * The next three lines will disable the re-use of the
3872 * existing streams and cause us to open a new one if
3873 * needed.
3874 */
3879 /* quell any display output */
3882 /*------- Actually mail the message ------*/
3891 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3892 else
3894 }
3897 call_mailer_flags,
3898 call_mailer_file_result,
3904 }
3906 /*----- Was there an fcc involved? -----*/
3908 /*------ Write it if at least something worked ------*/
3920 }
3922 /*-- Now actually copy to fcc folder and close --*/
3928 }
3935 }
3938 }
3941 /*
3942 * Encode child's result in hi-byte of
3943 * editor's result
3944 */
3947 }
3950 }
3956 }
3965 }
3976 }
3979 /*------- Actually mail the message ------*/
3987 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3988 else
3990 }
3993 call_mailer_flags,
3994 call_mailer_file_result,
4000 }
4002 /*----- Was there an fcc involved? -----*/
4004 /*------ Write it if at least something worked ------*/
4015 }
4017 /*-- Now actually copy to fcc folder and close --*/
4022 }
4028 }
4031 }
4033 /*----- Mail Post FAILED, back to composer -----*/
4038 /*
4039 * Find field entry associated with fcc, and start
4040 * composer on it...
4041 */
4049 }
4057 }
4059 /*
4060 * If message sent *completely* successfully, there's a
4061 * reply struct AND we're allowed to write back state, do it.
4062 * But also protect against shifted message numbers due
4063 * to new mail arrival. Since the number passed is based
4064 * on the real imap msg no, AND we're sure no expunge has
4065 * been done, just fix up the sorted number...
4066 */
4069 /*----- Signed, sealed, delivered! ------*/
4074 }
4075 }
4094 }
4119 }
4122 /*
4123 * Check for subject in outgoing message.
4124 *
4125 * Asks user whether to proceed with no subject.
4126 */
4127 int
4129 {
4141 else
4143 }
4146 }
4150 }
4153 /*
4154 * Check for fcc in outgoing message.
4155 *
4156 * Asks user whether to proceed with no fcc.
4157 */
4158 int
4160 {
4168 else
4170 }
4173 }
4176 /*
4177 * Confirm that the user wants to send to MAILER-DAEMON
4178 */
4179 int
4181 {
4184 }
4187 void
4189 {
4195 }
4196 }
4199 int
4201 {
4208 }
4211 /*
4212 * call__mailer_file_result - some results from call_mailer might be in a file.
4213 * dislplay that file.
4214 */
4215 void
4217 {
4221 }
4224 }
4225 }
4226 }
4228 void
4230 {
4246 }
4247 }
4251 /*
4252 * This is specialized routine. It assumes that the only things that we
4253 * care about restoring are the body type, subtype, encoding and the
4254 * state of the charset parameter. It also assumes that if the charset
4255 * parameter exists when we save it, it won't be removed later.
4256 */
4257 BODY_PARTICULARS_S *
4259 {
4277 }
4281 }
4284 }
4287 void
4289 {
4311 }
4315 else
4319 }
4320 }
4323 /*
4324 * This can't happen because grope never removes
4325 * the charset parameter.
4326 */
4329 }
4330 /*
4331 else{
4332 ok, still no parameter
4333 }
4334 */
4335 }
4336 }
4342 }
4343 }
4346 void
4348 {
4357 }
4358 }
4361 /*----------------------------------------------------------------------
4362 Build a status message suitable for framing
4364 Returns: pointer to resulting buffer
4365 ---*/
4368 {
4407 /* dots on end of fixed, no fcc */
4411 }
4413 /* include whole fixed part, quotes and dots at end of fcc name */
4423 }
4425 /* whole thing */
4431 }
4437 }
4439 /* Callback from Pico to set the conditions for Alpine to start a new thread
4440 */
4442 void
4444 {
4446 }
4450 /*----------------------------------------------------------------------
4451 Call back for pico to insert the specified message's text
4453 Args: n -- message number to format
4454 f -- function to use to output the formatted message
4457 Returns: returns msg number formatted on success, zero on error.
4458 ----*/
4459 long
4461 {
4473 }
4475 /* temporarily assign a new quote string */
4479 /* build separator line */
4482 /* actually write message text */
4488 }
4493 }
4496 /*----------------------------------------------------------------------
4497 Call back for pico to prompt the user for exit confirmation
4499 Args: dflt -- default answer for confirmation prompt
4501 Returns: either NULL if the user accepts exit, or string containing
4502 reason why the user declined.
4503 ----*/
4504 int
4507 {
4534 }
4541 }
4548 /*
4549 * Build list of available filters...
4550 */
4554 ;
4562 }
4568 }
4573 }
4574 else
4583 }
4590 }
4591 }
4605 /* set global_filter_pointer to desired filter or NULL if none */
4606 /* prepare two keymenu slots for selecting filter */
4619 }
4622 /* setup keymenu slot to toggle verbose mode */
4627 }
4630 /* setup keymenu slot to toggle flowed mode */
4636 }
4639 /* setup keymenu slot to toggle attacment on fcc */
4644 }
4646 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
4652 }
4653 #endif
4660 #ifdef SMIME
4675 }
4676 }
4677 #endif
4682 /* setup keymenu slots to toggle dsn bits */
4700 }
4712 }
4721 else
4737 lparen++;
4738 }
4739 else
4741 }
4744 }
4751 lparen++;
4752 }
4756 }
4757 }
4764 }
4765 else
4767 }
4774 lparen++;
4775 }
4776 else
4778 }
4788 }
4795 lparen++;
4796 }
4797 else
4799 }
4804 }
4811 lparen++;
4812 }
4816 }
4817 }
4820 }
4822 #ifdef SMIME
4828 lparen++;
4829 }
4833 }
4834 }
4837 }
4844 lparen++;
4845 }
4849 }
4850 }
4853 }
4854 #endif
4892 }
4893 }
4904 h_send_prompt,
4905 RB_NORM);
4906 else
4917 h_send_prompt,
4918 RB_NORM);
4922 }
4926 }
4930 }
4933 }
4936 }
4939 }
4943 else
4948 }
4951 }
4956 }
4960 /* turn off related bits */
4963 }
4966 /* turn off related bits */
4969 }
4972 /* turn off related bits */
4975 }
4978 }
4979 }
4981 /*
4982 * When you turn on DSN, the default is to notify on
4983 * failure, success, or delay; and to return the whole
4984 * body on failure.
4985 */
4987 }
4995 }
5003 else
5005 }
5006 }
5007 #ifdef SMIME
5011 }
5015 }
5016 #endif
5030 }
5032 /* remember selection */
5045 }
5046 }
5057 }
5060 /*
5061 * Allow user to choose a priority for sending.
5062 *
5063 * Returns an allocated priority on success, NULL otherwise.
5064 */
5067 {
5076 cnt++;
5087 lp++;
5088 }
5095 /* TRANSLATORS: SELECT A PRIORITY is a screen title
5096 TRANSLATORS: Print something1 using something2.
5097 "priorities" is something1 */
5101 starting_val);
5111 }
5114 int
5116 {
5118 }
5121 /*----------------------------------------------------------------------
5122 Call back for pico to display mime type of attachment
5124 Args: file -- filename being attached
5126 Returns: returns 1 on success (message queued), zero otherwise (don't know
5127 type so nothing queued).
5128 ----*/
5129 int
5131 {
5140 /* don't know where the cursor's been, reset it */
5146 }
5147 }
5155 }
5156 else
5161 }
5164 /*----------------------------------------------------------------------
5165 Call back for pico to receive an uploaded message
5167 Args: fname -- name for uploaded file (empty if they want us to assign it)
5168 size -- pointer to long to hold the attachment's size
5170 Notes: the attachment is uploaded to a temp file, and
5172 Returns: TRUE on success, FALSE otherwise
5173 ----*/
5174 int
5176 {
5194 }
5195 }
5196 else
5213 }
5221 }
5222 else
5229 }
5234 {
5245 };
5256 }
5260 }
5261 else
5263 }
5267 }
5270 /*----------------------------------------------------------------------
5271 Pass the first text segment of the message thru the "send filter"
5273 Args: body pointer and address for storage object of old data
5275 Returns: returns 1 on success, zero on error.
5276 ----*/
5277 int
5280 {
5289 #define DO_HEADERS 1
5295 /*
5296 * We need WRITE_TO_LOCALE here because the user is going to
5297 * be operating on tmpf. We need to change it back after they
5298 * are done.
5299 */
5304 }
5306 /*
5307 * If the headers are wanted for filtering, we can just
5308 * stick them in the tmpf file that is already there before
5309 * putting the body in.
5310 */
5317 }
5327 }
5328 else
5330 }
5332 /*
5333 * Gf_filter wants a single storage object to read from.
5334 * If headers are wanted for filtering we'll have to put them
5335 * and the body into a temp file first and then use that
5336 * as the storage object for gf_filter.
5337 * We don't use WRITE_TO_LOCALE in this case because gf_filter
5338 * takes care of that.
5339 */
5341 /* put headers in our_tmpf_so */
5348 /* put body in our_tmpf_so */
5357 /* tell gf_filter to read from our_tmpf_so instead of *so */
5359 }
5360 else
5362 }
5363 else
5381 /* now we undo the WRITE_FROM_LOCALE change in tmpf */
5388 }
5389 else
5391 }
5392 else
5394 }
5395 else
5397 }
5398 else
5401 pipe_callback);
5408 #ifdef _WINDOWS
5410 /*
5411 * Can't really be using stdout, so don't print message that
5412 * gets printed in the else. Ideally the program being called
5413 * will wait after showing the message, we might want to look
5414 * into doing the waiting in console based apps... or not.
5415 */
5416 #else
5425 }
5435 /*
5436 * If the command said it would return new MIME
5437 * mime type data, check it out...
5438 */
5450 ;
5468 }
5471 }
5474 }
5475 }
5477 /*
5478 * Reevaluate the encoding in case form's changed...
5479 */
5482 }
5486 }
5487 else
5489 }
5492 }
5493 else
5499 }
5504 }
5511 }
5517 errstr);
5520 }
5523 }
5526 /*----------------------------------------------------------------------
5527 Copy the newsgroup name of the given mailbox into the given buffer
5529 Args:
5531 Returns:
5532 ----*/
5533 void
5535 {
5536 NETMBX mb;
5541 }
5544 }
5545 else
5547 }
5550 /*----------------------------------------------------------------------
5551 Set up fields for passing to pico. Assumes first text part is
5552 intended to be passed along for editing, and is in the form of
5553 of a storage object brought into existence sometime before pico_send().
5554 -----*/
5555 void
5558 {
5561 /*
5562 * SIMPLIFYING ASSUMPTION #37: the first TEXT part's storage object
5563 * is guaranteed to be of type PicoText!
5564 */
5568 /* mark storage object as user edited */
5571 }
5578 /*
5579 * We used to jump out the window if the first part wasn't text,
5580 * but that may not be the case when bouncing a message with
5581 * a leading non-text segment. So, IT'S UNDERSTOOD that the
5582 * contents of the first part to send is still ALWAYS in a
5583 * PicoText storage object, *AND* if that object doesn't contain
5584 * data of type text, then it must contain THE ENCODED NON-TEXT
5585 * DATA of the piece being sent.
5586 *
5587 * It's up to the programmer to make sure that such a message is
5588 * sent via pine_simple_send and never get to the composer via
5589 * pine_send.
5590 *
5591 * Make sense?
5592 */
5595 /* mark storage object as user edited */
5599 /*
5600 * If we already had a list, blast it now, so we can build a new
5601 * attachment list that reflects what's really there...
5602 */
5607 /* Simplifyihg assumption #28e. (see cross reference)
5608 All parts in the body passed in here that are not already
5609 in the attachments list are added to the end of the attachments
5610 list. Attachment items not in the body list will be taken care
5611 of in strings2outgoing, but they are unlikely to occur
5612 */
5615 /* Already in list? */
5619 ;
5633 }
5637 }
5638 }
5639 else
5645 /*
5646 * If we can find a "name" parm, display that too...
5647 */
5649 /* Convert any [ or ]'s the name contained */
5657 }
5658 else
5678 }
5679 }
5680 }
5681 }
5684 /*------------------------------------------------------------------
5685 Malloc strings to pass to composer editor because it expects
5686 such strings so it can realloc them
5687 -----------------------------------------------------------------*/
5688 /*
5689 * turn any address fields into text strings
5690 */
5691 /*
5692 * SIMPLIFYING ASSUMPTION #116: all header strings are understood
5693 * NOT to be RFC1522 decoded. Said differently, they're understood
5694 * to be RFC1522 ENCODED as necessary. The intent is to preserve
5695 * original charset tagging as far into the compose/send pipe as
5696 * we can.
5697 */
5708 /*
5709 * Scan for and fix-up patently bogus fields.
5710 *
5711 * NOTE: collaboration with this code and what's done in
5712 * reply.c:reply_cp_addr to package up the bogus stuff
5713 * is required.
5714 */
5720 /*
5721 * Rfc822_cat has been changed so that it now quotes
5722 * this sometimes. So we have to look out for quotes
5723 * which confuse the decoder. It was only quoting
5724 * because we were putting \r \n in the input, I think.
5725 */
5748 }
5756 /*
5757 * Replace control characters with ^C notation, unless
5758 * some conditions are met (see istrncpy).
5759 * If user doesn't edit, then we switch back to the
5760 * original version. If user does edit, then all bets
5761 * are off.
5762 */
5768 }
5771 }
5772 }
5791 }
5796 }
5801 /*
5802 * Replace control characters with ^C notation, unless
5803 * some conditions are met (see istrncpy).
5804 * If user doesn't edit, then we switch back to the
5805 * original version. If user does edit, then all bets
5806 * are off.
5807 */
5813 }
5816 }
5817 }
5823 }
5824 }
5827 /*----------------------------------------------------------------------
5828 Restore fields returned from pico to form useful to sending
5829 routines.
5830 -----*/
5831 void
5833 {
5839 /*
5840 * turn any local address strings into address lists
5841 */
5862 }
5874 }
5880 }
5883 }
5889 }
5892 /*----------------------------------------------------------------------
5894 The head of the body list here is always either TEXT or MULTIPART. It may be
5895 changed from TEXT to MULTIPART if there are attachments to be added
5896 and it is not already multipart.
5897 ----*/
5898 void
5900 {
5909 /*
5910 * if conditions are met short circuit MIME wrapping
5911 */
5914 /* only override assigned encoding if it might need upgrading */
5925 }
5928 }
5931 /*-- Current type is text, but there are attachments to add --*/
5932 /*-- Upgrade to a TYPEMULTIPART --*/
5937 /*
5938 * Why do we do this?
5939 * The problem is that base64 or quoted-printable encoding is
5940 * sensitive to having random data appended to it's end. If
5941 * we use a single part TEXT message and something in between
5942 * us and the end appends advertising without adjusting for
5943 * the encoding, the message is screwed up. So we wrap the
5944 * text part inside a multipart and then the appended data
5945 * will come after the boundary.
5946 *
5947 * We wish we could do this on the way out the door in a
5948 * child of post_rfc822_output because at that point we know
5949 * the character set and the encoding being used. For example,
5950 * iso-2022-jp is an encoding that is not sensitive to data
5951 * appended to the end, so it wouldn't need to be wrapped.
5952 * We could conceivably have post_rfc822_body inspect the
5953 * body and change it before doing the output. It would work
5954 * but would be very fragile. We'd be passed a body from
5955 * c-client to output and instead of just doing the output
5956 * we'd change the body and then output it. Not worth it
5957 * since the multipart wrapping is completely correct for
5958 * MIME-aware mailers.
5959 */
5961 /* move contents which were NOT copied */
5964 }
5971 }
5975 }
5978 /*-- Now type must be MULTIPART with first part text --*/
5981 }
5983 /*------ Go through the parts list remove those to be deleted -----*/
5986 /* already existed? */
5990 /*
5991 * decode original to see if it matches what was decoded
5992 * when we sent it in.
5993 */
6004 /* encoding happens as msg text is written */
6006 }
6012 }
6021 }
6022 else
6024 }
6026 /*---------- Now add any new attachments ---------*/
6032 /*
6033 * the idea is handle ALL attachments as open FILE *'s. Actual
6034 * encoding and such is handled at the time the message
6035 * is shoved into the mail slot or written to disk...
6036 *
6037 * Also, we never unlink a file, so it's up to whoever opens
6038 * it to deal with tmpfile issues.
6039 */
6047 }
6054 /*
6055 * Set type to unknown and let set_mime_type_by_* figure it out.
6056 * Always encode attachments we add as BINARY.
6057 */
6064 }
6071 /* Add name attribute for backward compatibility */
6080 }
6081 else
6085 pa->filename
6089 /* Then set the Content-Disposition ala RFC1806 */
6100 }
6101 else
6105 pa->filename
6108 }
6112 }
6114 /*
6115 * Now, if this multipart has but one text piece (that is, no
6116 * attachments), then downgrade from a composite type to a discrete
6117 * text/plain message if CTE is not 8bit.
6118 */
6124 /* Clone the interesting body part */
6127 /* and rub out what we don't want cleaned up when it's free'd */
6131 }
6135 }
6138 /*
6139 * Fill in text BODY part's structure
6140 *
6141 */
6142 void
6144 {
6149 }
6156 }
6159 /*
6160 * free_attachment_list - free attachments in given list
6161 */
6162 void
6164 {
6180 }
6191 }
6192 }
6195 void
6197 {
6209 }
6212 /*
6213 * view_as_rich - set the rich_header flag
6214 *
6215 * name - name of the header field
6216 * deflt - default value to return if user didn't set it
6217 *
6218 * Note: if the user tries to turn them all off with "", then
6219 * we take that to mean default, since otherwise there is no
6220 * way to get to the headers.
6221 */
6222 int
6224 {
6234 }
6237 }
6239 }
6242 /*
6243 * background_posting - return whether or not we're already in the process
6244 * of posting
6245 */
6246 int
6248 {
6254 }
6257 }
6260 /*----------------------------------------------------------------------
6261 Validate the given subject relative to any news groups.
6263 Args: none
6265 Returns: always returns 1, but also returns error if
6266 ----*/
6267 int
6269 {
6276 /*
6277 * Now look for any header entry we passed to pico that has to do
6278 * with news. If there's no subject, gripe.
6279 */
6287 }
6288 }
6291 }
6294 /*
6295 * This is the build_address used by the composer to check for an address
6296 * in the addrbook.
6297 *
6298 * Args: to -- the passed in line to parse
6299 * full_to -- Address of a pointer to return the full address in.
6300 * This will be allocated here and freed by the caller.
6301 * error -- Address of a pointer to return an error message in.
6302 * This will be allocated here and freed by the caller.
6303 * barg -- Address of a pointer to return the fcc in is in
6304 * fcc->tptr. It will have already been allocated by the
6305 * caller but we may free it and reallocate if we wish.
6306 * Caller will free it.
6307 *
6308 * Result: 0 is returned if address was OK,
6309 * -1 if address wasn't OK.
6310 *
6311 * Side effect: Can flush addrbook entry cache entries so they need to be
6312 * re-fetched afterwords.
6313 */
6314 int
6316 {
6319 BuildTo bldto;
6327 /* check to see if to string is empty to avoid work */
6336 }
6344 /* No guarantee cursor or status line is how we saved it */
6352 /*
6353 * If we end up jumping back here because somebody else changed one of
6354 * our addrbooks out from underneath us, we may well leak some memory.
6355 * That's probably ok since this will be very rare.
6356 *
6357 * The reason for the memcpy of the jmp_buf is that we may actually
6358 * be indirectly calling this function from within the address book.
6359 * For example, we may be in the address book screen and then run
6360 * the ComposeTo command which puts us in the composer, then we call
6361 * build_address from there which resets addrbook_changed_unexpectedly.
6362 * Once we leave build_address we need to reset addrbook_changed_un...
6363 * because this position on the stack will no longer be valid.
6364 * Same is true of the other setjmp's in this file which are wrapped
6365 * in memcpy calls.
6366 */
6385 }
6387 ab_nesting_level++;
6394 ab_nesting_level--;
6398 /*
6399 * Have to rfc1522_decode the full_to string before sending it back.
6400 */
6409 /* p == q means that decoding happened, p is decoded *full_to */
6413 }
6414 else
6416 }
6421 /* Pt will point to headents[Fcc].bldr_private */
6426 /*
6427 * If *barg->aff is set, that means fcc was set from a list
6428 * during some previous builder call.
6429 * If the current To line contains the old expansion as a prefix, then
6430 * we should leave things as they are. In order to decide that,
6431 * we look at a hash value computed from the strings.
6432 */
6444 }
6445 else
6447 }
6453 /* replace fcc value */
6464 }
6477 }
6479 /*
6480 * If result is reproducible, we don't keep track here.
6481 */
6484 }
6485 }
6486 }
6487 else
6489 }
6491 /* This is so pico will erase the old message */
6498 }
6501 /*
6502 * This is the builder used by the composer for the Lcc line.
6503 *
6504 * Args: lcc -- the passed in Lcc line to parse
6505 * full_lcc -- Address of a pointer to return the full address in.
6506 * This will be allocated here and freed by the caller.
6507 * error -- Address of a pointer to return an error message in.
6508 * This is not allocated so should not be freed by the caller.
6509 * barg -- This is a pointer to text for affected entries which
6510 * we may be changing. The first one in the list is the
6511 * To entry. We may put the name of the list in empty
6512 * group syntax form there (like List Name: ;).
6513 * The second one in the list is the fcc field.
6514 * The tptr members already point to text allocated in the
6515 * caller. We may free and reallocate here, caller will
6516 * free the result in any case.
6517 *
6518 * Result: 0 is returned if address was OK,
6519 * -1 if address wasn't OK.
6520 *
6521 * Side effect: Can flush addrbook entry cache entries so they need to be
6522 * re-fetched afterwords.
6523 */
6524 int
6526 {
6530 BuildTo bldlcc;
6541 /* check to see if to string is empty to avoid work */
6550 }
6559 /*
6560 * If we end up jumping back here because somebody else changed one of
6561 * our addrbooks out from underneath us, we may well leak some memory.
6562 * That's probably ok since this will be very rare.
6563 */
6583 }
6585 ab_nesting_level++;
6589 /*
6590 * To is first affected_entry and Fcc is second.
6591 * The conditional stuff for the fcc argument says to only change the
6592 * fcc if the fcc pointer is passed in non-null, and the To pointer
6593 * is also non-null. If they are null, that means they've already been
6594 * entered (are sticky). We don't affect fcc if either fcc or To has
6595 * been typed in.
6596 */
6598 full_lcc,
6599 error,
6606 ab_nesting_level--;
6610 /* full_lcc is what ends up in the Lcc: line */
6614 /*
6615 * Have to rfc1522_decode the full_lcc string before sending it back.
6616 */
6622 }
6623 else
6625 }
6627 /* to is what ends up in the To: line */
6632 /*
6633 * Have to rfc1522_decode the full_to string before sending it back.
6634 */
6639 /*
6640 * If the caller wants us to try to preserve the charset
6641 * information (they set aff) we copy it into encoded->etext.
6642 * We don't have to worry about pasting together pieces of
6643 * etext like we do in build_address because whenever the
6644 * Lcc line is setting the To line it will be setting the
6645 * whole line, not modifying it.
6646 * Pt will point to headents[To].bldr_private.
6647 */
6655 }
6656 }
6660 }
6661 else
6668 /*
6669 * This part is recording the fact that the To line was set to
6670 * what it is by entering something on the Lcc line. In particular,
6671 * if a list alias was entered here then the fullname of the list
6672 * goes in the To line. We save this affector information so that
6673 * we can tell it shouldn't be modified if we call build_addr_lcc
6674 * again unless we actually modified what's in the Lcc line so that
6675 * it doesn't start with the same thing. The problem we're solving
6676 * is that the contents of the Lcc line no longer look like the
6677 * list they were derived from.
6678 * Pt will point to headents[To].bldr_private.
6679 */
6694 }
6695 else
6697 }
6704 /* replace to value */
6720 }
6726 }
6733 }
6746 }
6748 /*
6749 * If result is reproducible, we don't keep track here.
6750 */
6753 }
6754 }
6755 }
6756 else
6758 }
6763 /*
6764 * If *barg->next->aff is set, that means fcc was set from a list
6765 * during some previous builder call. If the current Lcc line
6766 * contains the old expansion as a prefix, then we should leave
6767 * things as they are. In order to decide that we look at a hash
6768 * value computed from the strings.
6769 * Pt will point to headents[Fcc].bldr_private
6770 */
6786 }
6787 else
6789 }
6796 /* replace fcc value */
6807 }
6820 }
6822 /*
6823 * If result is reproducible, we don't keep track here.
6824 */
6827 }
6828 }
6829 }
6830 else
6832 }
6841 }
6844 /*----------------------------------------------------------------------
6845 Verify and canonicalize news groups names.
6846 Called from the message composer
6848 Args: given_group -- List of groups typed by user
6849 expanded_group -- pointer to point to expanded list, which will be
6850 allocated here and freed in caller. If this is
6851 NULL, don't attempt to validate.
6852 error -- pointer to store error message
6853 fcc -- pointer to point to fcc, which will be
6854 allocated here and freed in caller
6856 Returns: 0 if all is OK
6857 -1 if addresses weren't valid
6859 Test the given list of newstroups against those recognized by our nntp
6860 servers. Testing by actually trying to open the list is much cheaper, both
6861 in bandwidth and memory, than yanking the whole list across the wire.
6862 ----*/
6863 int
6864 news_build(char *given_group, char **expanded_group, char **error, BUILDER_ARG *fcc, int *mangled)
6865 {
6876 /* assign any new fcc to the BUILDER_ARG */
6879 /* it changed */
6884 }
6885 }
6889 }
6891 /* deal with any busy indicator */
6899 }
6903 }
6906 void
6908 {
6910 }
6913 #if defined(DOS) || defined(OS2)
6915 /*----------------------------------------------------------------------
6916 Verify that the necessary pieces are around to allow for
6917 message sending under DOS
6919 Args: strict -- tells us if a remote stream is required before
6920 sending is permitted.
6922 The idea is to make sure pine knows enough to put together a valid
6923 from line. The things we MUST know are a user-id, user-domain and
6924 smtp server to dump the message off on. Typically these are
6925 provided in pine's configuration file, but if not, the user is
6926 queried here.
6927 ----*/
6928 int
6930 {
6933 HelpType help;
6935 /*
6936 * query for user name portion of address, use IMAP login
6937 * name as default
6938 */
6940 NETMBX mb;
6948 }
6950 /* no user-id prompting if set */
6961 }
6962 else
6964 }
6965 else
6969 /* No prompt, just assume mailbox login is user-id */
6972 }
6988 }
6992 }
6998 }
7000 /* save the name */
7005 && !no_prompt_user_id
7008 }
7012 }
7013 }
7015 /* query for personal name */
7033 }
7037 }
7046 }
7050 }
7051 }
7052 }
7054 /*
7055 * query for host/domain portion of address, using IMAP
7056 * host as default
7057 */
7067 }
7068 else
7085 }
7089 }
7095 }
7097 /* save the name */
7107 }
7112 }
7113 }
7115 /* check for smtp server */
7127 }
7128 else
7145 }
7149 }
7155 }
7157 /* save the name */
7164 }
7167 }