| blob | 5725b4825851be58b80eed3cd220892ea1d7bab5 |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2006-2008 University of Washington
8 * Copyright 2013-2015 Eduardo Chappa
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 ====*/
77 /*
78 * macro to bind pico's headerentry pointer to PINEFIELD "extdata" hook
79 */
80 #define HE(PF) ((struct headerentry *)((PF)->extdata))
83 /*
84 * Internal Prototypes
85 */
96 BODY_PARTICULARS_S
119 #if defined(DOS) || defined(OS2)
124 /*
125 * Pointer to buffer to hold pointers into pine data that's needed by pico.
126 */
138 /* local global to save busy_cue state */
142 /*
143 * Various useful strings
144 */
145 #define INTRPT_PMT \
147 #define PSTPND_PMT \
149 #define FORM_PMT \
151 #define PSTPN_FORM_PMT \
153 #define POST_PMT \
155 #define INTR_DEL_PMT \
159 /*
160 * Macros to help sort out posting results
161 */
162 #define P_MAIL_WIN 0x01
163 #define P_MAIL_LOSE 0x02
164 #define P_MAIL_BITS 0x03
165 #define P_NEWS_WIN 0x04
166 #define P_NEWS_LOSE 0x08
167 #define P_NEWS_BITS 0x0C
168 #define P_FCC_WIN 0x10
169 #define P_FCC_LOSE 0x20
170 #define P_FCC_BITS 0x30
176 /*
177 * For check_for_subject and check_for_fcc
178 */
179 #define CF_OK 0x1
180 #define CF_MISSING 0x2
183 /*----------------------------------------------------------------------
184 Compose screen (not forward or reply). Set up envelope, call composer
186 Args: pine_state -- The usual pine structure
188 Little front end for the compose screen
189 ---*/
190 void
192 {
202 }
205 /*----------------------------------------------------------------------
206 Alternate compose screen. Set up role and call regular compose.
208 Args: pine_state -- The usual pine structure
209 ---*/
210 void
212 {
221 /* Setup role */
227 }
229 /*
230 * If default role was selected (NULL) we need to make up a role which
231 * won't do anything, but will cause compose_mail to think there's
232 * already a role so that it won't try to confirm the default.
233 */
240 }
247 }
250 /*----------------------------------------------------------------------
251 Format envelope for outgoing message and call editor
253 Args: given_to -- An address to send mail to (usually from command line
254 invocation)
255 fcc_arg -- The fcc that goes with this address.
257 If a "To" line is given format that into the envelope and get ready to call
258 the composer
259 If there's a message postponed, offer to continue it, and set it up,
260 otherwise just fill in the outgoing envelope as blank.
262 NOTE: we ignore postponed and interrupted messages in nr mode
263 ----*/
264 void
267 {
288 /*-- Check for INTERRUPTED mail --*/
292 /* build filename and see if it exists. build_path creates
293 * an explicit local path name, so all c-client access is thru
294 * local drivers.
295 */
302 /* check to see if the folder exists, the user wants to continue
303 * and that we can actually read something in...
304 */
307 }
309 /*-- Check for postponed mail --*/
317 /*-- Check for form letter folder --*/
351 }
358 }
365 }
385 }
389 }
417 }
436 {
447 }
453 }
468 }
469 }
493 }
495 to_is_sticky++;
497 /* redraft() may or may not have closed stream */
502 }
509 }
510 }
511 }
515 file_path);
518 }
519 }
520 }
534 done++;
536 /* stream may or may not be closed in redraft() */
540 to_is_sticky++;
542 }
550 done++;
551 }
552 }
553 }
555 done++;
559 }
572 done++;
574 /* stream may or may not be closed in redraft() */
578 to_is_sticky++;
580 }
588 done++;
589 }
590 }
591 }
597 }
598 }
602 }
604 /*-- normal composition --*/
608 PAT_STATE dummy;
610 /*================= Compose new message ===============*/
619 /*
620 * Setup possible role
621 */
626 /* Setup possible compose role */
628 /*
629 * setup default role
630 * Msgno = -1 means there is no msg.
631 * This will match roles which have the Compose Use turned
632 * on, and have no patterns set, and match the Current
633 * Folder Type.
634 */
643 }
644 }
645 }
651 /*
652 * The type of storage object allocated below is vitally
653 * important. See SIMPLIFYING ASSUMPTION #37
654 */
663 }
664 }
665 }
670 }
682 }
685 }
686 }
687 else
698 }
704 }
710 /*
711 * check whether a build_address-produced fcc is different from
712 * fcc. If same, do nothing, if different, set sticky bit in pine_send.
713 */
722 }
725 /* not sticky */
726 }
727 else
728 fcc_is_sticky++;
732 }
748 }
760 }
763 /*----------------------------------------------------------------------
764 Args: stream -- This is where we get the postponed messages from
765 We'll expunge and close it here unless it is mail_stream.
767 These are all return values:
768 ================
769 outgoing --
770 body --
771 fcc --
772 lcc --
773 reply --
774 redraft_pos --
775 custom --
776 role --
777 ================
779 flags --
781 ----*/
782 int
786 {
796 /*
797 * If we're manipulating the current folder, don't bother
798 * with index
799 */
803 else
807 }
810 /*
811 * Since the user's got this folder already opened and they're
812 * on a selected message, pick that one rather than rebuild
813 * another index screen...
814 */
816 }
824 }
827 }
842 q_status_message(SM_ORDER, 3, 3, _("Undelete messages to remain postponed, and then continue message"));
843 else
844 q_status_message(SM_ORDER, 3, 3, _("Undelete form letters you want to keep, and then continue message"));
847 }
850 }
867 }
873 }
876 }
877 }
883 else
885 }
888 int
890 {
894 type);
896 }
899 }
902 /* this is for initializing the fixed header elements in pine_send() */
903 /*
904 prompt::name::help::prwid::maxlen::realaddr::
905 builder::affected_entry::next_affected::selector::key_label::fileedit::
906 display_it::break_on_comma::is_attach::rich_header::only_file_chars::
907 single_space::sticky::dirty::start_here::blank::sticky_special::KS_ODATAVAR
908 */
988 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
992 #endif
993 };
1007 /*----------------------------------------------------------------------
1008 Get addressee for message, then post message
1010 Args: outgoing -- Partially formatted outgoing ENVELOPE
1011 body -- Body of outgoing message
1012 prmpt_who -- Optional prompt for optionally_enter call
1013 prmpt_cnf -- Optional prompt for confirmation call
1014 used_tobufval -- The string that the to was eventually set equal to.
1015 This gets passed back if non-NULL on entry.
1016 flagsarg -- SS_PROMPTFORTO - Allow user to change recipient
1017 SS_NULLRP - Use null return-path so we'll send an
1018 SMTP MAIL FROM: <>
1020 Result: message "To: " field is provided and message is sent or cancelled.
1022 Fields:
1023 remail -
1024 return_path -
1025 date added here
1026 from added here
1027 sender -
1028 reply_to -
1029 subject passed in, NOT edited but maybe canonized here
1030 to possibly passed in, edited and canonized here
1031 cc -
1032 bcc -
1033 in_reply_to -
1034 message_id -
1036 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1037 with the first part TYPETEXT! All newlines in the text here also end with
1038 CRLF.
1040 Returns 0 on success, -1 on failure.
1041 ----*/
1042 int
1050 {
1056 HelpType help;
1059 BUILDER_ARG ba_fcc;
1070 /*----- Fill in a few general parts of the envelope ----*/
1080 }
1085 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
1086 else
1088 }
1089 else
1091 }
1106 }
1121 /*----------------------------------------------------------------------
1122 Loop editing the "To: " field until everything goes well
1123 ----*/
1130 og2s_done++;
1132 }
1147 }
1153 }
1159 prmpt_who
1160 ? prmpt_who
1165 }
1166 else
1174 done++;
1181 }
1182 else
1191 }
1192 else
1209 /*
1210 * Just make it look like user typed this list in.
1211 */
1213 got_something++;
1217 }
1222 }
1232 }
1242 /*
1243 * If role has an fcc, use it instead of what build_address
1244 * tells us.
1245 */
1251 }
1263 }
1270 /* confirm address */
1282 ps_global))))
1283 /*--- Addresses didn't check out---*/
1299 /* setup keymenu slot to toggle verbose mode */
1309 }
1310 }
1312 /* clear DSN flags */
1315 /* setup keymenu slots to toggle dsn bits */
1333 }
1355 ? addr
1372 /* TRANSLATORS: several possible key labels follow */
1392 }
1393 }
1401 }
1404 }
1407 }
1411 else
1413 }
1417 /* turn off related bits */
1420 }
1423 /* turn off related bits */
1426 }
1429 /* turn off related bits */
1432 }
1435 }
1436 }
1439 }
1453 }
1454 }
1469 /*
1470 * If special name "inbox" then replace it with the
1471 * real inbox path.
1472 */
1480 }
1481 }
1483 /*---- Check out fcc -----*/
1493 }
1494 else
1496 }
1497 else
1499 }
1500 else
1507 }
1515 q_status_message(SM_ORDER | SM_DING, 5, 5, _("Use of a role-defined smtp-server is administratively prohibited"));
1516 else
1518 }
1521 call_mailer_flags,
1522 call_mailer_file_result,
1523 pipe_callback);
1525 }
1526 else
1532 /*----- Was there an fcc involved? -----*/
1544 }
1546 /* Now actually copy to fcc folder and close */
1547 fcc_result =
1549 label,
1552 }
1558 }
1561 }
1567 else
1569 }
1593 SIZEOF_20KBUF,
1595 }
1596 }
1600 }
1604 }
1605 }
1614 else
1616 }
1618 }
1623 }
1624 }
1626 done++;
1631 done++;
1638 ? h_anon_forward
1656 }
1660 }
1663 }
1667 }
1674 }
1675 }
1677 finish:
1684 }
1687 /*
1688 * pine_simple_send_header - generate header suitable for simple_sending
1689 */
1690 METAENV *
1692 {
1699 /* assign he_dummy to "To:" field "he" for strings2outgoing */
1706 }
1709 }
1713 /*----------------------------------------------------------------------
1714 Prepare data structures for pico, call pico, then post message
1716 Args: outgoing -- Partially formatted outgoing ENVELOPE
1717 body -- Body of outgoing message
1718 editor_title -- Title for anchor line in composer
1719 fcc_arg -- The file carbon copy field
1720 reply -- Struct describing set of msgs being replied-to
1721 lcc_arg --
1722 custom -- custom header list.
1723 sticky_fcc --
1725 Result: message is edited, then postponed, cancelled or sent.
1727 Fields:
1728 remail -
1729 return_path -
1730 date added here
1731 from added here
1732 sender -
1733 reply_to -
1734 subject passed in, edited and cannonized here
1735 to possibly passed in, edited and cannonized here
1736 cc possibly passed in, edited and cannonized here
1737 bcc edited and cannonized here
1738 in_reply_to generated in reply() and passed in
1739 message_id -
1741 Storage for these fields comes from anywhere outside. It is remalloced
1742 here so the composer can realloc them if needed. The copies here are also
1743 freed here.
1745 Can only deal with message bodies that are either TYPETEXT or TYPEMULTIPART
1746 with the first part TYPETEXT! All newlines in the text here also end with
1747 CRLF.
1749 There's a further assumption that the text in the TYPETEXT part is
1750 stored in a storage object (see filter.c).
1751 ----*/
1752 void
1757 {
1770 METAENV header;
1776 CustomType ct;
1785 /*
1786 * Cancel any pending initial commands since pico uses a different
1787 * input routine. If we didn't cancel them, they would happen after
1788 * we returned from the editor, which would be confusing.
1789 */
1799 }
1802 }
1804 #if defined(DOS) || defined(OS2)
1808 }
1811 #else
1815 #endif
1833 /* We actually want to set this only if message we're sending is flowed */
1847 #if defined(DOS) || defined(OS2)
1850 }
1851 #endif
1856 /* NOTE: initial cursor position set below */
1860 /*
1861 * When user runs compose and the current folder is a newsgroup,
1862 * offer to post to the current newsgroup.
1863 */
1871 /*
1872 * Replies don't get this far because To or Newsgroups will already
1873 * be filled in. So must be either ordinary compose or forward.
1874 * Forward sets subject, so use that to tell the difference.
1875 */
1887 }
1898 }
1908 }
1913 }
1919 }
1922 }
1937 }
1938 }
1939 }
1943 NETMBX news_mb;
1951 suggested_nntp_server =
1957 /* take out /nntp, which gets added in nntp_open */
1964 else
1965 p++;
1973 }
1975 }
1976 }
1977 }
1978 else
1980 }
1981 }
1983 /*
1984 * If we don't already have custom headers set and the role has custom
1985 * headers, then incorporate those custom headers into "custom".
1986 */
1991 /*
1992 * If we allow the Combine argument here, we're saying that we want to
1993 * combine the values from the envelope and the role for the fields To,
1994 * Cc, Bcc, and Newsgroups. For example, if we are replying to a message
1995 * we'll have a To in the envelope because we're replying. If our role also
1996 * has a To action, then Combine would combine those two and offer both
1997 * to the user. We've decided against doing this. Instead, we always use
1998 * Replace, and the role's header value replaces the value from the
1999 * envelope. It might also make sense in some cases to do the opposite,
2000 * which would be treating the role headers as defaults, just like
2001 * customized-hdrs.
2002 */
2003 #ifdef WANT_TO_COMBINE_ADDRESSES
2006 #else
2009 #endif
2016 }
2021 }
2022 }
2023 else
2025 }
2029 /* how many fixed fields are there? */
2031 ;
2035 /* the fixed part of the PINEFIELDs */
2040 /* temporary headerentry array for pico */
2054 /* custom part of PINEFIELDs */
2060 /*
2061 * For Address types, pf->addr points to an ADDRESS *.
2062 * If that address is in the "outgoing" envelope, it will
2063 * be freed by the caller, otherwise, it should be freed here.
2064 * Pf->textbuf for an Address is used a little to set up a default,
2065 * but then is freed right away below. Pf->scratch is used for a
2066 * pointer to some alloced space for pico to edit in. Addresses in
2067 * the custom area are freed by free_customs().
2068 *
2069 * For FreeText types, pf->addr is not used. Pf->text points to a
2070 * pointer that points to the text. Pf->textbuf points to a copy of
2071 * the text that must be freed before we leave, otherwise, it is
2072 * probably a pointer into the envelope and that gets freed by the
2073 * caller.
2074 *
2075 * He->realaddr is the pointer to the text that pico actually edits.
2076 */
2078 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2079 # define NN 4
2080 #else
2081 # define NN 3
2082 #endif
2085 use_news_order++;
2087 /* initialize the fixed header elements of the two temp arrays */
2094 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2095 , N_SENDER
2096 #endif
2097 };
2100 /* slightly different editing order if sending to news */
2105 /* copy the templates */
2110 /* slide string over so it is Sender instead of X-X-Sender */
2163 }
2164 }
2168 }
2173 /* if no value, use default */
2177 }
2183 }
2185 /* If there is a newsgroup, we'd better show it */
2193 }
2198 }
2203 }
2208 }
2213 }
2218 }
2224 }
2230 }
2236 }
2242 }
2248 }
2254 }
2260 }
2266 }
2272 }
2278 }
2282 }
2286 /* can't do a default for this one */
2288 /* If there is an attachment already, we'd better show them */
2301 q_status_message(SM_ORDER, 3, 3, _("Site policy doesn't allow changing From address so role's From has no effect"));
2306 }
2307 }
2315 /* If already set, make it act like we typed it in */
2332 }
2337 SIZEOF_20KBUF,
2343 }
2355 /* if bcc exists, make sure it's exposed so nothing's
2356 * sent by mistake...
2357 */
2373 }
2387 }
2391 #if !(defined(DOS) || defined(OS2)) || defined(NOAUTH)
2396 #endif
2402 }
2404 /*
2405 * If this is a reply to news, don't show the regular email
2406 * recipient headers (unless they are non-empty).
2407 */
2422 }
2423 else
2425 }
2427 /*
2428 * If this address doesn't already have a value, then we check
2429 * for a default value assigned by the user.
2430 */
2441 /*
2442 * Try to set To based on Lcc. Don't attempt Fcc.
2443 */
2481 }
2482 }
2489 }
2493 }
2503 }
2504 }
2506 /* if we still don't have a from */
2509 }
2511 /*
2512 * Addr is already set in the rest of the cases.
2513 */
2517 /*
2518 * We get to this case of the ifelse if the from or reply-to
2519 * addr was set by a role above.
2520 */
2522 /* figure out the default value */
2531 }
2533 /* if value set by role is different from default, show it */
2537 /* malformed */
2541 }
2545 }
2550 /*
2551 * These three are different from the others because we
2552 * might add the addresses to what is already there instead
2553 * of replacing.
2554 */
2578 ;
2584 }
2591 }
2594 }
2613 }
2616 }
2621 }
2626 /* outgoing2strings will alloc the string pf->scratch below */
2635 else
2641 }
2673 /* if no value, use default */
2676 }
2680 }
2683 }
2694 }
2696 /*
2697 * We may or may not want to give the user the chance to edit
2698 * the From and Reply-To lines. If they are listed in either
2699 * Default-composer-hdrs or Customized-hdrs, then they can edit
2700 * them, else no.
2701 * If canedit is not set, that means that this header is not in
2702 * the user's customized-hdrs. If rich_header is set, that
2703 * means that this header is not in the user's
2704 * default-composer-hdrs (since From and Reply-To are rich
2705 * by default). So, don't give it an he to edit with in that case.
2706 *
2707 * For other types, just not setting canedit will cause it to be
2708 * uneditable, regardless of what the user does.
2709 */
2712 /* to allow it, we let this fall through to the reply-to case below */
2723 }
2729 }
2732 he++;
2733 }
2741 }
2742 else
2743 he++;
2746 }
2747 }
2749 /*
2750 * This is so the builder can tell the composer to fill the affected
2751 * field based on the value in the field on the left.
2752 *
2753 * Note that this mechanism isn't completely general. Each entry has
2754 * only a single next_affected, so if some other entry points an
2755 * affected entry at an entry with a next_affected, they all inherit
2756 * that next_affected. Since this isn't used much a careful ordering
2757 * of the affected fields should make it a sufficient mechanism.
2758 */
2767 /*
2768 * Set up headerentries for custom fields.
2769 * NOTE: "i" is assumed to now index first custom field in sending
2770 * order.
2771 */
2789 /* change default text into an ADDRESS */
2790 /* strip quotes around whole default */
2802 }
2821 }
2825 /* use first 8 characters for prompt */
2830 he++;
2831 }
2833 /*
2834 * Make sure at least *one* field is displayable...
2835 */
2840 }
2842 /*
2843 * None displayable!!! Warn and display defaults.
2844 */
2852 }
2854 /*
2855 * Save information about body which set_mime_type_by_grope might change.
2856 * Then, if we get an error sending, we reset these things so that
2857 * grope can do it's thing again after we edit some more.
2858 */
2861 else
2867 /*----------------------------------------------------------------------
2868 Loop calling the editor until everything goes well
2869 ----*/
2873 /* Reset body to what it was when we started. */
2876 else
2878 /*
2879 * set initial cursor position based on how many times we've been
2880 * thru the loop...
2881 */
2884 }
2888 }
2891 /* set the start_here bit in correct header */
2897 }
2899 /* If didn't find it, we start in body. */
2902 }
2905 }
2907 /* in case these were turned on in previous pass through loop */
2911 }
2916 /*
2917 * If a sending attempt failed after we passed the message text
2918 * thru a user-defined filter, "orig_so" points to the original
2919 * text. Replace the body's encoded data with the original...
2920 */
2928 }
2930 /*
2931 * Convert the envelope and body to the string format that
2932 * pico can edit
2933 */
2937 /*
2938 * If this isn't the first time through this loop, we may have
2939 * freed some of the FreeText headers below so that they wouldn't
2940 * show up as empty headers in the finished message. Need to
2941 * alloc them again here so they can be edited.
2942 */
2948 }
2950 /*
2951 * If From is exposed, probably by a role, then start the cursor
2952 * on the first line which isn't filled in. If it isn't, then we
2953 * don't move the cursor, mostly for back-compat.
2954 */
2965 }
2966 }
2968 #ifdef _WINDOWS
2970 #endif
2975 /* turn off user input timeout when in composer */
2983 #ifdef _WINDOWS
2985 #endif
2988 /*
2989 * Only reinitialize signals if we didn't receive an interesting
2990 * one while in pico, since pico's return is part of processing that
2991 * signal and it should continue to be ignored.
2992 */
2996 /*
2997 * We're going to save in DEADLETTER. Dump attachments first.
2998 */
3002 /* Turn strings back into structures */
3005 /* Make newsgroups NULL if it is "" (so won't show up in headers) */
3010 }
3012 /* Make subject NULL if it is "" (so won't show up in headers) */
3016 /* remove custom fields that are empty */
3022 }
3023 }
3024 }
3028 /*-------- Stamp it with a current date -------*/
3041 /* Set return_path based on From which is going to be used */
3047 /*
3048 * Don't ever believe the sender that is there.
3049 * If From doesn't look quite right, generate our own sender.
3050 */
3054 /*
3055 * If the LHS of the address doesn't match, or the RHS
3056 * doesn't match one of localdomain or hostname,
3057 * then add a sender line (really X-X-Sender).
3058 *
3059 * Don't add a personal_name since the user can change that.
3060 */
3062 &&
3073 }
3078 }
3080 /*----- Message is edited, now decide what to do with it ----*/
3082 /*=========== Postpone or Interrupted message ============*/
3100 }
3102 /*
3103 * The idea here is to use the Fcc: writing facility
3104 * to append to the special postponed message folder...
3105 *
3106 * NOTE: the strategy now is to write the message and
3107 * all attachments as they exist at composition time.
3108 * In other words, attachments are postponed by value
3109 * and not reference. This may change later, but we'll
3110 * need a local "message/external-body" type that
3111 * outgoing2strings knows how to properly set up for
3112 * the composer. Maybe later...
3113 */
3120 /*--- Addresses didn't check out---*/
3124 }
3126 /*
3127 * Build the local message copy so.
3128 *
3129 * In the HUP case, we'll write the bezerk delimiter by
3130 * hand and output the message directly into the folder.
3131 * It's not only faster, we don't have to worry about
3132 * c-client reentrance and less hands paw over the data so
3133 * there's less chance of a problem.
3134 *
3135 * In the Postpone case, just create it if the user wants to
3136 * and create a temporary storage object to write into. */
3137 fake_hup:
3143 #if defined(DOS) || defined(OS2)
3144 /*
3145 * we can't assume anything about root or home dirs, so
3146 * just plunk it down in the same place as the pinerc
3147 */
3155 }
3160 }
3161 else
3162 #endif
3164 ps_global->VAR_OPER_DIR
3186 }
3194 }
3197 }
3198 else
3213 else
3217 }
3218 }
3219 }
3220 }
3227 }
3229 /*
3230 * Store the cursor position
3231 *
3232 * First find the header entry with the start_here
3233 * bit set, if any. This means the editor is telling
3234 * us to start on this header field next time.
3235 */
3241 }
3243 /* If there wasn't one, ":" means we start in the body. */
3255 }
3262 }
3265 }
3271 /* copy fcc line to postponed or interrupted folder */
3275 /* plug error into header for later display to user */
3280 }
3282 /*
3283 * if reply, write (UID)folder header field so we can
3284 * later flag the replied-to message \\ANSWERED
3285 * DON'T save MSGNO's.
3286 */
3296 }
3312 /*
3313 * Logically, this ought to be part of pf_uid, but this
3314 * was added later and so had to be in a separate header
3315 * for backwards compatibility.
3316 */
3322 }
3324 /* Save cursor position */
3334 }
3336 /*
3337 * Work around c-client reply-to bug. C-client will
3338 * return a reply_to in an envelope even if there is
3339 * no reply-to header field. We want to note here whether
3340 * the reply-to is real or not.
3341 */
3347 else
3349 }
3351 /* Save the role-specific smtp server */
3357 /*
3358 * Turn the list of smtp servers into a space-
3359 * delimited list in a single string.
3360 */
3372 }
3375 }
3381 else
3383 }
3385 /* Save the role-specific nntp server */
3393 /*
3394 * Turn the list of nntp servers into a space-
3395 * delimited list in a single string.
3396 */
3408 }
3411 }
3412 }
3413 else
3420 else
3422 }
3424 /*
3425 * Write the list of custom headers to the
3426 * X-Our-Headers header so that we can recover the
3427 * list in redraft.
3428 */
3446 }
3449 }
3451 /*
3452 * We need to make sure any header values that got cleared
3453 * get written to the postponed message (they won't if
3454 * pf->text is NULL). Otherwise, we can't tell previously
3455 * non-existent custom headers or default values from
3456 * custom (or other) headers that got blanked in the
3457 * composer...
3458 */
3463 /*
3464 * We're saving the message for use later. It may be that the
3465 * characters in the message are not all convertible to the
3466 * user's posting_charmap. We'll save it as UTF-8 instead
3467 * and worry about that the next time they try to send it.
3468 * Use a different save pointer just to be sure we don't
3469 * mess up the other stuff. We should probably make the
3470 * charset an argument.
3471 *
3472 * We also need to fix the charset of the body part
3473 * the user is editing so that we can read it back
3474 * successfully when we resume the composition.
3475 */
3478 {
3483 else
3489 ;
3496 }
3497 }
3511 }
3528 }
3529 else
3536 }
3537 else
3540 }
3542 /* discontinue coerced UTF-8 posting */
3546 }
3547 else
3552 /*
3553 * Special Hack #291: if any hi-byte bits are set in
3554 * editor's result, we put them there.
3555 */
3562 }
3569 else
3574 }
3587 }
3593 }
3594 }
3596 /*------ Must be sending mail or posting ! -----*/
3603 /* --- If posting, confirm with user ----*/
3610 }
3620 continue_with_only_fcc++;
3621 }
3627 }
3628 }
3631 /*--- Addresses didn't check out---*/
3634 }
3637 && !continue_with_only_fcc
3646 local_redraft_pos
3651 }
3659 local_redraft_pos
3664 }
3672 local_redraft_pos
3677 }
3681 /*---- Check out fcc -----*/
3683 /*
3684 * If special name "inbox" then replace it with the
3685 * real inbox path.
3686 */
3694 }
3697 /* lmc.text_only set on command line */
3699 /* ---- Open or allocation of fcc failed ----- */
3702 /*
3703 * Find field entry associated with fcc, and start
3704 * composer on it...
3705 */
3711 }
3712 else
3714 }
3715 else
3718 /*---- Take care of any requested prefiltering ----*/
3726 }
3728 /*------ Actually post -------*/
3743 }
3744 }
3753 }
3754 else
3756 }
3758 /*
3759 * BUG: IF we've posted the message *and* an fcc was specified
3760 * then we've already got a neatly formatted message in the
3761 * lmc.so. It'd be nice not to have to re-encode everything
3762 * to insert it into the smtp slot...
3763 */
3765 /*
3766 * Turn on "undisclosed recipients" header if no To or cc.
3767 */
3772 }
3777 }
3779 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
3780 /*
3781 * If requested, launch backgroud posting...
3782 */
3790 /*
3791 * Put us in new process group...
3792 */
3795 /* BUG: should fix argv[0] to indicate what we're up to */
3797 /*
3798 * If there are any live streams, pretend we never
3799 * knew them. Problem is two processes writing
3800 * same server process.
3801 * This is not clean but we're just going to exit
3802 * right away anyway. We just want to be sure to leave
3803 * the stuff that the parent is going to use alone.
3804 * The next three lines will disable the re-use of the
3805 * existing streams and cause us to open a new one if
3806 * needed.
3807 */
3812 /* quell any display output */
3815 /*------- Actually mail the message ------*/
3824 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3825 else
3827 }
3830 call_mailer_flags,
3831 call_mailer_file_result,
3837 }
3839 /*----- Was there an fcc involved? -----*/
3841 /*------ Write it if at least something worked ------*/
3853 }
3855 /*-- Now actually copy to fcc folder and close --*/
3861 }
3868 }
3871 }
3874 /*
3875 * Encode child's result in hi-byte of
3876 * editor's result
3877 */
3880 }
3883 }
3889 }
3898 }
3909 }
3912 /*------- Actually mail the message ------*/
3920 q_status_message(SM_ORDER | SM_DING, 5, 5, "Use of a role-defined smtp-server is administratively prohibited");
3921 else
3923 }
3926 call_mailer_flags,
3927 call_mailer_file_result,
3933 }
3935 /*----- Was there an fcc involved? -----*/
3937 /*------ Write it if at least something worked ------*/
3948 }
3950 /*-- Now actually copy to fcc folder and close --*/
3955 }
3961 }
3964 }
3966 /*----- Mail Post FAILED, back to composer -----*/
3971 /*
3972 * Find field entry associated with fcc, and start
3973 * composer on it...
3974 */
3982 }
3990 }
3992 /*
3993 * If message sent *completely* successfully, there's a
3994 * reply struct AND we're allowed to write back state, do it.
3995 * But also protect against shifted message numbers due
3996 * to new mail arrival. Since the number passed is based
3997 * on the real imap msg no, AND we're sure no expunge has
3998 * been done, just fix up the sorted number...
3999 */
4002 /*----- Signed, sealed, delivered! ------*/
4007 }
4008 }
4027 }
4052 }
4055 /*
4056 * Check for subject in outgoing message.
4057 *
4058 * Asks user whether to proceed with no subject.
4059 */
4060 int
4062 {
4074 else
4076 }
4079 }
4083 }
4086 /*
4087 * Check for fcc in outgoing message.
4088 *
4089 * Asks user whether to proceed with no fcc.
4090 */
4091 int
4093 {
4101 else
4103 }
4106 }
4109 /*
4110 * Confirm that the user wants to send to MAILER-DAEMON
4111 */
4112 int
4114 {
4117 }
4120 void
4122 {
4128 }
4129 }
4132 int
4134 {
4141 }
4144 /*
4145 * call__mailer_file_result - some results from call_mailer might be in a file.
4146 * dislplay that file.
4147 */
4148 void
4150 {
4154 }
4157 }
4158 }
4159 }
4161 void
4163 {
4179 }
4180 }
4184 /*
4185 * This is specialized routine. It assumes that the only things that we
4186 * care about restoring are the body type, subtype, encoding and the
4187 * state of the charset parameter. It also assumes that if the charset
4188 * parameter exists when we save it, it won't be removed later.
4189 */
4190 BODY_PARTICULARS_S *
4192 {
4210 }
4214 }
4217 }
4220 void
4222 {
4244 }
4248 else
4252 }
4253 }
4256 /*
4257 * This can't happen because grope never removes
4258 * the charset parameter.
4259 */
4262 }
4263 /*
4264 else{
4265 ok, still no parameter
4266 }
4267 */
4268 }
4269 }
4275 }
4276 }
4279 void
4281 {
4290 }
4291 }
4294 /*----------------------------------------------------------------------
4295 Build a status message suitable for framing
4297 Returns: pointer to resulting buffer
4298 ---*/
4301 {
4340 /* dots on end of fixed, no fcc */
4344 }
4346 /* include whole fixed part, quotes and dots at end of fcc name */
4356 }
4358 /* whole thing */
4364 }
4370 }
4372 /* Callback from Pico to set the conditions for Alpine to start a new thread
4373 */
4375 void
4377 {
4379 }
4383 /*----------------------------------------------------------------------
4384 Call back for pico to insert the specified message's text
4386 Args: n -- message number to format
4387 f -- function to use to output the formatted message
4390 Returns: returns msg number formatted on success, zero on error.
4391 ----*/
4392 long
4394 {
4406 }
4408 /* temporarily assign a new quote string */
4412 /* build separator line */
4415 /* actually write message text */
4421 }
4426 }
4429 /*----------------------------------------------------------------------
4430 Call back for pico to prompt the user for exit confirmation
4432 Args: dflt -- default answer for confirmation prompt
4434 Returns: either NULL if the user accepts exit, or string containing
4435 reason why the user declined.
4436 ----*/
4437 int
4440 {
4467 }
4474 }
4481 /*
4482 * Build list of available filters...
4483 */
4487 ;
4495 }
4501 }
4506 }
4507 else
4516 }
4523 }
4524 }
4538 /* set global_filter_pointer to desired filter or NULL if none */
4539 /* prepare two keymenu slots for selecting filter */
4552 }
4555 /* setup keymenu slot to toggle verbose mode */
4560 }
4563 /* setup keymenu slot to toggle flowed mode */
4569 }
4572 /* setup keymenu slot to toggle attacment on fcc */
4577 }
4579 #if defined(BACKGROUND_POST) && defined(SIGCHLD)
4585 }
4586 #endif
4593 #ifdef SMIME
4608 }
4609 }
4610 #endif
4615 /* setup keymenu slots to toggle dsn bits */
4633 }
4645 }
4654 else
4670 lparen++;
4671 }
4672 else
4674 }
4677 }
4684 lparen++;
4685 }
4689 }
4690 }
4697 }
4698 else
4700 }
4707 lparen++;
4708 }
4709 else
4711 }
4721 }
4728 lparen++;
4729 }
4730 else
4732 }
4737 }
4744 lparen++;
4745 }
4749 }
4750 }
4753 }
4755 #ifdef SMIME
4761 lparen++;
4762 }
4766 }
4767 }
4770 }
4777 lparen++;
4778 }
4782 }
4783 }
4786 }
4787 #endif
4825 }
4826 }
4837 h_send_prompt,
4838 RB_NORM);
4839 else
4850 h_send_prompt,
4851 RB_NORM);
4855 }
4859 }
4863 }
4866 }
4869 }
4872 }
4876 else
4881 }
4884 }
4889 }
4893 /* turn off related bits */
4896 }
4899 /* turn off related bits */
4902 }
4905 /* turn off related bits */
4908 }
4911 }
4912 }
4914 /*
4915 * When you turn on DSN, the default is to notify on
4916 * failure, success, or delay; and to return the whole
4917 * body on failure.
4918 */
4920 }
4928 }
4936 else
4938 }
4939 }
4940 #ifdef SMIME
4944 }
4948 }
4949 #endif
4963 }
4965 /* remember selection */
4978 }
4979 }
4990 }
4993 /*
4994 * Allow user to choose a priority for sending.
4995 *
4996 * Returns an allocated priority on success, NULL otherwise.
4997 */
5000 {
5009 cnt++;
5020 lp++;
5021 }
5028 /* TRANSLATORS: SELECT A PRIORITY is a screen title
5029 TRANSLATORS: Print something1 using something2.
5030 "priorities" is something1 */
5034 starting_val);
5044 }
5047 int
5049 {
5051 }
5054 /*----------------------------------------------------------------------
5055 Call back for pico to display mime type of attachment
5057 Args: file -- filename being attached
5059 Returns: returns 1 on success (message queued), zero otherwise (don't know
5060 type so nothing queued).
5061 ----*/
5062 int
5064 {
5073 /* don't know where the cursor's been, reset it */
5079 }
5080 }
5088 }
5089 else
5094 }
5097 /*----------------------------------------------------------------------
5098 Call back for pico to receive an uploaded message
5100 Args: fname -- name for uploaded file (empty if they want us to assign it)
5101 size -- pointer to long to hold the attachment's size
5103 Notes: the attachment is uploaded to a temp file, and
5105 Returns: TRUE on success, FALSE otherwise
5106 ----*/
5107 int
5109 {
5127 }
5128 }
5129 else
5146 }
5154 }
5155 else
5162 }
5167 {
5178 };
5189 }
5193 }
5194 else
5196 }
5200 }
5203 /*----------------------------------------------------------------------
5204 Pass the first text segment of the message thru the "send filter"
5206 Args: body pointer and address for storage object of old data
5208 Returns: returns 1 on success, zero on error.
5209 ----*/
5210 int
5213 {
5222 #define DO_HEADERS 1
5228 /*
5229 * We need WRITE_TO_LOCALE here because the user is going to
5230 * be operating on tmpf. We need to change it back after they
5231 * are done.
5232 */
5237 }
5239 /*
5240 * If the headers are wanted for filtering, we can just
5241 * stick them in the tmpf file that is already there before
5242 * putting the body in.
5243 */
5250 }
5260 }
5261 else
5263 }
5265 /*
5266 * Gf_filter wants a single storage object to read from.
5267 * If headers are wanted for filtering we'll have to put them
5268 * and the body into a temp file first and then use that
5269 * as the storage object for gf_filter.
5270 * We don't use WRITE_TO_LOCALE in this case because gf_filter
5271 * takes care of that.
5272 */
5274 /* put headers in our_tmpf_so */
5281 /* put body in our_tmpf_so */
5290 /* tell gf_filter to read from our_tmpf_so instead of *so */
5292 }
5293 else
5295 }
5296 else
5314 /* now we undo the WRITE_FROM_LOCALE change in tmpf */
5321 }
5322 else
5324 }
5325 else
5327 }
5328 else
5330 }
5331 else
5334 pipe_callback);
5341 #ifdef _WINDOWS
5343 /*
5344 * Can't really be using stdout, so don't print message that
5345 * gets printed in the else. Ideally the program being called
5346 * will wait after showing the message, we might want to look
5347 * into doing the waiting in console based apps... or not.
5348 */
5349 #else
5358 }
5368 /*
5369 * If the command said it would return new MIME
5370 * mime type data, check it out...
5371 */
5383 ;
5401 }
5404 }
5407 }
5408 }
5410 /*
5411 * Reevaluate the encoding in case form's changed...
5412 */
5415 }
5419 }
5420 else
5422 }
5425 }
5426 else
5432 }
5437 }
5444 }
5450 errstr);
5453 }
5456 }
5459 /*----------------------------------------------------------------------
5460 Copy the newsgroup name of the given mailbox into the given buffer
5462 Args:
5464 Returns:
5465 ----*/
5466 void
5468 {
5469 NETMBX mb;
5474 }
5477 }
5478 else
5480 }
5483 /*----------------------------------------------------------------------
5484 Generate and send a message back to the pine development team
5486 Args: none
5488 Returns: none
5489 ----*/
5490 void
5492 {
5501 }
5529 }
5530 else
5537 }
5540 /*----------------------------------------------------------------------
5541 Set up fields for passing to pico. Assumes first text part is
5542 intended to be passed along for editing, and is in the form of
5543 of a storage object brought into existence sometime before pico_send().
5544 -----*/
5545 void
5548 {
5551 /*
5552 * SIMPLIFYING ASSUMPTION #37: the first TEXT part's storage object
5553 * is guaranteed to be of type PicoText!
5554 */
5558 /* mark storage object as user edited */
5561 }
5568 /*
5569 * We used to jump out the window if the first part wasn't text,
5570 * but that may not be the case when bouncing a message with
5571 * a leading non-text segment. So, IT'S UNDERSTOOD that the
5572 * contents of the first part to send is still ALWAYS in a
5573 * PicoText storage object, *AND* if that object doesn't contain
5574 * data of type text, then it must contain THE ENCODED NON-TEXT
5575 * DATA of the piece being sent.
5576 *
5577 * It's up to the programmer to make sure that such a message is
5578 * sent via pine_simple_send and never get to the composer via
5579 * pine_send.
5580 *
5581 * Make sense?
5582 */
5585 /* mark storage object as user edited */
5589 /*
5590 * If we already had a list, blast it now, so we can build a new
5591 * attachment list that reflects what's really there...
5592 */
5597 /* Simplifyihg assumption #28e. (see cross reference)
5598 All parts in the body passed in here that are not already
5599 in the attachments list are added to the end of the attachments
5600 list. Attachment items not in the body list will be taken care
5601 of in strings2outgoing, but they are unlikey to occur
5602 */
5605 /* Already in list? */
5609 ;
5623 }
5627 }
5628 }
5629 else
5635 /*
5636 * If we can find a "name" parm, display that too...
5637 */
5639 /* Convert any [ or ]'s the name contained */
5647 }
5648 else
5668 }
5669 }
5670 }
5671 }
5674 /*------------------------------------------------------------------
5675 Malloc strings to pass to composer editor because it expects
5676 such strings so it can realloc them
5677 -----------------------------------------------------------------*/
5678 /*
5679 * turn any address fields into text strings
5680 */
5681 /*
5682 * SIMPLIFYING ASSUMPTION #116: all header strings are understood
5683 * NOT to be RFC1522 decoded. Said differently, they're understood
5684 * to be RFC1522 ENCODED as necessary. The intent is to preserve
5685 * original charset tagging as far into the compose/send pipe as
5686 * we can.
5687 */
5698 /*
5699 * Scan for and fix-up patently bogus fields.
5700 *
5701 * NOTE: collaboration with this code and what's done in
5702 * reply.c:reply_cp_addr to package up the bogus stuff
5703 * is required.
5704 */
5710 /*
5711 * Rfc822_cat has been changed so that it now quotes
5712 * this sometimes. So we have to look out for quotes
5713 * which confuse the decoder. It was only quoting
5714 * because we were putting \r \n in the input, I think.
5715 */
5738 }
5746 /*
5747 * Replace control characters with ^C notation, unless
5748 * some conditions are met (see istrncpy).
5749 * If user doesn't edit, then we switch back to the
5750 * original version. If user does edit, then all bets
5751 * are off.
5752 */
5758 }
5761 }
5762 }
5781 }
5786 }
5791 /*
5792 * Replace control characters with ^C notation, unless
5793 * some conditions are met (see istrncpy).
5794 * If user doesn't edit, then we switch back to the
5795 * original version. If user does edit, then all bets
5796 * are off.
5797 */
5803 }
5806 }
5807 }
5813 }
5814 }
5817 /*----------------------------------------------------------------------
5818 Restore fields returned from pico to form useful to sending
5819 routines.
5820 -----*/
5821 void
5823 {
5829 /*
5830 * turn any local address strings into address lists
5831 */
5852 }
5864 }
5870 }
5873 }
5879 }
5882 /*----------------------------------------------------------------------
5884 The head of the body list here is always either TEXT or MULTIPART. It may be
5885 changed from TEXT to MULTIPART if there are attachments to be added
5886 and it is not already multipart.
5887 ----*/
5888 void
5890 {
5899 /*
5900 * if conditions are met short circuit MIME wrapping
5901 */
5904 /* only override assigned encoding if it might need upgrading */
5915 }
5918 }
5921 /*-- Current type is text, but there are attachments to add --*/
5922 /*-- Upgrade to a TYPEMULTIPART --*/
5927 /*
5928 * Why do we do this?
5929 * The problem is that base64 or quoted-printable encoding is
5930 * sensitive to having random data appended to it's end. If
5931 * we use a single part TEXT message and something in between
5932 * us and the end appends advertising without adjusting for
5933 * the encoding, the message is screwed up. So we wrap the
5934 * text part inside a multipart and then the appended data
5935 * will come after the boundary.
5936 *
5937 * We wish we could do this on the way out the door in a
5938 * child of post_rfc822_output because at that point we know
5939 * the character set and the encoding being used. For example,
5940 * iso-2022-jp is an encoding that is not sensitive to data
5941 * appended to the end, so it wouldn't need to be wrapped.
5942 * We could conceivably have post_rfc822_body inspect the
5943 * body and change it before doing the output. It would work
5944 * but would be very fragile. We'd be passed a body from
5945 * c-client to output and instead of just doing the output
5946 * we'd change the body and then output it. Not worth it
5947 * since the multipart wrapping is completely correct for
5948 * MIME-aware mailers.
5949 */
5951 /* move contents which were NOT copied */
5954 }
5961 }
5965 }
5968 /*-- Now type must be MULTIPART with first part text --*/
5971 }
5973 /*------ Go through the parts list remove those to be deleted -----*/
5976 /* already existed? */
5980 /*
5981 * decode original to see if it matches what was decoded
5982 * when we sent it in.
5983 */
5994 /* encoding happens as msg text is written */
5996 }
6002 }
6011 }
6012 else
6014 }
6016 /*---------- Now add any new attachments ---------*/
6022 /*
6023 * the idea is handle ALL attachments as open FILE *'s. Actual
6024 * encoding and such is handled at the time the message
6025 * is shoved into the mail slot or written to disk...
6026 *
6027 * Also, we never unlink a file, so it's up to whoever opens
6028 * it to deal with tmpfile issues.
6029 */
6037 }
6044 /*
6045 * Set type to unknown and let set_mime_type_by_* figure it out.
6046 * Always encode attachments we add as BINARY.
6047 */
6054 }
6061 /* Add name attribute for backward compatibility */
6070 }
6071 else
6075 pa->filename
6079 /* Then set the Content-Disposition ala RFC1806 */
6090 }
6091 else
6095 pa->filename
6098 }
6102 }
6104 /*
6105 * Now, if this multipart has but one text piece (that is, no
6106 * attachments), then downgrade from a composite type to a discrete
6107 * text/plain message if CTE is not 8bit.
6108 */
6114 /* Clone the interesting body part */
6117 /* and rub out what we don't want cleaned up when it's free'd */
6121 }
6125 }
6128 /*
6129 * Fill in text BODY part's structure
6130 *
6131 */
6132 void
6134 {
6142 }
6145 /*
6146 * free_attachment_list - free attachments in given list
6147 */
6148 void
6150 {
6166 }
6177 }
6178 }
6181 void
6183 {
6195 }
6198 /*
6199 * view_as_rich - set the rich_header flag
6200 *
6201 * name - name of the header field
6202 * deflt - default value to return if user didn't set it
6203 *
6204 * Note: if the user tries to turn them all off with "", then
6205 * we take that to mean default, since otherwise there is no
6206 * way to get to the headers.
6207 */
6208 int
6210 {
6220 }
6223 }
6225 }
6228 /*
6229 * background_posting - return whether or not we're already in the process
6230 * of posting
6231 */
6232 int
6234 {
6240 }
6243 }
6246 /*----------------------------------------------------------------------
6247 Validate the given subject relative to any news groups.
6249 Args: none
6251 Returns: always returns 1, but also returns error if
6252 ----*/
6253 int
6255 {
6262 /*
6263 * Now look for any header entry we passed to pico that has to do
6264 * with news. If there's no subject, gripe.
6265 */
6273 }
6274 }
6277 }
6280 /*
6281 * This is the build_address used by the composer to check for an address
6282 * in the addrbook.
6283 *
6284 * Args: to -- the passed in line to parse
6285 * full_to -- Address of a pointer to return the full address in.
6286 * This will be allocated here and freed by the caller.
6287 * error -- Address of a pointer to return an error message in.
6288 * This will be allocated here and freed by the caller.
6289 * barg -- Address of a pointer to return the fcc in is in
6290 * fcc->tptr. It will have already been allocated by the
6291 * caller but we may free it and reallocate if we wish.
6292 * Caller will free it.
6293 *
6294 * Result: 0 is returned if address was OK,
6295 * -1 if address wasn't OK.
6296 *
6297 * Side effect: Can flush addrbook entry cache entries so they need to be
6298 * re-fetched afterwords.
6299 */
6300 int
6302 {
6305 BuildTo bldto;
6313 /* check to see if to string is empty to avoid work */
6322 }
6330 /* No guarantee cursor or status line is how we saved it */
6338 /*
6339 * If we end up jumping back here because somebody else changed one of
6340 * our addrbooks out from underneath us, we may well leak some memory.
6341 * That's probably ok since this will be very rare.
6342 *
6343 * The reason for the memcpy of the jmp_buf is that we may actually
6344 * be indirectly calling this function from within the address book.
6345 * For example, we may be in the address book screen and then run
6346 * the ComposeTo command which puts us in the composer, then we call
6347 * build_address from there which resets addrbook_changed_unexpectedly.
6348 * Once we leave build_address we need to reset addrbook_changed_un...
6349 * because this position on the stack will no longer be valid.
6350 * Same is true of the other setjmp's in this file which are wrapped
6351 * in memcpy calls.
6352 */
6371 }
6373 ab_nesting_level++;
6380 ab_nesting_level--;
6384 /*
6385 * Have to rfc1522_decode the full_to string before sending it back.
6386 */
6395 /* p == q means that decoding happened, p is decoded *full_to */
6399 }
6400 else
6402 }
6407 /* Pt will point to headents[Fcc].bldr_private */
6412 /*
6413 * If *barg->aff is set, that means fcc was set from a list
6414 * during some previous builder call.
6415 * If the current To line contains the old expansion as a prefix, then
6416 * we should leave things as they are. In order to decide that,
6417 * we look at a hash value computed from the strings.
6418 */
6430 }
6431 else
6433 }
6439 /* replace fcc value */
6450 }
6463 }
6465 /*
6466 * If result is reproducible, we don't keep track here.
6467 */
6470 }
6471 }
6472 }
6473 else
6475 }
6477 /* This is so pico will erase the old message */
6484 }
6487 /*
6488 * This is the builder used by the composer for the Lcc line.
6489 *
6490 * Args: lcc -- the passed in Lcc line to parse
6491 * full_lcc -- Address of a pointer to return the full address in.
6492 * This will be allocated here and freed by the caller.
6493 * error -- Address of a pointer to return an error message in.
6494 * This is not allocated so should not be freed by the caller.
6495 * barg -- This is a pointer to text for affected entries which
6496 * we may be changing. The first one in the list is the
6497 * To entry. We may put the name of the list in empty
6498 * group syntax form there (like List Name: ;).
6499 * The second one in the list is the fcc field.
6500 * The tptr members already point to text allocated in the
6501 * caller. We may free and reallocate here, caller will
6502 * free the result in any case.
6503 *
6504 * Result: 0 is returned if address was OK,
6505 * -1 if address wasn't OK.
6506 *
6507 * Side effect: Can flush addrbook entry cache entries so they need to be
6508 * re-fetched afterwords.
6509 */
6510 int
6512 {
6516 BuildTo bldlcc;
6527 /* check to see if to string is empty to avoid work */
6536 }
6545 /*
6546 * If we end up jumping back here because somebody else changed one of
6547 * our addrbooks out from underneath us, we may well leak some memory.
6548 * That's probably ok since this will be very rare.
6549 */
6569 }
6571 ab_nesting_level++;
6575 /*
6576 * To is first affected_entry and Fcc is second.
6577 * The conditional stuff for the fcc argument says to only change the
6578 * fcc if the fcc pointer is passed in non-null, and the To pointer
6579 * is also non-null. If they are null, that means they've already been
6580 * entered (are sticky). We don't affect fcc if either fcc or To has
6581 * been typed in.
6582 */
6584 full_lcc,
6585 error,
6592 ab_nesting_level--;
6596 /* full_lcc is what ends up in the Lcc: line */
6600 /*
6601 * Have to rfc1522_decode the full_lcc string before sending it back.
6602 */
6608 }
6609 else
6611 }
6613 /* to is what ends up in the To: line */
6618 /*
6619 * Have to rfc1522_decode the full_to string before sending it back.
6620 */
6625 /*
6626 * If the caller wants us to try to preserve the charset
6627 * information (they set aff) we copy it into encoded->etext.
6628 * We don't have to worry about pasting together pieces of
6629 * etext like we do in build_address because whenever the
6630 * Lcc line is setting the To line it will be setting the
6631 * whole line, not modifying it.
6632 * Pt will point to headents[To].bldr_private.
6633 */
6641 }
6642 }
6646 }
6647 else
6654 /*
6655 * This part is recording the fact that the To line was set to
6656 * what it is by entering something on the Lcc line. In particular,
6657 * if a list alias was entered here then the fullname of the list
6658 * goes in the To line. We save this affector information so that
6659 * we can tell it shouldn't be modified if we call build_addr_lcc
6660 * again unless we actually modified what's in the Lcc line so that
6661 * it doesn't start with the same thing. The problem we're solving
6662 * is that the contents of the Lcc line no longer look like the
6663 * list they were derived from.
6664 * Pt will point to headents[To].bldr_private.
6665 */
6680 }
6681 else
6683 }
6690 /* replace to value */
6706 }
6712 }
6719 }
6732 }
6734 /*
6735 * If result is reproducible, we don't keep track here.
6736 */
6739 }
6740 }
6741 }
6742 else
6744 }
6749 /*
6750 * If *barg->next->aff is set, that means fcc was set from a list
6751 * during some previous builder call. If the current Lcc line
6752 * contains the old expansion as a prefix, then we should leave
6753 * things as they are. In order to decide that we look at a hash
6754 * value computed from the strings.
6755 * Pt will point to headents[Fcc].bldr_private
6756 */
6772 }
6773 else
6775 }
6782 /* replace fcc value */
6793 }
6806 }
6808 /*
6809 * If result is reproducible, we don't keep track here.
6810 */
6813 }
6814 }
6815 }
6816 else
6818 }
6827 }
6830 /*----------------------------------------------------------------------
6831 Verify and canonicalize news groups names.
6832 Called from the message composer
6834 Args: given_group -- List of groups typed by user
6835 expanded_group -- pointer to point to expanded list, which will be
6836 allocated here and freed in caller. If this is
6837 NULL, don't attempt to validate.
6838 error -- pointer to store error message
6839 fcc -- pointer to point to fcc, which will be
6840 allocated here and freed in caller
6842 Returns: 0 if all is OK
6843 -1 if addresses weren't valid
6845 Test the given list of newstroups against those recognized by our nntp
6846 servers. Testing by actually trying to open the list is much cheaper, both
6847 in bandwidth and memory, than yanking the whole list across the wire.
6848 ----*/
6849 int
6850 news_build(char *given_group, char **expanded_group, char **error, BUILDER_ARG *fcc, int *mangled)
6851 {
6862 /* assign any new fcc to the BUILDER_ARG */
6865 /* it changed */
6870 }
6871 }
6875 }
6877 /* deal with any busy indicator */
6885 }
6889 }
6892 void
6894 {
6896 }
6899 #if defined(DOS) || defined(OS2)
6901 /*----------------------------------------------------------------------
6902 Verify that the necessary pieces are around to allow for
6903 message sending under DOS
6905 Args: strict -- tells us if a remote stream is required before
6906 sending is permitted.
6908 The idea is to make sure pine knows enough to put together a valid
6909 from line. The things we MUST know are a user-id, user-domain and
6910 smtp server to dump the message off on. Typically these are
6911 provided in pine's configuration file, but if not, the user is
6912 queried here.
6913 ----*/
6914 int
6916 {
6919 HelpType help;
6921 /*
6922 * query for user name portion of address, use IMAP login
6923 * name as default
6924 */
6926 NETMBX mb;
6934 }
6936 /* no user-id prompting if set */
6947 }
6948 else
6950 }
6951 else
6955 /* No prompt, just assume mailbox login is user-id */
6958 }
6974 }
6978 }
6984 }
6986 /* save the name */
6991 && !no_prompt_user_id
6994 }
6998 }
6999 }
7001 /* query for personal name */
7019 }
7023 }
7032 }
7036 }
7037 }
7038 }
7040 /*
7041 * query for host/domain portion of address, using IMAP
7042 * host as default
7043 */
7053 }
7054 else
7071 }
7075 }
7081 }
7083 /* save the name */
7093 }
7098 }
7099 }
7101 /* check for smtp server */
7113 }
7114 else
7131 }
7135 }
7141 }
7143 /* save the name */
7150 }
7153 }