| blob | e21d8009595472f6b9a3a012e149a2186b5c9912 |
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 ===============*/
616 /*
617 * Setup possible role
618 */
623 /* Setup possible compose role */
625 /*
626 * setup default role
627 * Msgno = -1 means there is no msg.
628 * This will match roles which have the Compose Use turned
629 * on, and have no patterns set, and match the Current
630 * Folder Type.
631 */
640 }
641 }
642 }
648 /*
649 * The type of storage object allocated below is vitally
650 * important. See SIMPLIFYING ASSUMPTION #37
651 */
660 }
661 }
662 }
667 }
679 }
682 }
683 }
684 else
695 }
701 }
707 /*
708 * check whether a build_address-produced fcc is different from
709 * fcc. If same, do nothing, if different, set sticky bit in pine_send.
710 */
719 }
722 /* not sticky */
723 }
724 else
725 fcc_is_sticky++;
729 }
745 }
757 }
760 /*----------------------------------------------------------------------
761 Args: stream -- This is where we get the postponed messages from
762 We'll expunge and close it here unless it is mail_stream.
764 These are all return values:
765 ================
766 outgoing --
767 body --
768 fcc --
769 lcc --
770 reply --
771 redraft_pos --
772 custom --
773 role --
774 ================
776 flags --
778 ----*/
779 int
783 {
793 /*
794 * If we're manipulating the current folder, don't bother
795 * with index
796 */
800 else
804 }
807 /*
808 * Since the user's got this folder already opened and they're
809 * on a selected message, pick that one rather than rebuild
810 * another index screen...
811 */
813 }
821 }
824 }
839 q_status_message(SM_ORDER, 3, 3, _("Undelete messages to remain postponed, and then continue message"));
840 else
841 q_status_message(SM_ORDER, 3, 3, _("Undelete form letters you want to keep, and then continue message"));
844 }
847 }
864 }
870 }
873 }
874 }
880 else
882 }
885 int
887 {
891 type);
893 }
896 }
899 /* this is for initializing the fixed header elements in pine_send() */
900 /*
901 prompt::name::help::prwid::maxlen::realaddr::
902 builder::affected_entry::next_affected::selector::key_label::fileedit::
903 display_it::break_on_comma::is_attach::rich_header::only_file_chars::
904 single_space::sticky::dirty::start_here::blank::sticky_special::KS_ODATAVAR
905 */
985 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
989 #endif
990 };
1004 /*----------------------------------------------------------------------
1005 Get addressee for message, then post message
1007 Args: outgoing -- Partially formatted outgoing ENVELOPE
1008 body -- Body of outgoing message
1009 prmpt_who -- Optional prompt for optionally_enter call
1010 prmpt_cnf -- Optional prompt for confirmation call
1011 used_tobufval -- The string that the to was eventually set equal to.
1012 This gets passed back if non-NULL on entry.
1013 flagsarg -- SS_PROMPTFORTO - Allow user to change recipient
1014 SS_NULLRP - Use null return-path so we'll send an
1015 SMTP MAIL FROM: <>
1017 Result: message "To: " field is provided and message is sent or cancelled.
1019 Fields:
1020 remail -
1021 return_path -
1022 date added here
1023 from added here
1024 sender -
1025 reply_to -
1026 subject passed in, NOT edited but maybe canonized here
1027 to possibly passed in, edited and canonized here
1028 cc -
1029 bcc -
1030 in_reply_to -
1031 message_id -
1033 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1034 with the first part TYPETEXT! All newlines in the text here also end with
1035 CRLF.
1037 Returns 0 on success, -1 on failure.
1038 ----*/
1039 int
1047 {
1053 HelpType help;
1056 BUILDER_ARG ba_fcc;
1059 PAT_STATE pstate;
1069 /*----- Fill in a few general parts of the envelope ----*/
1079 }
1084 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
1085 else
1087 }
1088 else
1090 }
1105 }
1112 }
1130 /*----------------------------------------------------------------------
1131 Loop editing the "To: " field until everything goes well
1132 ----*/
1140 snprintf(tmp, sizeof(tmp), _("BOUNCE (redirect) message using role \"%s\" to : "), role->nick);
1141 else
1144 }
1147 og2s_done++;
1149 }
1164 }
1170 }
1176 prmpt_who
1177 ? prmpt_who
1180 }
1181 else
1189 done++;
1211 }
1212 }
1224 }
1226 }
1233 }
1234 else
1243 }
1244 else
1261 /*
1262 * Just make it look like user typed this list in.
1263 */
1265 got_something++;
1269 }
1274 }
1284 }
1294 /*
1295 * If role has an fcc, use it instead of what build_address
1296 * tells us.
1297 */
1303 }
1315 }
1322 /* confirm address */
1334 ps_global))))
1335 /*--- Addresses didn't check out---*/
1351 /* setup keymenu slot to toggle verbose mode */
1361 }
1362 }
1364 /* clear DSN flags */
1367 /* setup keymenu slots to toggle dsn bits */
1385 }
1407 ? addr
1424 /* TRANSLATORS: several possible key labels follow */
1444 }
1445 }
1453 }
1456 }
1459 }
1463 else
1465 }
1469 /* turn off related bits */
1472 }
1475 /* turn off related bits */
1478 }
1481 /* turn off related bits */
1484 }
1487 }
1488 }
1491 }
1505 }
1506 }
1521 /*
1522 * If special name "inbox" then replace it with the
1523 * real inbox path.
1524 */
1532 }
1533 }
1535 /*---- Check out fcc -----*/
1545 }
1546 else
1548 }
1549 else
1551 }
1552 else
1559 }
1567 q_status_message(SM_ORDER | SM_DING, 5, 5, _("Use of a role-defined smtp-server is administratively prohibited"));
1568 else
1570 }
1573 call_mailer_flags,
1574 call_mailer_file_result,
1575 pipe_callback);
1577 }
1578 else
1584 /*----- Was there an fcc involved? -----*/
1596 }
1598 /* Now actually copy to fcc folder and close */
1599 fcc_result =
1601 label,
1604 }
1610 }
1613 }
1619 else
1621 }
1645 SIZEOF_20KBUF,
1647 }
1648 }
1652 }
1656 }
1657 }
1666 else
1668 }
1670 }
1675 }
1676 }
1678 done++;
1683 done++;
1690 ? h_anon_forward
1708 }
1712 }
1715 }
1719 }
1726 }
1727 }
1729 finish:
1736 }
1739 /*
1740 * pine_simple_send_header - generate header suitable for simple_sending
1741 */
1742 METAENV *
1744 {
1751 /* assign he_dummy to "To:" field "he" for strings2outgoing */
1758 }
1761 }
1765 /*----------------------------------------------------------------------
1766 Prepare data structures for pico, call pico, then post message
1768 Args: outgoing -- Partially formatted outgoing ENVELOPE
1769 body -- Body of outgoing message
1770 editor_title -- Title for anchor line in composer
1771 fcc_arg -- The file carbon copy field
1772 reply -- Struct describing set of msgs being replied-to
1773 lcc_arg --
1774 custom -- custom header list.
1775 sticky_fcc --
1777 Result: message is edited, then postponed, cancelled or sent.
1779 Fields:
1780 remail -
1781 return_path -
1782 date added here
1783 from added here
1784 sender -
1785 reply_to -
1786 subject passed in, edited and cannonized here
1787 to possibly passed in, edited and cannonized here
1788 cc possibly passed in, edited and cannonized here
1789 bcc edited and cannonized here
1790 in_reply_to generated in reply() and passed in
1791 message_id -
1793 Storage for these fields comes from anywhere outside. It is remalloced
1794 here so the composer can realloc them if needed. The copies here are also
1795 freed here.
1797 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1798 with the first part TYPETEXT! All newlines in the text here also end with
1799 CRLF.
1801 There's a further assumption that the text in the TYPETEXT part is
1802 stored in a storage object (see filter.c).
1803 ----*/
1804 void
1809 {
1822 METAENV header;
1828 CustomType ct;
1837 /*
1838 * Cancel any pending initial commands since pico uses a different
1839 * input routine. If we didn't cancel them, they would happen after
1840 * we returned from the editor, which would be confusing.
1841 */
1851 }
1854 }
1856 #if defined(DOS) || defined(OS2)
1860 }
1863 #else
1867 #endif
1877 #ifdef _WINDOWS
1891 /* We actually want to set this only if message we're sending is flowed */
1905 #if defined(DOS) || defined(OS2)
1908 }
1909 #endif
1914 /* NOTE: initial cursor position set below */
1918 /*
1919 * When user runs compose and the current folder is a newsgroup,
1920 * offer to post to the current newsgroup.
1921 */
1929 /*
1930 * Replies don't get this far because To or Newsgroups will already
1931 * be filled in. So must be either ordinary compose or forward.
1932 * Forward sets subject, so use that to tell the difference.
1933 */
1945 }
1956 }
1966 }
1971 }
1977 }
1980 }
1995 }
1996 }
1997 }
2001 NETMBX news_mb;
2009 suggested_nntp_server =
2015 /* take out /nntp, which gets added in nntp_open */
2022 else
2023 p++;
2031 }
2033 }
2034 }
2035 }
2036 else
2038 }
2039 }
2041 /*
2042 * If we don't already have custom headers set and the role has custom
2043 * headers, then incorporate those custom headers into "custom".
2044 */
2049 /*
2050 * If we allow the Combine argument here, we're saying that we want to
2051 * combine the values from the envelope and the role for the fields To,
2052 * Cc, Bcc, and Newsgroups. For example, if we are replying to a message
2053 * we'll have a To in the envelope because we're replying. If our role also
2054 * has a To action, then Combine would combine those two and offer both
2055 * to the user. We've decided against doing this. Instead, we always use
2056 * Replace, and the role's header value replaces the value from the
2057 * envelope. It might also make sense in some cases to do the opposite,
2058 * which would be treating the role headers as defaults, just like
2059 * customized-hdrs.
2060 */
2061 #ifdef WANT_TO_COMBINE_ADDRESSES
2064 #else
2067 #endif
2074 }
2079 }
2080 }
2081 else
2083 }
2087 /* how many fixed fields are there? */
2089 ;
2093 /* the fixed part of the PINEFIELDs */
2098 /* temporary headerentry array for pico */
2112 /* custom part of PINEFIELDs */
2118 /*
2119 * For Address types, pf->addr points to an ADDRESS *.
2120 * If that address is in the "outgoing" envelope, it will
2121 * be freed by the caller, otherwise, it should be freed here.
2122 * Pf->textbuf for an Address is used a little to set up a default,
2123 * but then is freed right away below. Pf->scratch is used for a
2124 * pointer to some alloced space for pico to edit in. Addresses in
2125 * the custom area are freed by free_customs().
2126 *
2127 * For FreeText types, pf->addr is not used. Pf->text points to a
2128 * pointer that points to the text. Pf->textbuf points to a copy of
2129 * the text that must be freed before we leave, otherwise, it is
2130 * probably a pointer into the envelope and that gets freed by the
2131 * caller.
2132 *
2133 * He->realaddr is the pointer to the text that pico actually edits.
2134 */
2136 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2137 # define NN 4
2138 #else
2139 # define NN 3
2140 #endif
2143 use_news_order++;
2145 /* initialize the fixed header elements of the two temp arrays */
2152 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2153 , N_SENDER
2154 #endif
2155 };
2158 /* slightly different editing order if sending to news */
2163 /* copy the templates */
2168 /* slide string over so it is Sender instead of X-X-Sender */
2172 }
2222 }
2223 }
2227 }
2232 /* if no value, use default */
2236 }
2242 }
2244 /* If there is a newsgroup, we'd better show it */
2252 }
2257 }
2262 }
2267 }
2272 }
2277 }
2283 }
2289 }
2295 }
2301 }
2307 }
2313 }
2319 }
2325 }
2331 }
2337 }
2341 }
2345 /* can't do a default for this one */
2347 /* If there is an attachment already, we'd better show them */
2360 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
2365 }
2366 }
2374 /* If already set, make it act like we typed it in */
2391 }
2396 SIZEOF_20KBUF,
2402 }
2414 /* if bcc exists, make sure it's exposed so nothing's
2415 * sent by mistake...
2416 */
2432 }
2446 }
2450 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2455 #endif
2461 }
2463 /*
2464 * If this is a reply to news, don't show the regular email
2465 * recipient headers (unless they are non-empty).
2466 */
2481 }
2482 else
2484 }
2486 /*
2487 * If this address doesn't already have a value, then we check
2488 * for a default value assigned by the user.
2489 */
2500 /*
2501 * Try to set To based on Lcc. Don't attempt Fcc.
2502 */
2540 }
2541 }
2548 }
2552 }
2562 }
2563 }
2565 /* if we still don't have a from */
2568 }
2570 /*
2571 * Addr is already set in the rest of the cases.
2572 */
2576 /*
2577 * We get to this case of the ifelse if the from or reply-to
2578 * addr was set by a role above.
2579 */
2581 /* figure out the default value */
2590 }
2592 /* if value set by role is different from default, show it */
2596 /* malformed */
2600 }
2604 }
2609 /*
2610 * These three are different from the others because we
2611 * might add the addresses to what is already there instead
2612 * of replacing.
2613 */
2637 ;
2643 }
2650 }
2653 }
2672 }
2675 }
2680 }
2685 /* outgoing2strings will alloc the string pf->scratch below */
2694 else
2700 }
2732 /* if no value, use default */
2735 }
2739 }
2742 }
2753 }
2755 /*
2756 * We may or may not want to give the user the chance to edit
2757 * the From and Reply-To lines. If they are listed in either
2758 * Default-composer-hdrs or Customized-hdrs, then they can edit
2759 * them, else no.
2760 * If canedit is not set, that means that this header is not in
2761 * the user's customized-hdrs. If rich_header is set, that
2762 * means that this header is not in the user's
2763 * default-composer-hdrs (since From and Reply-To are rich
2764 * by default). So, don't give it an he to edit with in that case.
2765 *
2766 * For other types, just not setting canedit will cause it to be
2767 * uneditable, regardless of what the user does.
2768 */
2771 /* to allow it, we let this fall through to the reply-to case below */
2782 }
2788 }
2791 he++;
2792 }
2800 }
2801 else
2802 he++;
2805 }
2806 }
2808 /*
2809 * This is so the builder can tell the composer to fill the affected
2810 * field based on the value in the field on the left.
2811 *
2812 * Note that this mechanism isn't completely general. Each entry has
2813 * only a single next_affected, so if some other entry points an
2814 * affected entry at an entry with a next_affected, they all inherit
2815 * that next_affected. Since this isn't used much a careful ordering
2816 * of the affected fields should make it a sufficient mechanism.
2817 */
2826 /*
2827 * Set up headerentries for custom fields.
2828 * NOTE: "i" is assumed to now index first custom field in sending
2829 * order.
2830 */
2848 /* change default text into an ADDRESS */
2849 /* strip quotes around whole default */
2861 }
2880 }
2884 /* use first 8 characters for prompt */
2889 he++;
2890 }
2892 /*
2893 * Make sure at least *one* field is displayable...
2894 */
2899 }
2901 /*
2902 * None displayable!!! Warn and display defaults.
2903 */
2911 }
2913 /*
2914 * Save information about body which set_mime_type_by_grope might change.
2915 * Then, if we get an error sending, we reset these things so that
2916 * grope can do it's thing again after we edit some more.
2917 */
2920 else
2926 /*----------------------------------------------------------------------
2927 Loop calling the editor until everything goes well
2928 ----*/
2932 /* Reset body to what it was when we started. */
2935 else
2937 /*
2938 * set initial cursor position based on how many times we've been
2939 * thru the loop...
2940 */
2943 }
2947 }
2950 /* set the start_here bit in correct header */
2956 }
2958 /* If didn't find it, we start in body. */
2961 }
2964 }
2966 /* in case these were turned on in previous pass through loop */
2970 }
2975 /*
2976 * If a sending attempt failed after we passed the message text
2977 * thru a user-defined filter, "orig_so" points to the original
2978 * text. Replace the body's encoded data with the original...
2979 */
2987 }
2989 /*
2990 * Convert the envelope and body to the string format that
2991 * pico can edit
2992 */
2996 /*
2997 * If this isn't the first time through this loop, we may have
2998 * freed some of the FreeText headers below so that they wouldn't
2999 * show up as empty headers in the finished message. Need to
3000 * alloc them again here so they can be edited.
3001 */
3007 }
3009 /*
3010 * If From is exposed, probably by a role, then start the cursor
3011 * on the first line which isn't filled in. If it isn't, then we
3012 * don't move the cursor, mostly for back-compat.
3013 */
3024 }
3025 }
3027 #ifdef _WINDOWS
3029 #endif
3034 /* turn off user input timeout when in composer */
3042 #ifdef _WINDOWS
3044 #endif
3047 /*
3048 * Only reinitialize signals if we didn't receive an interesting
3049 * one while in pico, since pico's return is part of processing that
3050 * signal and it should continue to be ignored.
3051 */
3055 /*
3056 * We're going to save in DEADLETTER. Dump attachments first.
3057 */
3061 /* Turn strings back into structures */
3064 /* Make newsgroups NULL if it is "" (so won't show up in headers) */
3069 }
3071 /* Make subject NULL if it is "" (so won't show up in headers) */
3075 /* remove custom fields that are empty */
3081 }
3082 }
3083 }
3087 /*-------- Stamp it with a current date -------*/
3100 /* Set return_path based on From which is going to be used */
3106 /*
3107 * Don't ever believe the sender that is there.
3108 * If From doesn't look quite right, generate our own sender.
3109 */
3113 /*
3114 * If the LHS of the address doesn't match, or the RHS
3115 * doesn't match one of localdomain or hostname,
3116 * then add a sender line (really X-X-Sender).
3117 *
3118 * Don't add a personal_name since the user can change that.
3119 */
3121 &&
3132 }
3137 }
3139 /*----- Message is edited, now decide what to do with it ----*/
3141 /*=========== Postpone or Interrupted message ============*/
3159 }
3161 /*
3162 * The idea here is to use the Fcc: writing facility
3163 * to append to the special postponed message folder...
3164 *
3165 * NOTE: the strategy now is to write the message and
3166 * all attachments as they exist at composition time.
3167 * In other words, attachments are postponed by value
3168 * and not reference. This may change later, but we'll
3169 * need a local "message/external-body" type that
3170 * outgoing2strings knows how to properly set up for
3171 * the composer. Maybe later...
3172 */
3179 /*--- Addresses didn't check out---*/
3183 }
3185 /*
3186 * Build the local message copy so.
3187 *
3188 * In the HUP case, we'll write the bezerk delimiter by
3189 * hand and output the message directly into the folder.
3190 * It's not only faster, we don't have to worry about
3191 * c-client reentrance and less hands paw over the data so
3192 * there's less chance of a problem.
3193 *
3194 * In the Postpone case, just create it if the user wants to
3195 * and create a temporary storage object to write into. */
3196 fake_hup:
3202 #if defined(DOS) || defined(OS2)
3203 /*
3204 * we can't assume anything about root or home dirs, so
3205 * just plunk it down in the same place as the pinerc
3206 */
3214 }
3219 }
3220 else
3221 #endif
3223 ps_global->VAR_OPER_DIR
3245 }
3253 }
3256 }
3257 else
3272 else
3276 }
3277 }
3278 }
3279 }
3286 }
3288 /*
3289 * Store the cursor position
3290 *
3291 * First find the header entry with the start_here
3292 * bit set, if any. This means the editor is telling
3293 * us to start on this header field next time.
3294 */
3300 }
3302 /* If there wasn't one, ":" means we start in the body. */
3314 }
3321 }
3324 }
3330 /* copy fcc line to postponed or interrupted folder */
3334 /* plug error into header for later display to user */
3339 }
3341 /*
3342 * if reply, write (UID)folder header field so we can
3343 * later flag the replied-to message \\ANSWERED
3344 * DON'T save MSGNO's.
3345 */
3355 }
3371 /*
3372 * Logically, this ought to be part of pf_uid, but this
3373 * was added later and so had to be in a separate header
3374 * for backwards compatibility.
3375 */
3381 }
3383 /* Save cursor position */
3393 }
3395 /*
3396 * Work around c-client reply-to bug. C-client will
3397 * return a reply_to in an envelope even if there is
3398 * no reply-to header field. We want to note here whether
3399 * the reply-to is real or not.
3400 */
3406 else
3408 }
3410 /* Save the role-specific smtp server */
3416 /*
3417 * Turn the list of smtp servers into a space-
3418 * delimited list in a single string.
3419 */
3431 }
3434 }
3440 else
3442 }
3444 /* Save the role-specific nntp server */
3452 /*
3453 * Turn the list of nntp servers into a space-
3454 * delimited list in a single string.
3455 */
3467 }
3470 }
3471 }
3472 else
3479 else
3481 }
3483 /*
3484 * Write the list of custom headers to the
3485 * X-Our-Headers header so that we can recover the
3486 * list in redraft.
3487 */
3505 }
3508 }
3510 /*
3511 * We need to make sure any header values that got cleared
3512 * get written to the postponed message (they won't if
3513 * pf->text is NULL). Otherwise, we can't tell previously
3514 * non-existent custom headers or default values from
3515 * custom (or other) headers that got blanked in the
3516 * composer...
3517 */
3522 /*
3523 * We're saving the message for use later. It may be that the
3524 * characters in the message are not all convertible to the
3525 * user's posting_charmap. We'll save it as UTF-8 instead
3526 * and worry about that the next time they try to send it.
3527 * Use a different save pointer just to be sure we don't
3528 * mess up the other stuff. We should probably make the
3529 * charset an argument.
3530 *
3531 * We also need to fix the charset of the body part
3532 * the user is editing so that we can read it back
3533 * successfully when we resume the composition.
3534 */
3537 {
3542 else
3548 ;
3555 }
3556 }
3570 }
3587 }
3588 else
3595 }
3596 else
3599 }
3601 /* discontinue coerced UTF-8 posting */
3605 }
3606 else
3611 /*
3612 * Special Hack #291: if any hi-byte bits are set in
3613 * editor's result, we put them there.
3614 */
3621 }
3628 else
3633 }
3646 }
3652 }
3653 }
3655 /*------ Must be sending mail or posting ! -----*/
3662 /* --- If posting, confirm with user ----*/
3669 }
3679 continue_with_only_fcc++;
3680 }
3686 }
3687 }
3690 /*--- Addresses didn't check out---*/
3693 }
3696 && !continue_with_only_fcc
3705 local_redraft_pos
3710 }
3718 local_redraft_pos
3723 }
3731 local_redraft_pos
3736 }
3740 /*---- Check out fcc -----*/
3742 /*
3743 * If special name "inbox" then replace it with the
3744 * real inbox path.
3745 */
3753 }
3756 /* lmc.text_only set on command line */
3758 /* ---- Open or allocation of fcc failed ----- */
3761 /*
3762 * Find field entry associated with fcc, and start
3763 * composer on it...
3764 */
3770 }
3771 else
3773 }
3774 else
3777 /*---- Take care of any requested prefiltering ----*/
3785 }
3787 /*------ Actually post -------*/
3802 }
3803 }
3812 }
3813 else
3815 }
3817 /*
3818 * BUG: IF we've posted the message *and* an fcc was specified
3819 * then we've already got a neatly formatted message in the
3820 * lmc.so. It'd be nice not to have to re-encode everything
3821 * to insert it into the smtp slot...
3822 */
3824 /*
3825 * Turn on "undisclosed recipients" header if no To or cc.
3826 */
3831 }
3836 }
3838 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
3839 /*
3840 * If requested, launch background posting...
3841 */
3849 /*
3850 * Put us in new process group...
3851 */
3854 /* BUG: should fix argv[0] to indicate what we're up to */
3856 /*
3857 * If there are any live streams, pretend we never
3858 * knew them. Problem is two processes writing
3859 * same server process.
3860 * This is not clean but we're just going to exit
3861 * right away anyway. We just want to be sure to leave
3862 * the stuff that the parent is going to use alone.
3863 * The next three lines will disable the re-use of the
3864 * existing streams and cause us to open a new one if
3865 * needed.
3866 */
3871 /* quell any display output */
3874 /*------- Actually mail the message ------*/
3883 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3884 else
3886 }
3889 call_mailer_flags,
3890 call_mailer_file_result,
3896 }
3898 /*----- Was there an fcc involved? -----*/
3900 /*------ Write it if at least something worked ------*/
3912 }
3914 /*-- Now actually copy to fcc folder and close --*/
3920 }
3927 }
3930 }
3933 /*
3934 * Encode child's result in hi-byte of
3935 * editor's result
3936 */
3939 }
3942 }
3948 }
3957 }
3968 }
3971 /*------- Actually mail the message ------*/
3979 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3980 else
3982 }
3985 call_mailer_flags,
3986 call_mailer_file_result,
3992 }
3994 /*----- Was there an fcc involved? -----*/
3996 /*------ Write it if at least something worked ------*/
4007 }
4009 /*-- Now actually copy to fcc folder and close --*/
4014 }
4020 }
4023 }
4025 /*----- Mail Post FAILED, back to composer -----*/
4030 /*
4031 * Find field entry associated with fcc, and start
4032 * composer on it...
4033 */
4041 }
4049 }
4051 /*
4052 * If message sent *completely* successfully, there's a
4053 * reply struct AND we're allowed to write back state, do it.
4054 * But also protect against shifted message numbers due
4055 * to new mail arrival. Since the number passed is based
4056 * on the real imap msg no, AND we're sure no expunge has
4057 * been done, just fix up the sorted number...
4058 */
4061 /*----- Signed, sealed, delivered! ------*/
4066 }
4067 }
4086 }
4111 }
4114 /*
4115 * Check for subject in outgoing message.
4116 *
4117 * Asks user whether to proceed with no subject.
4118 */
4119 int
4121 {
4133 else
4135 }
4138 }
4142 }
4145 /*
4146 * Check for fcc in outgoing message.
4147 *
4148 * Asks user whether to proceed with no fcc.
4149 */
4150 int
4152 {
4160 else
4162 }
4165 }
4168 /*
4169 * Confirm that the user wants to send to MAILER-DAEMON
4170 */
4171 int
4173 {
4176 }
4179 void
4181 {
4187 }
4188 }
4191 int
4193 {
4200 }
4203 /*
4204 * call__mailer_file_result - some results from call_mailer might be in a file.
4205 * dislplay that file.
4206 */
4207 void
4209 {
4213 }
4216 }
4217 }
4218 }
4220 void
4222 {
4238 }
4239 }
4243 /*
4244 * This is specialized routine. It assumes that the only things that we
4245 * care about restoring are the body type, subtype, encoding and the
4246 * state of the charset parameter. It also assumes that if the charset
4247 * parameter exists when we save it, it won't be removed later.
4248 */
4249 BODY_PARTICULARS_S *
4251 {
4269 }
4273 }
4276 }
4279 void
4281 {
4303 }
4307 else
4311 }
4312 }
4315 /*
4316 * This can't happen because grope never removes
4317 * the charset parameter.
4318 */
4321 }
4322 /*
4323 else{
4324 ok, still no parameter
4325 }
4326 */
4327 }
4328 }
4334 }
4335 }
4338 void
4340 {
4349 }
4350 }
4353 /*----------------------------------------------------------------------
4354 Build a status message suitable for framing
4356 Returns: pointer to resulting buffer
4357 ---*/
4360 {
4399 /* dots on end of fixed, no fcc */
4403 }
4405 /* include whole fixed part, quotes and dots at end of fcc name */
4415 }
4417 /* whole thing */
4423 }
4429 }
4431 /* Callback from Pico to set the conditions for Alpine to start a new thread
4432 */
4434 void
4436 {
4438 }
4442 /*----------------------------------------------------------------------
4443 Call back for pico to insert the specified message's text
4445 Args: n -- message number to format
4446 f -- function to use to output the formatted message
4449 Returns: returns msg number formatted on success, zero on error.
4450 ----*/
4451 long
4453 {
4465 }
4467 /* temporarily assign a new quote string */
4471 /* build separator line */
4474 /* actually write message text */
4480 }
4485 }
4488 /*----------------------------------------------------------------------
4489 Call back for pico to prompt the user for exit confirmation
4491 Args: dflt -- default answer for confirmation prompt
4493 Returns: either NULL if the user accepts exit, or string containing
4494 reason why the user declined.
4495 ----*/
4496 int
4499 {
4526 }
4533 }
4540 /*
4541 * Build list of available filters...
4542 */
4546 ;
4554 }
4560 }
4565 }
4566 else
4575 }
4582 }
4583 }
4597 /* set global_filter_pointer to desired filter or NULL if none */
4598 /* prepare two keymenu slots for selecting filter */
4611 }
4614 /* setup keymenu slot to toggle verbose mode */
4619 }
4622 /* setup keymenu slot to toggle flowed mode */
4628 }
4631 /* setup keymenu slot to toggle attacment on fcc */
4636 }
4638 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
4644 }
4645 #endif
4652 #ifdef SMIME
4667 }
4668 }
4669 #endif
4674 /* setup keymenu slots to toggle dsn bits */
4692 }
4704 }
4713 else
4729 lparen++;
4730 }
4731 else
4733 }
4736 }
4743 lparen++;
4744 }
4748 }
4749 }
4756 }
4757 else
4759 }
4766 lparen++;
4767 }
4768 else
4770 }
4780 }
4787 lparen++;
4788 }
4789 else
4791 }
4796 }
4803 lparen++;
4804 }
4808 }
4809 }
4812 }
4814 #ifdef SMIME
4820 lparen++;
4821 }
4825 }
4826 }
4829 }
4836 lparen++;
4837 }
4841 }
4842 }
4845 }
4846 #endif
4884 }
4885 }
4896 h_send_prompt,
4897 RB_NORM);
4898 else
4909 h_send_prompt,
4910 RB_NORM);
4914 }
4918 }
4922 }
4925 }
4928 }
4931 }
4935 else
4940 }
4943 }
4948 }
4952 /* turn off related bits */
4955 }
4958 /* turn off related bits */
4961 }
4964 /* turn off related bits */
4967 }
4970 }
4971 }
4973 /*
4974 * When you turn on DSN, the default is to notify on
4975 * failure, success, or delay; and to return the whole
4976 * body on failure.
4977 */
4979 }
4987 }
4995 else
4997 }
4998 }
4999 #ifdef SMIME
5003 }
5007 }
5008 #endif
5022 }
5024 /* remember selection */
5037 }
5038 }
5049 }
5052 /*
5053 * Allow user to choose a priority for sending.
5054 *
5055 * Returns an allocated priority on success, NULL otherwise.
5056 */
5059 {
5068 cnt++;
5079 lp++;
5080 }
5087 /* TRANSLATORS: SELECT A PRIORITY is a screen title
5088 TRANSLATORS: Print something1 using something2.
5089 "priorities" is something1 */
5093 starting_val);
5103 }
5106 int
5108 {
5110 }
5113 /*----------------------------------------------------------------------
5114 Call back for pico to display mime type of attachment
5116 Args: file -- filename being attached
5118 Returns: returns 1 on success (message queued), zero otherwise (don't know
5119 type so nothing queued).
5120 ----*/
5121 int
5123 {
5132 /* don't know where the cursor's been, reset it */
5138 }
5139 }
5147 }
5148 else
5153 }
5156 /*----------------------------------------------------------------------
5157 Call back for pico to receive an uploaded message
5159 Args: fname -- name for uploaded file (empty if they want us to assign it)
5160 size -- pointer to long to hold the attachment's size
5162 Notes: the attachment is uploaded to a temp file, and
5164 Returns: TRUE on success, FALSE otherwise
5165 ----*/
5166 int
5168 {
5186 }
5187 }
5188 else
5205 }
5213 }
5214 else
5221 }
5226 {
5237 };
5248 }
5252 }
5253 else
5255 }
5259 }
5262 /*----------------------------------------------------------------------
5263 Pass the first text segment of the message thru the "send filter"
5265 Args: body pointer and address for storage object of old data
5267 Returns: returns 1 on success, zero on error.
5268 ----*/
5269 int
5272 {
5281 #define DO_HEADERS 1
5287 /*
5288 * We need WRITE_TO_LOCALE here because the user is going to
5289 * be operating on tmpf. We need to change it back after they
5290 * are done.
5291 */
5296 }
5298 /*
5299 * If the headers are wanted for filtering, we can just
5300 * stick them in the tmpf file that is already there before
5301 * putting the body in.
5302 */
5309 }
5319 }
5320 else
5322 }
5324 /*
5325 * Gf_filter wants a single storage object to read from.
5326 * If headers are wanted for filtering we'll have to put them
5327 * and the body into a temp file first and then use that
5328 * as the storage object for gf_filter.
5329 * We don't use WRITE_TO_LOCALE in this case because gf_filter
5330 * takes care of that.
5331 */
5333 /* put headers in our_tmpf_so */
5340 /* put body in our_tmpf_so */
5349 /* tell gf_filter to read from our_tmpf_so instead of *so */
5351 }
5352 else
5354 }
5355 else
5373 /* now we undo the WRITE_FROM_LOCALE change in tmpf */
5380 }
5381 else
5383 }
5384 else
5386 }
5387 else
5389 }
5390 else
5393 pipe_callback);
5400 #ifdef _WINDOWS
5402 /*
5403 * Can't really be using stdout, so don't print message that
5404 * gets printed in the else. Ideally the program being called
5405 * will wait after showing the message, we might want to look
5406 * into doing the waiting in console based apps... or not.
5407 */
5408 #else
5417 }
5427 /*
5428 * If the command said it would return new MIME
5429 * mime type data, check it out...
5430 */
5442 ;
5460 }
5463 }
5466 }
5467 }
5469 /*
5470 * Reevaluate the encoding in case form's changed...
5471 */
5474 }
5478 }
5479 else
5481 }
5484 }
5485 else
5491 }
5496 }
5503 }
5509 errstr);
5512 }
5515 }
5518 /*----------------------------------------------------------------------
5519 Copy the newsgroup name of the given mailbox into the given buffer
5521 Args:
5523 Returns:
5524 ----*/
5525 void
5527 {
5528 NETMBX mb;
5533 }
5536 }
5537 else
5539 }
5542 /*----------------------------------------------------------------------
5543 Set up fields for passing to pico. Assumes first text part is
5544 intended to be passed along for editing, and is in the form of
5545 of a storage object brought into existence sometime before pico_send().
5546 -----*/
5547 void
5550 {
5553 /*
5554 * SIMPLIFYING ASSUMPTION #37: the first TEXT part's storage object
5555 * is guaranteed to be of type PicoText!
5556 */
5560 /* mark storage object as user edited */
5563 }
5570 /*
5571 * We used to jump out the window if the first part wasn't text,
5572 * but that may not be the case when bouncing a message with
5573 * a leading non-text segment. So, IT'S UNDERSTOOD that the
5574 * contents of the first part to send is still ALWAYS in a
5575 * PicoText storage object, *AND* if that object doesn't contain
5576 * data of type text, then it must contain THE ENCODED NON-TEXT
5577 * DATA of the piece being sent.
5578 *
5579 * It's up to the programmer to make sure that such a message is
5580 * sent via pine_simple_send and never get to the composer via
5581 * pine_send.
5582 *
5583 * Make sense?
5584 */
5587 /* mark storage object as user edited */
5591 /*
5592 * If we already had a list, blast it now, so we can build a new
5593 * attachment list that reflects what's really there...
5594 */
5599 /* Simplifyihg assumption #28e. (see cross reference)
5600 All parts in the body passed in here that are not already
5601 in the attachments list are added to the end of the attachments
5602 list. Attachment items not in the body list will be taken care
5603 of in strings2outgoing, but they are unlikely to occur
5604 */
5607 /* Already in list? */
5611 ;
5625 }
5629 }
5630 }
5631 else
5637 /*
5638 * If we can find a "name" parm, display that too...
5639 */
5641 /* Convert any [ or ]'s the name contained */
5649 }
5650 else
5670 }
5671 }
5672 }
5673 }
5676 /*------------------------------------------------------------------
5677 Malloc strings to pass to composer editor because it expects
5678 such strings so it can realloc them
5679 -----------------------------------------------------------------*/
5680 /*
5681 * turn any address fields into text strings
5682 */
5683 /*
5684 * SIMPLIFYING ASSUMPTION #116: all header strings are understood
5685 * NOT to be RFC1522 decoded. Said differently, they're understood
5686 * to be RFC1522 ENCODED as necessary. The intent is to preserve
5687 * original charset tagging as far into the compose/send pipe as
5688 * we can.
5689 */
5700 /*
5701 * Scan for and fix-up patently bogus fields.
5702 *
5703 * NOTE: collaboration with this code and what's done in
5704 * reply.c:reply_cp_addr to package up the bogus stuff
5705 * is required.
5706 */
5712 /*
5713 * Rfc822_cat has been changed so that it now quotes
5714 * this sometimes. So we have to look out for quotes
5715 * which confuse the decoder. It was only quoting
5716 * because we were putting \r \n in the input, I think.
5717 */
5740 }
5748 /*
5749 * Replace control characters with ^C notation, unless
5750 * some conditions are met (see istrncpy).
5751 * If user doesn't edit, then we switch back to the
5752 * original version. If user does edit, then all bets
5753 * are off.
5754 */
5760 }
5763 }
5764 }
5783 }
5788 }
5793 /*
5794 * Replace control characters with ^C notation, unless
5795 * some conditions are met (see istrncpy).
5796 * If user doesn't edit, then we switch back to the
5797 * original version. If user does edit, then all bets
5798 * are off.
5799 */
5805 }
5808 }
5809 }
5815 }
5816 }
5819 /*----------------------------------------------------------------------
5820 Restore fields returned from pico to form useful to sending
5821 routines.
5822 -----*/
5823 void
5825 {
5831 /*
5832 * turn any local address strings into address lists
5833 */
5854 }
5866 }
5872 }
5875 }
5881 }
5884 /*----------------------------------------------------------------------
5886 The head of the body list here is always either TEXT or MULTIPART. It may be
5887 changed from TEXT to MULTIPART if there are attachments to be added
5888 and it is not already multipart.
5889 ----*/
5890 void
5892 {
5901 /*
5902 * if conditions are met short circuit MIME wrapping
5903 */
5906 /* only override assigned encoding if it might need upgrading */
5917 }
5920 }
5923 /*-- Current type is text, but there are attachments to add --*/
5924 /*-- Upgrade to a TYPEMULTIPART --*/
5929 /*
5930 * Why do we do this?
5931 * The problem is that base64 or quoted-printable encoding is
5932 * sensitive to having random data appended to it's end. If
5933 * we use a single part TEXT message and something in between
5934 * us and the end appends advertising without adjusting for
5935 * the encoding, the message is screwed up. So we wrap the
5936 * text part inside a multipart and then the appended data
5937 * will come after the boundary.
5938 *
5939 * We wish we could do this on the way out the door in a
5940 * child of post_rfc822_output because at that point we know
5941 * the character set and the encoding being used. For example,
5942 * iso-2022-jp is an encoding that is not sensitive to data
5943 * appended to the end, so it wouldn't need to be wrapped.
5944 * We could conceivably have post_rfc822_body inspect the
5945 * body and change it before doing the output. It would work
5946 * but would be very fragile. We'd be passed a body from
5947 * c-client to output and instead of just doing the output
5948 * we'd change the body and then output it. Not worth it
5949 * since the multipart wrapping is completely correct for
5950 * MIME-aware mailers.
5951 */
5953 /* move contents which were NOT copied */
5956 }
5963 }
5967 }
5970 /*-- Now type must be MULTIPART with first part text --*/
5973 }
5975 /*------ Go through the parts list remove those to be deleted -----*/
5978 /* already existed? */
5982 /*
5983 * decode original to see if it matches what was decoded
5984 * when we sent it in.
5985 */
5996 /* encoding happens as msg text is written */
5998 }
6004 }
6013 }
6014 else
6016 }
6018 /*---------- Now add any new attachments ---------*/
6024 /*
6025 * the idea is handle ALL attachments as open FILE *'s. Actual
6026 * encoding and such is handled at the time the message
6027 * is shoved into the mail slot or written to disk...
6028 *
6029 * Also, we never unlink a file, so it's up to whoever opens
6030 * it to deal with tmpfile issues.
6031 */
6039 }
6046 /*
6047 * Set type to unknown and let set_mime_type_by_* figure it out.
6048 * Always encode attachments we add as BINARY.
6049 */
6056 }
6063 /* Add name attribute for backward compatibility */
6072 }
6073 else
6077 pa->filename
6081 /* Then set the Content-Disposition ala RFC1806 */
6092 }
6093 else
6097 pa->filename
6100 }
6104 }
6106 /*
6107 * Now, if this multipart has but one text piece (that is, no
6108 * attachments), then downgrade from a composite type to a discrete
6109 * text/plain message if CTE is not 8bit.
6110 */
6116 /* Clone the interesting body part */
6119 /* and rub out what we don't want cleaned up when it's free'd */
6123 }
6127 }
6130 /*
6131 * Fill in text BODY part's structure
6132 *
6133 */
6134 void
6136 {
6141 }
6148 }
6151 /*
6152 * free_attachment_list - free attachments in given list
6153 */
6154 void
6156 {
6172 }
6183 }
6184 }
6187 void
6189 {
6201 }
6204 /*
6205 * view_as_rich - set the rich_header flag
6206 *
6207 * name - name of the header field
6208 * deflt - default value to return if user didn't set it
6209 *
6210 * Note: if the user tries to turn them all off with "", then
6211 * we take that to mean default, since otherwise there is no
6212 * way to get to the headers.
6213 */
6214 int
6216 {
6226 }
6229 }
6231 }
6234 /*
6235 * background_posting - return whether or not we're already in the process
6236 * of posting
6237 */
6238 int
6240 {
6246 }
6249 }
6252 /*----------------------------------------------------------------------
6253 Validate the given subject relative to any news groups.
6255 Args: none
6257 Returns: always returns 1, but also returns error if
6258 ----*/
6259 int
6261 {
6268 /*
6269 * Now look for any header entry we passed to pico that has to do
6270 * with news. If there's no subject, gripe.
6271 */
6279 }
6280 }
6283 }
6286 /*
6287 * This is the build_address used by the composer to check for an address
6288 * in the addrbook.
6289 *
6290 * Args: to -- the passed in line to parse
6291 * full_to -- Address of a pointer to return the full address in.
6292 * This will be allocated here and freed by the caller.
6293 * error -- Address of a pointer to return an error message in.
6294 * This will be allocated here and freed by the caller.
6295 * barg -- Address of a pointer to return the fcc in is in
6296 * fcc->tptr. It will have already been allocated by the
6297 * caller but we may free it and reallocate if we wish.
6298 * Caller will free it.
6299 *
6300 * Result: 0 is returned if address was OK,
6301 * -1 if address wasn't OK.
6302 *
6303 * Side effect: Can flush addrbook entry cache entries so they need to be
6304 * re-fetched afterwords.
6305 */
6306 int
6308 {
6311 BuildTo bldto;
6319 /* check to see if to string is empty to avoid work */
6328 }
6336 /* No guarantee cursor or status line is how we saved it */
6344 /*
6345 * If we end up jumping back here because somebody else changed one of
6346 * our addrbooks out from underneath us, we may well leak some memory.
6347 * That's probably ok since this will be very rare.
6348 *
6349 * The reason for the memcpy of the jmp_buf is that we may actually
6350 * be indirectly calling this function from within the address book.
6351 * For example, we may be in the address book screen and then run
6352 * the ComposeTo command which puts us in the composer, then we call
6353 * build_address from there which resets addrbook_changed_unexpectedly.
6354 * Once we leave build_address we need to reset addrbook_changed_un...
6355 * because this position on the stack will no longer be valid.
6356 * Same is true of the other setjmp's in this file which are wrapped
6357 * in memcpy calls.
6358 */
6377 }
6379 ab_nesting_level++;
6386 ab_nesting_level--;
6390 /*
6391 * Have to rfc1522_decode the full_to string before sending it back.
6392 */
6401 /* p == q means that decoding happened, p is decoded *full_to */
6405 }
6406 else
6408 }
6413 /* Pt will point to headents[Fcc].bldr_private */
6418 /*
6419 * If *barg->aff is set, that means fcc was set from a list
6420 * during some previous builder call.
6421 * If the current To line contains the old expansion as a prefix, then
6422 * we should leave things as they are. In order to decide that,
6423 * we look at a hash value computed from the strings.
6424 */
6436 }
6437 else
6439 }
6445 /* replace fcc value */
6456 }
6469 }
6471 /*
6472 * If result is reproducible, we don't keep track here.
6473 */
6476 }
6477 }
6478 }
6479 else
6481 }
6483 /* This is so pico will erase the old message */
6490 }
6493 /*
6494 * This is the builder used by the composer for the Lcc line.
6495 *
6496 * Args: lcc -- the passed in Lcc line to parse
6497 * full_lcc -- Address of a pointer to return the full address in.
6498 * This will be allocated here and freed by the caller.
6499 * error -- Address of a pointer to return an error message in.
6500 * This is not allocated so should not be freed by the caller.
6501 * barg -- This is a pointer to text for affected entries which
6502 * we may be changing. The first one in the list is the
6503 * To entry. We may put the name of the list in empty
6504 * group syntax form there (like List Name: ;).
6505 * The second one in the list is the fcc field.
6506 * The tptr members already point to text allocated in the
6507 * caller. We may free and reallocate here, caller will
6508 * free the result in any case.
6509 *
6510 * Result: 0 is returned if address was OK,
6511 * -1 if address wasn't OK.
6512 *
6513 * Side effect: Can flush addrbook entry cache entries so they need to be
6514 * re-fetched afterwords.
6515 */
6516 int
6518 {
6522 BuildTo bldlcc;
6533 /* check to see if to string is empty to avoid work */
6542 }
6551 /*
6552 * If we end up jumping back here because somebody else changed one of
6553 * our addrbooks out from underneath us, we may well leak some memory.
6554 * That's probably ok since this will be very rare.
6555 */
6575 }
6577 ab_nesting_level++;
6581 /*
6582 * To is first affected_entry and Fcc is second.
6583 * The conditional stuff for the fcc argument says to only change the
6584 * fcc if the fcc pointer is passed in non-null, and the To pointer
6585 * is also non-null. If they are null, that means they've already been
6586 * entered (are sticky). We don't affect fcc if either fcc or To has
6587 * been typed in.
6588 */
6590 full_lcc,
6591 error,
6598 ab_nesting_level--;
6602 /* full_lcc is what ends up in the Lcc: line */
6606 /*
6607 * Have to rfc1522_decode the full_lcc string before sending it back.
6608 */
6614 }
6615 else
6617 }
6619 /* to is what ends up in the To: line */
6624 /*
6625 * Have to rfc1522_decode the full_to string before sending it back.
6626 */
6631 /*
6632 * If the caller wants us to try to preserve the charset
6633 * information (they set aff) we copy it into encoded->etext.
6634 * We don't have to worry about pasting together pieces of
6635 * etext like we do in build_address because whenever the
6636 * Lcc line is setting the To line it will be setting the
6637 * whole line, not modifying it.
6638 * Pt will point to headents[To].bldr_private.
6639 */
6647 }
6648 }
6652 }
6653 else
6660 /*
6661 * This part is recording the fact that the To line was set to
6662 * what it is by entering something on the Lcc line. In particular,
6663 * if a list alias was entered here then the fullname of the list
6664 * goes in the To line. We save this affector information so that
6665 * we can tell it shouldn't be modified if we call build_addr_lcc
6666 * again unless we actually modified what's in the Lcc line so that
6667 * it doesn't start with the same thing. The problem we're solving
6668 * is that the contents of the Lcc line no longer look like the
6669 * list they were derived from.
6670 * Pt will point to headents[To].bldr_private.
6671 */
6686 }
6687 else
6689 }
6696 /* replace to value */
6712 }
6718 }
6725 }
6738 }
6740 /*
6741 * If result is reproducible, we don't keep track here.
6742 */
6745 }
6746 }
6747 }
6748 else
6750 }
6755 /*
6756 * If *barg->next->aff is set, that means fcc was set from a list
6757 * during some previous builder call. If the current Lcc line
6758 * contains the old expansion as a prefix, then we should leave
6759 * things as they are. In order to decide that we look at a hash
6760 * value computed from the strings.
6761 * Pt will point to headents[Fcc].bldr_private
6762 */
6778 }
6779 else
6781 }
6788 /* replace fcc value */
6799 }
6812 }
6814 /*
6815 * If result is reproducible, we don't keep track here.
6816 */
6819 }
6820 }
6821 }
6822 else
6824 }
6833 }
6836 /*----------------------------------------------------------------------
6837 Verify and canonicalize news groups names.
6838 Called from the message composer
6840 Args: given_group -- List of groups typed by user
6841 expanded_group -- pointer to point to expanded list, which will be
6842 allocated here and freed in caller. If this is
6843 NULL, don't attempt to validate.
6844 error -- pointer to store error message
6845 fcc -- pointer to point to fcc, which will be
6846 allocated here and freed in caller
6848 Returns: 0 if all is OK
6849 -1 if addresses weren't valid
6851 Test the given list of newstroups against those recognized by our nntp
6852 servers. Testing by actually trying to open the list is much cheaper, both
6853 in bandwidth and memory, than yanking the whole list across the wire.
6854 ----*/
6855 int
6856 news_build(char *given_group, char **expanded_group, char **error, BUILDER_ARG *fcc, int *mangled)
6857 {
6868 /* assign any new fcc to the BUILDER_ARG */
6871 /* it changed */
6876 }
6877 }
6881 }
6883 /* deal with any busy indicator */
6891 }
6895 }
6898 void
6900 {
6902 }
6905 #if defined(DOS) || defined(OS2)
6907 /*----------------------------------------------------------------------
6908 Verify that the necessary pieces are around to allow for
6909 message sending under DOS
6911 Args: strict -- tells us if a remote stream is required before
6912 sending is permitted.
6914 The idea is to make sure pine knows enough to put together a valid
6915 from line. The things we MUST know are a user-id, user-domain and
6916 smtp server to dump the message off on. Typically these are
6917 provided in pine's configuration file, but if not, the user is
6918 queried here.
6919 ----*/
6920 int
6922 {
6925 HelpType help;
6927 /*
6928 * query for user name portion of address, use IMAP login
6929 * name as default
6930 */
6932 NETMBX mb;
6940 }
6942 /* no user-id prompting if set */
6953 }
6954 else
6956 }
6957 else
6961 /* No prompt, just assume mailbox login is user-id */
6964 }
6980 }
6984 }
6990 }
6992 /* save the name */
6997 && !no_prompt_user_id
7000 }
7004 }
7005 }
7007 /* query for personal name */
7025 }
7029 }
7038 }
7042 }
7043 }
7044 }
7046 /*
7047 * query for host/domain portion of address, using IMAP
7048 * host as default
7049 */
7059 }
7060 else
7077 }
7081 }
7087 }
7089 /* save the name */
7099 }
7104 }
7105 }
7107 /* check for smtp server */
7119 }
7120 else
7137 }
7141 }
7147 }
7149 /* save the name */
7156 }
7159 }