| blob | 4d988a0c0c922dd60d6217bfca8f8845aca9136e |
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;
608 /*================= Compose new message ===============*/
615 /*
616 * Setup possible role
617 */
622 /* Setup possible compose role */
624 /*
625 * setup default role
626 * Msgno = -1 means there is no msg.
627 * This will match roles which have the Compose Use turned
628 * on, and have no patterns set, and match the Current
629 * Folder Type.
630 */
639 }
640 }
641 }
647 /*
648 * set ps_global->hostname to something sensible, if possible,
649 * for purposes of generating a message id
650 */
657 else
660 /* undo the changes above */
665 /*
666 * The type of storage object allocated below is vitally
667 * important. See SIMPLIFYING ASSUMPTION #37
668 */
677 }
678 }
679 }
684 }
696 }
699 }
700 }
701 else
712 }
718 }
724 /*
725 * check whether a build_address-produced fcc is different from
726 * fcc. If same, do nothing, if different, set sticky bit in pine_send.
727 */
736 }
739 /* not sticky */
740 }
741 else
742 fcc_is_sticky++;
746 }
762 }
774 }
777 /*----------------------------------------------------------------------
778 Args: stream -- This is where we get the postponed messages from
779 We'll expunge and close it here unless it is mail_stream.
781 These are all return values:
782 ================
783 outgoing --
784 body --
785 fcc --
786 lcc --
787 reply --
788 redraft_pos --
789 custom --
790 role --
791 ================
793 flags --
795 ----*/
796 int
800 {
810 /*
811 * If we're manipulating the current folder, don't bother
812 * with index
813 */
817 else
821 }
824 /*
825 * Since the user's got this folder already opened and they're
826 * on a selected message, pick that one rather than rebuild
827 * another index screen...
828 */
830 }
838 }
841 }
856 q_status_message(SM_ORDER, 3, 3, _("Undelete messages to remain postponed, and then continue message"));
857 else
858 q_status_message(SM_ORDER, 3, 3, _("Undelete form letters you want to keep, and then continue message"));
861 }
864 }
881 }
887 }
890 }
891 }
897 else
899 }
902 int
904 {
908 type);
910 }
913 }
916 /* this is for initializing the fixed header elements in pine_send() */
917 /*
918 prompt::name::help::prwid::maxlen::realaddr::
919 builder::affected_entry::next_affected::selector::key_label::fileedit::
920 display_it::break_on_comma::is_attach::rich_header::only_file_chars::
921 single_space::sticky::dirty::start_here::blank::sticky_special::KS_ODATAVAR
922 */
1002 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
1006 #endif
1007 };
1021 /*----------------------------------------------------------------------
1022 Get addressee for message, then post message
1024 Args: outgoing -- Partially formatted outgoing ENVELOPE
1025 body -- Body of outgoing message
1026 prmpt_who -- Optional prompt for optionally_enter call
1027 prmpt_cnf -- Optional prompt for confirmation call
1028 used_tobufval -- The string that the to was eventually set equal to.
1029 This gets passed back if non-NULL on entry.
1030 flagsarg -- SS_PROMPTFORTO - Allow user to change recipient
1031 SS_NULLRP - Use null return-path so we'll send an
1032 SMTP MAIL FROM: <>
1034 Result: message "To: " field is provided and message is sent or cancelled.
1036 Fields:
1037 remail -
1038 return_path -
1039 date added here
1040 from added here
1041 sender -
1042 reply_to -
1043 subject passed in, NOT edited but maybe canonized here
1044 to possibly passed in, edited and canonized here
1045 cc -
1046 bcc -
1047 in_reply_to -
1048 message_id -
1050 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1051 with the first part TYPETEXT! All newlines in the text here also end with
1052 CRLF.
1054 Returns 0 on success, -1 on failure.
1055 ----*/
1056 int
1064 {
1070 HelpType help;
1073 BUILDER_ARG ba_fcc;
1076 PAT_STATE pstate;
1086 /*----- Fill in a few general parts of the envelope ----*/
1096 }
1101 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
1102 else
1104 }
1105 else
1107 }
1122 }
1129 }
1147 /*----------------------------------------------------------------------
1148 Loop editing the "To: " field until everything goes well
1149 ----*/
1162 snprintf(tmp, sizeof(tmp), _("BOUNCE (redirect) message using role \"%s\" to : "), role->nick);
1163 else
1166 }
1169 og2s_done++;
1171 }
1186 }
1192 }
1198 prmpt_who
1199 ? prmpt_who
1202 }
1203 else
1211 done++;
1233 }
1234 }
1249 }
1250 }
1252 }
1259 }
1260 else
1269 }
1270 else
1287 /*
1288 * Just make it look like user typed this list in.
1289 */
1291 got_something++;
1295 }
1300 }
1310 }
1320 /*
1321 * If role has an fcc, use it instead of what build_address
1322 * tells us.
1323 */
1329 }
1341 }
1348 /* confirm address */
1360 ps_global))))
1361 /*--- Addresses didn't check out---*/
1377 /* setup keymenu slot to toggle verbose mode */
1387 }
1388 }
1390 /* clear DSN flags */
1393 /* setup keymenu slots to toggle dsn bits */
1411 }
1433 ? addr
1450 /* TRANSLATORS: several possible key labels follow */
1470 }
1471 }
1479 }
1482 }
1485 }
1489 else
1491 }
1495 /* turn off related bits */
1498 }
1501 /* turn off related bits */
1504 }
1507 /* turn off related bits */
1510 }
1513 }
1514 }
1517 }
1531 }
1532 }
1547 /*
1548 * If special name "inbox" then replace it with the
1549 * real inbox path.
1550 */
1558 }
1559 }
1561 /*---- Check out fcc -----*/
1571 }
1572 else
1574 }
1575 else
1577 }
1578 else
1585 }
1593 q_status_message(SM_ORDER | SM_DING, 5, 5, _("Use of a role-defined smtp-server is administratively prohibited"));
1594 else
1596 }
1599 call_mailer_flags,
1600 call_mailer_file_result,
1601 pipe_callback);
1603 }
1604 else
1610 /*----- Was there an fcc involved? -----*/
1622 }
1624 /* Now actually copy to fcc folder and close */
1625 fcc_result =
1627 label,
1630 }
1636 }
1639 }
1645 else
1647 }
1671 SIZEOF_20KBUF,
1673 }
1674 }
1678 }
1682 }
1683 }
1692 else
1694 }
1696 }
1701 }
1702 }
1704 done++;
1709 done++;
1716 ? h_anon_forward
1734 }
1738 }
1741 }
1745 }
1752 }
1753 }
1755 finish:
1762 }
1765 /*
1766 * pine_simple_send_header - generate header suitable for simple_sending
1767 */
1768 METAENV *
1770 {
1777 /* assign he_dummy to "To:" field "he" for strings2outgoing */
1784 }
1787 }
1791 /*----------------------------------------------------------------------
1792 Prepare data structures for pico, call pico, then post message
1794 Args: outgoing -- Partially formatted outgoing ENVELOPE
1795 body -- Body of outgoing message
1796 editor_title -- Title for anchor line in composer
1797 fcc_arg -- The file carbon copy field
1798 reply -- Struct describing set of msgs being replied-to
1799 lcc_arg --
1800 custom -- custom header list.
1801 sticky_fcc --
1803 Result: message is edited, then postponed, cancelled or sent.
1805 Fields:
1806 remail -
1807 return_path -
1808 date added here
1809 from added here
1810 sender -
1811 reply_to -
1812 subject passed in, edited and cannonized here
1813 to possibly passed in, edited and cannonized here
1814 cc possibly passed in, edited and cannonized here
1815 bcc edited and cannonized here
1816 in_reply_to generated in reply() and passed in
1817 message_id -
1819 Storage for these fields comes from anywhere outside. It is remalloced
1820 here so the composer can realloc them if needed. The copies here are also
1821 freed here.
1823 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1824 with the first part TYPETEXT! All newlines in the text here also end with
1825 CRLF.
1827 There's a further assumption that the text in the TYPETEXT part is
1828 stored in a storage object (see filter.c).
1829 ----*/
1830 void
1835 {
1848 METAENV header;
1854 CustomType ct;
1863 /*
1864 * Cancel any pending initial commands since pico uses a different
1865 * input routine. If we didn't cancel them, they would happen after
1866 * we returned from the editor, which would be confusing.
1867 */
1877 }
1880 }
1882 #if defined(DOS) || defined(OS2)
1886 }
1889 #else
1893 #endif
1903 #ifdef _WINDOWS
1917 /* We actually want to set this only if message we're sending is flowed */
1931 #if defined(DOS) || defined(OS2)
1934 }
1935 #endif
1940 /* NOTE: initial cursor position set below */
1944 /*
1945 * When user runs compose and the current folder is a newsgroup,
1946 * offer to post to the current newsgroup.
1947 */
1955 /*
1956 * Replies don't get this far because To or Newsgroups will already
1957 * be filled in. So must be either ordinary compose or forward.
1958 * Forward sets subject, so use that to tell the difference.
1959 */
1971 }
1982 }
1992 }
1997 }
2003 }
2006 }
2021 }
2022 }
2023 }
2027 NETMBX news_mb;
2035 suggested_nntp_server =
2041 /* take out /nntp, which gets added in nntp_open */
2048 else
2049 p++;
2057 }
2059 }
2060 }
2061 }
2062 else
2064 }
2065 }
2067 /*
2068 * If we don't already have custom headers set and the role has custom
2069 * headers, then incorporate those custom headers into "custom".
2070 */
2075 /*
2076 * If we allow the Combine argument here, we're saying that we want to
2077 * combine the values from the envelope and the role for the fields To,
2078 * Cc, Bcc, and Newsgroups. For example, if we are replying to a message
2079 * we'll have a To in the envelope because we're replying. If our role also
2080 * has a To action, then Combine would combine those two and offer both
2081 * to the user. We've decided against doing this. Instead, we always use
2082 * Replace, and the role's header value replaces the value from the
2083 * envelope. It might also make sense in some cases to do the opposite,
2084 * which would be treating the role headers as defaults, just like
2085 * customized-hdrs.
2086 */
2087 #ifdef WANT_TO_COMBINE_ADDRESSES
2090 #else
2093 #endif
2100 }
2105 }
2106 }
2107 else
2109 }
2113 /* how many fixed fields are there? */
2115 ;
2119 /* the fixed part of the PINEFIELDs */
2124 /* temporary headerentry array for pico */
2138 /* custom part of PINEFIELDs */
2144 /*
2145 * For Address types, pf->addr points to an ADDRESS *.
2146 * If that address is in the "outgoing" envelope, it will
2147 * be freed by the caller, otherwise, it should be freed here.
2148 * Pf->textbuf for an Address is used a little to set up a default,
2149 * but then is freed right away below. Pf->scratch is used for a
2150 * pointer to some alloced space for pico to edit in. Addresses in
2151 * the custom area are freed by free_customs().
2152 *
2153 * For FreeText types, pf->addr is not used. Pf->text points to a
2154 * pointer that points to the text. Pf->textbuf points to a copy of
2155 * the text that must be freed before we leave, otherwise, it is
2156 * probably a pointer into the envelope and that gets freed by the
2157 * caller.
2158 *
2159 * He->realaddr is the pointer to the text that pico actually edits.
2160 */
2162 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2163 # define NN 4
2164 #else
2165 # define NN 3
2166 #endif
2169 use_news_order++;
2171 /* initialize the fixed header elements of the two temp arrays */
2178 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2179 , N_SENDER
2180 #endif
2181 };
2184 /* slightly different editing order if sending to news */
2189 /* copy the templates */
2194 /* slide string over so it is Sender instead of X-X-Sender */
2198 }
2248 }
2249 }
2253 }
2258 /* if no value, use default */
2262 }
2268 }
2270 /* If there is a newsgroup, we'd better show it */
2278 }
2283 }
2288 }
2293 }
2298 }
2303 }
2309 }
2315 }
2321 }
2327 }
2333 }
2339 }
2345 }
2351 }
2357 }
2363 }
2367 }
2371 /* can't do a default for this one */
2373 /* If there is an attachment already, we'd better show them */
2386 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
2391 }
2392 }
2400 /* If already set, make it act like we typed it in */
2417 }
2422 SIZEOF_20KBUF,
2428 }
2440 /* if bcc exists, make sure it's exposed so nothing's
2441 * sent by mistake...
2442 */
2458 }
2472 }
2476 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2481 #endif
2487 }
2489 /*
2490 * If this is a reply to news, don't show the regular email
2491 * recipient headers (unless they are non-empty).
2492 */
2507 }
2508 else
2510 }
2512 /*
2513 * If this address doesn't already have a value, then we check
2514 * for a default value assigned by the user.
2515 */
2526 /*
2527 * Try to set To based on Lcc. Don't attempt Fcc.
2528 */
2566 }
2567 }
2574 }
2578 }
2588 }
2589 }
2591 /* if we still don't have a from */
2594 }
2596 /*
2597 * Addr is already set in the rest of the cases.
2598 */
2602 /*
2603 * We get to this case of the ifelse if the from or reply-to
2604 * addr was set by a role above.
2605 */
2607 /* figure out the default value */
2616 }
2618 /* if value set by role is different from default, show it */
2622 /* malformed */
2626 }
2630 }
2635 /*
2636 * These three are different from the others because we
2637 * might add the addresses to what is already there instead
2638 * of replacing.
2639 */
2663 ;
2669 }
2676 }
2679 }
2698 }
2701 }
2706 }
2711 /* outgoing2strings will alloc the string pf->scratch below */
2720 else
2726 }
2758 /* if no value, use default */
2761 }
2765 }
2768 }
2779 }
2781 /*
2782 * We may or may not want to give the user the chance to edit
2783 * the From and Reply-To lines. If they are listed in either
2784 * Default-composer-hdrs or Customized-hdrs, then they can edit
2785 * them, else no.
2786 * If canedit is not set, that means that this header is not in
2787 * the user's customized-hdrs. If rich_header is set, that
2788 * means that this header is not in the user's
2789 * default-composer-hdrs (since From and Reply-To are rich
2790 * by default). So, don't give it an he to edit with in that case.
2791 *
2792 * For other types, just not setting canedit will cause it to be
2793 * uneditable, regardless of what the user does.
2794 */
2797 /* to allow it, we let this fall through to the reply-to case below */
2808 }
2814 }
2817 he++;
2818 }
2826 }
2827 else
2828 he++;
2831 }
2832 }
2834 /*
2835 * This is so the builder can tell the composer to fill the affected
2836 * field based on the value in the field on the left.
2837 *
2838 * Note that this mechanism isn't completely general. Each entry has
2839 * only a single next_affected, so if some other entry points an
2840 * affected entry at an entry with a next_affected, they all inherit
2841 * that next_affected. Since this isn't used much a careful ordering
2842 * of the affected fields should make it a sufficient mechanism.
2843 */
2852 /*
2853 * Set up headerentries for custom fields.
2854 * NOTE: "i" is assumed to now index first custom field in sending
2855 * order.
2856 */
2874 /* change default text into an ADDRESS */
2875 /* strip quotes around whole default */
2887 }
2906 }
2910 /* use first 8 characters for prompt */
2915 he++;
2916 }
2918 /*
2919 * Make sure at least *one* field is displayable...
2920 */
2925 }
2927 /*
2928 * None displayable!!! Warn and display defaults.
2929 */
2937 }
2939 /*
2940 * Save information about body which set_mime_type_by_grope might change.
2941 * Then, if we get an error sending, we reset these things so that
2942 * grope can do it's thing again after we edit some more.
2943 */
2946 else
2952 /*----------------------------------------------------------------------
2953 Loop calling the editor until everything goes well
2954 ----*/
2958 /* Reset body to what it was when we started. */
2961 else
2963 /*
2964 * set initial cursor position based on how many times we've been
2965 * thru the loop...
2966 */
2969 }
2973 }
2976 /* set the start_here bit in correct header */
2982 }
2984 /* If didn't find it, we start in body. */
2987 }
2990 }
2992 /* in case these were turned on in previous pass through loop */
2996 }
3001 /*
3002 * If a sending attempt failed after we passed the message text
3003 * thru a user-defined filter, "orig_so" points to the original
3004 * text. Replace the body's encoded data with the original...
3005 */
3013 }
3015 /*
3016 * Convert the envelope and body to the string format that
3017 * pico can edit
3018 */
3022 /*
3023 * If this isn't the first time through this loop, we may have
3024 * freed some of the FreeText headers below so that they wouldn't
3025 * show up as empty headers in the finished message. Need to
3026 * alloc them again here so they can be edited.
3027 */
3033 }
3035 /*
3036 * If From is exposed, probably by a role, then start the cursor
3037 * on the first line which isn't filled in. If it isn't, then we
3038 * don't move the cursor, mostly for back-compat.
3039 */
3050 }
3051 }
3053 #ifdef _WINDOWS
3055 #endif
3060 /* turn off user input timeout when in composer */
3068 #ifdef _WINDOWS
3070 #endif
3073 /*
3074 * Only reinitialize signals if we didn't receive an interesting
3075 * one while in pico, since pico's return is part of processing that
3076 * signal and it should continue to be ignored.
3077 */
3081 /*
3082 * We're going to save in DEADLETTER. Dump attachments first.
3083 */
3087 /* Turn strings back into structures */
3090 /* Make newsgroups NULL if it is "" (so won't show up in headers) */
3095 }
3097 /* Make subject NULL if it is "" (so won't show up in headers) */
3101 /* remove custom fields that are empty */
3107 }
3108 }
3109 }
3113 /*-------- Stamp it with a current date -------*/
3126 /* Set return_path based on From which is going to be used */
3132 /*
3133 * Don't ever believe the sender that is there.
3134 * If From doesn't look quite right, generate our own sender.
3135 */
3139 /*
3140 * If the LHS of the address doesn't match, or the RHS
3141 * doesn't match one of localdomain or hostname,
3142 * then add a sender line (really X-X-Sender).
3143 *
3144 * Don't add a personal_name since the user can change that.
3145 */
3147 &&
3158 }
3163 }
3165 /*----- Message is edited, now decide what to do with it ----*/
3167 /*=========== Postpone or Interrupted message ============*/
3185 }
3187 /*
3188 * The idea here is to use the Fcc: writing facility
3189 * to append to the special postponed message folder...
3190 *
3191 * NOTE: the strategy now is to write the message and
3192 * all attachments as they exist at composition time.
3193 * In other words, attachments are postponed by value
3194 * and not reference. This may change later, but we'll
3195 * need a local "message/external-body" type that
3196 * outgoing2strings knows how to properly set up for
3197 * the composer. Maybe later...
3198 */
3205 /*--- Addresses didn't check out---*/
3209 }
3211 /*
3212 * Build the local message copy so.
3213 *
3214 * In the HUP case, we'll write the bezerk delimiter by
3215 * hand and output the message directly into the folder.
3216 * It's not only faster, we don't have to worry about
3217 * c-client reentrance and less hands paw over the data so
3218 * there's less chance of a problem.
3219 *
3220 * In the Postpone case, just create it if the user wants to
3221 * and create a temporary storage object to write into. */
3222 fake_hup:
3228 #if defined(DOS) || defined(OS2)
3229 /*
3230 * we can't assume anything about root or home dirs, so
3231 * just plunk it down in the same place as the pinerc
3232 */
3240 }
3245 }
3246 else
3247 #endif
3249 ps_global->VAR_OPER_DIR
3271 }
3279 }
3282 }
3283 else
3298 else
3302 }
3303 }
3304 }
3305 }
3312 }
3314 /*
3315 * Store the cursor position
3316 *
3317 * First find the header entry with the start_here
3318 * bit set, if any. This means the editor is telling
3319 * us to start on this header field next time.
3320 */
3326 }
3328 /* If there wasn't one, ":" means we start in the body. */
3340 }
3347 }
3350 }
3356 /* copy fcc line to postponed or interrupted folder */
3360 /* plug error into header for later display to user */
3365 }
3367 /*
3368 * if reply, write (UID)folder header field so we can
3369 * later flag the replied-to message \\ANSWERED
3370 * DON'T save MSGNO's.
3371 */
3381 }
3397 /*
3398 * Logically, this ought to be part of pf_uid, but this
3399 * was added later and so had to be in a separate header
3400 * for backwards compatibility.
3401 */
3407 }
3409 /* Save cursor position */
3419 }
3421 /*
3422 * Work around c-client reply-to bug. C-client will
3423 * return a reply_to in an envelope even if there is
3424 * no reply-to header field. We want to note here whether
3425 * the reply-to is real or not.
3426 */
3432 else
3434 }
3436 /* Save the role-specific smtp server */
3442 /*
3443 * Turn the list of smtp servers into a space-
3444 * delimited list in a single string.
3445 */
3457 }
3460 }
3466 else
3468 }
3470 /* Save the role-specific nntp server */
3478 /*
3479 * Turn the list of nntp servers into a space-
3480 * delimited list in a single string.
3481 */
3493 }
3496 }
3497 }
3498 else
3505 else
3507 }
3509 /*
3510 * Write the list of custom headers to the
3511 * X-Our-Headers header so that we can recover the
3512 * list in redraft.
3513 */
3531 }
3534 }
3536 /*
3537 * We need to make sure any header values that got cleared
3538 * get written to the postponed message (they won't if
3539 * pf->text is NULL). Otherwise, we can't tell previously
3540 * non-existent custom headers or default values from
3541 * custom (or other) headers that got blanked in the
3542 * composer...
3543 */
3548 /*
3549 * We're saving the message for use later. It may be that the
3550 * characters in the message are not all convertible to the
3551 * user's posting_charmap. We'll save it as UTF-8 instead
3552 * and worry about that the next time they try to send it.
3553 * Use a different save pointer just to be sure we don't
3554 * mess up the other stuff. We should probably make the
3555 * charset an argument.
3556 *
3557 * We also need to fix the charset of the body part
3558 * the user is editing so that we can read it back
3559 * successfully when we resume the composition.
3560 */
3563 {
3568 else
3574 ;
3581 }
3582 }
3596 }
3613 }
3614 else
3621 }
3622 else
3625 }
3627 /* discontinue coerced UTF-8 posting */
3631 }
3632 else
3637 /*
3638 * Special Hack #291: if any hi-byte bits are set in
3639 * editor's result, we put them there.
3640 */
3647 }
3654 else
3659 }
3672 }
3678 }
3679 }
3681 /*------ Must be sending mail or posting ! -----*/
3688 /* --- If posting, confirm with user ----*/
3695 }
3705 continue_with_only_fcc++;
3706 }
3712 }
3713 }
3716 /*--- Addresses didn't check out---*/
3719 }
3722 && !continue_with_only_fcc
3731 local_redraft_pos
3736 }
3744 local_redraft_pos
3749 }
3757 local_redraft_pos
3762 }
3766 /*---- Check out fcc -----*/
3768 /*
3769 * If special name "inbox" then replace it with the
3770 * real inbox path.
3771 */
3779 }
3782 /* lmc.text_only set on command line */
3784 /* ---- Open or allocation of fcc failed ----- */
3787 /*
3788 * Find field entry associated with fcc, and start
3789 * composer on it...
3790 */
3796 }
3797 else
3799 }
3800 else
3803 /*---- Take care of any requested prefiltering ----*/
3811 }
3813 /*------ Actually post -------*/
3828 }
3829 }
3838 }
3839 else
3841 }
3843 /*
3844 * BUG: IF we've posted the message *and* an fcc was specified
3845 * then we've already got a neatly formatted message in the
3846 * lmc.so. It'd be nice not to have to re-encode everything
3847 * to insert it into the smtp slot...
3848 */
3850 /*
3851 * Turn on "undisclosed recipients" header if no To or cc.
3852 */
3857 }
3862 }
3864 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
3865 /*
3866 * If requested, launch background posting...
3867 */
3875 /*
3876 * Put us in new process group...
3877 */
3880 /* BUG: should fix argv[0] to indicate what we're up to */
3882 /*
3883 * If there are any live streams, pretend we never
3884 * knew them. Problem is two processes writing
3885 * same server process.
3886 * This is not clean but we're just going to exit
3887 * right away anyway. We just want to be sure to leave
3888 * the stuff that the parent is going to use alone.
3889 * The next three lines will disable the re-use of the
3890 * existing streams and cause us to open a new one if
3891 * needed.
3892 */
3897 /* quell any display output */
3900 /*------- Actually mail the message ------*/
3909 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3910 else
3912 }
3915 call_mailer_flags,
3916 call_mailer_file_result,
3922 }
3924 /*----- Was there an fcc involved? -----*/
3926 /*------ Write it if at least something worked ------*/
3938 }
3940 /*-- Now actually copy to fcc folder and close --*/
3946 }
3953 }
3956 }
3959 /*
3960 * Encode child's result in hi-byte of
3961 * editor's result
3962 */
3965 }
3968 }
3974 }
3983 }
3994 }
3997 /*------- Actually mail the message ------*/
4005 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
4006 else
4008 }
4011 call_mailer_flags,
4012 call_mailer_file_result,
4018 }
4020 /*----- Was there an fcc involved? -----*/
4022 /*------ Write it if at least something worked ------*/
4033 }
4035 /*-- Now actually copy to fcc folder and close --*/
4040 }
4046 }
4049 }
4051 /*----- Mail Post FAILED, back to composer -----*/
4056 /*
4057 * Find field entry associated with fcc, and start
4058 * composer on it...
4059 */
4067 }
4075 }
4077 /*
4078 * If message sent *completely* successfully, there's a
4079 * reply struct AND we're allowed to write back state, do it.
4080 * But also protect against shifted message numbers due
4081 * to new mail arrival. Since the number passed is based
4082 * on the real imap msg no, AND we're sure no expunge has
4083 * been done, just fix up the sorted number...
4084 */
4087 /*----- Signed, sealed, delivered! ------*/
4092 }
4093 }
4112 }
4137 }
4140 /*
4141 * Check for subject in outgoing message.
4142 *
4143 * Asks user whether to proceed with no subject.
4144 */
4145 int
4147 {
4159 else
4161 }
4164 }
4168 }
4171 /*
4172 * Check for fcc in outgoing message.
4173 *
4174 * Asks user whether to proceed with no fcc.
4175 */
4176 int
4178 {
4186 else
4188 }
4191 }
4194 /*
4195 * Confirm that the user wants to send to MAILER-DAEMON
4196 */
4197 int
4199 {
4202 }
4205 void
4207 {
4213 }
4214 }
4217 int
4219 {
4226 }
4229 /*
4230 * call__mailer_file_result - some results from call_mailer might be in a file.
4231 * dislplay that file.
4232 */
4233 void
4235 {
4239 }
4242 }
4243 }
4244 }
4246 void
4248 {
4264 }
4265 }
4269 /*
4270 * This is specialized routine. It assumes that the only things that we
4271 * care about restoring are the body type, subtype, encoding and the
4272 * state of the charset parameter. It also assumes that if the charset
4273 * parameter exists when we save it, it won't be removed later.
4274 */
4275 BODY_PARTICULARS_S *
4277 {
4295 }
4299 }
4302 }
4305 void
4307 {
4329 }
4333 else
4337 }
4338 }
4341 /*
4342 * This can't happen because grope never removes
4343 * the charset parameter.
4344 */
4347 }
4348 /*
4349 else{
4350 ok, still no parameter
4351 }
4352 */
4353 }
4354 }
4360 }
4361 }
4364 void
4366 {
4375 }
4376 }
4379 /*----------------------------------------------------------------------
4380 Build a status message suitable for framing
4382 Returns: pointer to resulting buffer
4383 ---*/
4386 {
4425 /* dots on end of fixed, no fcc */
4429 }
4431 /* include whole fixed part, quotes and dots at end of fcc name */
4441 }
4443 /* whole thing */
4449 }
4455 }
4457 /* Callback from Pico to set the conditions for Alpine to start a new thread
4458 */
4460 void
4462 {
4464 }
4468 /*----------------------------------------------------------------------
4469 Call back for pico to insert the specified message's text
4471 Args: n -- message number to format
4472 f -- function to use to output the formatted message
4475 Returns: returns msg number formatted on success, zero on error.
4476 ----*/
4477 long
4479 {
4491 }
4493 /* temporarily assign a new quote string */
4497 /* build separator line */
4500 /* actually write message text */
4506 }
4511 }
4514 /*----------------------------------------------------------------------
4515 Call back for pico to prompt the user for exit confirmation
4517 Args: dflt -- default answer for confirmation prompt
4519 Returns: either NULL if the user accepts exit, or string containing
4520 reason why the user declined.
4521 ----*/
4522 int
4525 {
4552 }
4559 }
4566 /*
4567 * Build list of available filters...
4568 */
4572 ;
4580 }
4586 }
4591 }
4592 else
4601 }
4608 }
4609 }
4623 /* set global_filter_pointer to desired filter or NULL if none */
4624 /* prepare two keymenu slots for selecting filter */
4637 }
4640 /* setup keymenu slot to toggle verbose mode */
4645 }
4648 /* setup keymenu slot to toggle flowed mode */
4654 }
4657 /* setup keymenu slot to toggle attacment on fcc */
4662 }
4664 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
4670 }
4671 #endif
4678 #ifdef SMIME
4693 }
4694 }
4695 #endif
4700 /* setup keymenu slots to toggle dsn bits */
4718 }
4730 }
4739 else
4755 lparen++;
4756 }
4757 else
4759 }
4762 }
4769 lparen++;
4770 }
4774 }
4775 }
4782 }
4783 else
4785 }
4792 lparen++;
4793 }
4794 else
4796 }
4806 }
4813 lparen++;
4814 }
4815 else
4817 }
4822 }
4829 lparen++;
4830 }
4834 }
4835 }
4838 }
4840 #ifdef SMIME
4846 lparen++;
4847 }
4851 }
4852 }
4855 }
4862 lparen++;
4863 }
4867 }
4868 }
4871 }
4872 #endif
4910 }
4911 }
4922 h_send_prompt,
4923 RB_NORM);
4924 else
4935 h_send_prompt,
4936 RB_NORM);
4940 }
4944 }
4948 }
4951 }
4954 }
4957 }
4961 else
4966 }
4969 }
4974 }
4978 /* turn off related bits */
4981 }
4984 /* turn off related bits */
4987 }
4990 /* turn off related bits */
4993 }
4996 }
4997 }
4999 /*
5000 * When you turn on DSN, the default is to notify on
5001 * failure, success, or delay; and to return the whole
5002 * body on failure.
5003 */
5005 }
5013 }
5021 else
5023 }
5024 }
5025 #ifdef SMIME
5029 }
5033 }
5034 #endif
5048 }
5050 /* remember selection */
5063 }
5064 }
5075 }
5078 /*
5079 * Allow user to choose a priority for sending.
5080 *
5081 * Returns an allocated priority on success, NULL otherwise.
5082 */
5085 {
5094 cnt++;
5105 lp++;
5106 }
5113 /* TRANSLATORS: SELECT A PRIORITY is a screen title
5114 TRANSLATORS: Print something1 using something2.
5115 "priorities" is something1 */
5119 starting_val);
5129 }
5132 int
5134 {
5136 }
5139 /*----------------------------------------------------------------------
5140 Call back for pico to display mime type of attachment
5142 Args: file -- filename being attached
5144 Returns: returns 1 on success (message queued), zero otherwise (don't know
5145 type so nothing queued).
5146 ----*/
5147 int
5149 {
5158 /* don't know where the cursor's been, reset it */
5164 }
5165 }
5173 }
5174 else
5179 }
5182 /*----------------------------------------------------------------------
5183 Call back for pico to receive an uploaded message
5185 Args: fname -- name for uploaded file (empty if they want us to assign it)
5186 size -- pointer to long to hold the attachment's size
5188 Notes: the attachment is uploaded to a temp file, and
5190 Returns: TRUE on success, FALSE otherwise
5191 ----*/
5192 int
5194 {
5212 }
5213 }
5214 else
5231 }
5239 }
5240 else
5247 }
5252 {
5263 };
5274 }
5278 }
5279 else
5281 }
5285 }
5288 /*----------------------------------------------------------------------
5289 Pass the first text segment of the message thru the "send filter"
5291 Args: body pointer and address for storage object of old data
5293 Returns: returns 1 on success, zero on error.
5294 ----*/
5295 int
5298 {
5307 #define DO_HEADERS 1
5313 /*
5314 * We need WRITE_TO_LOCALE here because the user is going to
5315 * be operating on tmpf. We need to change it back after they
5316 * are done.
5317 */
5322 }
5324 /*
5325 * If the headers are wanted for filtering, we can just
5326 * stick them in the tmpf file that is already there before
5327 * putting the body in.
5328 */
5335 }
5345 }
5346 else
5348 }
5350 /*
5351 * Gf_filter wants a single storage object to read from.
5352 * If headers are wanted for filtering we'll have to put them
5353 * and the body into a temp file first and then use that
5354 * as the storage object for gf_filter.
5355 * We don't use WRITE_TO_LOCALE in this case because gf_filter
5356 * takes care of that.
5357 */
5359 /* put headers in our_tmpf_so */
5366 /* put body in our_tmpf_so */
5375 /* tell gf_filter to read from our_tmpf_so instead of *so */
5377 }
5378 else
5380 }
5381 else
5399 /* now we undo the WRITE_FROM_LOCALE change in tmpf */
5406 }
5407 else
5409 }
5410 else
5412 }
5413 else
5415 }
5416 else
5419 pipe_callback);
5426 #ifdef _WINDOWS
5428 /*
5429 * Can't really be using stdout, so don't print message that
5430 * gets printed in the else. Ideally the program being called
5431 * will wait after showing the message, we might want to look
5432 * into doing the waiting in console based apps... or not.
5433 */
5434 #else
5443 }
5453 /*
5454 * If the command said it would return new MIME
5455 * mime type data, check it out...
5456 */
5468 ;
5486 }
5489 }
5492 }
5493 }
5495 /*
5496 * Reevaluate the encoding in case form's changed...
5497 */
5500 }
5504 }
5505 else
5507 }
5510 }
5511 else
5517 }
5522 }
5529 }
5535 errstr);
5538 }
5541 }
5544 /*----------------------------------------------------------------------
5545 Copy the newsgroup name of the given mailbox into the given buffer
5547 Args:
5549 Returns:
5550 ----*/
5551 void
5553 {
5554 NETMBX mb;
5559 }
5562 }
5563 else
5565 }
5568 /*----------------------------------------------------------------------
5569 Set up fields for passing to pico. Assumes first text part is
5570 intended to be passed along for editing, and is in the form of
5571 of a storage object brought into existence sometime before pico_send().
5572 -----*/
5573 void
5576 {
5579 /*
5580 * SIMPLIFYING ASSUMPTION #37: the first TEXT part's storage object
5581 * is guaranteed to be of type PicoText!
5582 */
5586 /* mark storage object as user edited */
5589 }
5596 /*
5597 * We used to jump out the window if the first part wasn't text,
5598 * but that may not be the case when bouncing a message with
5599 * a leading non-text segment. So, IT'S UNDERSTOOD that the
5600 * contents of the first part to send is still ALWAYS in a
5601 * PicoText storage object, *AND* if that object doesn't contain
5602 * data of type text, then it must contain THE ENCODED NON-TEXT
5603 * DATA of the piece being sent.
5604 *
5605 * It's up to the programmer to make sure that such a message is
5606 * sent via pine_simple_send and never get to the composer via
5607 * pine_send.
5608 *
5609 * Make sense?
5610 */
5613 /* mark storage object as user edited */
5617 /*
5618 * If we already had a list, blast it now, so we can build a new
5619 * attachment list that reflects what's really there...
5620 */
5625 /* Simplifyihg assumption #28e. (see cross reference)
5626 All parts in the body passed in here that are not already
5627 in the attachments list are added to the end of the attachments
5628 list. Attachment items not in the body list will be taken care
5629 of in strings2outgoing, but they are unlikely to occur
5630 */
5633 /* Already in list? */
5637 ;
5651 }
5655 }
5656 }
5657 else
5663 /*
5664 * If we can find a "name" parm, display that too...
5665 */
5667 /* Convert any [ or ]'s the name contained */
5675 }
5676 else
5696 }
5697 }
5698 }
5699 }
5702 /*------------------------------------------------------------------
5703 Malloc strings to pass to composer editor because it expects
5704 such strings so it can realloc them
5705 -----------------------------------------------------------------*/
5706 /*
5707 * turn any address fields into text strings
5708 */
5709 /*
5710 * SIMPLIFYING ASSUMPTION #116: all header strings are understood
5711 * NOT to be RFC1522 decoded. Said differently, they're understood
5712 * to be RFC1522 ENCODED as necessary. The intent is to preserve
5713 * original charset tagging as far into the compose/send pipe as
5714 * we can.
5715 */
5726 /*
5727 * Scan for and fix-up patently bogus fields.
5728 *
5729 * NOTE: collaboration with this code and what's done in
5730 * reply.c:reply_cp_addr to package up the bogus stuff
5731 * is required.
5732 */
5738 /*
5739 * Rfc822_cat has been changed so that it now quotes
5740 * this sometimes. So we have to look out for quotes
5741 * which confuse the decoder. It was only quoting
5742 * because we were putting \r \n in the input, I think.
5743 */
5766 }
5774 /*
5775 * Replace control characters with ^C notation, unless
5776 * some conditions are met (see istrncpy).
5777 * If user doesn't edit, then we switch back to the
5778 * original version. If user does edit, then all bets
5779 * are off.
5780 */
5786 }
5789 }
5790 }
5809 }
5814 }
5819 /*
5820 * Replace control characters with ^C notation, unless
5821 * some conditions are met (see istrncpy).
5822 * If user doesn't edit, then we switch back to the
5823 * original version. If user does edit, then all bets
5824 * are off.
5825 */
5831 }
5834 }
5835 }
5841 }
5842 }
5845 /*----------------------------------------------------------------------
5846 Restore fields returned from pico to form useful to sending
5847 routines.
5848 -----*/
5849 void
5851 {
5857 /*
5858 * turn any local address strings into address lists
5859 */
5880 }
5892 }
5898 }
5901 }
5907 }
5910 /*----------------------------------------------------------------------
5912 The head of the body list here is always either TEXT or MULTIPART. It may be
5913 changed from TEXT to MULTIPART if there are attachments to be added
5914 and it is not already multipart.
5915 ----*/
5916 void
5918 {
5927 /*
5928 * if conditions are met short circuit MIME wrapping
5929 */
5932 /* only override assigned encoding if it might need upgrading */
5943 }
5946 }
5949 /*-- Current type is text, but there are attachments to add --*/
5950 /*-- Upgrade to a TYPEMULTIPART --*/
5955 /*
5956 * Why do we do this?
5957 * The problem is that base64 or quoted-printable encoding is
5958 * sensitive to having random data appended to it's end. If
5959 * we use a single part TEXT message and something in between
5960 * us and the end appends advertising without adjusting for
5961 * the encoding, the message is screwed up. So we wrap the
5962 * text part inside a multipart and then the appended data
5963 * will come after the boundary.
5964 *
5965 * We wish we could do this on the way out the door in a
5966 * child of post_rfc822_output because at that point we know
5967 * the character set and the encoding being used. For example,
5968 * iso-2022-jp is an encoding that is not sensitive to data
5969 * appended to the end, so it wouldn't need to be wrapped.
5970 * We could conceivably have post_rfc822_body inspect the
5971 * body and change it before doing the output. It would work
5972 * but would be very fragile. We'd be passed a body from
5973 * c-client to output and instead of just doing the output
5974 * we'd change the body and then output it. Not worth it
5975 * since the multipart wrapping is completely correct for
5976 * MIME-aware mailers.
5977 */
5979 /* move contents which were NOT copied */
5982 }
5989 }
5993 }
5996 /*-- Now type must be MULTIPART with first part text --*/
5999 }
6001 /*------ Go through the parts list remove those to be deleted -----*/
6004 /* already existed? */
6008 /*
6009 * decode original to see if it matches what was decoded
6010 * when we sent it in.
6011 */
6022 /* encoding happens as msg text is written */
6024 }
6030 }
6039 }
6040 else
6042 }
6044 /*---------- Now add any new attachments ---------*/
6050 /*
6051 * the idea is handle ALL attachments as open FILE *'s. Actual
6052 * encoding and such is handled at the time the message
6053 * is shoved into the mail slot or written to disk...
6054 *
6055 * Also, we never unlink a file, so it's up to whoever opens
6056 * it to deal with tmpfile issues.
6057 */
6065 }
6072 /*
6073 * Set type to unknown and let set_mime_type_by_* figure it out.
6074 * Always encode attachments we add as BINARY.
6075 */
6082 }
6089 /* Add name attribute for backward compatibility */
6098 }
6099 else
6103 pa->filename
6107 /* Then set the Content-Disposition ala RFC1806 */
6118 }
6119 else
6123 pa->filename
6126 }
6130 }
6132 /*
6133 * Now, if this multipart has but one text piece (that is, no
6134 * attachments), then downgrade from a composite type to a discrete
6135 * text/plain message if CTE is not 8bit.
6136 */
6142 /* Clone the interesting body part */
6145 /* and rub out what we don't want cleaned up when it's free'd */
6149 }
6153 }
6156 /*
6157 * Fill in text BODY part's structure
6158 *
6159 */
6160 void
6162 {
6167 }
6174 }
6177 /*
6178 * free_attachment_list - free attachments in given list
6179 */
6180 void
6182 {
6198 }
6209 }
6210 }
6213 void
6215 {
6227 }
6230 /*
6231 * view_as_rich - set the rich_header flag
6232 *
6233 * name - name of the header field
6234 * deflt - default value to return if user didn't set it
6235 *
6236 * Note: if the user tries to turn them all off with "", then
6237 * we take that to mean default, since otherwise there is no
6238 * way to get to the headers.
6239 */
6240 int
6242 {
6252 }
6255 }
6257 }
6260 /*
6261 * background_posting - return whether or not we're already in the process
6262 * of posting
6263 */
6264 int
6266 {
6272 }
6275 }
6278 /*----------------------------------------------------------------------
6279 Validate the given subject relative to any news groups.
6281 Args: none
6283 Returns: always returns 1, but also returns error if
6284 ----*/
6285 int
6287 {
6294 /*
6295 * Now look for any header entry we passed to pico that has to do
6296 * with news. If there's no subject, gripe.
6297 */
6305 }
6306 }
6309 }
6312 /*
6313 * This is the build_address used by the composer to check for an address
6314 * in the addrbook.
6315 *
6316 * Args: to -- the passed in line to parse
6317 * full_to -- Address of a pointer to return the full address in.
6318 * This will be allocated here and freed by the caller.
6319 * error -- Address of a pointer to return an error message in.
6320 * This will be allocated here and freed by the caller.
6321 * barg -- Address of a pointer to return the fcc in is in
6322 * fcc->tptr. It will have already been allocated by the
6323 * caller but we may free it and reallocate if we wish.
6324 * Caller will free it.
6325 *
6326 * Result: 0 is returned if address was OK,
6327 * -1 if address wasn't OK.
6328 *
6329 * Side effect: Can flush addrbook entry cache entries so they need to be
6330 * re-fetched afterwords.
6331 */
6332 int
6334 {
6337 BuildTo bldto;
6345 /* check to see if to string is empty to avoid work */
6354 }
6362 /* No guarantee cursor or status line is how we saved it */
6370 /*
6371 * If we end up jumping back here because somebody else changed one of
6372 * our addrbooks out from underneath us, we may well leak some memory.
6373 * That's probably ok since this will be very rare.
6374 *
6375 * The reason for the memcpy of the jmp_buf is that we may actually
6376 * be indirectly calling this function from within the address book.
6377 * For example, we may be in the address book screen and then run
6378 * the ComposeTo command which puts us in the composer, then we call
6379 * build_address from there which resets addrbook_changed_unexpectedly.
6380 * Once we leave build_address we need to reset addrbook_changed_un...
6381 * because this position on the stack will no longer be valid.
6382 * Same is true of the other setjmp's in this file which are wrapped
6383 * in memcpy calls.
6384 */
6403 }
6405 ab_nesting_level++;
6412 ab_nesting_level--;
6416 /*
6417 * Have to rfc1522_decode the full_to string before sending it back.
6418 */
6427 /* p == q means that decoding happened, p is decoded *full_to */
6431 }
6432 else
6434 }
6439 /* Pt will point to headents[Fcc].bldr_private */
6444 /*
6445 * If *barg->aff is set, that means fcc was set from a list
6446 * during some previous builder call.
6447 * If the current To line contains the old expansion as a prefix, then
6448 * we should leave things as they are. In order to decide that,
6449 * we look at a hash value computed from the strings.
6450 */
6462 }
6463 else
6465 }
6471 /* replace fcc value */
6482 }
6495 }
6497 /*
6498 * If result is reproducible, we don't keep track here.
6499 */
6502 }
6503 }
6504 }
6505 else
6507 }
6509 /* This is so pico will erase the old message */
6516 }
6519 /*
6520 * This is the builder used by the composer for the Lcc line.
6521 *
6522 * Args: lcc -- the passed in Lcc line to parse
6523 * full_lcc -- Address of a pointer to return the full address in.
6524 * This will be allocated here and freed by the caller.
6525 * error -- Address of a pointer to return an error message in.
6526 * This is not allocated so should not be freed by the caller.
6527 * barg -- This is a pointer to text for affected entries which
6528 * we may be changing. The first one in the list is the
6529 * To entry. We may put the name of the list in empty
6530 * group syntax form there (like List Name: ;).
6531 * The second one in the list is the fcc field.
6532 * The tptr members already point to text allocated in the
6533 * caller. We may free and reallocate here, caller will
6534 * free the result in any case.
6535 *
6536 * Result: 0 is returned if address was OK,
6537 * -1 if address wasn't OK.
6538 *
6539 * Side effect: Can flush addrbook entry cache entries so they need to be
6540 * re-fetched afterwords.
6541 */
6542 int
6544 {
6548 BuildTo bldlcc;
6559 /* check to see if to string is empty to avoid work */
6568 }
6577 /*
6578 * If we end up jumping back here because somebody else changed one of
6579 * our addrbooks out from underneath us, we may well leak some memory.
6580 * That's probably ok since this will be very rare.
6581 */
6601 }
6603 ab_nesting_level++;
6607 /*
6608 * To is first affected_entry and Fcc is second.
6609 * The conditional stuff for the fcc argument says to only change the
6610 * fcc if the fcc pointer is passed in non-null, and the To pointer
6611 * is also non-null. If they are null, that means they've already been
6612 * entered (are sticky). We don't affect fcc if either fcc or To has
6613 * been typed in.
6614 */
6616 full_lcc,
6617 error,
6624 ab_nesting_level--;
6628 /* full_lcc is what ends up in the Lcc: line */
6632 /*
6633 * Have to rfc1522_decode the full_lcc string before sending it back.
6634 */
6640 }
6641 else
6643 }
6645 /* to is what ends up in the To: line */
6650 /*
6651 * Have to rfc1522_decode the full_to string before sending it back.
6652 */
6657 /*
6658 * If the caller wants us to try to preserve the charset
6659 * information (they set aff) we copy it into encoded->etext.
6660 * We don't have to worry about pasting together pieces of
6661 * etext like we do in build_address because whenever the
6662 * Lcc line is setting the To line it will be setting the
6663 * whole line, not modifying it.
6664 * Pt will point to headents[To].bldr_private.
6665 */
6673 }
6674 }
6678 }
6679 else
6686 /*
6687 * This part is recording the fact that the To line was set to
6688 * what it is by entering something on the Lcc line. In particular,
6689 * if a list alias was entered here then the fullname of the list
6690 * goes in the To line. We save this affector information so that
6691 * we can tell it shouldn't be modified if we call build_addr_lcc
6692 * again unless we actually modified what's in the Lcc line so that
6693 * it doesn't start with the same thing. The problem we're solving
6694 * is that the contents of the Lcc line no longer look like the
6695 * list they were derived from.
6696 * Pt will point to headents[To].bldr_private.
6697 */
6712 }
6713 else
6715 }
6722 /* replace to value */
6738 }
6744 }
6751 }
6764 }
6766 /*
6767 * If result is reproducible, we don't keep track here.
6768 */
6771 }
6772 }
6773 }
6774 else
6776 }
6781 /*
6782 * If *barg->next->aff is set, that means fcc was set from a list
6783 * during some previous builder call. If the current Lcc line
6784 * contains the old expansion as a prefix, then we should leave
6785 * things as they are. In order to decide that we look at a hash
6786 * value computed from the strings.
6787 * Pt will point to headents[Fcc].bldr_private
6788 */
6804 }
6805 else
6807 }
6814 /* replace fcc value */
6825 }
6838 }
6840 /*
6841 * If result is reproducible, we don't keep track here.
6842 */
6845 }
6846 }
6847 }
6848 else
6850 }
6859 }
6862 /*----------------------------------------------------------------------
6863 Verify and canonicalize news groups names.
6864 Called from the message composer
6866 Args: given_group -- List of groups typed by user
6867 expanded_group -- pointer to point to expanded list, which will be
6868 allocated here and freed in caller. If this is
6869 NULL, don't attempt to validate.
6870 error -- pointer to store error message
6871 fcc -- pointer to point to fcc, which will be
6872 allocated here and freed in caller
6874 Returns: 0 if all is OK
6875 -1 if addresses weren't valid
6877 Test the given list of newstroups against those recognized by our nntp
6878 servers. Testing by actually trying to open the list is much cheaper, both
6879 in bandwidth and memory, than yanking the whole list across the wire.
6880 ----*/
6881 int
6882 news_build(char *given_group, char **expanded_group, char **error, BUILDER_ARG *fcc, int *mangled)
6883 {
6894 /* assign any new fcc to the BUILDER_ARG */
6897 /* it changed */
6902 }
6903 }
6907 }
6909 /* deal with any busy indicator */
6917 }
6921 }
6924 void
6926 {
6928 }
6931 #if defined(DOS) || defined(OS2)
6933 /*----------------------------------------------------------------------
6934 Verify that the necessary pieces are around to allow for
6935 message sending under DOS
6937 Args: strict -- tells us if a remote stream is required before
6938 sending is permitted.
6940 The idea is to make sure pine knows enough to put together a valid
6941 from line. The things we MUST know are a user-id, user-domain and
6942 smtp server to dump the message off on. Typically these are
6943 provided in pine's configuration file, but if not, the user is
6944 queried here.
6945 ----*/
6946 int
6948 {
6951 HelpType help;
6953 /*
6954 * query for user name portion of address, use IMAP login
6955 * name as default
6956 */
6958 NETMBX mb;
6966 }
6968 /* no user-id prompting if set */
6979 }
6980 else
6982 }
6983 else
6987 /* No prompt, just assume mailbox login is user-id */
6990 }
7006 }
7010 }
7016 }
7018 /* save the name */
7023 && !no_prompt_user_id
7026 }
7030 }
7031 }
7033 /* query for personal name */
7051 }
7055 }
7064 }
7068 }
7069 }
7070 }
7072 /*
7073 * query for host/domain portion of address, using IMAP
7074 * host as default
7075 */
7085 }
7086 else
7103 }
7107 }
7113 }
7115 /* save the name */
7125 }
7130 }
7131 }
7133 /* check for smtp server */
7145 }
7146 else
7163 }
7167 }
7173 }
7175 /* save the name */
7182 }
7185 }