| blob | 301c303775677d6b1df534ee94d9a2d49bde2bf1 |
1 /*
2 * ========================================================================
3 * Copyright 2013-2022 Eduardo Chappa
4 * Copyright 2006-2008 University of Washington
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * ========================================================================
13 */
15 /*======================================================================
16 stream.c
17 Implements the Pine mail stream management routines
18 and c-client wrapper functions
19 ====*/
44 /*
45 * Internal prototypes
46 */
69 /*
70 * Pine wrapper around mail_open. If we have the PREFER_ALT_AUTH flag turned
71 * on, we need to set the TRYALT flag before trying the open.
72 * This routine manages the stream pool, too. It tries to re-use existing
73 * streams instead of opening new ones, or maybe it will leave one open and
74 * use a new one if that seems to make more sense. Pine_mail_close leaves
75 * streams open so that they may be re-used. Each pine_mail_open should have
76 * a matching pine_mail_close (or possible pine_mail_actually_close) somewhere
77 * that goes with it.
78 *
79 * Args:
80 * stream -- A possible stream for recycling. This isn't usually the
81 * way recycling happens. Usually it is automatic.
82 * mailbox -- The mailbox to be opened.
83 * openflags -- Flags passed here to modify the behavior.
84 * retflags -- Flags returned from here. SP_MATCH will be lit if that is
85 * what happened. If SP_MATCH is lit then SP_LOCKED may also
86 * be lit if the matched stream was already locked when
87 * we got here.
88 */
89 MAILSTREAM *
91 {
103 openflags,
121 }
126 /* inbox is still special, assume that we want to permlock it */
129 /* check to see if user wants this folder permlocked */
135 /* there isn't really a pair, it just dequotes for us */
138 /*
139 * Check to see if this is an incoming nickname and replace it
140 * with the full name.
141 */
152 ||
157 permlocked++;
161 }
163 /*
164 * Only cache if remote, not nntp, not pop, and caller asked us to.
165 * It might make sense to do some caching for nntp and pop, as well, but
166 * we aren't doing it right now. For example, an nntp stream open to
167 * one group could be reused for another group. An open pop stream could
168 * be used for mail_copy_full.
169 *
170 * An implication of doing only imap here is that sp_stream_get will only
171 * be concerned with imap streams.
172 */
176 }
179 dprint((9, "pine_mail_open: not cacheable: %s\n", !d ? "no driver?" : d->name ? d->name : "?" ));
180 }
183 /*
184 * This is a strange case. We want to allow stay-open local
185 * folders, but they don't fit into the rest of the framework
186 * well. So we'll look for it being already open in this case
187 * and special-case it (the already_open_stream() case
188 * below).
189 */
192 }
196 }
197 }
198 }
200 /* If driver doesn't support halfopen, just open it. */
205 }
207 /*
208 * Some of the flags are pine's, the rest are meant for mail_open.
209 * We've noted the pine flags, now remove them before we call mail_open.
210 */
214 #ifdef DEBUG
217 #endif
223 }
233 }
237 }
239 /*
240 * One of the problems is that the new-style stream caching (the
241 * sp_stream_get stuff) may conflict with some of the old-style caching
242 * (the passed in argument stream) that is still in the code. We should
243 * probably eliminate the old-style caching, but some of it is still useful,
244 * especially if it deals with something other than IMAP. We want to prevent
245 * mistakes caused by conflicts between the two styles. In particular, we
246 * don't want to have a new-style cached stream re-opened because of the
247 * old-style caching code. This can happen if a stream is passed in that
248 * is not usable, and then a new stream is opened because the passed in
249 * stream causes us to bypass the new caching code. Play it safe. If it
250 * is an IMAP stream, just close it. This should leave it in the new-style
251 * cache anyway, causing no loss. Maybe not if the cache wasn't large
252 * enough to have it in there in the first place, in which case we get
253 * a possibly unnecessary close and open. If it isn't IMAP we still have
254 * to worry about it because it will cause us to bypass the caching code.
255 * So if the stream isn't IMAP but the mailbox we're opening is, close it.
256 * The immediate alternative would be to try to emulate the code in
257 * mail_open that checks whether it is re-usable or not, but that is
258 * dangerous if that code changes on us.
259 */
268 }
273 }
277 }
278 }
280 /*
281 * Maildrops are special. The mailbox name will be a #move name. If the
282 * target of the maildrop is an IMAP folder we want to be sure it isn't
283 * already open in another cached stream, to avoid double opens. This
284 * could have happened if the user opened it manually as the target
285 * instead of as a maildrop. It could also be a side-effect of marking
286 * an answered flag after a reply.
287 */
297 }
298 }
299 }
306 else
310 flags = SP_LOCKED
317 /*
318 * If the stream wasn't already locked, then we reset it so it
319 * looks like we are reopening it. We have to worry about recent
320 * messages since they will still be recent, if that affects us.
321 */
329 }
338 }
344 }
356 }
359 }
360 }
363 /*
364 * First, we look for an exact match, a stream which is already
365 * open to the mailbox we are trying to re-open, and we use that.
366 * Skip permlocked only because we did it above already.
367 */
373 flags = SP_LOCKED
380 /*
381 * If the stream wasn't already locked, then we reset it so it
382 * looks like we are reopening it. We have to worry about recent
383 * messages since they will still be recent, if that affects us.
384 */
392 }
401 }
407 }
411 /*
412 * We may be re-using a stream that was previously open
413 * with OP_SILENT and now we don't want OP_SILENT.
414 * We don't turn !silent into silent because the !silentness
415 * could be important in the original context (for example,
416 * silent suppresses mm_expunged calls).
417 *
418 * WARNING: we're messing with c-client internals.
419 */
428 }
431 }
433 /*
434 * No exact match, look for a stream which is open to the same
435 * server and marked for TEMPUSE.
436 */
441 }
442 /*
443 * No SAME/TEMPUSE stream so we look to see if there is an
444 * open slot available (we're not yet at max_remstream). If there
445 * is an open slot, we'll just open a new stream and put it there.
446 * If not, we'll go inside this conditional.
447 */
452 /*
453 * No empty remote slots available. See if there is a
454 * TEMPUSE stream that is open but to the wrong server.
455 */
458 /*
459 * We will close this stream and use the empty slot
460 * that that creates.
461 */
466 }
469 /*
470 * Still no luck. Look for a stream open to the same
471 * server that is just not locked. This would be a
472 * stream that might be reusable in the future, but we
473 * need it now instead.
474 */
479 }
481 /*
482 * We'll take any UNLOCKED stream and re-use it.
483 */
486 /*
487 * We will close this stream and use the empty slot
488 * that that creates.
489 */
494 }
498 }
501 }
512 }
513 }
514 }
515 }
516 }
520 }
522 /*
523 * We'll make an assumption here. If we were asked to halfopen a
524 * stream then we'll assume that the caller doesn't really care if
525 * the stream is halfopen or if it happens to be open to some mailbox
526 * already. They are just saying halfopen because they don't need to
527 * SELECT a mailbox. That's the assumption, anyway.
528 */
540 }
546 }
548 /*
549 * We're going to SELECT another folder with this open stream.
550 */
552 /*
553 * We will have just pinged the stream to make sure it is
554 * still alive. That ping may have discovered some new mail.
555 * Before unselecting the folder, we should process the filters
556 * for that new mail.
557 */
569 }
571 /*
572 * We need to reset the counters and everything.
573 * The easiest way to do that is just to delete all of the
574 * sp_s data and let the open fill it in correctly for
575 * the new folder.
576 */
578 }
579 }
581 /*
582 * When we pass a stream to mail_open, it will either re-use it or
583 * close it.
584 */
589 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));
591 /*
592 * So it is easier to figure out which command goes with which
593 * stream when debugging, change the tag associated with each stream.
594 * Of course, this will come after the SELECT, so the startup IMAP
595 * commands will have confusing tags.
596 */
601 }
607 }
609 /*
610 * Catch the case where our test up above (where usepool was set)
611 * did not notice that this was news, but that we can tell once
612 * we've opened the stream. (One such case would be an imap proxy
613 * to an nntp server.) Remove it from being cached here. There was
614 * a possible penalty for not noticing sooner. If all the usepool
615 * slots were full, we will have closed one of the UNLOCKED streams
616 * above, preventing us from future re-use of that stream.
617 * We could figure out how to do the test better with just the
618 * name. We could open the stream and then close the other one
619 * after the fact. Or we could just not worry about it since it is
620 * rare.
621 */
625 }
627 /* make sure the message map has been instantiated */
630 /*
631 * If a referral during the mail_open above causes a stream
632 * re-use which involves a BYE on an IMAP stream, then that
633 * BYE will have caused an mm_notify which will have
634 * instantiated the sp_data and set dead_stream! Trust that
635 * it is alive up to here and reset it to zero.
636 */
639 flags = SP_LOCKED
649 /* initialize the reference count */
657 flags = SP_LOCKED
666 }
669 /*
670 * When opening a newsgroup, c-client marks the messages up to the
671 * last Deleted as Unseen. If the feature news-approximates-new-status
672 * is on, we'd rather they be treated as Seen. That way, selecting New
673 * messages will give us the ones past the last Deleted. So we're going
674 * to change them to Seen. Since Seen is a session flag for news, making
675 * this change won't have any permanent effect. C-client also marks the
676 * messages after the last deleted Recent, which is the bit of
677 * information we'll use to find the messages we want to change.
678 */
685 /*
686 * Search for !recent messages to set the searched bit for
687 * those messages we want to change. Then we'll flip the bits.
688 */
694 else
702 }
703 }
704 }
707 }
710 void
712 {
735 /*
736 * Get rid of zooming and selections, but leave filtering flags. All the
737 * flag counts and everything should still be correct because set_lflag
738 * preserves them correctly.
739 */
745 }
747 /*
748 * We could try to set up a default sort order, but the caller is going
749 * to re-sort anyway if they are interested in sorting. So we won't do
750 * it here.
751 */
752 }
755 /*
756 * We have to be careful when we change the flags of an already
757 * open stream, because there may be more than one section of
758 * code actively using the stream.
759 * We allow turning on (but not off) SP_LOCKED
760 * SP_PERMLOCKED
761 * SP_USERFLDR
762 * SP_INBOX
763 * We allow turning off (but not on) SP_TEMPUSE
764 */
765 void
767 {
769 /* allow turning on but not off */
783 /* allow turning off but not on */
788 /* leave the way they already are */
795 }
796 }
799 /*
800 * Pine wrapper around mail_create. If we have the PREFER_ALT_AUTH flag turned
801 * on we don't want to pass a NULL stream to c-client because it will open
802 * a non-ssl connection when we want it to be ssl.
803 */
804 long
806 {
822 }
824 /*
825 * We don't really need this anymore, since we are now using IMAPTRYALT.
826 * We'll leave it since it works.
827 */
836 }
837 }
845 /*
846 * It is only useful to open a stream in the imap case.
847 */
853 }
854 }
862 }
865 /*
866 * Pine wrapper around mail_delete.
867 */
868 long
870 {
886 }
888 /*
889 * We don't really need this anymore, since we are now using IMAPTRYALT.
890 */
899 }
900 }
902 /* oops, we seem to be deleting a selected stream */
906 }
912 /*
913 * It is only useful to open a stream in the imap case.
914 */
920 }
921 }
929 }
932 /*
933 * Pine wrapper around mail_append.
934 */
935 long
936 pine_mail_append_full(MAILSTREAM *stream, char *mailbox, char *flags, char *date, STRING *message)
937 {
950 /* strip delimiter, it has no meaning in an APPEND and could cause trouble */
959 }
960 }
967 }
969 /*
970 * We don't really need this anymore, since we are now using IMAPTRYALT.
971 */
980 }
981 }
989 /*
990 * It is only useful to open a stream in the imap case.
991 */
997 }
998 }
1006 }
1009 /*
1010 * Pine wrapper around mail_append.
1011 */
1012 long
1015 {
1032 }
1042 }
1043 }
1045 /*
1046 * We have to be careful re-using streams for multiappend, because of
1047 * the way it works. We call into c-client below but part of the call
1048 * is data containing a callback function to us to supply the data to
1049 * be appended. That function may need to get the data from the server.
1050 * If that uses the same stream as we're trying to append on, we're
1051 * in trouble. We can't call back into c-client from c-client on the same
1052 * stream. (Just think about it, we're in the middle of an APPEND command.
1053 * We can't issue a FETCH before the APPEND completes in order to complete
1054 * the APPEND.) We can re-use a stream if it is a different stream from
1055 * the one we are reading from, so that's what the not_this_stream
1056 * stuff is for. If we mark it !SP_USEPOOL, it won't get reused.
1057 */
1059 we_blocked_reuse++;
1061 }
1069 /*
1070 * It is only useful to open a stream in the imap case.
1071 */
1077 }
1078 }
1089 }
1092 /*
1093 * Pine wrapper around mail_copy.
1094 */
1095 long
1097 {
1110 /* strip delimiter, it has no meaning in a COPY and could cause trouble */
1119 }
1120 }
1127 }
1129 /*
1130 * We don't really need this anymore, since we are now using IMAPTRYALT.
1131 */
1140 }
1141 }
1149 /*
1150 * It is only useful to open a stream in the imap case.
1151 * Actually, mail_copy_full is the case where it might also be
1152 * useful to provide a stream in the nntp and pop3 cases. If we
1153 * cache such streams, then we will probably want to open one
1154 * here so that it gets cached.
1155 */
1161 }
1162 }
1170 }
1173 /*
1174 * Pine wrapper around mail_rename.
1175 */
1176 long
1178 {
1187 /*
1188 * We don't really need this anymore, since we are now using IMAPTRYALT.
1189 */
1198 }
1199 }
1201 /* oops, we seem to be renaming a selected stream */
1205 }
1211 /*
1212 * It is only useful to open a stream in the imap case.
1213 */
1219 }
1220 }
1228 }
1231 /*----------------------------------------------------------------------
1232 Our mail_close wrapper to clean up anything on the mailstream we may have
1233 added to it. mostly in the unused bits of the elt's.
1234 ----*/
1235 void
1237 {
1253 /*
1254 * Instead of checkpointing here, which takes time that the user
1255 * definitely notices, we checkpoint in new_mail at the next
1256 * opportune time, hopefully when the user is idle.
1257 */
1258 #if 0
1266 }
1267 }
1268 #endif
1270 /*
1271 * Uid_last is valid when we first open a stream, but not always
1272 * valid after that. So if we know the last uid should be higher
1273 * than uid_last (!#%) use that instead.
1274 */
1283 /*
1284 * If the reference count is down to 0, unlock it.
1285 * In any case, don't actually do any real closing.
1286 */
1298 /*
1299 * Logically, we ought to be unflagging SP_INBOX, too. However,
1300 * the filtering code uses SP_INBOX when deciding if it should
1301 * filter some things, and we keep filtering after the mailbox
1302 * is closed. So leave SP_INBOX alone. This (the closing of INBOX)
1303 * usually only happens in goodnight_gracey when we're
1304 * shutting everything down.
1305 */
1307 }
1310 refcnt));
1311 }
1312 }
1320 /*
1321 * If the reference count is down to 0, unlock it.
1322 * In any case, don't actually do any real closing.
1323 */
1330 }
1333 refcnt));
1334 }
1336 }
1337 }
1340 void
1342 {
1361 /*
1362 * let sp_free_callback() free the sp_s stuff and the callbacks to
1363 * free_pine_elt free the per-elt pine stuff.
1364 */
1366 }
1367 }
1370 /*
1371 * If we haven't used a stream for a while, we may want to logout.
1372 */
1373 void
1375 {
1376 #define KILL_IF_IDLE_TIME (25 * 60)
1388 /*
1389 * Another thing we could do here instead is to unselect the
1390 * mailbox, leaving the stream open to the server.
1391 */
1393 }
1394 }
1397 /*
1398 * Catch searches that don't need to go to the server.
1399 * (Not anymore, now c-client does this for us.)
1400 */
1401 long
1404 {
1405 /*
1406 * The charset should either be UTF-8 or NULL for alpine.
1407 * If it is UTF-8 we may be able to change it to NULL if
1408 * everything in the search is actually ascii. We try to
1409 * do this because not all servers understand the CHARSET
1410 * parameter.
1411 */
1420 }
1423 int
1425 {
1460 }
1463 int
1465 {
1471 }
1474 int
1476 {
1484 }
1487 int
1489 {
1499 }
1502 void
1504 {
1508 }
1511 ENVELOPE *
1513 {
1522 }
1525 ENVELOPE *
1528 {
1537 }
1540 ENVELOPE *
1541 pine_mail_fetchstructure(MAILSTREAM *stream, long unsigned int msgno, struct mail_bodystruct **body)
1542 {
1551 }
1554 /*
1555 * Wrapper around mail_fetch_body.
1556 * Currently only used to turn on partial fetching if trying
1557 * to work around the microsoft ssl bug.
1558 */
1562 {
1563 #ifdef _WINDOWS
1567 else
1568 #endif
1570 }
1572 /*
1573 * Wrapper around mail_fetch_text.
1574 * Currently the only purpose this wrapper serves is to turn
1575 * on partial fetching for quell-ssl-largeblocks.
1576 */
1580 {
1581 #ifdef _WINDOWS
1586 else
1587 #endif
1589 }
1592 /*
1593 * Determine whether to do partial-fetching or not, and do it
1594 * args - same as c-client functions being wrapped around
1595 * get_n_bytes - try to partial fetch for the first n bytes.
1596 * makes no guarantees, might wind up fetching
1597 * the entire text anyway.
1598 * str_to_free - pointer to string to free if we only get
1599 * (non-cachable) partial text (required for
1600 * get_n_bytes).
1601 * is_text_fetch -
1602 * set, tells us to do mail_fetch_text and mail_partial_text
1603 * unset, tells us to do mail_fetch_body and mail_partial_body
1604 */
1610 {
1616 SIZEDTEXT new_text;
1627 #ifdef _WINDOWS
1629 #else
1634 else
1647 /*
1648 * imap_cache, originally intended for c-client internal use,
1649 * takes a section argument that is different from one we
1650 * would pass to mail_body. Typically in this function
1651 * section is NULL, which translates to "TEXT", but in other
1652 * cases we would want to append ".TEXT" to the section
1653 */
1658 else
1663 #ifdef _WINDOWS
1666 #else
1674 }
1678 }
1681 #ifdef _WINDOWS
1685 AVOID_MICROSOFT_SSL_CHUNKING_BUG);
1686 else
1688 }
1689 else
1700 /* start fetching */
1707 }
1723 /*
1724 * don't write to cache if we're only dealing with
1725 * partial text.
1726 */
1729 else
1731 }
1733 /* ugh, rewrite string in case it got stomped on last call */
1738 else
1743 }
1753 }
1754 else
1756 }
1757 else
1759 }
1761 /*
1762 * c-client callback that handles getting the text
1763 */
1766 {
1779 }
1782 /*
1783 * Pings the stream. Returns 0 if the stream is dead, non-zero otherwise.
1784 */
1785 long
1787 {
1795 }
1801 }
1804 }
1807 void
1809 {
1812 }
1815 /*
1816 * Unlike mail_list, this version returns a value. The returned value is
1817 * TRUE if the stream is opened ok, and FALSE if we failed opening the
1818 * stream. This allows us to differentiate between a LIST which returns
1819 * no matches and a failure opening the stream. We do this by pre-opening
1820 * the stream ourselves.
1821 */
1822 int
1824 {
1836 ||
1847 }
1850 we_open++;
1854 }
1855 else
1857 }
1869 /*
1870 * POP is a special case. We don't need to have a stream
1871 * to call mail_list for a POP name. The else part is the
1872 * POP part.
1873 */
1880 }
1881 else
1883 }
1886 }
1887 else
1894 }
1897 /*
1898 * mail_list_internal -- A monument to software religion and those who
1899 * would force it upon us.
1900 */
1901 void
1903 {
1908 /* MAILTMPLEN = sizeof(tmp)/2 */
1912 }
1913 else
1915 }
1918 long
1920 {
1922 }
1925 long
1928 {
1938 /* tell mm_status() to write partial return here */
1943 /* do status of destination */
1947 /* should never be news, don't worry about mulnewrsc flag*/
1949 uidnext))
1952 /* do status of source */
1968 }
1974 }
1980 /*
1981 * If the target has recent messages, then we don't come
1982 * through here. We just use the answer from the target.
1983 *
1984 * If not, then we leave the target results in "status" and
1985 * run a mail_status on the source that puts its results
1986 * in "cache". Combine the results from cache with the
1987 * results that were already in status.
1988 *
1989 * We count all messages in the source mailbox as recent and
1990 * unseen, even if they are not recent or unseen in the source,
1991 * because they will be recent and unseen in the target
1992 * when we open it. (Not quite true. It is possible that some
1993 * messages from a POP server will end up seen instead
1994 * of unseen.
1995 * It is also possible that it is correct. If we add unseen, or
1996 * if we add messages, we could get it wrong. As far as I
1997 * can tell, Pine doesn't ever even use status.unseen, so it
1998 * is currently academic anyway.) Hubert 2003-03-05
1999 * (Does now 2004-06-02 in next_folder.)
2000 *
2001 * However, we don't want to count all messages as recent if
2002 * the source mailbox is NNTP or NEWS, because we won't be
2003 * deleting those messages from the source.
2004 * We only count recent.
2005 *
2006 * There are other cases that are trouble. One in particular
2007 * is an IMAP-to-NNTP proxy, where the messages can't be removed
2008 * from the mailbox but they can be deleted. If we count
2009 * messages in the source as being recent and it turns out they
2010 * were all deleted already, then we incorrectly say the folder
2011 * has recent messages when it doesn't. We can recover from that
2012 * case at some cost by actually opening the folder the first
2013 * time if there are not recents, and then checking to see if
2014 * everything is deleted. Subsequently, we store the uid values
2015 * (which are returned by status) so that we can know if the
2016 * mailbox changed or not. The problem being solved is that
2017 * the TAB command indicates new messages in a folder when there
2018 * really aren't any. An alternative would be to use the is_news
2019 * half of the if-else in all cases. A problem with that is
2020 * that there could be non-recent messages sitting in the
2021 * source mailbox that we never discover. Hubert 2003-03-28
2022 */
2026 is_news++;
2033 }
2042 }
2048 }
2053 /* Actually open it up and check */
2064 }
2068 NULL);
2070 }
2075 }
2081 }
2088 }
2089 }
2090 }
2092 /*
2093 * Do the regular mm_status callback which we've been intercepting
2094 * into different locations above.
2095 */
2099 }
2111 /*
2112 * We just use this to find the answer.
2113 * We're asking for trouble if we do a STATUS on a
2114 * selected mailbox. I don't believe this happens in pine.
2115 * It does now (2004-06-02) in next_folder if the
2116 * F_TAB_USES_UNSEEN option is set and the folder was
2117 * already opened.
2118 */
2125 }
2130 }
2147 }
2152 }
2157 }
2161 }
2169 }
2170 }
2175 }
2179 }
2185 }
2188 /*
2189 * Check for a mailbox name that is a legitimate #move mailbox.
2190 *
2191 * Args mbox -- The mailbox name to check
2192 * sourcebuf -- Copy the source mailbox name into this buffer
2193 * sbuflen -- Length of sourcebuf
2194 * targetptr -- Set the pointer this points to to point to the
2195 * target mailbox name in the original string
2196 *
2197 * Returns 1 - is a #move mailbox
2198 * 0 - not
2199 */
2200 int
2202 {
2219 }
2225 }
2228 }
2231 /*
2232 * Checks through stream cache for a stream pointer already open to
2233 * this mailbox, read/write. Very similar to sp_stream_get, but we want
2234 * to look at all streams, not just imap streams.
2235 * Right now it is very specialized. If we want to use it more generally,
2236 * generalize it or combine it with sp_stream_get somehow.
2237 */
2238 MAILSTREAM *
2240 {
2254 }
2255 }
2268 }
2269 }
2272 }
2275 void
2277 {
2294 /* but can interrupt these ones */
2297 }
2298 }
2301 /*
2302 * Tells us whether we ought to check for a dead stream or not.
2303 * We assume that we ought to check if it is not IMAP and if it is IMAP we
2304 * don't need to check if the last activity was within the last 5 minutes.
2305 */
2306 int
2308 {
2312 else
2314 }
2316 void
2318 {
2328 }
2329 }
2332 /*
2333 * Returns 0 if stream flags not set, non-zero if they are.
2334 */
2335 int
2337 {
2339 }
2342 void
2344 {
2354 }
2355 }
2358 void
2360 {
2370 }
2371 }
2374 /*
2375 * Sets flags absolutely, erasing old flags.
2376 */
2377 void
2379 {
2385 flags,
2396 }
2399 /*
2400 * Clear individual stream flags.
2401 */
2402 void
2404 {
2410 flags,
2423 flags,
2430 }
2433 /*
2434 * Set dead stream indicator and close if not locked.
2435 */
2436 void
2438 {
2445 /*
2446 * If the stream isn't locked, it is no longer useful. Get rid of it.
2447 */
2451 /*
2452 * If it is locked, then we have to worry about references to it
2453 * that still exist. For example, it might be a permlocked stream
2454 * or it might be the current stream. We need to let it be discovered
2455 * by those referencers instead of just eliminating it, so that they
2456 * can clean up the mess they need to clean up.
2457 */
2459 }
2460 }
2463 /*
2464 * Returns the number of streams in the stream pool which are
2465 * SP_USEPOOL but not SP_PERMLOCKED.
2466 */
2467 int
2469 {
2476 cnt++;
2477 }
2480 }
2483 /*
2484 * Returns the number of folders that the user has marked to be PERMLOCKED
2485 * folders (plus INBOX) that are remote IMAP folders.
2486 *
2487 * This routine depends on the fact that VAR_INBOX_PATH, VAR_PERMLOCKED,
2488 * and the ps_global->context_list are correctly set.
2489 */
2490 int
2492 {
2497 /* first check if INBOX is remote */
2501 cnt++;
2503 /* then count the user-specified permlocked folders */
2505 lock_these++){
2507 /*
2508 * Skip inbox, already done above. Should do this better so that we
2509 * catch the case where the user puts the technical spec of the inbox
2510 * in the list, or where the user lists one folder twice.
2511 */
2515 /* there isn't really a pair, it just dequotes for us */
2518 /*
2519 * Check to see if this is an incoming nickname and replace it
2520 * with the full name.
2521 */
2525 FN_WHOLE_NAME))))
2533 cnt++;
2537 }
2540 }
2543 /*
2544 * Look for an already open stream that can be used for a new purpose.
2545 * (Note that we only look through streams flagged SP_USEPOOL.)
2546 *
2547 * Args: mailbox
2548 * flags
2549 *
2550 * Flags is a set of values or'd together which tells us what the request
2551 * is looking for.
2552 *
2553 * Returns: a live stream from the stream pool or NULL.
2554 */
2555 MAILSTREAM *
2557 {
2569 /* look for stream already open to this mailbox */
2586 }
2589 }
2592 }
2593 }
2594 }
2596 /*
2597 * SP_SAME will not match if an SP_MATCH match would have worked.
2598 * If the caller is interested in SP_MATCH streams as well as SP_SAME
2599 * streams then the caller should make two separate calls to this
2600 * routine.
2601 */
2603 /*
2604 * If the flags arg does not have either SP_TEMPUSE or SP_UNLOCKED
2605 * set, then we'll accept any stream, even if locked.
2606 * We want to prefer the LOCKED case so that we don't have to ping.
2607 */
2619 }
2622 }
2623 }
2625 /* consider the unlocked streams */
2632 /* always ping unlocked streams */
2643 }
2646 }
2647 }
2648 }
2650 /*
2651 * Prefer streams marked SP_TEMPUSE and not LOCKED.
2652 * If SP_TEMPUSE is set in the flags arg then this is the
2653 * only loop we try.
2654 */
2670 }
2673 }
2674 }
2676 /*
2677 * If SP_TEMPUSE is not set in the flags arg but SP_UNLOCKED is,
2678 * then we will consider
2679 * streams which are not marked SP_TEMPUSE (but are still not
2680 * locked). We go through these in reverse order so that we'll get
2681 * the last one added instead of the first one. It's not clear if
2682 * that is a good idea or if a more complex search would somehow
2683 * be better. Maybe we should use a round-robin sort of search
2684 * here so that we don't leave behind unused streams. Or maybe
2685 * we should keep track of when we used it and look for the LRU stream.
2686 */
2703 }
2706 }
2707 }
2708 }
2709 }
2711 /*
2712 * If we can't find a useful stream to use in pine_mail_open, we may
2713 * want to re-use one that is not actively being used even though it
2714 * is not on the same server. We'll have to close it and then re-use
2715 * the slot.
2716 */
2718 /*
2719 * Prefer streams marked SP_TEMPUSE and not LOCKED.
2720 * If SP_TEMPUSE is set in the flags arg then this is the
2721 * only loop we try.
2722 */
2729 /*
2730 * We ping it in case there is new mail that we should
2731 * pass through our filters. Pine_mail_actually_close will
2732 * do that.
2733 */
2736 }
2737 }
2739 /*
2740 * If SP_TEMPUSE is not set in the flags arg, then we will consider
2741 * streams which are not marked SP_TEMPUSE (but are still not
2742 * locked). Maybe we should use a round-robin sort of search
2743 * here so that we don't leave behind unused streams. Or maybe
2744 * we should keep track of when we used it and look for the LRU stream.
2745 */
2752 /*
2753 * We ping it in case there is new mail that we should
2754 * pass through our filters. Pine_mail_actually_close will
2755 * do that.
2756 */
2759 }
2760 }
2761 }
2762 }
2767 }
2770 void
2772 {
2782 }
2788 }
2791 /*
2792 * Find a vacant slot to put this new stream in.
2793 * We are willing to close and kick out another stream as long as it isn't
2794 * LOCKED. However, we may find that there is no place to put this one
2795 * because all the slots are used and locked. For now, we'll return -1
2796 * in that case and leave the new stream out of the pool.
2797 */
2798 int
2800 {
2810 }
2812 /* If this stream is already there, don't add it again */
2820 }
2821 }
2829 }
2831 /* Look for an unused slot */
2839 }
2840 }
2842 /* else, allocate more space */
2851 }
2859 }
2863 }
2868 }
2872 }
2873 }
2876 /*
2877 * Simply remove this stream from the stream pool.
2878 */
2879 void
2881 {
2891 /*
2892 * There are some global stream pointers that we have to worry
2893 * about before deleting the stream.
2894 */
2896 /* first, mail_stream is the global currently open folder */
2900 /* remote address books may have open stream pointers */
2913 }
2914 }
2915 }
2918 /*
2919 * Returns 1 if any locked userfldr is dead, 0 if all alive.
2920 */
2921 int
2923 {
2931 ret++;
2932 }
2935 }
2938 /*
2939 * Returns 1 if any locked stream is changed, 0 otherwise
2940 */
2941 int
2943 {
2951 ret++;
2952 }
2955 }
2958 /*
2959 * Returns the inbox stream or NULL.
2960 */
2961 MAILSTREAM *
2963 {
2971 }
2974 }
2977 /*
2978 * Make sure that the sp_data per-stream data storage area exists.
2979 *
2980 * Returns a handle to the sp_data data unless stream is NULL,
2981 * in which case NULL is returned
2982 */
2983 PER_STREAM_S **
2985 {
2993 }
2994 }
2997 }
3000 /*
3001 * Returns a pointer to the msgmap associated with the argument stream.
3002 *
3003 * If the PER_STREAM_S data or the msgmap does not already exist, it will be
3004 * created.
3005 */
3006 MSGNO_S *
3008 {
3019 }
3022 void
3024 {
3032 /*
3033 * It is possible that this has been called from c-client when
3034 * we weren't expecting it. We need to clean up the stream pool
3035 * entries if the stream that goes with this pointer is in the
3036 * stream pool somewhere.
3037 */
3042 }
3049 }
3052 }
3053 }
3056 /*
3057 * Free the data but don't mess with the stream pool.
3058 */
3059 void
3061 {
3068 }
3074 }
3075 }
3079 /*----------------------------------------------------------------------
3080 See if stream can be used for a mailbox name
3082 Accepts: mailbox name
3083 candidate stream
3084 Returns: stream if it can be used, else NIL
3086 This is called to weed out unnecessary use of c-client streams. In other
3087 words, to help facilitate re-use of streams.
3089 This code is very similar to the same_remote_mailboxes code below, which
3090 is used in pine_mail_open. That code compares two mailbox names. One is
3091 usually from the config file and the other is either from the config file
3092 or is typed in. Here and in same_stream_and_mailbox below, we're comparing
3093 an open stream to a name instead of two names. We could conceivably use
3094 same_remote_mailboxes to compare stream->mailbox to name, but it isn't
3095 exactly the same and the differences may be important. Some stuff that
3096 happens here seems wrong, but it isn't easy to fix.
3097 Having !mb_n.port count as a match to any mb_s.port isn't right. It should
3098 only match if mb_s.port is equal to the default, but the default isn't
3099 something that is available to us. The same thing is done in c-client in
3100 the mail_usable_network_stream() routine, and it isn't right there, either.
3101 The semantics of a missing user are also suspect, because just like with
3102 port, a default is used.
3103 ----*/
3104 MAILSTREAM *
3106 {
3121 ||
3126 ||
3130 ||
3133 && (struncmp(mb_n.service, "imap", 4) ? 1 : strcmp(imap_host(stream), ".NO-IMAP-CONNECTION."))){
3138 }
3144 }
3148 /*----------------------------------------------------------------------
3149 See if this stream has the named mailbox selected.
3151 Accepts: mailbox name
3152 candidate stream
3153 Returns: stream if it can be used, else NIL
3154 ----*/
3155 MAILSTREAM *
3157 {
3172 }
3179 }
3181 /*
3182 * Args -- name1 and name2 are remote mailbox names.
3183 *
3184 * Returns -- True if names refer to same mailbox accessed in same way
3185 * False if not
3186 *
3187 * This has some very similar code to same_stream_and_mailbox but we're not
3188 * quite ready to discard the differences.
3189 * The treatment of the port and the user is not quite the same.
3190 */
3191 int
3193 {
3197 /*
3198 * Probably we should allow !port equal to default port, but we don't
3199 * know how to get the default port. To match what c-client does we
3200 * allow !port to be equal to anything.
3201 */
3218 ||
3220 ||
3224 ||
3228 ||
3232 ||
3236 }
3239 int
3241 {
3244 }
3247 int
3249 {
3251 }
3254 /*----------------------------------------------------------------------
3255 Check and see if all the stream are alive
3257 Returns: 0 if there was no change
3258 >0 if streams have died since last call
3260 Also outputs a message that the streams have died
3261 ----*/
3262 int
3264 {
3275 rv++;
3283 folder));
3290 }
3292 }
3293 }
3298 /*
3299 * If a cached stream died and then we tried to use it
3300 * it could cause problems. We could warn about it here
3301 * but it may be confusing because it might be
3302 * unrelated to what the user is doing and not cause
3303 * any problem at all.
3304 */
3305 #if 0
3309 #endif
3312 folder));
3313 }
3316 }
3317 }
3318 }
3321 }
3324 /* Some stream is locked checks to see if there is any stream for which we
3325 * are in a callback from c-client
3326 */
3328 int
3330 {
3337 rv++;
3338 }
3341 }
3343 /*
3344 * Very simple version of appenduid_cb until we need something
3345 * more complex.
3346 */
3350 void
3352 {
3354 }
3357 imapuid_t
3359 {
3361 }
3364 /*
3365 * mail_cmd_stream - return a stream suitable for mail_lsub,
3366 * mail_subscribe, and mail_unsubscribe
3367 *
3368 */
3369 MAILSTREAM *
3371 {
3379 NULL));
3380 }
3383 /*
3384 * This is so we can replace the old rfc822_ routines like rfc822_header_line
3385 * with the new version that checks bounds, like rfc822_output_header_line.
3386 * This routine is called when would be a bounds overflow, which we simply log
3387 * and go on with the truncated data.
3388 */
3389 long
3391 {
3394 }