| blob | feddf1c2aa7d912c5f2643ed843659d3e8d66872 |
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 remote.c
17 Implements remote IMAP config files (remote config, remote abook).
18 ====*/
39 /*
40 * Internal prototypes
41 */
58 {
67 /*
68 * We don't cache the pinerc, we always copy it.
69 *
70 * Don't store the config in a temporary file, just leave it
71 * in memory while using it.
72 * It is currently required that NO_PERM_CACHE be set if NO_FILE is set.
73 */
76 create_the_remote_folder:
82 }
84 /* this will cause the remote folder to be created */
86 }
88 /*
89 * We could parse the name here to find what type it is. So far we
90 * only have type RemImap.
91 */
93 REMOTE_PINERC_SUBTYPE,
99 /*
100 * On first use we just use a temp file instead of memory (NO_FILE).
101 * In other words, for our convenience, we don't turn NO_FILE back on
102 * here. Why is that convenient? Because of the stuff that happened in
103 * rd_create_remote when flags was set to zero.
104 */
115 }
116 else
118 }
124 /*
125 * If the cached info says it is readonly but
126 * it looks like it's been fixed now, change it to readwrite.
127 */
130 /*
131 * We go to this trouble since readonly pinercs
132 * are likely a mistake. They are usually supposed to be
133 * readwrite so we open it and check if it's been fixed.
134 */
139 }
140 else
142 }
148 /*
149 * We don't check for the existence of the remote
150 * folder when this flag is turned on, so we could
151 * fail here because the remote folder doesn't exist.
152 * We try to create it.
153 */
154 no_perm_create_pass++;
156 }
160 /*
161 * Don't give up altogether. We still may be
162 * able to use a cached copy.
163 */
164 }
170 }
171 }
175 }
177 /* If we couldn't get to remote folder, try using the cached copy */
188 }
192 }
193 }
196 /* copy text, leave sonofile for later use */
198 else
201 bail_out:
207 }
210 }
213 /*
214 * Check if the remote data folder exists and create an empty folder
215 * if it doesn't exist.
216 *
217 * Args - type -- The type of remote storage.
218 * remote_name --
219 * type_spec -- Type-specific data.
220 * flags --
221 * err_prefix -- Should usually end with a SPACE
222 * err_suffix -- Should usually begin with a SPACE
223 *
224 * Returns a pointer to a REMDATA_S with access set to either
225 * NoExists or MaybeRorW. On success, "so" will point to a storage object.
226 */
227 REMDATA_S *
230 {
249 }
251 /*
252 * We're not going to check if it is there in this case,
253 * in order to save ourselves some round trips and
254 * connections. We'll just try to select it and then
255 * recover at that point if it isn't already there.
256 */
259 }
261 }
263 /*
264 * Open_fcc creates the folder if it didn't already exist.
265 */
268 /*
269 * We know the folder is there but don't know what access
270 * rights we have until we try to select it, which we don't
271 * want to do unless we have to. So delay evaluating.
272 */
274 }
275 }
282 }
285 }
288 REMDATA_S *
290 {
312 }
315 }
318 /*
319 * Closes the remote stream and frees.
320 */
321 void
323 {
336 }
341 }
357 }
360 }
361 }
364 /*
365 * Call this when finished with the remdata. This does the REMTRIM if the
366 * flag is set, the DEL_FILE if the flag is set. It also closes the stream
367 * and frees the rd.
368 */
369 void
371 {
377 /*
378 * Trim the number of saved copies of remote data history.
379 * The first message is a fake message that always
380 * stays there, then come ps_global->remote_abook_history messages
381 * which are each a revision of the data, then comes the active
382 * data.
383 */
388 /* make sure stream is open */
399 /*
400 * If user manually deleted some, we'd better not delete
401 * any more.
402 */
405 dprint((4, " rd_trim: trimming remote: mark msgs 2-%ld deleted (%s)\n", (*rd)->t.i.stream->nmsgs - 1 - ps_global->remote_abook_history, (*rd)->rn ? (*rd)->rn : "?"));
410 }
411 else
412 user_deleted++;
418 /* else
419 * don't update metafile because user is messing with
420 * the remote folder manually. We'd better re-read it next
421 * time. */
422 }
423 }
426 }
433 }
434 }
437 /*
438 * All done with this remote data. Trim the folder, close the
439 * stream, and free.
440 */
441 void
443 {
452 /* this closes the stream and frees memory */
454 }
457 /*
458 * Looks in the metadata file for the cache line corresponding to rd and
459 * fills in data in rd.
460 *
461 * Return value -- 1 if it is likely that the filename we're returning
462 * is the permanent name of the local cache file and it may already have
463 * a cached copy of the data. This is to tell us if it makes sense to use
464 * the cached copy when we are unable to contact the remote server.
465 * 0 otherwise.
466 */
467 int
469 {
481 else
490 }
492 /* display error */
498 }
499 }
505 /*
506 * This should be the normal case. The file is stored as a
507 * filename in the pinerc dir, so that it can be
508 * accessed from the PC or from unix where the pathnames to
509 * get there will be different.
510 */
519 }
523 }
527 }
530 /* don't free this below, we're using it */
532 }
560 }
564 }
565 /*
566 * The line for this data wasn't in the metadata file yet.
567 * Figure out what should go there and put it in.
568 */
570 /*
571 * The local_cache_file is where we will store the cached local
572 * copy of the remote data.
573 */
580 }
581 else
583 }
591 }
594 }
597 /*
598 * Write out the contents of the metadata file.
599 *
600 * Each line should be: folder_name cache_file uidvalidity uidnext uid nmsgs
601 * read_status date
602 *
603 * If delete_it is set, then remove the line instead of updating it.
604 *
605 * We have to be careful with the metadata, because it exists in user's
606 * existing metadata files now, and it is oriented towards only RemImap.
607 * We would have to change the version number and the format of the lines
608 * in the file if we add another type.
609 */
610 void
612 {
630 }
648 else
657 /*
658 * Write the header line.
659 */
665 /*
666 * Skip the header line and any lines that don't begin
667 * with a "{".
668 */
672 /* skip the old cache line for this key */
676 /* add this line to new version of file */
679 }
680 }
682 /* add the cache line for this key */
683 /* Warning: this is type RemImap specific right now! */
688 p ||
698 }
703 }
708 }
721 io_err:
731 }
738 }
741 void
743 {
756 /*
757 * If nmsgs < 2 then something is wrong. Maybe it is just
758 * that we haven't been told about the messages we've
759 * appended ourselves. Try closing and re-opening the stream
760 * to see those.
761 */
771 }
772 }
776 /*
777 * If nmsgs < 2 something is wrong.
778 */
783 }
788 /*
789 * Uid_last is not always valid. If the last known uid is
790 * greater than uid_last, go with it instead (uid+1).
791 * If our guess is wrong (too low), the penalty is not
792 * harsh. When the uidnexts don't match we open the
793 * mailbox to check the uid of the actual last message.
794 * If it was a false hit then we adjust uidnext so it
795 * will be correct the next time through.
796 */
799 }
800 }
804 /*
805 * Save the date so that we can check if it changed next time
806 * we go to write.
807 */
813 }
816 }
826 }
827 }
832 REMDATA_META_S *
834 {
848 /*
849 * Open the metadata file and get some information out.
850 */
865 }
867 /*
868 * If we make it to this point where we have opened the metadata file
869 * we return a structure (possibly empty) instead of just a NULL pointer.
870 */
874 /*
875 * Check for header line. If it isn't there or is incorrect,
876 * return with the empty rab. This call also positions the file pointer
877 * past the header line.
878 */
885 /* Make it size zero so we won't copy any bad stuff */
903 }
906 }
907 else
912 }
916 /* Look for our line */
921 #define SKIP_TO_TAB(p) do{while(*p && *p != TAB)p++;}while(0)
923 /*
924 * The line should be TAB-separated with fields:
925 * folder_name cache_file uidvalidity uidnext uid nmsgs read_status date
926 * This part is highly RemImap-specific right now.
927 */
963 p++;
967 }
968 }
969 }
970 }
971 }
972 }
973 }
974 }
978 }
981 /*
982 * Returns: -1 if this doesn't look like a metafile or some error,
983 * or if it looks like a non-current metafile.
984 * 0 if it looks like a current metafile.
985 *
986 * A side effect is that the file pointer will be pointing to the second
987 * line if 0 is returned.
988 */
989 int
991 {
1004 /* check for magic */
1012 /*
1013 * If we change to a new version, we may want to add code here to convert
1014 * or to cleanup after the old version. For example, it might just
1015 * remove the old cache files here.
1016 */
1018 /* check for matching version number */
1023 SIZEOF_VERSION_NUM)
1030 /* Position file pointer to second line */
1038 }
1041 /*
1042 * Open a data stream to the remote data.
1043 */
1044 void
1046 {
1058 }
1070 /* Don't try to reopen if there was a problem (auth failure, etc.) */
1075 /* this is a failure */
1077 }
1087 }
1088 }
1091 /*
1092 * Close a data stream to the remote data.
1093 */
1094 void
1096 {
1111 }
1112 }
1115 int
1117 {
1128 }
1131 }
1134 /*
1135 * Ping the stream and return 1 if it is still alive.
1136 */
1137 int
1139 {
1151 /*
1152 * If this stream is already actually open, officially open
1153 * it and use it.
1154 */
1162 }
1168 }
1169 }
1179 else
1188 }
1191 }
1194 /*
1195 * Change readonly access to readwrite if appropriate. Call this if
1196 * the remote data ought to be readwrite but it is marked readonly in
1197 * the metadata.
1198 */
1199 void
1201 {
1209 }
1217 }
1218 }
1219 }
1222 /*
1223 * Initialize remote data. The remote data is initialized
1224 * with no data. On success, the local file will be empty and the remote
1225 * folder (if type RemImap) will contain a header message and an empty
1226 * data message.
1227 * The remote folder already exists before we get here, though it may be empty.
1228 *
1229 * Returns -1 on failure
1230 * 0 on success
1231 */
1232 int
1234 {
1244 }
1246 /*
1247 * The rest is currently type RemImap-specific.
1248 */
1261 }
1263 /* already init'd */
1272 /*
1273 * We want to protect the user who specifies an actual address book
1274 * file on the remote system as a remote address book. For example,
1275 * they might say address-book={host}.addressbook where .addressbook
1276 * is just a file on host. Remote address books are folders, not
1277 * files. We also want to protect the user who specifies an existing
1278 * mail folder as a remote address book. We do that by requiring the
1279 * first message in the folder to be our header message.
1280 */
1297 }
1305 /*
1306 * The first message in a remote data folder is a special
1307 * header message. It is there as a way to explain what the
1308 * folder is to users who open it trying to read it. It is also
1309 * used as a consistency check so that we don't use a folder
1310 * that was being used for something else as a remote
1311 * data folder.
1312 */
1321 }
1338 }
1339 }
1340 }
1341 }
1343 /*
1344 * Add the second (empty) message.
1345 */
1353 }
1362 }
1374 }
1375 else
1384 }
1388 }
1399 }
1400 }
1401 }
1405 /* turn off out of date flag */
1407 }
1410 }
1413 /*
1414 * IMAP stream should already be open to a remote folder.
1415 * Check the first message in the folder to be sure it is the right
1416 * kind of message, not some message from some other folder.
1417 *
1418 * Returns 0 if ok, < 0 if invalid format.
1419 *
1420 */
1421 int
1423 {
1434 try_again:
1439 }
1451 }
1463 }
1471 }
1472 }
1473 else
1489 else
1491 }
1494 }
1503 }
1509 }
1512 /* null stream */
1515 }
1517 /* no messages in folder */
1522 }
1524 /* no cookie */
1529 }
1531 /* Received header */
1536 }
1539 /* cookie is 0 */
1541 /*
1542 * This is a failure and should not happen, but we're not going to
1543 * fail on this condition.
1544 */
1549 }
1558 }
1560 /* cookie is 1, upgrade it */
1562 /* now check again */
1564 tried_again++;
1566 }
1567 }
1569 /*
1570 * This is actually a failure but we've decided that this
1571 * failure is ok.
1572 */
1574 }
1575 }
1581 }
1584 /*
1585 * For remote data, this adds the explanatory header
1586 * message to the remote IMAP folder.
1587 *
1588 * Args: rd -- Remote data handle
1589 * date -- The date string to use
1590 *
1591 * Result: 0 success
1592 * -1 failure
1593 */
1594 int
1596 {
1607 }
1612 /* Write the dummy message */
1632 }
1652 }
1672 }
1674 /* Take the message from "so" to the remote folder */
1680 else
1684 }
1687 }
1690 /*
1691 * Write some fake header lines into storage object rd->so.
1692 *
1693 * Args: rd
1694 * subject -- subject to put in header
1695 * subtype -- subtype to put in header
1696 * date -- date to put in header
1697 */
1698 int
1700 {
1707 RFC822BUFFER rbuf;
1742 }
1760 /* Write the fake headers */
1765 }
1768 /*
1769 * We have discovered that the data in the remote folder is suspicious.
1770 * In some cases it is just because it is from an old version of pine.
1771 * We have decided to update the data so that it won't look suspicious
1772 * next time.
1773 *
1774 * Args -- only_update_last If set, that means to just add a new last message
1775 * by calling rd_update_remote. Don't create a new
1776 * header message and delete the old header message.
1777 * nmsgs Not used if only_update_last is set
1778 */
1779 int
1781 {
1785 /*
1786 * We need to copy the data from the last message, add a new header
1787 * message with a random cookie, add the data back in with the
1788 * new cookie, and delete the old messages.
1789 */
1791 /* get data */
1794 /*
1795 * The local copy may be newer than the remote copy. We don't want to
1796 * blast the local copy in that case. The BELIEVE_CACHE flag tells us
1797 * to not do the blasting.
1798 */
1804 }
1811 }
1816 }
1823 /*
1824 * We've created a new header message and added a new copy of the
1825 * data after it. Only problem is that the new copy will have used
1826 * the original header message to get its cookie (== 1) from. We
1827 * could have deleted the original messages before the last step
1828 * to get it right but that would delete all copies of the data
1829 * temporarily. Delete now and then re-update.
1830 */
1838 }
1839 }
1842 }
1845 /*
1846 * Copy remote data to local file. If needed, the remote data is initialized
1847 * with no data. On success, the local file contains the remote data (which
1848 * means it will be empty if we initialized).
1849 *
1850 * Returns != 0 on failure
1851 * 0 on success
1852 */
1853 int
1855 {
1858 gf_io_t pc;
1873 }
1887 }
1894 }
1898 }
1901 }
1908 /* force ReadOnly */
1912 }
1913 else
1926 }
1932 }
1939 }
1949 }
1951 /* Copy the data into tempfile */
1964 }
1965 }
1967 /*
1968 * Copy from the last message in the folder.
1969 */
1978 }
1987 }
2000 }
2009 }
2020 }
2029 }
2033 else
2041 }
2055 }
2056 else
2057 /* attempt to upgrade cookie in last message */
2065 }
2068 /* store may have been written to at this point, so we'll clear it out */
2087 }
2088 }
2098 }
2101 }
2104 #ifdef _WINDOWS
2116 }
2117 else
2119 {
2129 }
2134 }
2141 /* turn off out of date flag */
2148 }
2157 }
2164 }
2165 }
2168 /*
2169 * Copy local data to remote folder.
2170 *
2171 * Args lf -- Local file name
2172 * rn -- Remote name
2173 * header_to_check -- Name of indicator header in remote folder
2174 * imapstuff -- Structure holding info about connection
2175 * returndate -- Pointer to the date that was stored in the remote folder
2176 *
2177 * Returns !=0 on failure
2178 * 0 on success
2179 */
2180 int
2182 {
2192 }
2204 }
2224 }
2236 }
2242 }
2246 /*
2247 * The data that will be going to the remote folder rn is
2248 * written into the following storage object and then copied to
2249 * the remote folder from there.
2250 */
2256 }
2257 else
2265 /* Reset the storage object, since we may have already used it. */
2277 /* save the date for later comparisons */
2281 /* Write the data */
2283 /*
2284 * C-client expects CRLF-terminated lines. Convert them
2285 * as we copy into c-client. Read ahead isn't available.
2286 * Leave CRLF as is, convert LF to CRLF, leave CR as is.
2287 */
2289 /* Convert \n to CRFL */
2294 }
2299 }
2300 }
2302 /*
2303 * Take that message from so to the remote folder.
2304 * We append to that folder and always
2305 * use the final message as the active data.
2306 */
2312 else
2317 }
2322 }
2323 else
2331 }
2334 /*
2335 * Check to see if the remote data has changed since we cached it.
2336 *
2337 * Args rd -- REMDATA handle
2338 * do_it_now -- If > 0, check now regardless
2339 * If = 0, check if time since last chk more than default
2340 * If < 0, check if time since last chk more than -do_it_now
2341 */
2342 void
2344 {
2357 }
2368 }
2376 }
2381 }
2382 else
2385 /* too soon to check again */
2397 /* make sure the cache file is still there */
2405 }
2407 /*
2408 * If the stream is open we should check there instead of using
2409 * a STATUS command. Check to see if it is really still alive with the
2410 * ping. It would be convenient if we could use a status command
2411 * on the open stream but apparently that won't work everywhere.
2412 */
2415 try_looking_in_stream:
2417 /*
2418 * Get the current number of messages in the folder to
2419 * compare with our saved number of messages.
2420 */
2426 got_cmsgs++;
2427 }
2430 /*
2431 * Try to use the imap status command
2432 * to get the information as cheaply as possible.
2433 * If NO_STATUSCMD is set we just bypass all this stuff.
2434 */
2439 /*
2440 * If we don't have a stream to use for the status command we
2441 * skip it and open the folder instead. Then, next time we want to
2442 * check we'll probably be able to use that open stream instead of
2443 * opening another one each time for the status command.
2444 */
2451 }
2453 /*
2454 * This sure seems like a crock. We have to check to
2455 * see if the stream is actually open to the folder
2456 * we want to do the status on because c-client can't
2457 * do a status on an open folder. In this case, we fake
2458 * the status command results ourselves.
2459 * If we're so unlucky as to get back a stream that will
2460 * work for the status command while we also have another
2461 * stream that is rd->rn and we don't pick up on that,
2462 * too bad.
2463 */
2472 }
2480 /* failed, mark it so we won't try again */
2486 }
2487 }
2490 }
2491 }
2493 /* if we got back a result from the status command, use it */
2500 got_cmsgs++;
2501 }
2502 }
2503 }
2505 /*
2506 * Check current_nmsgs versus what we think it should be.
2507 * If they're different we know things have changed and we can
2508 * return now. If they're the same we don't know.
2509 */
2516 }
2518 /*
2519 * Get the current uidvalidity and uidnext values from the
2520 * folder to compare with our saved values.
2521 */
2524 /*
2525 * Uid is valid so we just have to check whether or not the
2526 * uid of the last message has changed or not and return.
2527 */
2529 /* uid has changed so we're out of date */
2534 }
2537 }
2540 }
2542 /*
2543 * If the uidvalidity changed that probably means it can't
2544 * be relied on to be meaningful, so don't use it in the future.
2545 */
2550 }
2551 }
2557 /*
2558 * Uids are valid.
2559 */
2562 /*
2563 * Uidnext valid and unchanged, so the folder is unchanged.
2564 */
2567 }
2574 /*
2575 * Since c-client can't handle a status cmd on the selected
2576 * mailbox, we may have had to guess at the value of uidnext,
2577 * and we don't know for sure that this is a real change.
2578 * We need to open the mailbox and find out for sure.
2579 */
2584 imapuid_t last_msg_uid;
2602 }
2604 /*
2605 * The uid of the last message is the same as we
2606 * remembered, so the problem is that our guess
2607 * for the nextuid was wrong. It didn't actually
2608 * change. Since we know the correct uidnext now we
2609 * can reset that guess to the correct value for
2610 * next time, avoiding this extra mail_open.
2611 */
2619 }
2625 }
2631 }
2632 }
2633 }
2635 /*
2636 * If the status command doesn't return these or
2637 * if the uidvalidity is changing that probably means it can't
2638 * be relied on to be meaningful, so don't use it.
2639 *
2640 * We also come here if we don't have a stat_stream handy to
2641 * look up the status. This happens, for example, if our
2642 * address book is on a different server from the open mail
2643 * folders. In that case, instead of opening a stream,
2644 * doing a status command, and closing the stream, we open
2645 * the stream and use it to check next time, too.
2646 */
2652 }
2659 NULL);
2671 }
2672 }
2673 }
2675 /*
2676 * If we got here that means that we still don't know if the folder
2677 * changed or not. If the stream is open then it must be the case that
2678 * uidvalidity changed so we can't rely on using uids. If the stream
2679 * isn't open, then either the status command didn't work or the
2680 * uidvalidity changed. In any case, we need to fall back to looking
2681 * inside the folder at the last message and checking whether or not the
2682 * Date of the last message is the one we remembered.
2683 */
2688 /*
2689 * Fall back to looking in the folder at the Date header.
2690 */
2709 }
2718 }
2719 }
2726 }
2727 /* else, we give up and go with the cache copy */
2735 }
2738 /*
2739 * Returns nonzero if remote data is currently readonly.
2740 *
2741 * Returns 0 -- apparently writeable
2742 * 1 -- stream not open
2743 * 2 -- stream open but not writeable
2744 */
2745 int
2747 {
2762 }
2765 }
2768 /*
2769 * Returns 0 if ok
2770 * -1 if not ok and user says No
2771 * 1 if not ok but user says Yes, ok to use it
2772 */
2773 int
2775 {
2796 else
2800 }
2801 else
2811 }
2816 }