| blob | 16dfedd0cc413fc6d2104912e04259da2d7dfd2e |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2013-2021 Eduardo Chappa
8 * Copyright 2006-2008 University of Washington
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * ========================================================================
17 */
19 /*======================================================================
20 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 usable, 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 {
1912 /* MAILTMPLEN = sizeof(tmp)/2 */
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 {
2301 }
2302 }
2305 /*
2306 * Tells us whether we ought to check for a dead stream or not.
2307 * We assume that we ought to check if it is not IMAP and if it is IMAP we
2308 * don't need to check if the last activity was within the last 5 minutes.
2309 */
2310 int
2312 {
2316 else
2318 }
2320 void
2322 {
2332 }
2333 }
2336 /*
2337 * Returns 0 if stream flags not set, non-zero if they are.
2338 */
2339 int
2341 {
2343 }
2346 void
2348 {
2358 }
2359 }
2362 void
2364 {
2374 }
2375 }
2378 /*
2379 * Sets flags absolutely, erasing old flags.
2380 */
2381 void
2383 {
2389 flags,
2400 }
2403 /*
2404 * Clear individual stream flags.
2405 */
2406 void
2408 {
2414 flags,
2427 flags,
2434 }
2437 /*
2438 * Set dead stream indicator and close if not locked.
2439 */
2440 void
2442 {
2449 /*
2450 * If the stream isn't locked, it is no longer useful. Get rid of it.
2451 */
2455 /*
2456 * If it is locked, then we have to worry about references to it
2457 * that still exist. For example, it might be a permlocked stream
2458 * or it might be the current stream. We need to let it be discovered
2459 * by those referencers instead of just eliminating it, so that they
2460 * can clean up the mess they need to clean up.
2461 */
2463 }
2464 }
2467 /*
2468 * Returns the number of streams in the stream pool which are
2469 * SP_USEPOOL but not SP_PERMLOCKED.
2470 */
2471 int
2473 {
2480 cnt++;
2481 }
2484 }
2487 /*
2488 * Returns the number of folders that the user has marked to be PERMLOCKED
2489 * folders (plus INBOX) that are remote IMAP folders.
2490 *
2491 * This routine depends on the fact that VAR_INBOX_PATH, VAR_PERMLOCKED,
2492 * and the ps_global->context_list are correctly set.
2493 */
2494 int
2496 {
2501 /* first check if INBOX is remote */
2505 cnt++;
2507 /* then count the user-specified permlocked folders */
2509 lock_these++){
2511 /*
2512 * Skip inbox, already done above. Should do this better so that we
2513 * catch the case where the user puts the technical spec of the inbox
2514 * in the list, or where the user lists one folder twice.
2515 */
2519 /* there isn't really a pair, it just dequotes for us */
2522 /*
2523 * Check to see if this is an incoming nickname and replace it
2524 * with the full name.
2525 */
2529 FN_WHOLE_NAME))))
2537 cnt++;
2541 }
2544 }
2547 /*
2548 * Look for an already open stream that can be used for a new purpose.
2549 * (Note that we only look through streams flagged SP_USEPOOL.)
2550 *
2551 * Args: mailbox
2552 * flags
2553 *
2554 * Flags is a set of values or'd together which tells us what the request
2555 * is looking for.
2556 *
2557 * Returns: a live stream from the stream pool or NULL.
2558 */
2559 MAILSTREAM *
2561 {
2573 /* look for stream already open to this mailbox */
2590 }
2593 }
2596 }
2597 }
2598 }
2600 /*
2601 * SP_SAME will not match if an SP_MATCH match would have worked.
2602 * If the caller is interested in SP_MATCH streams as well as SP_SAME
2603 * streams then the caller should make two separate calls to this
2604 * routine.
2605 */
2607 /*
2608 * If the flags arg does not have either SP_TEMPUSE or SP_UNLOCKED
2609 * set, then we'll accept any stream, even if locked.
2610 * We want to prefer the LOCKED case so that we don't have to ping.
2611 */
2623 }
2626 }
2627 }
2629 /* consider the unlocked streams */
2636 /* always ping unlocked streams */
2647 }
2650 }
2651 }
2652 }
2654 /*
2655 * Prefer streams marked SP_TEMPUSE and not LOCKED.
2656 * If SP_TEMPUSE is set in the flags arg then this is the
2657 * only loop we try.
2658 */
2674 }
2677 }
2678 }
2680 /*
2681 * If SP_TEMPUSE is not set in the flags arg but SP_UNLOCKED is,
2682 * then we will consider
2683 * streams which are not marked SP_TEMPUSE (but are still not
2684 * locked). We go through these in reverse order so that we'll get
2685 * the last one added instead of the first one. It's not clear if
2686 * that is a good idea or if a more complex search would somehow
2687 * be better. Maybe we should use a round-robin sort of search
2688 * here so that we don't leave behind unused streams. Or maybe
2689 * we should keep track of when we used it and look for the LRU stream.
2690 */
2707 }
2710 }
2711 }
2712 }
2713 }
2715 /*
2716 * If we can't find a useful stream to use in pine_mail_open, we may
2717 * want to re-use one that is not actively being used even though it
2718 * is not on the same server. We'll have to close it and then re-use
2719 * the slot.
2720 */
2722 /*
2723 * Prefer streams marked SP_TEMPUSE and not LOCKED.
2724 * If SP_TEMPUSE is set in the flags arg then this is the
2725 * only loop we try.
2726 */
2733 /*
2734 * We ping it in case there is new mail that we should
2735 * pass through our filters. Pine_mail_actually_close will
2736 * do that.
2737 */
2740 }
2741 }
2743 /*
2744 * If SP_TEMPUSE is not set in the flags arg, then we will consider
2745 * streams which are not marked SP_TEMPUSE (but are still not
2746 * locked). Maybe we should use a round-robin sort of search
2747 * here so that we don't leave behind unused streams. Or maybe
2748 * we should keep track of when we used it and look for the LRU stream.
2749 */
2756 /*
2757 * We ping it in case there is new mail that we should
2758 * pass through our filters. Pine_mail_actually_close will
2759 * do that.
2760 */
2763 }
2764 }
2765 }
2766 }
2771 }
2774 void
2776 {
2786 }
2792 }
2795 /*
2796 * Find a vacant slot to put this new stream in.
2797 * We are willing to close and kick out another stream as long as it isn't
2798 * LOCKED. However, we may find that there is no place to put this one
2799 * because all the slots are used and locked. For now, we'll return -1
2800 * in that case and leave the new stream out of the pool.
2801 */
2802 int
2804 {
2814 }
2816 /* If this stream is already there, don't add it again */
2824 }
2825 }
2833 }
2835 /* Look for an unused slot */
2843 }
2844 }
2846 /* else, allocate more space */
2855 }
2863 }
2867 }
2872 }
2876 }
2877 }
2880 /*
2881 * Simply remove this stream from the stream pool.
2882 */
2883 void
2885 {
2895 /*
2896 * There are some global stream pointers that we have to worry
2897 * about before deleting the stream.
2898 */
2900 /* first, mail_stream is the global currently open folder */
2904 /* remote address books may have open stream pointers */
2917 }
2918 }
2919 }
2922 /*
2923 * Returns 1 if any locked userfldr is dead, 0 if all alive.
2924 */
2925 int
2927 {
2935 ret++;
2936 }
2939 }
2942 /*
2943 * Returns 1 if any locked stream is changed, 0 otherwise
2944 */
2945 int
2947 {
2955 ret++;
2956 }
2959 }
2962 /*
2963 * Returns the inbox stream or NULL.
2964 */
2965 MAILSTREAM *
2967 {
2975 }
2978 }
2981 /*
2982 * Make sure that the sp_data per-stream data storage area exists.
2983 *
2984 * Returns a handle to the sp_data data unless stream is NULL,
2985 * in which case NULL is returned
2986 */
2987 PER_STREAM_S **
2989 {
2997 }
2998 }
3001 }
3004 /*
3005 * Returns a pointer to the msgmap associated with the argument stream.
3006 *
3007 * If the PER_STREAM_S data or the msgmap does not already exist, it will be
3008 * created.
3009 */
3010 MSGNO_S *
3012 {
3023 }
3026 void
3028 {
3036 /*
3037 * It is possible that this has been called from c-client when
3038 * we weren't expecting it. We need to clean up the stream pool
3039 * entries if the stream that goes with this pointer is in the
3040 * stream pool somewhere.
3041 */
3046 }
3053 }
3056 }
3057 }
3060 /*
3061 * Free the data but don't mess with the stream pool.
3062 */
3063 void
3065 {
3072 }
3078 }
3079 }
3083 /*----------------------------------------------------------------------
3084 See if stream can be used for a mailbox name
3086 Accepts: mailbox name
3087 candidate stream
3088 Returns: stream if it can be used, else NIL
3090 This is called to weed out unnecessary use of c-client streams. In other
3091 words, to help facilitate re-use of streams.
3093 This code is very similar to the same_remote_mailboxes code below, which
3094 is used in pine_mail_open. That code compares two mailbox names. One is
3095 usually from the config file and the other is either from the config file
3096 or is typed in. Here and in same_stream_and_mailbox below, we're comparing
3097 an open stream to a name instead of two names. We could conceivably use
3098 same_remote_mailboxes to compare stream->mailbox to name, but it isn't
3099 exactly the same and the differences may be important. Some stuff that
3100 happens here seems wrong, but it isn't easy to fix.
3101 Having !mb_n.port count as a match to any mb_s.port isn't right. It should
3102 only match if mb_s.port is equal to the default, but the default isn't
3103 something that is available to us. The same thing is done in c-client in
3104 the mail_usable_network_stream() routine, and it isn't right there, either.
3105 The semantics of a missing user are also suspect, because just like with
3106 port, a default is used.
3107 ----*/
3108 MAILSTREAM *
3110 {
3125 ||
3130 ||
3134 ||
3137 && (struncmp(mb_n.service, "imap", 4) ? 1 : strcmp(imap_host(stream), ".NO-IMAP-CONNECTION."))){
3142 }
3148 }
3152 /*----------------------------------------------------------------------
3153 See if this stream has the named mailbox selected.
3155 Accepts: mailbox name
3156 candidate stream
3157 Returns: stream if it can be used, else NIL
3158 ----*/
3159 MAILSTREAM *
3161 {
3176 }
3183 }
3185 /*
3186 * Args -- name1 and name2 are remote mailbox names.
3187 *
3188 * Returns -- True if names refer to same mailbox accessed in same way
3189 * False if not
3190 *
3191 * This has some very similar code to same_stream_and_mailbox but we're not
3192 * quite ready to discard the differences.
3193 * The treatment of the port and the user is not quite the same.
3194 */
3195 int
3197 {
3201 /*
3202 * Probably we should allow !port equal to default port, but we don't
3203 * know how to get the default port. To match what c-client does we
3204 * allow !port to be equal to anything.
3205 */
3222 ||
3224 ||
3228 ||
3232 ||
3236 ||
3240 }
3243 int
3245 {
3248 }
3251 int
3253 {
3255 }
3258 /*----------------------------------------------------------------------
3259 Check and see if all the stream are alive
3261 Returns: 0 if there was no change
3262 >0 if streams have died since last call
3264 Also outputs a message that the streams have died
3265 ----*/
3266 int
3268 {
3279 rv++;
3287 folder));
3294 }
3296 }
3297 }
3302 /*
3303 * If a cached stream died and then we tried to use it
3304 * it could cause problems. We could warn about it here
3305 * but it may be confusing because it might be
3306 * unrelated to what the user is doing and not cause
3307 * any problem at all.
3308 */
3309 #if 0
3313 #endif
3316 folder));
3317 }
3320 }
3321 }
3322 }
3325 }
3328 /* Some stream is locked checks to see if there is any stream for which we
3329 * are in a callback from c-client
3330 */
3332 int
3334 {
3341 rv++;
3342 }
3345 }
3347 /*
3348 * Very simple version of appenduid_cb until we need something
3349 * more complex.
3350 */
3354 void
3356 {
3358 }
3361 imapuid_t
3363 {
3365 }
3368 /*
3369 * mail_cmd_stream - return a stream suitable for mail_lsub,
3370 * mail_subscribe, and mail_unsubscribe
3371 *
3372 */
3373 MAILSTREAM *
3375 {
3383 NULL));
3384 }
3387 /*
3388 * This is so we can replace the old rfc822_ routines like rfc822_header_line
3389 * with the new version that checks bounds, like rfc822_output_header_line.
3390 * This routine is called when would be a bounds overflow, which we simply log
3391 * and go on with the truncated data.
3392 */
3393 long
3395 {
3398 }