| blob | cfdcc9a5cbe076111a88235c4b6063d8a3b6511b |
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 stream.c
21 Implements the Pine mail stream management routines
22 and c-client wrapper functions
23 ====*/
48 /*
49 * Internal prototypes
50 */
73 /*
74 * Pine wrapper around mail_open. If we have the PREFER_ALT_AUTH flag turned
75 * on, we need to set the TRYALT flag before trying the open.
76 * This routine manages the stream pool, too. It tries to re-use existing
77 * streams instead of opening new ones, or maybe it will leave one open and
78 * use a new one if that seems to make more sense. Pine_mail_close leaves
79 * streams open so that they may be re-used. Each pine_mail_open should have
80 * a matching pine_mail_close (or possible pine_mail_actually_close) somewhere
81 * that goes with it.
82 *
83 * Args:
84 * stream -- A possible stream for recycling. This isn't usually the
85 * way recycling happens. Usually it is automatic.
86 * mailbox -- The mailbox to be opened.
87 * openflags -- Flags passed here to modify the behavior.
88 * retflags -- Flags returned from here. SP_MATCH will be lit if that is
89 * what happened. If SP_MATCH is lit then SP_LOCKED may also
90 * be lit if the matched stream was already locked when
91 * we got here.
92 */
93 MAILSTREAM *
95 {
107 openflags,
125 }
130 /* inbox is still special, assume that we want to permlock it */
133 /* check to see if user wants this folder permlocked */
139 /* there isn't really a pair, it just dequotes for us */
142 /*
143 * Check to see if this is an incoming nickname and replace it
144 * with the full name.
145 */
156 ||
161 permlocked++;
165 }
167 /*
168 * Only cache if remote, not nntp, not pop, and caller asked us to.
169 * It might make sense to do some caching for nntp and pop, as well, but
170 * we aren't doing it right now. For example, an nntp stream open to
171 * one group could be reused for another group. An open pop stream could
172 * be used for mail_copy_full.
173 *
174 * An implication of doing only imap here is that sp_stream_get will only
175 * be concerned with imap streams.
176 */
180 }
183 dprint((9, "pine_mail_open: not cacheable: %s\n", !d ? "no driver?" : d->name ? d->name : "?" ));
184 }
187 /*
188 * This is a strange case. We want to allow stay-open local
189 * folders, but they don't fit into the rest of the framework
190 * well. So we'll look for it being already open in this case
191 * and special-case it (the already_open_stream() case
192 * below).
193 */
196 }
200 }
201 }
202 }
204 /* If driver doesn't support halfopen, just open it. */
209 }
211 /*
212 * Some of the flags are pine's, the rest are meant for mail_open.
213 * We've noted the pine flags, now remove them before we call mail_open.
214 */
218 #ifdef DEBUG
221 #endif
227 }
237 }
241 }
243 /*
244 * One of the problems is that the new-style stream caching (the
245 * sp_stream_get stuff) may conflict with some of the old-style caching
246 * (the passed in argument stream) that is still in the code. We should
247 * probably eliminate the old-style caching, but some of it is still useful,
248 * especially if it deals with something other than IMAP. We want to prevent
249 * mistakes caused by conflicts between the two styles. In particular, we
250 * don't want to have a new-style cached stream re-opened because of the
251 * old-style caching code. This can happen if a stream is passed in that
252 * is not useable, and then a new stream is opened because the passed in
253 * stream causes us to bypass the new caching code. Play it safe. If it
254 * is an IMAP stream, just close it. This should leave it in the new-style
255 * cache anyway, causing no loss. Maybe not if the cache wasn't large
256 * enough to have it in there in the first place, in which case we get
257 * a possibly unnecessary close and open. If it isn't IMAP we still have
258 * to worry about it because it will cause us to bypass the caching code.
259 * So if the stream isn't IMAP but the mailbox we're opening is, close it.
260 * The immediate alternative would be to try to emulate the code in
261 * mail_open that checks whether it is re-usable or not, but that is
262 * dangerous if that code changes on us.
263 */
272 }
277 }
281 }
282 }
284 /*
285 * Maildrops are special. The mailbox name will be a #move name. If the
286 * target of the maildrop is an IMAP folder we want to be sure it isn't
287 * already open in another cached stream, to avoid double opens. This
288 * could have happened if the user opened it manually as the target
289 * instead of as a maildrop. It could also be a side-effect of marking
290 * an answered flag after a reply.
291 */
301 }
302 }
303 }
310 else
314 flags = SP_LOCKED
321 /*
322 * If the stream wasn't already locked, then we reset it so it
323 * looks like we are reopening it. We have to worry about recent
324 * messages since they will still be recent, if that affects us.
325 */
333 }
342 }
348 }
360 }
363 }
364 }
367 /*
368 * First, we look for an exact match, a stream which is already
369 * open to the mailbox we are trying to re-open, and we use that.
370 * Skip permlocked only because we did it above already.
371 */
377 flags = SP_LOCKED
384 /*
385 * If the stream wasn't already locked, then we reset it so it
386 * looks like we are reopening it. We have to worry about recent
387 * messages since they will still be recent, if that affects us.
388 */
396 }
405 }
411 }
415 /*
416 * We may be re-using a stream that was previously open
417 * with OP_SILENT and now we don't want OP_SILENT.
418 * We don't turn !silent into silent because the !silentness
419 * could be important in the original context (for example,
420 * silent suppresses mm_expunged calls).
421 *
422 * WARNING: we're messing with c-client internals.
423 */
432 }
435 }
437 /*
438 * No exact match, look for a stream which is open to the same
439 * server and marked for TEMPUSE.
440 */
445 }
446 /*
447 * No SAME/TEMPUSE stream so we look to see if there is an
448 * open slot available (we're not yet at max_remstream). If there
449 * is an open slot, we'll just open a new stream and put it there.
450 * If not, we'll go inside this conditional.
451 */
456 /*
457 * No empty remote slots available. See if there is a
458 * TEMPUSE stream that is open but to the wrong server.
459 */
462 /*
463 * We will close this stream and use the empty slot
464 * that that creates.
465 */
470 }
473 /*
474 * Still no luck. Look for a stream open to the same
475 * server that is just not locked. This would be a
476 * stream that might be reusable in the future, but we
477 * need it now instead.
478 */
483 }
485 /*
486 * We'll take any UNLOCKED stream and re-use it.
487 */
490 /*
491 * We will close this stream and use the empty slot
492 * that that creates.
493 */
498 }
502 }
505 }
516 }
517 }
518 }
519 }
520 }
524 }
526 /*
527 * We'll make an assumption here. If we were asked to halfopen a
528 * stream then we'll assume that the caller doesn't really care if
529 * the stream is halfopen or if it happens to be open to some mailbox
530 * already. They are just saying halfopen because they don't need to
531 * SELECT a mailbox. That's the assumption, anyway.
532 */
544 }
550 }
552 /*
553 * We're going to SELECT another folder with this open stream.
554 */
556 /*
557 * We will have just pinged the stream to make sure it is
558 * still alive. That ping may have discovered some new mail.
559 * Before unselecting the folder, we should process the filters
560 * for that new mail.
561 */
573 }
575 /*
576 * We need to reset the counters and everything.
577 * The easiest way to do that is just to delete all of the
578 * sp_s data and let the open fill it in correctly for
579 * the new folder.
580 */
582 }
583 }
585 /*
586 * When we pass a stream to mail_open, it will either re-use it or
587 * close it.
588 */
593 dprint((7, "pine_mail_open: mail_open returns stream:\n original_mailbox=%s\n mailbox=%s\n driver=%s rdonly=%d halfopen=%d secure=%d nmsgs=%ld recent=%ld\n", retstream->original_mailbox ? retstream->original_mailbox : "?", retstream->mailbox ? retstream->mailbox : "?", (retstream->dtb && retstream->dtb->name) ? retstream->dtb->name : "?", retstream->rdonly, retstream->halfopen, retstream->secure, retstream->nmsgs, retstream->recent));
595 /*
596 * So it is easier to figure out which command goes with which
597 * stream when debugging, change the tag associated with each stream.
598 * Of course, this will come after the SELECT, so the startup IMAP
599 * commands will have confusing tags.
600 */
605 }
611 }
613 /*
614 * Catch the case where our test up above (where usepool was set)
615 * did not notice that this was news, but that we can tell once
616 * we've opened the stream. (One such case would be an imap proxy
617 * to an nntp server.) Remove it from being cached here. There was
618 * a possible penalty for not noticing sooner. If all the usepool
619 * slots were full, we will have closed one of the UNLOCKED streams
620 * above, preventing us from future re-use of that stream.
621 * We could figure out how to do the test better with just the
622 * name. We could open the stream and then close the other one
623 * after the fact. Or we could just not worry about it since it is
624 * rare.
625 */
629 }
631 /* make sure the message map has been instantiated */
634 /*
635 * If a referral during the mail_open above causes a stream
636 * re-use which involves a BYE on an IMAP stream, then that
637 * BYE will have caused an mm_notify which will have
638 * instantiated the sp_data and set dead_stream! Trust that
639 * it is alive up to here and reset it to zero.
640 */
643 flags = SP_LOCKED
653 /* initialize the reference count */
661 flags = SP_LOCKED
670 }
673 /*
674 * When opening a newsgroup, c-client marks the messages up to the
675 * last Deleted as Unseen. If the feature news-approximates-new-status
676 * is on, we'd rather they be treated as Seen. That way, selecting New
677 * messages will give us the ones past the last Deleted. So we're going
678 * to change them to Seen. Since Seen is a session flag for news, making
679 * this change won't have any permanent effect. C-client also marks the
680 * messages after the last deleted Recent, which is the bit of
681 * information we'll use to find the messages we want to change.
682 */
689 /*
690 * Search for !recent messages to set the searched bit for
691 * those messages we want to change. Then we'll flip the bits.
692 */
698 else
706 }
707 }
708 }
711 }
714 void
716 {
739 /*
740 * Get rid of zooming and selections, but leave filtering flags. All the
741 * flag counts and everything should still be correct because set_lflag
742 * preserves them correctly.
743 */
749 }
751 /*
752 * We could try to set up a default sort order, but the caller is going
753 * to re-sort anyway if they are interested in sorting. So we won't do
754 * it here.
755 */
756 }
759 /*
760 * We have to be careful when we change the flags of an already
761 * open stream, because there may be more than one section of
762 * code actively using the stream.
763 * We allow turning on (but not off) SP_LOCKED
764 * SP_PERMLOCKED
765 * SP_USERFLDR
766 * SP_INBOX
767 * We allow turning off (but not on) SP_TEMPUSE
768 */
769 void
771 {
773 /* allow turning on but not off */
787 /* allow turning off but not on */
792 /* leave the way they already are */
799 }
800 }
803 /*
804 * Pine wrapper around mail_create. If we have the PREFER_ALT_AUTH flag turned
805 * on we don't want to pass a NULL stream to c-client because it will open
806 * a non-ssl connection when we want it to be ssl.
807 */
808 long
810 {
826 }
828 /*
829 * We don't really need this anymore, since we are now using IMAPTRYALT.
830 * We'll leave it since it works.
831 */
840 }
841 }
849 /*
850 * It is only useful to open a stream in the imap case.
851 */
857 }
858 }
866 }
869 /*
870 * Pine wrapper around mail_delete.
871 */
872 long
874 {
890 }
892 /*
893 * We don't really need this anymore, since we are now using IMAPTRYALT.
894 */
903 }
904 }
906 /* oops, we seem to be deleting a selected stream */
910 }
916 /*
917 * It is only useful to open a stream in the imap case.
918 */
924 }
925 }
933 }
936 /*
937 * Pine wrapper around mail_append.
938 */
939 long
940 pine_mail_append_full(MAILSTREAM *stream, char *mailbox, char *flags, char *date, STRING *message)
941 {
954 /* strip delimiter, it has no meaning in an APPEND and could cause trouble */
963 }
964 }
971 }
973 /*
974 * We don't really need this anymore, since we are now using IMAPTRYALT.
975 */
984 }
985 }
993 /*
994 * It is only useful to open a stream in the imap case.
995 */
1001 }
1002 }
1010 }
1013 /*
1014 * Pine wrapper around mail_append.
1015 */
1016 long
1019 {
1036 }
1046 }
1047 }
1049 /*
1050 * We have to be careful re-using streams for multiappend, because of
1051 * the way it works. We call into c-client below but part of the call
1052 * is data containing a callback function to us to supply the data to
1053 * be appended. That function may need to get the data from the server.
1054 * If that uses the same stream as we're trying to append on, we're
1055 * in trouble. We can't call back into c-client from c-client on the same
1056 * stream. (Just think about it, we're in the middle of an APPEND command.
1057 * We can't issue a FETCH before the APPEND completes in order to complete
1058 * the APPEND.) We can re-use a stream if it is a different stream from
1059 * the one we are reading from, so that's what the not_this_stream
1060 * stuff is for. If we mark it !SP_USEPOOL, it won't get reused.
1061 */
1063 we_blocked_reuse++;
1065 }
1073 /*
1074 * It is only useful to open a stream in the imap case.
1075 */
1081 }
1082 }
1093 }
1096 /*
1097 * Pine wrapper around mail_copy.
1098 */
1099 long
1101 {
1114 /* strip delimiter, it has no meaning in a COPY and could cause trouble */
1123 }
1124 }
1131 }
1133 /*
1134 * We don't really need this anymore, since we are now using IMAPTRYALT.
1135 */
1144 }
1145 }
1153 /*
1154 * It is only useful to open a stream in the imap case.
1155 * Actually, mail_copy_full is the case where it might also be
1156 * useful to provide a stream in the nntp and pop3 cases. If we
1157 * cache such streams, then we will probably want to open one
1158 * here so that it gets cached.
1159 */
1165 }
1166 }
1174 }
1177 /*
1178 * Pine wrapper around mail_rename.
1179 */
1180 long
1182 {
1191 /*
1192 * We don't really need this anymore, since we are now using IMAPTRYALT.
1193 */
1202 }
1203 }
1205 /* oops, we seem to be renaming a selected stream */
1209 }
1215 /*
1216 * It is only useful to open a stream in the imap case.
1217 */
1223 }
1224 }
1232 }
1235 /*----------------------------------------------------------------------
1236 Our mail_close wrapper to clean up anything on the mailstream we may have
1237 added to it. mostly in the unused bits of the elt's.
1238 ----*/
1239 void
1241 {
1257 /*
1258 * Instead of checkpointing here, which takes time that the user
1259 * definitely notices, we checkpoint in new_mail at the next
1260 * opportune time, hopefully when the user is idle.
1261 */
1262 #if 0
1270 }
1271 }
1272 #endif
1274 /*
1275 * Uid_last is valid when we first open a stream, but not always
1276 * valid after that. So if we know the last uid should be higher
1277 * than uid_last (!#%) use that instead.
1278 */
1287 /*
1288 * If the reference count is down to 0, unlock it.
1289 * In any case, don't actually do any real closing.
1290 */
1302 /*
1303 * Logically, we ought to be unflagging SP_INBOX, too. However,
1304 * the filtering code uses SP_INBOX when deciding if it should
1305 * filter some things, and we keep filtering after the mailbox
1306 * is closed. So leave SP_INBOX alone. This (the closing of INBOX)
1307 * usually only happens in goodnight_gracey when we're
1308 * shutting everything down.
1309 */
1311 }
1314 refcnt));
1315 }
1316 }
1324 /*
1325 * If the reference count is down to 0, unlock it.
1326 * In any case, don't actually do any real closing.
1327 */
1334 }
1337 refcnt));
1338 }
1340 }
1341 }
1344 void
1346 {
1365 /*
1366 * let sp_free_callback() free the sp_s stuff and the callbacks to
1367 * free_pine_elt free the per-elt pine stuff.
1368 */
1370 }
1371 }
1374 /*
1375 * If we haven't used a stream for a while, we may want to logout.
1376 */
1377 void
1379 {
1380 #define KILL_IF_IDLE_TIME (25 * 60)
1392 /*
1393 * Another thing we could do here instead is to unselect the
1394 * mailbox, leaving the stream open to the server.
1395 */
1397 }
1398 }
1401 /*
1402 * Catch searches that don't need to go to the server.
1403 * (Not anymore, now c-client does this for us.)
1404 */
1405 long
1408 {
1409 /*
1410 * The charset should either be UTF-8 or NULL for alpine.
1411 * If it is UTF-8 we may be able to change it to NULL if
1412 * everything in the search is actually ascii. We try to
1413 * do this because not all servers understand the CHARSET
1414 * parameter.
1415 */
1424 }
1427 int
1429 {
1464 }
1467 int
1469 {
1475 }
1478 int
1480 {
1488 }
1491 int
1493 {
1503 }
1506 void
1508 {
1512 }
1515 ENVELOPE *
1517 {
1526 }
1529 ENVELOPE *
1532 {
1541 }
1544 ENVELOPE *
1545 pine_mail_fetchstructure(MAILSTREAM *stream, long unsigned int msgno, struct mail_bodystruct **body)
1546 {
1555 }
1558 /*
1559 * Wrapper around mail_fetch_body.
1560 * Currently only used to turn on partial fetching if trying
1561 * to work around the microsoft ssl bug.
1562 */
1566 {
1567 #ifdef _WINDOWS
1571 else
1572 #endif
1574 }
1576 /*
1577 * Wrapper around mail_fetch_text.
1578 * Currently the only purpose this wrapper serves is to turn
1579 * on partial fetching for quell-ssl-largeblocks.
1580 */
1584 {
1585 #ifdef _WINDOWS
1590 else
1591 #endif
1593 }
1596 /*
1597 * Determine whether to do partial-fetching or not, and do it
1598 * args - same as c-client functions being wrapped around
1599 * get_n_bytes - try to partial fetch for the first n bytes.
1600 * makes no guarantees, might wind up fetching
1601 * the entire text anyway.
1602 * str_to_free - pointer to string to free if we only get
1603 * (non-cachable) partial text (required for
1604 * get_n_bytes).
1605 * is_text_fetch -
1606 * set, tells us to do mail_fetch_text and mail_partial_text
1607 * unset, tells us to do mail_fetch_body and mail_partial_body
1608 */
1614 {
1620 SIZEDTEXT new_text;
1631 #ifdef _WINDOWS
1633 #else
1638 else
1651 /*
1652 * imap_cache, originally intended for c-client internal use,
1653 * takes a section argument that is different from one we
1654 * would pass to mail_body. Typically in this function
1655 * section is NULL, which translates to "TEXT", but in other
1656 * cases we would want to append ".TEXT" to the section
1657 */
1662 else
1667 #ifdef _WINDOWS
1670 #else
1678 }
1682 }
1685 #ifdef _WINDOWS
1689 AVOID_MICROSOFT_SSL_CHUNKING_BUG);
1690 else
1692 }
1693 else
1704 /* start fetching */
1711 }
1727 /*
1728 * don't write to cache if we're only dealing with
1729 * partial text.
1730 */
1733 else
1735 }
1737 /* ugh, rewrite string in case it got stomped on last call */
1742 else
1747 }
1757 }
1758 else
1760 }
1761 else
1763 }
1765 /*
1766 * c-client callback that handles getting the text
1767 */
1770 {
1783 }
1786 /*
1787 * Pings the stream. Returns 0 if the stream is dead, non-zero otherwise.
1788 */
1789 long
1791 {
1799 }
1805 }
1808 }
1811 void
1813 {
1816 }
1819 /*
1820 * Unlike mail_list, this version returns a value. The returned value is
1821 * TRUE if the stream is opened ok, and FALSE if we failed opening the
1822 * stream. This allows us to differentiate between a LIST which returns
1823 * no matches and a failure opening the stream. We do this by pre-opening
1824 * the stream ourselves.
1825 */
1826 int
1828 {
1840 ||
1851 }
1854 we_open++;
1858 }
1859 else
1861 }
1873 /*
1874 * POP is a special case. We don't need to have a stream
1875 * to call mail_list for a POP name. The else part is the
1876 * POP part.
1877 */
1884 }
1885 else
1887 }
1890 }
1891 else
1898 }
1901 /*
1902 * mail_list_internal -- A monument to software religion and those who
1903 * would force it upon us.
1904 */
1905 void
1907 {
1916 }
1917 else
1919 }
1922 long
1924 {
1926 }
1929 long
1932 {
1942 /* tell mm_status() to write partial return here */
1947 /* do status of destination */
1951 /* should never be news, don't worry about mulnewrsc flag*/
1953 uidnext))
1956 /* do status of source */
1972 }
1978 }
1984 /*
1985 * If the target has recent messages, then we don't come
1986 * through here. We just use the answer from the target.
1987 *
1988 * If not, then we leave the target results in "status" and
1989 * run a mail_status on the source that puts its results
1990 * in "cache". Combine the results from cache with the
1991 * results that were already in status.
1992 *
1993 * We count all messages in the source mailbox as recent and
1994 * unseen, even if they are not recent or unseen in the source,
1995 * because they will be recent and unseen in the target
1996 * when we open it. (Not quite true. It is possible that some
1997 * messages from a POP server will end up seen instead
1998 * of unseen.
1999 * It is also possible that it is correct. If we add unseen, or
2000 * if we add messages, we could get it wrong. As far as I
2001 * can tell, Pine doesn't ever even use status.unseen, so it
2002 * is currently academic anyway.) Hubert 2003-03-05
2003 * (Does now 2004-06-02 in next_folder.)
2004 *
2005 * However, we don't want to count all messages as recent if
2006 * the source mailbox is NNTP or NEWS, because we won't be
2007 * deleting those messages from the source.
2008 * We only count recent.
2009 *
2010 * There are other cases that are trouble. One in particular
2011 * is an IMAP-to-NNTP proxy, where the messages can't be removed
2012 * from the mailbox but they can be deleted. If we count
2013 * messages in the source as being recent and it turns out they
2014 * were all deleted already, then we incorrectly say the folder
2015 * has recent messages when it doesn't. We can recover from that
2016 * case at some cost by actually opening the folder the first
2017 * time if there are not recents, and then checking to see if
2018 * everything is deleted. Subsequently, we store the uid values
2019 * (which are returned by status) so that we can know if the
2020 * mailbox changed or not. The problem being solved is that
2021 * the TAB command indicates new messages in a folder when there
2022 * really aren't any. An alternative would be to use the is_news
2023 * half of the if-else in all cases. A problem with that is
2024 * that there could be non-recent messages sitting in the
2025 * source mailbox that we never discover. Hubert 2003-03-28
2026 */
2030 is_news++;
2037 }
2046 }
2052 }
2057 /* Actually open it up and check */
2068 }
2072 NULL);
2074 }
2079 }
2085 }
2092 }
2093 }
2094 }
2096 /*
2097 * Do the regular mm_status callback which we've been intercepting
2098 * into different locations above.
2099 */
2103 }
2115 /*
2116 * We just use this to find the answer.
2117 * We're asking for trouble if we do a STATUS on a
2118 * selected mailbox. I don't believe this happens in pine.
2119 * It does now (2004-06-02) in next_folder if the
2120 * F_TAB_USES_UNSEEN option is set and the folder was
2121 * already opened.
2122 */
2129 }
2134 }
2151 }
2156 }
2161 }
2165 }
2173 }
2174 }
2179 }
2183 }
2189 }
2192 /*
2193 * Check for a mailbox name that is a legitimate #move mailbox.
2194 *
2195 * Args mbox -- The mailbox name to check
2196 * sourcebuf -- Copy the source mailbox name into this buffer
2197 * sbuflen -- Length of sourcebuf
2198 * targetptr -- Set the pointer this points to to point to the
2199 * target mailbox name in the original string
2200 *
2201 * Returns 1 - is a #move mailbox
2202 * 0 - not
2203 */
2204 int
2206 {
2223 }
2229 }
2232 }
2235 /*
2236 * Checks through stream cache for a stream pointer already open to
2237 * this mailbox, read/write. Very similar to sp_stream_get, but we want
2238 * to look at all streams, not just imap streams.
2239 * Right now it is very specialized. If we want to use it more generally,
2240 * generalize it or combine it with sp_stream_get somehow.
2241 */
2242 MAILSTREAM *
2244 {
2258 }
2259 }
2272 }
2273 }
2276 }
2279 void
2281 {
2296 }
2297 }
2300 /*
2301 * Tells us whether we ought to check for a dead stream or not.
2302 * We assume that we ought to check if it is not IMAP and if it is IMAP we
2303 * don't need to check if the last activity was within the last 5 minutes.
2304 */
2305 int
2307 {
2311 else
2313 }
2315 void
2317 {
2327 }
2328 }
2331 /*
2332 * Returns 0 if stream flags not set, non-zero if they are.
2333 */
2334 int
2336 {
2338 }
2341 void
2343 {
2353 }
2354 }
2357 void
2359 {
2369 }
2370 }
2373 /*
2374 * Sets flags absolutely, erasing old flags.
2375 */
2376 void
2378 {
2384 flags,
2395 }
2398 /*
2399 * Clear individual stream flags.
2400 */
2401 void
2403 {
2409 flags,
2422 flags,
2429 }
2432 /*
2433 * Set dead stream indicator and close if not locked.
2434 */
2435 void
2437 {
2444 /*
2445 * If the stream isn't locked, it is no longer useful. Get rid of it.
2446 */
2450 /*
2451 * If it is locked, then we have to worry about references to it
2452 * that still exist. For example, it might be a permlocked stream
2453 * or it might be the current stream. We need to let it be discovered
2454 * by those referencers instead of just eliminating it, so that they
2455 * can clean up the mess they need to clean up.
2456 */
2458 }
2459 }
2462 /*
2463 * Returns the number of streams in the stream pool which are
2464 * SP_USEPOOL but not SP_PERMLOCKED.
2465 */
2466 int
2468 {
2475 cnt++;
2476 }
2479 }
2482 /*
2483 * Returns the number of folders that the user has marked to be PERMLOCKED
2484 * folders (plus INBOX) that are remote IMAP folders.
2485 *
2486 * This routine depends on the fact that VAR_INBOX_PATH, VAR_PERMLOCKED,
2487 * and the ps_global->context_list are correctly set.
2488 */
2489 int
2491 {
2496 /* first check if INBOX is remote */
2500 cnt++;
2502 /* then count the user-specified permlocked folders */
2504 lock_these++){
2506 /*
2507 * Skip inbox, already done above. Should do this better so that we
2508 * catch the case where the user puts the technical spec of the inbox
2509 * in the list, or where the user lists one folder twice.
2510 */
2514 /* there isn't really a pair, it just dequotes for us */
2517 /*
2518 * Check to see if this is an incoming nickname and replace it
2519 * with the full name.
2520 */
2524 FN_WHOLE_NAME))))
2532 cnt++;
2536 }
2539 }
2542 /*
2543 * Look for an already open stream that can be used for a new purpose.
2544 * (Note that we only look through streams flagged SP_USEPOOL.)
2545 *
2546 * Args: mailbox
2547 * flags
2548 *
2549 * Flags is a set of values or'd together which tells us what the request
2550 * is looking for.
2551 *
2552 * Returns: a live stream from the stream pool or NULL.
2553 */
2554 MAILSTREAM *
2556 {
2568 /* look for stream already open to this mailbox */
2585 }
2588 }
2591 }
2592 }
2593 }
2595 /*
2596 * SP_SAME will not match if an SP_MATCH match would have worked.
2597 * If the caller is interested in SP_MATCH streams as well as SP_SAME
2598 * streams then the caller should make two separate calls to this
2599 * routine.
2600 */
2602 /*
2603 * If the flags arg does not have either SP_TEMPUSE or SP_UNLOCKED
2604 * set, then we'll accept any stream, even if locked.
2605 * We want to prefer the LOCKED case so that we don't have to ping.
2606 */
2618 }
2621 }
2622 }
2624 /* consider the unlocked streams */
2631 /* always ping unlocked streams */
2642 }
2645 }
2646 }
2647 }
2649 /*
2650 * Prefer streams marked SP_TEMPUSE and not LOCKED.
2651 * If SP_TEMPUSE is set in the flags arg then this is the
2652 * only loop we try.
2653 */
2669 }
2672 }
2673 }
2675 /*
2676 * If SP_TEMPUSE is not set in the flags arg but SP_UNLOCKED is,
2677 * then we will consider
2678 * streams which are not marked SP_TEMPUSE (but are still not
2679 * locked). We go through these in reverse order so that we'll get
2680 * the last one added instead of the first one. It's not clear if
2681 * that is a good idea or if a more complex search would somehow
2682 * be better. Maybe we should use a round-robin sort of search
2683 * here so that we don't leave behind unused streams. Or maybe
2684 * we should keep track of when we used it and look for the LRU stream.
2685 */
2702 }
2705 }
2706 }
2707 }
2708 }
2710 /*
2711 * If we can't find a useful stream to use in pine_mail_open, we may
2712 * want to re-use one that is not actively being used even though it
2713 * is not on the same server. We'll have to close it and then re-use
2714 * the slot.
2715 */
2717 /*
2718 * Prefer streams marked SP_TEMPUSE and not LOCKED.
2719 * If SP_TEMPUSE is set in the flags arg then this is the
2720 * only loop we try.
2721 */
2728 /*
2729 * We ping it in case there is new mail that we should
2730 * pass through our filters. Pine_mail_actually_close will
2731 * do that.
2732 */
2735 }
2736 }
2738 /*
2739 * If SP_TEMPUSE is not set in the flags arg, then we will consider
2740 * streams which are not marked SP_TEMPUSE (but are still not
2741 * locked). Maybe we should use a round-robin sort of search
2742 * here so that we don't leave behind unused streams. Or maybe
2743 * we should keep track of when we used it and look for the LRU stream.
2744 */
2751 /*
2752 * We ping it in case there is new mail that we should
2753 * pass through our filters. Pine_mail_actually_close will
2754 * do that.
2755 */
2758 }
2759 }
2760 }
2761 }
2766 }
2769 void
2771 {
2781 }
2787 }
2790 /*
2791 * Find a vacant slot to put this new stream in.
2792 * We are willing to close and kick out another stream as long as it isn't
2793 * LOCKED. However, we may find that there is no place to put this one
2794 * because all the slots are used and locked. For now, we'll return -1
2795 * in that case and leave the new stream out of the pool.
2796 */
2797 int
2799 {
2809 }
2811 /* If this stream is already there, don't add it again */
2819 }
2820 }
2828 }
2830 /* Look for an unused slot */
2838 }
2839 }
2841 /* else, allocate more space */
2850 }
2858 }
2862 }
2867 }
2871 }
2872 }
2875 /*
2876 * Simply remove this stream from the stream pool.
2877 */
2878 void
2880 {
2890 /*
2891 * There are some global stream pointers that we have to worry
2892 * about before deleting the stream.
2893 */
2895 /* first, mail_stream is the global currently open folder */
2899 /* remote address books may have open stream pointers */
2912 }
2913 }
2914 }
2917 /*
2918 * Returns 1 if any locked userfldr is dead, 0 if all alive.
2919 */
2920 int
2922 {
2930 ret++;
2931 }
2934 }
2937 /*
2938 * Returns 1 if any locked stream is changed, 0 otherwise
2939 */
2940 int
2942 {
2950 ret++;
2951 }
2954 }
2957 /*
2958 * Returns the inbox stream or NULL.
2959 */
2960 MAILSTREAM *
2962 {
2970 }
2973 }
2976 /*
2977 * Make sure that the sp_data per-stream data storage area exists.
2978 *
2979 * Returns a handle to the sp_data data unless stream is NULL,
2980 * in which case NULL is returned
2981 */
2982 PER_STREAM_S **
2984 {
2992 }
2993 }
2996 }
2999 /*
3000 * Returns a pointer to the msgmap associated with the argument stream.
3001 *
3002 * If the PER_STREAM_S data or the msgmap does not already exist, it will be
3003 * created.
3004 */
3005 MSGNO_S *
3007 {
3018 }
3021 void
3023 {
3031 /*
3032 * It is possible that this has been called from c-client when
3033 * we weren't expecting it. We need to clean up the stream pool
3034 * entries if the stream that goes with this pointer is in the
3035 * stream pool somewhere.
3036 */
3041 }
3048 }
3051 }
3052 }
3055 /*
3056 * Free the data but don't mess with the stream pool.
3057 */
3058 void
3060 {
3067 }
3073 }
3074 }
3078 /*----------------------------------------------------------------------
3079 See if stream can be used for a mailbox name
3081 Accepts: mailbox name
3082 candidate stream
3083 Returns: stream if it can be used, else NIL
3085 This is called to weed out unnecessary use of c-client streams. In other
3086 words, to help facilitate re-use of streams.
3088 This code is very similar to the same_remote_mailboxes code below, which
3089 is used in pine_mail_open. That code compares two mailbox names. One is
3090 usually from the config file and the other is either from the config file
3091 or is typed in. Here and in same_stream_and_mailbox below, we're comparing
3092 an open stream to a name instead of two names. We could conceivably use
3093 same_remote_mailboxes to compare stream->mailbox to name, but it isn't
3094 exactly the same and the differences may be important. Some stuff that
3095 happens here seems wrong, but it isn't easy to fix.
3096 Having !mb_n.port count as a match to any mb_s.port isn't right. It should
3097 only match if mb_s.port is equal to the default, but the default isn't
3098 something that is available to us. The same thing is done in c-client in
3099 the mail_usable_network_stream() routine, and it isn't right there, either.
3100 The semantics of a missing user are also suspect, because just like with
3101 port, a default is used.
3102 ----*/
3103 MAILSTREAM *
3105 {
3120 ||
3125 ||
3129 ||
3132 && (struncmp(mb_n.service, "imap", 4) ? 1 : strcmp(imap_host(stream), ".NO-IMAP-CONNECTION."))){
3137 }
3143 }
3147 /*----------------------------------------------------------------------
3148 See if this stream has the named mailbox selected.
3150 Accepts: mailbox name
3151 candidate stream
3152 Returns: stream if it can be used, else NIL
3153 ----*/
3154 MAILSTREAM *
3156 {
3171 }
3178 }
3180 /*
3181 * Args -- name1 and name2 are remote mailbox names.
3182 *
3183 * Returns -- True if names refer to same mailbox accessed in same way
3184 * False if not
3185 *
3186 * This has some very similar code to same_stream_and_mailbox but we're not
3187 * quite ready to discard the differences.
3188 * The treatment of the port and the user is not quite the same.
3189 */
3190 int
3192 {
3196 /*
3197 * Probably we should allow !port equal to default port, but we don't
3198 * know how to get the default port. To match what c-client does we
3199 * allow !port to be equal to anything.
3200 */
3217 ||
3219 ||
3223 ||
3227 ||
3231 ||
3235 }
3238 int
3240 {
3243 }
3246 int
3248 {
3250 }
3253 /*----------------------------------------------------------------------
3254 Check and see if all the stream are alive
3256 Returns: 0 if there was no change
3257 >0 if streams have died since last call
3259 Also outputs a message that the streams have died
3260 ----*/
3261 int
3263 {
3274 rv++;
3282 folder));
3289 }
3291 }
3292 }
3297 /*
3298 * If a cached stream died and then we tried to use it
3299 * it could cause problems. We could warn about it here
3300 * but it may be confusing because it might be
3301 * unrelated to what the user is doing and not cause
3302 * any problem at all.
3303 */
3304 #if 0
3308 #endif
3311 folder));
3312 }
3315 }
3316 }
3317 }
3320 }
3323 /* Some stream is locked checks to see if there is any stream for which we
3324 * are in a callback from c-client
3325 */
3327 int
3329 {
3336 rv++;
3337 }
3340 }
3342 /*
3343 * Very simple version of appenduid_cb until we need something
3344 * more complex.
3345 */
3349 void
3351 {
3353 }
3356 imapuid_t
3358 {
3360 }
3363 /*
3364 * mail_cmd_stream - return a stream suitable for mail_lsub,
3365 * mail_subscribe, and mail_unsubscribe
3366 *
3367 */
3368 MAILSTREAM *
3370 {
3378 NULL));
3379 }
3382 /*
3383 * This is so we can replace the old rfc822_ routines like rfc822_header_line
3384 * with the new version that checks bounds, like rfc822_output_header_line.
3385 * This routine is called when would be a bounds overflow, which we simply log
3386 * and go on with the truncated data.
3387 */
3388 long
3390 {
3393 }