| blob | 2853b86ae5b5934fecc53360a4670ec25cb3bb52 |
1 /*
2 * ========================================================================
3 * Copyright 2013-2022 Eduardo Chappa
4 * Copyright 2006-2008 University of Washington
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * ========================================================================
13 */
15 /*======================================================================
16 Functions for composing and sending mail
18 ====*/
70 /*
71 * macro to bind pico's headerentry pointer to PINEFIELD "extdata" hook
72 */
73 #define HE(PF) ((struct headerentry *)((PF)->extdata))
76 /*
77 * Internal Prototypes
78 */
89 BODY_PARTICULARS_S
112 #if defined(DOS) || defined(OS2)
117 /*
118 * Pointer to buffer to hold pointers into pine data that's needed by pico.
119 */
131 /* local global to save busy_cue state */
135 /*
136 * Various useful strings
137 */
138 #define INTRPT_PMT \
140 #define PSTPND_PMT \
142 #define FORM_PMT \
144 #define PSTPN_FORM_PMT \
146 #define POST_PMT \
148 #define INTR_DEL_PMT \
152 /*
153 * Macros to help sort out posting results
154 */
155 #define P_MAIL_WIN 0x01
156 #define P_MAIL_LOSE 0x02
157 #define P_MAIL_BITS 0x03
158 #define P_NEWS_WIN 0x04
159 #define P_NEWS_LOSE 0x08
160 #define P_NEWS_BITS 0x0C
161 #define P_FCC_WIN 0x10
162 #define P_FCC_LOSE 0x20
163 #define P_FCC_BITS 0x30
169 /*
170 * For check_for_subject and check_for_fcc
171 */
172 #define CF_OK 0x1
173 #define CF_MISSING 0x2
176 /*----------------------------------------------------------------------
177 Compose screen (not forward or reply). Set up envelope, call composer
179 Args: pine_state -- The usual pine structure
181 Little front end for the compose screen
182 ---*/
183 void
185 {
195 }
198 /*----------------------------------------------------------------------
199 Alternate compose screen. Set up role and call regular compose.
201 Args: pine_state -- The usual pine structure
202 ---*/
203 void
205 {
214 /* Setup role */
220 }
222 /*
223 * If default role was selected (NULL) we need to make up a role which
224 * won't do anything, but will cause compose_mail to think there's
225 * already a role so that it won't try to confirm the default.
226 */
233 }
240 }
243 /*----------------------------------------------------------------------
244 Format envelope for outgoing message and call editor
246 Args: given_to -- An address to send mail to (usually from command line
247 invocation)
248 fcc_arg -- The fcc that goes with this address.
250 If a "To" line is given format that into the envelope and get ready to call
251 the composer
252 If there's a message postponed, offer to continue it, and set it up,
253 otherwise just fill in the outgoing envelope as blank.
255 NOTE: we ignore postponed and interrupted messages in nr mode
256 ----*/
257 void
260 {
281 /*-- Check for INTERRUPTED mail --*/
285 /* build filename and see if it exists. build_path creates
286 * an explicit local path name, so all c-client access is thru
287 * local drivers.
288 */
295 /* check to see if the folder exists, the user wants to continue
296 * and that we can actually read something in...
297 */
300 }
302 /*-- Check for postponed mail --*/
310 /*-- Check for form letter folder --*/
344 }
351 }
358 }
378 }
382 }
410 }
429 {
440 }
446 }
461 }
462 }
486 }
488 to_is_sticky++;
490 /* redraft() may or may not have closed stream */
495 }
502 }
503 }
504 }
508 file_path);
511 }
512 }
513 }
527 done++;
529 /* stream may or may not be closed in redraft() */
533 to_is_sticky++;
535 }
543 done++;
544 }
545 }
546 }
550 done++;
551 }
555 }
568 done++;
570 /* stream may or may not be closed in redraft() */
574 to_is_sticky++;
576 }
584 done++;
585 }
586 }
587 }
593 }
594 }
598 }
600 /*-- normal composition --*/
604 PAT_STATE dummy;
606 /*================= Compose new message ===============*/
613 /*
614 * Setup possible role
615 */
620 /* Setup possible compose role */
622 /*
623 * setup default role
624 * Msgno = -1 means there is no msg.
625 * This will match roles which have the Compose Use turned
626 * on, and have no patterns set, and match the Current
627 * Folder Type.
628 */
637 }
638 }
639 }
646 /*
647 * The type of storage object allocated below is vitally
648 * important. See SIMPLIFYING ASSUMPTION #37
649 */
658 }
659 }
660 }
665 }
677 }
680 }
681 }
682 else
693 }
699 }
705 /*
706 * check whether a build_address-produced fcc is different from
707 * fcc. If same, do nothing, if different, set sticky bit in pine_send.
708 */
717 }
720 /* not sticky */
721 }
722 else
723 fcc_is_sticky++;
727 }
743 }
755 }
758 /*----------------------------------------------------------------------
759 Args: stream -- This is where we get the postponed messages from
760 We'll expunge and close it here unless it is mail_stream.
762 These are all return values:
763 ================
764 outgoing --
765 body --
766 fcc --
767 lcc --
768 reply --
769 redraft_pos --
770 custom --
771 role --
772 ================
774 flags --
776 ----*/
777 int
781 {
791 /*
792 * If we're manipulating the current folder, don't bother
793 * with index
794 */
798 else
802 }
805 /*
806 * Since the user's got this folder already opened and they're
807 * on a selected message, pick that one rather than rebuild
808 * another index screen...
809 */
811 }
819 }
822 }
837 q_status_message(SM_ORDER, 3, 3, _("Undelete messages to remain postponed, and then continue message"));
838 else
839 q_status_message(SM_ORDER, 3, 3, _("Undelete form letters you want to keep, and then continue message"));
842 }
845 }
862 }
868 }
871 }
872 }
878 else
880 }
883 int
885 {
889 type);
891 }
894 }
897 /* this is for initializing the fixed header elements in pine_send() */
898 /*
899 prompt::name::help::prwid::maxlen::realaddr::
900 builder::affected_entry::next_affected::selector::key_label::fileedit::
901 display_it::break_on_comma::is_attach::rich_header::only_file_chars::
902 single_space::sticky::dirty::start_here::blank::sticky_special::KS_ODATAVAR
903 */
983 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
987 #endif
988 };
1002 /*----------------------------------------------------------------------
1003 Get addressee for message, then post message
1005 Args: outgoing -- Partially formatted outgoing ENVELOPE
1006 body -- Body of outgoing message
1007 prmpt_who -- Optional prompt for optionally_enter call
1008 prmpt_cnf -- Optional prompt for confirmation call
1009 used_tobufval -- The string that the to was eventually set equal to.
1010 This gets passed back if non-NULL on entry.
1011 flagsarg -- SS_PROMPTFORTO - Allow user to change recipient
1012 SS_NULLRP - Use null return-path so we'll send an
1013 SMTP MAIL FROM: <>
1015 Result: message "To: " field is provided and message is sent or cancelled.
1017 Fields:
1018 remail -
1019 return_path -
1020 date added here
1021 from added here
1022 sender -
1023 reply_to -
1024 subject passed in, NOT edited but maybe canonized here
1025 to possibly passed in, edited and canonized here
1026 cc -
1027 bcc -
1028 in_reply_to -
1029 message_id -
1031 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1032 with the first part TYPETEXT! All newlines in the text here also end with
1033 CRLF.
1035 Returns 0 on success, -1 on failure.
1036 ----*/
1037 int
1045 {
1051 HelpType help;
1054 BUILDER_ARG ba_fcc;
1057 PAT_STATE pstate;
1067 /*----- Fill in a few general parts of the envelope ----*/
1077 }
1082 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
1083 else
1085 }
1086 else
1088 }
1103 }
1110 }
1128 /*----------------------------------------------------------------------
1129 Loop editing the "To: " field until everything goes well
1130 ----*/
1143 snprintf(tmp, sizeof(tmp), _("BOUNCE (redirect) message using role \"%s\" to : "), role->nick);
1144 else
1147 }
1150 og2s_done++;
1152 }
1167 }
1173 }
1179 prmpt_who
1180 ? prmpt_who
1183 }
1184 else
1192 done++;
1214 }
1215 }
1230 }
1231 }
1233 }
1240 }
1241 else
1250 }
1251 else
1268 /*
1269 * Just make it look like user typed this list in.
1270 */
1272 got_something++;
1276 }
1281 }
1291 }
1301 /*
1302 * If role has an fcc, use it instead of what build_address
1303 * tells us.
1304 */
1310 }
1322 }
1329 /* confirm address */
1341 ps_global))))
1342 /*--- Addresses didn't check out---*/
1358 /* setup keymenu slot to toggle verbose mode */
1368 }
1369 }
1371 /* clear DSN flags */
1374 /* setup keymenu slots to toggle dsn bits */
1392 }
1414 ? addr
1431 /* TRANSLATORS: several possible key labels follow */
1451 }
1452 }
1460 }
1463 }
1466 }
1470 else
1472 }
1476 /* turn off related bits */
1479 }
1482 /* turn off related bits */
1485 }
1488 /* turn off related bits */
1491 }
1494 }
1495 }
1498 }
1512 }
1513 }
1528 /*
1529 * If special name "inbox" then replace it with the
1530 * real inbox path.
1531 */
1539 }
1540 }
1542 /*---- Check out fcc -----*/
1552 }
1553 else
1555 }
1556 else
1558 }
1559 else
1566 }
1574 q_status_message(SM_ORDER | SM_DING, 5, 5, _("Use of a role-defined smtp-server is administratively prohibited"));
1575 else
1577 }
1580 call_mailer_flags,
1581 call_mailer_file_result,
1582 pipe_callback);
1584 }
1585 else
1591 /*----- Was there an fcc involved? -----*/
1603 }
1605 /* Now actually copy to fcc folder and close */
1606 fcc_result =
1608 label,
1611 }
1617 }
1620 }
1626 else
1628 }
1652 SIZEOF_20KBUF,
1654 }
1655 }
1659 }
1663 }
1664 }
1673 else
1675 }
1677 }
1682 }
1683 }
1685 done++;
1690 done++;
1697 ? h_anon_forward
1715 }
1719 }
1722 }
1726 }
1733 }
1734 }
1736 finish:
1743 }
1746 /*
1747 * pine_simple_send_header - generate header suitable for simple_sending
1748 */
1749 METAENV *
1751 {
1758 /* assign he_dummy to "To:" field "he" for strings2outgoing */
1765 }
1768 }
1772 /*----------------------------------------------------------------------
1773 Prepare data structures for pico, call pico, then post message
1775 Args: outgoing -- Partially formatted outgoing ENVELOPE
1776 body -- Body of outgoing message
1777 editor_title -- Title for anchor line in composer
1778 fcc_arg -- The file carbon copy field
1779 reply -- Struct describing set of msgs being replied-to
1780 lcc_arg --
1781 custom -- custom header list.
1782 sticky_fcc --
1784 Result: message is edited, then postponed, cancelled or sent.
1786 Fields:
1787 remail -
1788 return_path -
1789 date added here
1790 from added here
1791 sender -
1792 reply_to -
1793 subject passed in, edited and cannonized here
1794 to possibly passed in, edited and cannonized here
1795 cc possibly passed in, edited and cannonized here
1796 bcc edited and cannonized here
1797 in_reply_to generated in reply() and passed in
1798 message_id -
1800 Storage for these fields comes from anywhere outside. It is remalloced
1801 here so the composer can realloc them if needed. The copies here are also
1802 freed here.
1804 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1805 with the first part TYPETEXT! All newlines in the text here also end with
1806 CRLF.
1808 There's a further assumption that the text in the TYPETEXT part is
1809 stored in a storage object (see filter.c).
1810 ----*/
1811 void
1816 {
1823 struct headerentry *he, *headents, *he_to = NULL, *he_fcc = NULL, *he_news = NULL, *he_lcc = NULL,
1829 METAENV header;
1835 CustomType ct;
1844 /*
1845 * Cancel any pending initial commands since pico uses a different
1846 * input routine. If we didn't cancel them, they would happen after
1847 * we returned from the editor, which would be confusing.
1848 */
1858 }
1861 }
1863 #if defined(DOS) || defined(OS2)
1867 }
1870 #else
1874 #endif
1884 #ifdef _WINDOWS
1898 /* We actually want to set this only if message we're sending is flowed */
1912 #if defined(DOS) || defined(OS2)
1915 }
1916 #endif
1921 /* NOTE: initial cursor position set below */
1925 /*
1926 * When user runs compose and the current folder is a newsgroup,
1927 * offer to post to the current newsgroup.
1928 */
1936 /*
1937 * Replies don't get this far because To or Newsgroups will already
1938 * be filled in. So must be either ordinary compose or forward.
1939 * Forward sets subject, so use that to tell the difference.
1940 */
1952 }
1963 }
1973 }
1978 }
1984 }
1987 }
2002 }
2003 }
2004 }
2008 NETMBX news_mb;
2016 suggested_nntp_server =
2022 /* take out /nntp, which gets added in nntp_open */
2029 else
2030 p++;
2038 }
2040 }
2041 }
2042 }
2043 else
2045 }
2046 }
2048 /*
2049 * If we don't already have custom headers set and the role has custom
2050 * headers, then incorporate those custom headers into "custom".
2051 */
2056 /*
2057 * If we allow the Combine argument here, we're saying that we want to
2058 * combine the values from the envelope and the role for the fields To,
2059 * Cc, Bcc, and Newsgroups. For example, if we are replying to a message
2060 * we'll have a To in the envelope because we're replying. If our role also
2061 * has a To action, then Combine would combine those two and offer both
2062 * to the user. We've decided against doing this. Instead, we always use
2063 * Replace, and the role's header value replaces the value from the
2064 * envelope. It might also make sense in some cases to do the opposite,
2065 * which would be treating the role headers as defaults, just like
2066 * customized-hdrs.
2067 */
2068 #ifdef WANT_TO_COMBINE_ADDRESSES
2071 #else
2074 #endif
2081 }
2086 }
2087 }
2088 else
2090 }
2094 /* how many fixed fields are there? */
2096 ;
2100 /* the fixed part of the PINEFIELDs */
2105 /* temporary headerentry array for pico */
2119 /* custom part of PINEFIELDs */
2125 /*
2126 * For Address types, pf->addr points to an ADDRESS *.
2127 * If that address is in the "outgoing" envelope, it will
2128 * be freed by the caller, otherwise, it should be freed here.
2129 * Pf->textbuf for an Address is used a little to set up a default,
2130 * but then is freed right away below. Pf->scratch is used for a
2131 * pointer to some alloced space for pico to edit in. Addresses in
2132 * the custom area are freed by free_customs().
2133 *
2134 * For FreeText types, pf->addr is not used. Pf->text points to a
2135 * pointer that points to the text. Pf->textbuf points to a copy of
2136 * the text that must be freed before we leave, otherwise, it is
2137 * probably a pointer into the envelope and that gets freed by the
2138 * caller.
2139 *
2140 * He->realaddr is the pointer to the text that pico actually edits.
2141 */
2143 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2144 # define NN 4
2145 #else
2146 # define NN 3
2147 #endif
2150 use_news_order++;
2152 /* initialize the fixed header elements of the two temp arrays */
2159 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2160 , N_SENDER
2161 #endif
2162 };
2165 /* slightly different editing order if sending to news */
2170 /* copy the templates */
2175 /* slide string over so it is Sender instead of X-X-Sender */
2179 }
2229 }
2230 }
2234 }
2239 /* if no value, use default */
2243 }
2249 }
2251 /* If there is a newsgroup, we'd better show it */
2259 }
2264 }
2269 }
2274 }
2279 }
2284 }
2290 }
2296 }
2302 }
2308 }
2314 }
2320 }
2326 }
2332 }
2338 }
2344 }
2348 }
2352 /* can't do a default for this one */
2354 /* If there is an attachment already, we'd better show them */
2367 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
2372 }
2373 }
2381 /* If already set, make it act like we typed it in */
2398 }
2403 SIZEOF_20KBUF,
2409 }
2421 /* if bcc exists, make sure it's exposed so nothing's
2422 * sent by mistake...
2423 */
2439 }
2453 }
2457 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2462 #endif
2468 }
2470 /*
2471 * If this is a reply to news, don't show the regular email
2472 * recipient headers (unless they are non-empty).
2473 */
2488 }
2489 else
2491 }
2493 /*
2494 * If this address doesn't already have a value, then we check
2495 * for a default value assigned by the user.
2496 */
2507 /*
2508 * Try to set To based on Lcc. Don't attempt Fcc.
2509 */
2547 }
2548 }
2555 }
2559 }
2569 }
2570 }
2572 /* if we still don't have a from */
2575 }
2577 /*
2578 * Addr is already set in the rest of the cases.
2579 */
2583 /*
2584 * We get to this case of the ifelse if the from or reply-to
2585 * addr was set by a role above.
2586 */
2588 /* figure out the default value */
2597 }
2599 /* if value set by role is different from default, show it */
2603 /* malformed */
2607 }
2611 }
2616 /*
2617 * These three are different from the others because we
2618 * might add the addresses to what is already there instead
2619 * of replacing.
2620 */
2644 ;
2650 }
2657 }
2660 }
2679 }
2682 }
2687 }
2692 /* outgoing2strings will alloc the string pf->scratch below */
2701 else
2707 }
2739 /* if no value, use default */
2742 }
2746 }
2749 }
2760 }
2762 /*
2763 * We may or may not want to give the user the chance to edit
2764 * the From and Reply-To lines. If they are listed in either
2765 * Default-composer-hdrs or Customized-hdrs, then they can edit
2766 * them, else no.
2767 * If canedit is not set, that means that this header is not in
2768 * the user's customized-hdrs. If rich_header is set, that
2769 * means that this header is not in the user's
2770 * default-composer-hdrs (since From and Reply-To are rich
2771 * by default). So, don't give it an he to edit with in that case.
2772 *
2773 * For other types, just not setting canedit will cause it to be
2774 * uneditable, regardless of what the user does.
2775 */
2778 /* to allow it, we let this fall through to the reply-to case below */
2789 }
2795 }
2798 he++;
2799 }
2807 }
2808 else
2809 he++;
2812 }
2813 }
2815 /*
2816 * This is so the builder can tell the composer to fill the affected
2817 * field based on the value in the field on the left.
2818 *
2819 * Note that this mechanism isn't completely general. Each entry has
2820 * only a single next_affected, so if some other entry points an
2821 * affected entry at an entry with a next_affected, they all inherit
2822 * that next_affected. Since this isn't used much a careful ordering
2823 * of the affected fields should make it a sufficient mechanism.
2824 */
2833 /*
2834 * Set up headerentries for custom fields.
2835 * NOTE: "i" is assumed to now index first custom field in sending
2836 * order.
2837 */
2855 /* change default text into an ADDRESS */
2856 /* strip quotes around whole default */
2868 }
2887 }
2891 /* use first 8 characters for prompt */
2896 he++;
2897 }
2899 /*
2900 * Make sure at least *one* field is displayable...
2901 */
2906 }
2908 /*
2909 * None displayable!!! Warn and display defaults.
2910 */
2918 }
2920 /*
2921 * Save information about body which set_mime_type_by_grope might change.
2922 * Then, if we get an error sending, we reset these things so that
2923 * grope can do it's thing again after we edit some more.
2924 */
2927 else
2933 /*----------------------------------------------------------------------
2934 Loop calling the editor until everything goes well
2935 ----*/
2939 /* Reset body to what it was when we started. */
2942 else
2944 /*
2945 * set initial cursor position based on how many times we've been
2946 * thru the loop...
2947 */
2950 }
2954 }
2957 /* set the start_here bit in correct header */
2963 }
2965 /* If didn't find it, we start in body. */
2968 }
2971 }
2973 /* in case these were turned on in previous pass through loop */
2977 }
2982 /*
2983 * If a sending attempt failed after we passed the message text
2984 * thru a user-defined filter, "orig_so" points to the original
2985 * text. Replace the body's encoded data with the original...
2986 */
2994 }
2996 /*
2997 * Convert the envelope and body to the string format that
2998 * pico can edit
2999 */
3003 /*
3004 * If this isn't the first time through this loop, we may have
3005 * freed some of the FreeText headers below so that they wouldn't
3006 * show up as empty headers in the finished message. Need to
3007 * alloc them again here so they can be edited.
3008 */
3014 }
3016 /*
3017 * If From is exposed, probably by a role, then start the cursor
3018 * on the first line which isn't filled in. If it isn't, then we
3019 * don't move the cursor, mostly for back-compat.
3020 */
3031 }
3032 }
3034 #ifdef _WINDOWS
3036 #endif
3041 /* turn off user input timeout when in composer */
3049 #ifdef _WINDOWS
3051 #endif
3054 /*
3055 * Only reinitialize signals if we didn't receive an interesting
3056 * one while in pico, since pico's return is part of processing that
3057 * signal and it should continue to be ignored.
3058 */
3062 /*
3063 * We're going to save in DEADLETTER. Dump attachments first.
3064 */
3068 /* Turn strings back into structures */
3071 /* Make newsgroups NULL if it is "" (so won't show up in headers) */
3076 }
3078 /* Make subject NULL if it is "" (so won't show up in headers) */
3082 /* remove custom fields that are empty */
3088 }
3089 }
3090 }
3094 /*-------- Stamp it with a current date -------*/
3107 /* Set return_path based on From which is going to be used */
3113 /*
3114 * Don't ever believe the sender that is there.
3115 * If From doesn't look quite right, generate our own sender.
3116 */
3120 /*
3121 * If the LHS of the address doesn't match, or the RHS
3122 * doesn't match one of localdomain or hostname,
3123 * then add a sender line (really X-X-Sender).
3124 *
3125 * Don't add a personal_name since the user can change that.
3126 */
3128 &&
3139 }
3141 /* To protect the privacy of the user, make sure that the domain
3142 * part in the message id matches the domain in the from, so that
3143 * the user does not disclose more than they are already willing
3144 * to disclose.
3145 */
3155 }
3160 }
3162 /*----- Message is edited, now decide what to do with it ----*/
3164 /*=========== Postpone or Interrupted message ============*/
3182 }
3184 /*
3185 * The idea here is to use the Fcc: writing facility
3186 * to append to the special postponed message folder...
3187 *
3188 * NOTE: the strategy now is to write the message and
3189 * all attachments as they exist at composition time.
3190 * In other words, attachments are postponed by value
3191 * and not reference. This may change later, but we'll
3192 * need a local "message/external-body" type that
3193 * outgoing2strings knows how to properly set up for
3194 * the composer. Maybe later...
3195 */
3202 /*--- Addresses didn't check out---*/
3206 }
3208 /*
3209 * Build the local message copy so.
3210 *
3211 * In the HUP case, we'll write the bezerk delimiter by
3212 * hand and output the message directly into the folder.
3213 * It's not only faster, we don't have to worry about
3214 * c-client reentrance and less hands paw over the data so
3215 * there's less chance of a problem.
3216 *
3217 * In the Postpone case, just create it if the user wants to
3218 * and create a temporary storage object to write into. */
3219 fake_hup:
3226 #if defined(DOS) || defined(OS2)
3227 /*
3228 * we can't assume anything about root or home dirs, so
3229 * just plunk it down in the same place as the pinerc
3230 */
3238 }
3243 }
3244 else
3245 #endif
3247 ps_global->VAR_OPER_DIR
3269 }
3277 }
3280 }
3281 else
3296 else
3300 }
3301 }
3302 }
3303 }
3310 }
3312 /*
3313 * Store the cursor position
3314 *
3315 * First find the header entry with the start_here
3316 * bit set, if any. This means the editor is telling
3317 * us to start on this header field next time.
3318 */
3324 }
3326 /* If there wasn't one, ":" means we start in the body. */
3338 }
3345 }
3348 }
3354 /* copy fcc line to postponed or interrupted folder */
3358 /* plug error into header for later display to user */
3363 }
3365 /*
3366 * if reply, write (UID)folder header field so we can
3367 * later flag the replied-to message \\ANSWERED
3368 * DON'T save MSGNO's.
3369 */
3379 }
3395 /*
3396 * Logically, this ought to be part of pf_uid, but this
3397 * was added later and so had to be in a separate header
3398 * for backwards compatibility.
3399 */
3405 }
3407 /* Save cursor position */
3417 }
3419 /*
3420 * Work around c-client reply-to bug. C-client will
3421 * return a reply_to in an envelope even if there is
3422 * no reply-to header field. We want to note here whether
3423 * the reply-to is real or not.
3424 */
3430 else
3432 }
3434 /* Save the role-specific smtp server */
3440 /*
3441 * Turn the list of smtp servers into a space-
3442 * delimited list in a single string.
3443 */
3455 }
3458 }
3464 else
3466 }
3468 /* Save the role-specific nntp server */
3476 /*
3477 * Turn the list of nntp servers into a space-
3478 * delimited list in a single string.
3479 */
3491 }
3494 }
3495 }
3496 else
3503 else
3505 }
3507 /*
3508 * Write the list of custom headers to the
3509 * X-Our-Headers header so that we can recover the
3510 * list in redraft.
3511 */
3529 }
3532 }
3534 /*
3535 * We need to make sure any header values that got cleared
3536 * get written to the postponed message (they won't if
3537 * pf->text is NULL). Otherwise, we can't tell previously
3538 * non-existent custom headers or default values from
3539 * custom (or other) headers that got blanked in the
3540 * composer...
3541 */
3546 /*
3547 * We're saving the message for use later. It may be that the
3548 * characters in the message are not all convertible to the
3549 * user's posting_charmap. We'll save it as UTF-8 instead
3550 * and worry about that the next time they try to send it.
3551 * Use a different save pointer just to be sure we don't
3552 * mess up the other stuff. We should probably make the
3553 * charset an argument.
3554 *
3555 * We also need to fix the charset of the body part
3556 * the user is editing so that we can read it back
3557 * successfully when we resume the composition.
3558 */
3561 {
3566 else
3572 ;
3579 }
3580 }
3594 }
3611 }
3612 else
3619 }
3620 else
3623 }
3625 /* discontinue coerced UTF-8 posting */
3629 }
3630 else
3635 /*
3636 * Special Hack #291: if any hi-byte bits are set in
3637 * editor's result, we put them there.
3638 */
3645 }
3652 else
3657 }
3670 }
3676 }
3677 }
3679 /*------ Must be sending mail or posting ! -----*/
3686 /* --- If posting, confirm with user ----*/
3693 }
3703 continue_with_only_fcc++;
3704 }
3710 }
3711 }
3714 /*--- Addresses didn't check out---*/
3717 }
3720 && !continue_with_only_fcc
3729 local_redraft_pos
3734 }
3742 local_redraft_pos
3747 }
3755 local_redraft_pos
3760 }
3764 /*---- Check out fcc -----*/
3766 /*
3767 * If special name "inbox" then replace it with the
3768 * real inbox path.
3769 */
3777 }
3780 /* lmc.text_only set on command line */
3782 /* ---- Open or allocation of fcc failed ----- */
3785 /*
3786 * Find field entry associated with fcc, and start
3787 * composer on it...
3788 */
3794 }
3795 else
3797 }
3798 else
3801 /*---- Take care of any requested prefiltering ----*/
3809 }
3811 /*------ Actually post -------*/
3826 }
3827 }
3836 }
3837 else
3839 }
3841 /*
3842 * BUG: IF we've posted the message *and* an fcc was specified
3843 * then we've already got a neatly formatted message in the
3844 * lmc.so. It'd be nice not to have to re-encode everything
3845 * to insert it into the smtp slot...
3846 */
3848 /*
3849 * Turn on "undisclosed recipients" header if no To or cc.
3850 */
3855 }
3860 }
3862 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
3863 /*
3864 * If requested, launch background posting...
3865 */
3873 /*
3874 * Put us in new process group...
3875 */
3878 /* BUG: should fix argv[0] to indicate what we're up to */
3880 /*
3881 * If there are any live streams, pretend we never
3882 * knew them. Problem is two processes writing
3883 * same server process.
3884 * This is not clean but we're just going to exit
3885 * right away anyway. We just want to be sure to leave
3886 * the stuff that the parent is going to use alone.
3887 * The next three lines will disable the re-use of the
3888 * existing streams and cause us to open a new one if
3889 * needed.
3890 */
3895 /* quell any display output */
3898 /*------- Actually mail the message ------*/
3907 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3908 else
3910 }
3913 call_mailer_flags,
3914 call_mailer_file_result,
3920 }
3922 /*----- Was there an fcc involved? -----*/
3924 /*------ Write it if at least something worked ------*/
3936 }
3938 /*-- Now actually copy to fcc folder and close --*/
3944 }
3951 }
3954 }
3957 /*
3958 * Encode child's result in hi-byte of
3959 * editor's result
3960 */
3963 }
3966 }
3972 }
3981 }
3992 }
3995 /*------- Actually mail the message ------*/
4003 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
4004 else
4006 }
4009 call_mailer_flags,
4010 call_mailer_file_result,
4016 }
4018 /*----- Was there an fcc involved? -----*/
4020 /*------ Write it if at least something worked ------*/
4031 }
4033 /*-- Now actually copy to fcc folder and close --*/
4038 }
4044 }
4047 }
4049 /*----- Mail Post FAILED, back to composer -----*/
4054 /*
4055 * Find field entry associated with fcc, and start
4056 * composer on it...
4057 */
4065 }
4073 }
4075 /*
4076 * If message sent *completely* successfully, there's a
4077 * reply struct AND we're allowed to write back state, do it.
4078 * But also protect against shifted message numbers due
4079 * to new mail arrival. Since the number passed is based
4080 * on the real imap msg no, AND we're sure no expunge has
4081 * been done, just fix up the sorted number...
4082 */
4085 /*----- Signed, sealed, delivered! ------*/
4090 }
4091 }
4110 }
4135 }
4138 /*
4139 * Check for subject in outgoing message.
4140 *
4141 * Asks user whether to proceed with no subject.
4142 */
4143 int
4145 {
4157 else
4159 }
4162 }
4166 }
4169 /*
4170 * Check for fcc in outgoing message.
4171 *
4172 * Asks user whether to proceed with no fcc.
4173 */
4174 int
4176 {
4184 else
4186 }
4189 }
4192 /*
4193 * Confirm that the user wants to send to MAILER-DAEMON
4194 */
4195 int
4197 {
4200 }
4203 void
4205 {
4211 }
4212 }
4215 int
4217 {
4224 }
4227 /*
4228 * call__mailer_file_result - some results from call_mailer might be in a file.
4229 * dislplay that file.
4230 */
4231 void
4233 {
4237 }
4240 }
4241 }
4242 }
4244 void
4246 {
4262 }
4263 }
4267 /*
4268 * This is specialized routine. It assumes that the only things that we
4269 * care about restoring are the body type, subtype, encoding and the
4270 * state of the charset parameter. It also assumes that if the charset
4271 * parameter exists when we save it, it won't be removed later.
4272 */
4273 BODY_PARTICULARS_S *
4275 {
4293 }
4297 }
4300 }
4303 void
4305 {
4327 }
4331 else
4335 }
4336 }
4339 /*
4340 * This can't happen because grope never removes
4341 * the charset parameter.
4342 */
4345 }
4346 /*
4347 else{
4348 ok, still no parameter
4349 }
4350 */
4351 }
4352 }
4358 }
4359 }
4362 void
4364 {
4373 }
4374 }
4377 /*----------------------------------------------------------------------
4378 Build a status message suitable for framing
4380 Returns: pointer to resulting buffer
4381 ---*/
4384 {
4423 /* dots on end of fixed, no fcc */
4427 }
4429 /* include whole fixed part, quotes and dots at end of fcc name */
4439 }
4441 /* whole thing */
4447 }
4453 }
4455 /* Callback from Pico to set the conditions for Alpine to start a new thread
4456 */
4458 void
4460 {
4462 }
4466 /*----------------------------------------------------------------------
4467 Call back for pico to insert the specified message's text
4469 Args: n -- message number to format
4470 f -- function to use to output the formatted message
4473 Returns: returns msg number formatted on success, zero on error.
4474 ----*/
4475 long
4477 {
4489 }
4491 /* temporarily assign a new quote string */
4495 /* build separator line */
4498 /* actually write message text */
4504 }
4509 }
4512 /*----------------------------------------------------------------------
4513 Call back for pico to prompt the user for exit confirmation
4515 Args: dflt -- default answer for confirmation prompt
4517 Returns: either NULL if the user accepts exit, or string containing
4518 reason why the user declined.
4519 ----*/
4520 int
4523 {
4550 }
4557 }
4564 /*
4565 * Build list of available filters...
4566 */
4570 ;
4578 }
4584 }
4589 }
4590 else
4599 }
4606 }
4607 }
4621 /* set global_filter_pointer to desired filter or NULL if none */
4622 /* prepare two keymenu slots for selecting filter */
4635 }
4638 /* setup keymenu slot to toggle verbose mode */
4643 }
4646 /* setup keymenu slot to toggle flowed mode */
4652 }
4655 /* setup keymenu slot to toggle attacment on fcc */
4660 }
4662 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
4668 }
4669 #endif
4676 #ifdef SMIME
4691 }
4692 }
4693 #endif
4698 /* setup keymenu slots to toggle dsn bits */
4716 }
4728 }
4737 else
4753 lparen++;
4754 }
4755 else
4757 }
4760 }
4767 lparen++;
4768 }
4772 }
4773 }
4780 }
4781 else
4783 }
4790 lparen++;
4791 }
4792 else
4794 }
4804 }
4811 lparen++;
4812 }
4813 else
4815 }
4820 }
4827 lparen++;
4828 }
4832 }
4833 }
4836 }
4838 #ifdef SMIME
4844 lparen++;
4845 }
4849 }
4850 }
4853 }
4860 lparen++;
4861 }
4865 }
4866 }
4869 }
4870 #endif
4908 }
4909 }
4920 h_send_prompt,
4921 RB_NORM);
4922 else
4933 h_send_prompt,
4934 RB_NORM);
4938 }
4942 }
4946 }
4949 }
4952 }
4955 }
4959 else
4964 }
4967 }
4972 }
4976 /* turn off related bits */
4979 }
4982 /* turn off related bits */
4985 }
4988 /* turn off related bits */
4991 }
4994 }
4995 }
4997 /*
4998 * When you turn on DSN, the default is to notify on
4999 * failure, success, or delay; and to return the whole
5000 * body on failure.
5001 */
5003 }
5011 }
5019 else
5021 }
5022 }
5023 #ifdef SMIME
5027 }
5031 }
5032 #endif
5046 }
5048 /* remember selection */
5061 }
5062 }
5073 }
5076 /*
5077 * Allow user to choose a priority for sending.
5078 *
5079 * Returns an allocated priority on success, NULL otherwise.
5080 */
5083 {
5092 cnt++;
5103 lp++;
5104 }
5111 /* TRANSLATORS: SELECT A PRIORITY is a screen title
5112 TRANSLATORS: Print something1 using something2.
5113 "priorities" is something1 */
5117 starting_val);
5127 }
5130 int
5132 {
5134 }
5137 /*----------------------------------------------------------------------
5138 Call back for pico to display mime type of attachment
5140 Args: file -- filename being attached
5142 Returns: returns 1 on success (message queued), zero otherwise (don't know
5143 type so nothing queued).
5144 ----*/
5145 int
5147 {
5156 /* don't know where the cursor's been, reset it */
5162 }
5163 }
5171 }
5172 else
5177 }
5180 /*----------------------------------------------------------------------
5181 Call back for pico to receive an uploaded message
5183 Args: fname -- name for uploaded file (empty if they want us to assign it)
5184 size -- pointer to long to hold the attachment's size
5186 Notes: the attachment is uploaded to a temp file, and
5188 Returns: TRUE on success, FALSE otherwise
5189 ----*/
5190 int
5192 {
5210 }
5211 }
5212 else
5229 }
5237 }
5238 else
5245 }
5250 {
5261 };
5272 }
5276 }
5277 else
5279 }
5283 }
5286 /*----------------------------------------------------------------------
5287 Pass the first text segment of the message thru the "send filter"
5289 Args: body pointer and address for storage object of old data
5291 Returns: returns 1 on success, zero on error.
5292 ----*/
5293 int
5296 {
5305 #define DO_HEADERS 1
5311 /*
5312 * We need WRITE_TO_LOCALE here because the user is going to
5313 * be operating on tmpf. We need to change it back after they
5314 * are done.
5315 */
5320 }
5322 /*
5323 * If the headers are wanted for filtering, we can just
5324 * stick them in the tmpf file that is already there before
5325 * putting the body in.
5326 */
5333 }
5343 }
5344 else
5346 }
5348 /*
5349 * Gf_filter wants a single storage object to read from.
5350 * If headers are wanted for filtering we'll have to put them
5351 * and the body into a temp file first and then use that
5352 * as the storage object for gf_filter.
5353 * We don't use WRITE_TO_LOCALE in this case because gf_filter
5354 * takes care of that.
5355 */
5357 /* put headers in our_tmpf_so */
5364 /* put body in our_tmpf_so */
5373 /* tell gf_filter to read from our_tmpf_so instead of *so */
5375 }
5376 else
5378 }
5379 else
5397 /* now we undo the WRITE_FROM_LOCALE change in tmpf */
5404 }
5405 else
5407 }
5408 else
5410 }
5411 else
5413 }
5414 else
5417 pipe_callback);
5424 #ifdef _WINDOWS
5426 /*
5427 * Can't really be using stdout, so don't print message that
5428 * gets printed in the else. Ideally the program being called
5429 * will wait after showing the message, we might want to look
5430 * into doing the waiting in console based apps... or not.
5431 */
5432 #else
5441 }
5451 /*
5452 * If the command said it would return new MIME
5453 * mime type data, check it out...
5454 */
5466 ;
5484 }
5487 }
5490 }
5491 }
5493 /*
5494 * Reevaluate the encoding in case form's changed...
5495 */
5498 }
5502 }
5503 else
5505 }
5508 }
5509 else
5515 }
5520 }
5527 }
5533 errstr);
5536 }
5539 }
5542 /*----------------------------------------------------------------------
5543 Copy the newsgroup name of the given mailbox into the given buffer
5545 Args:
5547 Returns:
5548 ----*/
5549 void
5551 {
5552 NETMBX mb;
5557 }
5560 }
5561 else
5563 }
5566 /*----------------------------------------------------------------------
5567 Set up fields for passing to pico. Assumes first text part is
5568 intended to be passed along for editing, and is in the form of
5569 of a storage object brought into existence sometime before pico_send().
5570 -----*/
5571 void
5574 {
5577 /*
5578 * SIMPLIFYING ASSUMPTION #37: the first TEXT part's storage object
5579 * is guaranteed to be of type PicoText!
5580 */
5584 /* mark storage object as user edited */
5587 }
5594 /*
5595 * We used to jump out the window if the first part wasn't text,
5596 * but that may not be the case when bouncing a message with
5597 * a leading non-text segment. So, IT'S UNDERSTOOD that the
5598 * contents of the first part to send is still ALWAYS in a
5599 * PicoText storage object, *AND* if that object doesn't contain
5600 * data of type text, then it must contain THE ENCODED NON-TEXT
5601 * DATA of the piece being sent.
5602 *
5603 * It's up to the programmer to make sure that such a message is
5604 * sent via pine_simple_send and never get to the composer via
5605 * pine_send.
5606 *
5607 * Make sense?
5608 */
5611 /* mark storage object as user edited */
5615 /*
5616 * If we already had a list, blast it now, so we can build a new
5617 * attachment list that reflects what's really there...
5618 */
5623 /* Simplifyihg assumption #28e. (see cross reference)
5624 All parts in the body passed in here that are not already
5625 in the attachments list are added to the end of the attachments
5626 list. Attachment items not in the body list will be taken care
5627 of in strings2outgoing, but they are unlikely to occur
5628 */
5631 /* Already in list? */
5635 ;
5649 }
5653 }
5654 }
5655 else
5661 /*
5662 * If we can find a "name" parm, display that too...
5663 */
5665 /* Convert any [ or ]'s the name contained */
5673 }
5674 else
5694 }
5695 }
5696 }
5697 }
5700 /*------------------------------------------------------------------
5701 Malloc strings to pass to composer editor because it expects
5702 such strings so it can realloc them
5703 -----------------------------------------------------------------*/
5704 /*
5705 * turn any address fields into text strings
5706 */
5707 /*
5708 * SIMPLIFYING ASSUMPTION #116: all header strings are understood
5709 * NOT to be RFC1522 decoded. Said differently, they're understood
5710 * to be RFC1522 ENCODED as necessary. The intent is to preserve
5711 * original charset tagging as far into the compose/send pipe as
5712 * we can.
5713 */
5724 /*
5725 * Scan for and fix-up patently bogus fields.
5726 *
5727 * NOTE: collaboration with this code and what's done in
5728 * reply.c:reply_cp_addr to package up the bogus stuff
5729 * is required.
5730 */
5736 /*
5737 * Rfc822_cat has been changed so that it now quotes
5738 * this sometimes. So we have to look out for quotes
5739 * which confuse the decoder. It was only quoting
5740 * because we were putting \r \n in the input, I think.
5741 */
5764 }
5772 /*
5773 * Replace control characters with ^C notation, unless
5774 * some conditions are met (see istrncpy).
5775 * If user doesn't edit, then we switch back to the
5776 * original version. If user does edit, then all bets
5777 * are off.
5778 */
5784 }
5787 }
5788 }
5807 }
5812 }
5817 /*
5818 * Replace control characters with ^C notation, unless
5819 * some conditions are met (see istrncpy).
5820 * If user doesn't edit, then we switch back to the
5821 * original version. If user does edit, then all bets
5822 * are off.
5823 */
5829 }
5832 }
5833 }
5839 }
5840 }
5843 /*----------------------------------------------------------------------
5844 Restore fields returned from pico to form useful to sending
5845 routines.
5846 -----*/
5847 void
5849 {
5855 /*
5856 * turn any local address strings into address lists
5857 */
5878 }
5890 }
5896 }
5899 }
5905 }
5908 /*----------------------------------------------------------------------
5910 The head of the body list here is always either TEXT or MULTIPART. It may be
5911 changed from TEXT to MULTIPART if there are attachments to be added
5912 and it is not already multipart.
5913 ----*/
5914 void
5916 {
5925 /*
5926 * if conditions are met short circuit MIME wrapping
5927 */
5930 /* only override assigned encoding if it might need upgrading */
5941 }
5944 }
5947 /*-- Current type is text, but there are attachments to add --*/
5948 /*-- Upgrade to a TYPEMULTIPART --*/
5953 /*
5954 * Why do we do this?
5955 * The problem is that base64 or quoted-printable encoding is
5956 * sensitive to having random data appended to it's end. If
5957 * we use a single part TEXT message and something in between
5958 * us and the end appends advertising without adjusting for
5959 * the encoding, the message is screwed up. So we wrap the
5960 * text part inside a multipart and then the appended data
5961 * will come after the boundary.
5962 *
5963 * We wish we could do this on the way out the door in a
5964 * child of post_rfc822_output because at that point we know
5965 * the character set and the encoding being used. For example,
5966 * iso-2022-jp is an encoding that is not sensitive to data
5967 * appended to the end, so it wouldn't need to be wrapped.
5968 * We could conceivably have post_rfc822_body inspect the
5969 * body and change it before doing the output. It would work
5970 * but would be very fragile. We'd be passed a body from
5971 * c-client to output and instead of just doing the output
5972 * we'd change the body and then output it. Not worth it
5973 * since the multipart wrapping is completely correct for
5974 * MIME-aware mailers.
5975 */
5977 /* move contents which were NOT copied */
5980 }
5987 }
5991 }
5994 /*-- Now type must be MULTIPART with first part text --*/
5997 }
5999 /*------ Go through the parts list remove those to be deleted -----*/
6002 /* already existed? */
6006 /*
6007 * decode original to see if it matches what was decoded
6008 * when we sent it in.
6009 */
6020 /* encoding happens as msg text is written */
6022 }
6028 }
6037 }
6038 else
6040 }
6042 /*---------- Now add any new attachments ---------*/
6048 /*
6049 * the idea is handle ALL attachments as open FILE *'s. Actual
6050 * encoding and such is handled at the time the message
6051 * is shoved into the mail slot or written to disk...
6052 *
6053 * Also, we never unlink a file, so it's up to whoever opens
6054 * it to deal with tmpfile issues.
6055 */
6063 }
6070 /*
6071 * Set type to unknown and let set_mime_type_by_* figure it out.
6072 * Always encode attachments we add as BINARY.
6073 */
6080 }
6087 /* Add name attribute for backward compatibility */
6096 }
6097 else
6101 pa->filename
6105 /* Then set the Content-Disposition ala RFC1806 */
6116 }
6117 else
6121 pa->filename
6124 }
6128 }
6130 /*
6131 * Now, if this multipart has but one text piece (that is, no
6132 * attachments), then downgrade from a composite type to a discrete
6133 * text/plain message if CTE is not 8bit.
6134 */
6140 /* Clone the interesting body part */
6143 /* and rub out what we don't want cleaned up when it's free'd */
6147 }
6151 }
6154 /*
6155 * Fill in text BODY part's structure
6156 *
6157 */
6158 void
6160 {
6165 }
6172 }
6175 /*
6176 * free_attachment_list - free attachments in given list
6177 */
6178 void
6180 {
6196 }
6207 }
6208 }
6211 void
6213 {
6225 }
6228 /*
6229 * view_as_rich - set the rich_header flag
6230 *
6231 * name - name of the header field
6232 * deflt - default value to return if user didn't set it
6233 *
6234 * Note: if the user tries to turn them all off with "", then
6235 * we take that to mean default, since otherwise there is no
6236 * way to get to the headers.
6237 */
6238 int
6240 {
6250 }
6253 }
6255 }
6258 /*
6259 * background_posting - return whether or not we're already in the process
6260 * of posting
6261 */
6262 int
6264 {
6270 }
6273 }
6276 /*----------------------------------------------------------------------
6277 Validate the given subject relative to any news groups.
6279 Args: none
6281 Returns: always returns 1, but also returns error if
6282 ----*/
6283 int
6285 {
6292 /*
6293 * Now look for any header entry we passed to pico that has to do
6294 * with news. If there's no subject, gripe.
6295 */
6303 }
6304 }
6307 }
6310 /*
6311 * This is the build_address used by the composer to check for an address
6312 * in the addrbook.
6313 *
6314 * Args: to -- the passed in line to parse
6315 * full_to -- Address of a pointer to return the full address in.
6316 * This will be allocated here and freed by the caller.
6317 * error -- Address of a pointer to return an error message in.
6318 * This will be allocated here and freed by the caller.
6319 * barg -- Address of a pointer to return the fcc in is in
6320 * fcc->tptr. It will have already been allocated by the
6321 * caller but we may free it and reallocate if we wish.
6322 * Caller will free it.
6323 *
6324 * Result: 0 is returned if address was OK,
6325 * -1 if address wasn't OK.
6326 *
6327 * Side effect: Can flush addrbook entry cache entries so they need to be
6328 * re-fetched afterwords.
6329 */
6330 int
6332 {
6335 BuildTo bldto;
6343 /* check to see if to string is empty to avoid work */
6352 }
6360 /* No guarantee cursor or status line is how we saved it */
6368 /*
6369 * If we end up jumping back here because somebody else changed one of
6370 * our addrbooks out from underneath us, we may well leak some memory.
6371 * That's probably ok since this will be very rare.
6372 *
6373 * The reason for the memcpy of the jmp_buf is that we may actually
6374 * be indirectly calling this function from within the address book.
6375 * For example, we may be in the address book screen and then run
6376 * the ComposeTo command which puts us in the composer, then we call
6377 * build_address from there which resets addrbook_changed_unexpectedly.
6378 * Once we leave build_address we need to reset addrbook_changed_un...
6379 * because this position on the stack will no longer be valid.
6380 * Same is true of the other setjmp's in this file which are wrapped
6381 * in memcpy calls.
6382 */
6401 }
6403 ab_nesting_level++;
6410 ab_nesting_level--;
6414 /*
6415 * Have to rfc1522_decode the full_to string before sending it back.
6416 */
6425 /* p == q means that decoding happened, p is decoded *full_to */
6429 }
6430 else
6432 }
6437 /* Pt will point to headents[Fcc].bldr_private */
6442 /*
6443 * If *barg->aff is set, that means fcc was set from a list
6444 * during some previous builder call.
6445 * If the current To line contains the old expansion as a prefix, then
6446 * we should leave things as they are. In order to decide that,
6447 * we look at a hash value computed from the strings.
6448 */
6460 }
6461 else
6463 }
6469 /* replace fcc value */
6480 }
6493 }
6495 /*
6496 * If result is reproducible, we don't keep track here.
6497 */
6500 }
6501 }
6502 }
6503 else
6505 }
6507 /* This is so pico will erase the old message */
6514 }
6517 /*
6518 * This is the builder used by the composer for the Lcc line.
6519 *
6520 * Args: lcc -- the passed in Lcc line to parse
6521 * full_lcc -- Address of a pointer to return the full address in.
6522 * This will be allocated here and freed by the caller.
6523 * error -- Address of a pointer to return an error message in.
6524 * This is not allocated so should not be freed by the caller.
6525 * barg -- This is a pointer to text for affected entries which
6526 * we may be changing. The first one in the list is the
6527 * To entry. We may put the name of the list in empty
6528 * group syntax form there (like List Name: ;).
6529 * The second one in the list is the fcc field.
6530 * The tptr members already point to text allocated in the
6531 * caller. We may free and reallocate here, caller will
6532 * free the result in any case.
6533 *
6534 * Result: 0 is returned if address was OK,
6535 * -1 if address wasn't OK.
6536 *
6537 * Side effect: Can flush addrbook entry cache entries so they need to be
6538 * re-fetched afterwords.
6539 */
6540 int
6542 {
6546 BuildTo bldlcc;
6557 /* check to see if to string is empty to avoid work */
6566 }
6575 /*
6576 * If we end up jumping back here because somebody else changed one of
6577 * our addrbooks out from underneath us, we may well leak some memory.
6578 * That's probably ok since this will be very rare.
6579 */
6599 }
6601 ab_nesting_level++;
6605 /*
6606 * To is first affected_entry and Fcc is second.
6607 * The conditional stuff for the fcc argument says to only change the
6608 * fcc if the fcc pointer is passed in non-null, and the To pointer
6609 * is also non-null. If they are null, that means they've already been
6610 * entered (are sticky). We don't affect fcc if either fcc or To has
6611 * been typed in.
6612 */
6614 full_lcc,
6615 error,
6622 ab_nesting_level--;
6626 /* full_lcc is what ends up in the Lcc: line */
6630 /*
6631 * Have to rfc1522_decode the full_lcc string before sending it back.
6632 */
6638 }
6639 else
6641 }
6643 /* to is what ends up in the To: line */
6648 /*
6649 * Have to rfc1522_decode the full_to string before sending it back.
6650 */
6655 /*
6656 * If the caller wants us to try to preserve the charset
6657 * information (they set aff) we copy it into encoded->etext.
6658 * We don't have to worry about pasting together pieces of
6659 * etext like we do in build_address because whenever the
6660 * Lcc line is setting the To line it will be setting the
6661 * whole line, not modifying it.
6662 * Pt will point to headents[To].bldr_private.
6663 */
6671 }
6672 }
6676 }
6677 else
6684 /*
6685 * This part is recording the fact that the To line was set to
6686 * what it is by entering something on the Lcc line. In particular,
6687 * if a list alias was entered here then the fullname of the list
6688 * goes in the To line. We save this affector information so that
6689 * we can tell it shouldn't be modified if we call build_addr_lcc
6690 * again unless we actually modified what's in the Lcc line so that
6691 * it doesn't start with the same thing. The problem we're solving
6692 * is that the contents of the Lcc line no longer look like the
6693 * list they were derived from.
6694 * Pt will point to headents[To].bldr_private.
6695 */
6710 }
6711 else
6713 }
6720 /* replace to value */
6736 }
6742 }
6749 }
6762 }
6764 /*
6765 * If result is reproducible, we don't keep track here.
6766 */
6769 }
6770 }
6771 }
6772 else
6774 }
6779 /*
6780 * If *barg->next->aff is set, that means fcc was set from a list
6781 * during some previous builder call. If the current Lcc line
6782 * contains the old expansion as a prefix, then we should leave
6783 * things as they are. In order to decide that we look at a hash
6784 * value computed from the strings.
6785 * Pt will point to headents[Fcc].bldr_private
6786 */
6802 }
6803 else
6805 }
6812 /* replace fcc value */
6823 }
6836 }
6838 /*
6839 * If result is reproducible, we don't keep track here.
6840 */
6843 }
6844 }
6845 }
6846 else
6848 }
6857 }
6860 /*----------------------------------------------------------------------
6861 Verify and canonicalize news groups names.
6862 Called from the message composer
6864 Args: given_group -- List of groups typed by user
6865 expanded_group -- pointer to point to expanded list, which will be
6866 allocated here and freed in caller. If this is
6867 NULL, don't attempt to validate.
6868 error -- pointer to store error message
6869 fcc -- pointer to point to fcc, which will be
6870 allocated here and freed in caller
6872 Returns: 0 if all is OK
6873 -1 if addresses weren't valid
6875 Test the given list of newstroups against those recognized by our nntp
6876 servers. Testing by actually trying to open the list is much cheaper, both
6877 in bandwidth and memory, than yanking the whole list across the wire.
6878 ----*/
6879 int
6880 news_build(char *given_group, char **expanded_group, char **error, BUILDER_ARG *fcc, int *mangled)
6881 {
6892 /* assign any new fcc to the BUILDER_ARG */
6895 /* it changed */
6900 }
6901 }
6905 }
6907 /* deal with any busy indicator */
6915 }
6919 }
6922 void
6924 {
6926 }
6929 #if defined(DOS) || defined(OS2)
6931 /*----------------------------------------------------------------------
6932 Verify that the necessary pieces are around to allow for
6933 message sending under DOS
6935 Args: strict -- tells us if a remote stream is required before
6936 sending is permitted.
6938 The idea is to make sure pine knows enough to put together a valid
6939 from line. The things we MUST know are a user-id, user-domain and
6940 smtp server to dump the message off on. Typically these are
6941 provided in pine's configuration file, but if not, the user is
6942 queried here.
6943 ----*/
6944 int
6946 {
6949 HelpType help;
6951 /*
6952 * query for user name portion of address, use IMAP login
6953 * name as default
6954 */
6956 NETMBX mb;
6964 }
6966 /* no user-id prompting if set */
6977 }
6978 else
6980 }
6981 else
6985 /* No prompt, just assume mailbox login is user-id */
6988 }
7004 }
7008 }
7014 }
7016 /* save the name */
7021 && !no_prompt_user_id
7024 }
7028 }
7029 }
7031 /* query for personal name */
7049 }
7053 }
7062 }
7066 }
7067 }
7068 }
7070 /*
7071 * query for host/domain portion of address, using IMAP
7072 * host as default
7073 */
7083 }
7084 else
7101 }
7105 }
7111 }
7113 /* save the name */
7123 }
7128 }
7129 }
7131 /* check for smtp server */
7143 }
7144 else
7161 }
7165 }
7171 }
7173 /* save the name */
7180 }
7183 }