| blob | ac03c9a6fbc7e2f62cfb253be7b9a52295c31eb0 |
1 #if !defined(lint) && !defined(DOS)
3 #endif
5 /*
6 * ========================================================================
7 * Copyright 2013-2017 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 remote.c
21 Implements remote IMAP config files (remote config, remote abook).
22 ====*/
43 /*
44 * Internal prototypes
45 */
62 {
71 /*
72 * We don't cache the pinerc, we always copy it.
73 *
74 * Don't store the config in a temporary file, just leave it
75 * in memory while using it.
76 * It is currently required that NO_PERM_CACHE be set if NO_FILE is set.
77 */
80 create_the_remote_folder:
86 }
88 /* this will cause the remote folder to be created */
90 }
92 /*
93 * We could parse the name here to find what type it is. So far we
94 * only have type RemImap.
95 */
97 REMOTE_PINERC_SUBTYPE,
103 /*
104 * On first use we just use a temp file instead of memory (NO_FILE).
105 * In other words, for our convenience, we don't turn NO_FILE back on
106 * here. Why is that convenient? Because of the stuff that happened in
107 * rd_create_remote when flags was set to zero.
108 */
119 }
120 else
122 }
128 /*
129 * If the cached info says it is readonly but
130 * it looks like it's been fixed now, change it to readwrite.
131 */
134 /*
135 * We go to this trouble since readonly pinercs
136 * are likely a mistake. They are usually supposed to be
137 * readwrite so we open it and check if it's been fixed.
138 */
143 }
144 else
146 }
152 /*
153 * We don't check for the existence of the remote
154 * folder when this flag is turned on, so we could
155 * fail here because the remote folder doesn't exist.
156 * We try to create it.
157 */
158 no_perm_create_pass++;
160 }
164 /*
165 * Don't give up altogether. We still may be
166 * able to use a cached copy.
167 */
168 }
174 }
175 }
179 }
181 /* If we couldn't get to remote folder, try using the cached copy */
192 }
196 }
197 }
200 /* copy text, leave sonofile for later use */
202 else
205 bail_out:
211 }
214 }
217 /*
218 * Check if the remote data folder exists and create an empty folder
219 * if it doesn't exist.
220 *
221 * Args - type -- The type of remote storage.
222 * remote_name --
223 * type_spec -- Type-specific data.
224 * flags --
225 * err_prefix -- Should usually end with a SPACE
226 * err_suffix -- Should usually begin with a SPACE
227 *
228 * Returns a pointer to a REMDATA_S with access set to either
229 * NoExists or MaybeRorW. On success, "so" will point to a storage object.
230 */
231 REMDATA_S *
234 {
253 }
255 /*
256 * We're not going to check if it is there in this case,
257 * in order to save ourselves some round trips and
258 * connections. We'll just try to select it and then
259 * recover at that point if it isn't already there.
260 */
263 }
265 }
267 /*
268 * Open_fcc creates the folder if it didn't already exist.
269 */
272 /*
273 * We know the folder is there but don't know what access
274 * rights we have until we try to select it, which we don't
275 * want to do unless we have to. So delay evaluating.
276 */
278 }
279 }
286 }
289 }
292 REMDATA_S *
294 {
316 }
319 }
322 /*
323 * Closes the remote stream and frees.
324 */
325 void
327 {
340 }
345 }
361 }
364 }
365 }
368 /*
369 * Call this when finished with the remdata. This does the REMTRIM if the
370 * flag is set, the DEL_FILE if the flag is set. It also closes the stream
371 * and frees the rd.
372 */
373 void
375 {
381 /*
382 * Trim the number of saved copies of remote data history.
383 * The first message is a fake message that always
384 * stays there, then come ps_global->remote_abook_history messages
385 * which are each a revision of the data, then comes the active
386 * data.
387 */
392 /* make sure stream is open */
403 /*
404 * If user manually deleted some, we'd better not delete
405 * any more.
406 */
409 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 : "?"));
414 }
415 else
416 user_deleted++;
422 /* else
423 * don't update metafile because user is messing with
424 * the remote folder manually. We'd better re-read it next
425 * time. */
426 }
427 }
430 }
437 }
438 }
441 /*
442 * All done with this remote data. Trim the folder, close the
443 * stream, and free.
444 */
445 void
447 {
456 /* this closes the stream and frees memory */
458 }
461 /*
462 * Looks in the metadata file for the cache line corresponding to rd and
463 * fills in data in rd.
464 *
465 * Return value -- 1 if it is likely that the filename we're returning
466 * is the permanent name of the local cache file and it may already have
467 * a cached copy of the data. This is to tell us if it makes sense to use
468 * the cached copy when we are unable to contact the remote server.
469 * 0 otherwise.
470 */
471 int
473 {
485 else
494 }
496 /* display error */
502 }
503 }
509 /*
510 * This should be the normal case. The file is stored as a
511 * filename in the pinerc dir, so that it can be
512 * accessed from the PC or from unix where the pathnames to
513 * get there will be different.
514 */
523 }
527 }
531 }
534 /* don't free this below, we're using it */
536 }
564 }
568 }
569 /*
570 * The line for this data wasn't in the metadata file yet.
571 * Figure out what should go there and put it in.
572 */
574 /*
575 * The local_cache_file is where we will store the cached local
576 * copy of the remote data.
577 */
584 }
585 else
587 }
595 }
598 }
601 /*
602 * Write out the contents of the metadata file.
603 *
604 * Each line should be: folder_name cache_file uidvalidity uidnext uid nmsgs
605 * read_status date
606 *
607 * If delete_it is set, then remove the line instead of updating it.
608 *
609 * We have to be careful with the metadata, because it exists in user's
610 * existing metadata files now, and it is oriented towards only RemImap.
611 * We would have to change the version number and the format of the lines
612 * in the file if we add another type.
613 */
614 void
616 {
634 }
652 else
661 /*
662 * Write the header line.
663 */
669 /*
670 * Skip the header line and any lines that don't begin
671 * with a "{".
672 */
676 /* skip the old cache line for this key */
680 /* add this line to new version of file */
683 }
684 }
686 /* add the cache line for this key */
687 /* Warning: this is type RemImap specific right now! */
692 p ||
702 }
707 }
712 }
725 io_err:
735 }
742 }
745 void
747 {
760 /*
761 * If nmsgs < 2 then something is wrong. Maybe it is just
762 * that we haven't been told about the messages we've
763 * appended ourselves. Try closing and re-opening the stream
764 * to see those.
765 */
775 }
776 }
780 /*
781 * If nmsgs < 2 something is wrong.
782 */
787 }
792 /*
793 * Uid_last is not always valid. If the last known uid is
794 * greater than uid_last, go with it instead (uid+1).
795 * If our guess is wrong (too low), the penalty is not
796 * harsh. When the uidnexts don't match we open the
797 * mailbox to check the uid of the actual last message.
798 * If it was a false hit then we adjust uidnext so it
799 * will be correct the next time through.
800 */
803 }
804 }
808 /*
809 * Save the date so that we can check if it changed next time
810 * we go to write.
811 */
817 }
820 }
830 }
831 }
836 REMDATA_META_S *
838 {
852 /*
853 * Open the metadata file and get some information out.
854 */
869 }
871 /*
872 * If we make it to this point where we have opened the metadata file
873 * we return a structure (possibly empty) instead of just a NULL pointer.
874 */
878 /*
879 * Check for header line. If it isn't there or is incorrect,
880 * return with the empty rab. This call also positions the file pointer
881 * past the header line.
882 */
889 /* Make it size zero so we won't copy any bad stuff */
907 }
910 }
911 else
916 }
920 /* Look for our line */
925 #define SKIP_TO_TAB(p) do{while(*p && *p != TAB)p++;}while(0)
927 /*
928 * The line should be TAB-separated with fields:
929 * folder_name cache_file uidvalidity uidnext uid nmsgs read_status date
930 * This part is highly RemImap-specific right now.
931 */
967 p++;
971 }
972 }
973 }
974 }
975 }
976 }
977 }
978 }
982 }
985 /*
986 * Returns: -1 if this doesn't look like a metafile or some error,
987 * or if it looks like a non-current metafile.
988 * 0 if it looks like a current metafile.
989 *
990 * A side effect is that the file pointer will be pointing to the second
991 * line if 0 is returned.
992 */
993 int
995 {
1008 /* check for magic */
1016 /*
1017 * If we change to a new version, we may want to add code here to convert
1018 * or to cleanup after the old version. For example, it might just
1019 * remove the old cache files here.
1020 */
1022 /* check for matching version number */
1027 SIZEOF_VERSION_NUM)
1034 /* Position file pointer to second line */
1042 }
1045 /*
1046 * Open a data stream to the remote data.
1047 */
1048 void
1050 {
1062 }
1074 /* Don't try to reopen if there was a problem (auth failure, etc.) */
1079 /* this is a failure */
1081 }
1091 }
1092 }
1095 /*
1096 * Close a data stream to the remote data.
1097 */
1098 void
1100 {
1115 }
1116 }
1119 int
1121 {
1132 }
1135 }
1138 /*
1139 * Ping the stream and return 1 if it is still alive.
1140 */
1141 int
1143 {
1155 /*
1156 * If this stream is already actually open, officially open
1157 * it and use it.
1158 */
1166 }
1172 }
1173 }
1183 else
1192 }
1195 }
1198 /*
1199 * Change readonly access to readwrite if appropriate. Call this if
1200 * the remote data ought to be readwrite but it is marked readonly in
1201 * the metadata.
1202 */
1203 void
1205 {
1213 }
1221 }
1222 }
1223 }
1226 /*
1227 * Initialize remote data. The remote data is initialized
1228 * with no data. On success, the local file will be empty and the remote
1229 * folder (if type RemImap) will contain a header message and an empty
1230 * data message.
1231 * The remote folder already exists before we get here, though it may be empty.
1232 *
1233 * Returns -1 on failure
1234 * 0 on success
1235 */
1236 int
1238 {
1248 }
1250 /*
1251 * The rest is currently type RemImap-specific.
1252 */
1265 }
1267 /* already init'd */
1276 /*
1277 * We want to protect the user who specifies an actual address book
1278 * file on the remote system as a remote address book. For example,
1279 * they might say address-book={host}.addressbook where .addressbook
1280 * is just a file on host. Remote address books are folders, not
1281 * files. We also want to protect the user who specifies an existing
1282 * mail folder as a remote address book. We do that by requiring the
1283 * first message in the folder to be our header message.
1284 */
1301 }
1309 /*
1310 * The first message in a remote data folder is a special
1311 * header message. It is there as a way to explain what the
1312 * folder is to users who open it trying to read it. It is also
1313 * used as a consistency check so that we don't use a folder
1314 * that was being used for something else as a remote
1315 * data folder.
1316 */
1325 }
1342 }
1343 }
1344 }
1345 }
1347 /*
1348 * Add the second (empty) message.
1349 */
1357 }
1366 }
1378 }
1379 else
1388 }
1392 }
1403 }
1404 }
1405 }
1409 /* turn off out of date flag */
1411 }
1414 }
1417 /*
1418 * IMAP stream should already be open to a remote folder.
1419 * Check the first message in the folder to be sure it is the right
1420 * kind of message, not some message from some other folder.
1421 *
1422 * Returns 0 if ok, < 0 if invalid format.
1423 *
1424 */
1425 int
1427 {
1438 try_again:
1443 }
1455 }
1467 }
1475 }
1476 }
1477 else
1493 else
1495 }
1498 }
1507 }
1513 }
1516 /* null stream */
1519 }
1521 /* no messages in folder */
1526 }
1528 /* no cookie */
1533 }
1535 /* Received header */
1540 }
1543 /* cookie is 0 */
1545 /*
1546 * This is a failure and should not happen, but we're not going to
1547 * fail on this condition.
1548 */
1553 }
1562 }
1564 /* cookie is 1, upgrade it */
1566 /* now check again */
1568 tried_again++;
1570 }
1571 }
1573 /*
1574 * This is actually a failure but we've decided that this
1575 * failure is ok.
1576 */
1578 }
1579 }
1585 }
1588 /*
1589 * For remote data, this adds the explanatory header
1590 * message to the remote IMAP folder.
1591 *
1592 * Args: rd -- Remote data handle
1593 * date -- The date string to use
1594 *
1595 * Result: 0 success
1596 * -1 failure
1597 */
1598 int
1600 {
1611 }
1616 /* Write the dummy message */
1636 }
1656 }
1676 }
1678 /* Take the message from "so" to the remote folder */
1684 else
1688 }
1691 }
1694 /*
1695 * Write some fake header lines into storage object rd->so.
1696 *
1697 * Args: rd
1698 * subject -- subject to put in header
1699 * subtype -- subtype to put in header
1700 * date -- date to put in header
1701 */
1702 int
1704 {
1711 RFC822BUFFER rbuf;
1746 }
1764 /* Write the fake headers */
1769 }
1772 /*
1773 * We have discovered that the data in the remote folder is suspicious.
1774 * In some cases it is just because it is from an old version of pine.
1775 * We have decided to update the data so that it won't look suspicious
1776 * next time.
1777 *
1778 * Args -- only_update_last If set, that means to just add a new last message
1779 * by calling rd_update_remote. Don't create a new
1780 * header message and delete the old header message.
1781 * nmsgs Not used if only_update_last is set
1782 */
1783 int
1785 {
1789 /*
1790 * We need to copy the data from the last message, add a new header
1791 * message with a random cookie, add the data back in with the
1792 * new cookie, and delete the old messages.
1793 */
1795 /* get data */
1798 /*
1799 * The local copy may be newer than the remote copy. We don't want to
1800 * blast the local copy in that case. The BELIEVE_CACHE flag tells us
1801 * to not do the blasting.
1802 */
1808 }
1815 }
1820 }
1827 /*
1828 * We've created a new header message and added a new copy of the
1829 * data after it. Only problem is that the new copy will have used
1830 * the original header message to get its cookie (== 1) from. We
1831 * could have deleted the original messages before the last step
1832 * to get it right but that would delete all copies of the data
1833 * temporarily. Delete now and then re-update.
1834 */
1842 }
1843 }
1846 }
1849 /*
1850 * Copy remote data to local file. If needed, the remote data is initialized
1851 * with no data. On success, the local file contains the remote data (which
1852 * means it will be empty if we initialized).
1853 *
1854 * Returns != 0 on failure
1855 * 0 on success
1856 */
1857 int
1859 {
1862 gf_io_t pc;
1877 }
1891 }
1898 }
1902 }
1905 }
1912 /* force ReadOnly */
1916 }
1917 else
1930 }
1936 }
1943 }
1953 }
1955 /* Copy the data into tempfile */
1968 }
1969 }
1971 /*
1972 * Copy from the last message in the folder.
1973 */
1982 }
1991 }
2004 }
2013 }
2024 }
2033 }
2037 else
2045 }
2059 }
2060 else
2061 /* attempt to upgrade cookie in last message */
2069 }
2072 /* store may have been written to at this point, so we'll clear it out */
2091 }
2092 }
2102 }
2105 }
2108 #ifdef _WINDOWS
2120 }
2121 else
2123 {
2133 }
2138 }
2145 /* turn off out of date flag */
2152 }
2161 }
2168 }
2169 }
2172 /*
2173 * Copy local data to remote folder.
2174 *
2175 * Args lf -- Local file name
2176 * rn -- Remote name
2177 * header_to_check -- Name of indicator header in remote folder
2178 * imapstuff -- Structure holding info about connection
2179 * returndate -- Pointer to the date that was stored in the remote folder
2180 *
2181 * Returns !=0 on failure
2182 * 0 on success
2183 */
2184 int
2186 {
2196 }
2208 }
2228 }
2240 }
2246 }
2250 /*
2251 * The data that will be going to the remote folder rn is
2252 * written into the following storage object and then copied to
2253 * the remote folder from there.
2254 */
2260 }
2261 else
2269 /* Reset the storage object, since we may have already used it. */
2281 /* save the date for later comparisons */
2285 /* Write the data */
2287 /*
2288 * C-client expects CRLF-terminated lines. Convert them
2289 * as we copy into c-client. Read ahead isn't available.
2290 * Leave CRLF as is, convert LF to CRLF, leave CR as is.
2291 */
2293 /* Convert \n to CRFL */
2298 }
2303 }
2304 }
2306 /*
2307 * Take that message from so to the remote folder.
2308 * We append to that folder and always
2309 * use the final message as the active data.
2310 */
2316 else
2321 }
2326 }
2327 else
2335 }
2338 /*
2339 * Check to see if the remote data has changed since we cached it.
2340 *
2341 * Args rd -- REMDATA handle
2342 * do_it_now -- If > 0, check now regardless
2343 * If = 0, check if time since last chk more than default
2344 * If < 0, check if time since last chk more than -do_it_now
2345 */
2346 void
2348 {
2361 }
2372 }
2380 }
2385 }
2386 else
2389 /* too soon to check again */
2401 /* make sure the cache file is still there */
2409 }
2411 /*
2412 * If the stream is open we should check there instead of using
2413 * a STATUS command. Check to see if it is really still alive with the
2414 * ping. It would be convenient if we could use a status command
2415 * on the open stream but apparently that won't work everywhere.
2416 */
2419 try_looking_in_stream:
2421 /*
2422 * Get the current number of messages in the folder to
2423 * compare with our saved number of messages.
2424 */
2430 got_cmsgs++;
2431 }
2434 /*
2435 * Try to use the imap status command
2436 * to get the information as cheaply as possible.
2437 * If NO_STATUSCMD is set we just bypass all this stuff.
2438 */
2443 /*
2444 * If we don't have a stream to use for the status command we
2445 * skip it and open the folder instead. Then, next time we want to
2446 * check we'll probably be able to use that open stream instead of
2447 * opening another one each time for the status command.
2448 */
2455 }
2457 /*
2458 * This sure seems like a crock. We have to check to
2459 * see if the stream is actually open to the folder
2460 * we want to do the status on because c-client can't
2461 * do a status on an open folder. In this case, we fake
2462 * the status command results ourselves.
2463 * If we're so unlucky as to get back a stream that will
2464 * work for the status command while we also have another
2465 * stream that is rd->rn and we don't pick up on that,
2466 * too bad.
2467 */
2476 }
2484 /* failed, mark it so we won't try again */
2490 }
2491 }
2494 }
2495 }
2497 /* if we got back a result from the status command, use it */
2504 got_cmsgs++;
2505 }
2506 }
2507 }
2509 /*
2510 * Check current_nmsgs versus what we think it should be.
2511 * If they're different we know things have changed and we can
2512 * return now. If they're the same we don't know.
2513 */
2520 }
2522 /*
2523 * Get the current uidvalidity and uidnext values from the
2524 * folder to compare with our saved values.
2525 */
2528 /*
2529 * Uid is valid so we just have to check whether or not the
2530 * uid of the last message has changed or not and return.
2531 */
2533 /* uid has changed so we're out of date */
2538 }
2541 }
2544 }
2546 /*
2547 * If the uidvalidity changed that probably means it can't
2548 * be relied on to be meaningful, so don't use it in the future.
2549 */
2554 }
2555 }
2561 /*
2562 * Uids are valid.
2563 */
2566 /*
2567 * Uidnext valid and unchanged, so the folder is unchanged.
2568 */
2571 }
2578 /*
2579 * Since c-client can't handle a status cmd on the selected
2580 * mailbox, we may have had to guess at the value of uidnext,
2581 * and we don't know for sure that this is a real change.
2582 * We need to open the mailbox and find out for sure.
2583 */
2588 imapuid_t last_msg_uid;
2606 }
2608 /*
2609 * The uid of the last message is the same as we
2610 * remembered, so the problem is that our guess
2611 * for the nextuid was wrong. It didn't actually
2612 * change. Since we know the correct uidnext now we
2613 * can reset that guess to the correct value for
2614 * next time, avoiding this extra mail_open.
2615 */
2623 }
2629 }
2635 }
2636 }
2637 }
2639 /*
2640 * If the status command doesn't return these or
2641 * if the uidvalidity is changing that probably means it can't
2642 * be relied on to be meaningful, so don't use it.
2643 *
2644 * We also come here if we don't have a stat_stream handy to
2645 * look up the status. This happens, for example, if our
2646 * address book is on a different server from the open mail
2647 * folders. In that case, instead of opening a stream,
2648 * doing a status command, and closing the stream, we open
2649 * the stream and use it to check next time, too.
2650 */
2656 }
2663 NULL);
2675 }
2676 }
2677 }
2679 /*
2680 * If we got here that means that we still don't know if the folder
2681 * changed or not. If the stream is open then it must be the case that
2682 * uidvalidity changed so we can't rely on using uids. If the stream
2683 * isn't open, then either the status command didn't work or the
2684 * uidvalidity changed. In any case, we need to fall back to looking
2685 * inside the folder at the last message and checking whether or not the
2686 * Date of the last message is the one we remembered.
2687 */
2692 /*
2693 * Fall back to looking in the folder at the Date header.
2694 */
2713 }
2722 }
2723 }
2730 }
2731 /* else, we give up and go with the cache copy */
2739 }
2742 /*
2743 * Returns nonzero if remote data is currently readonly.
2744 *
2745 * Returns 0 -- apparently writeable
2746 * 1 -- stream not open
2747 * 2 -- stream open but not writeable
2748 */
2749 int
2751 {
2766 }
2769 }
2772 /*
2773 * Returns 0 if ok
2774 * -1 if not ok and user says No
2775 * 1 if not ok but user says Yes, ok to use it
2776 */
2777 int
2779 {
2800 else
2804 }
2805 else
2815 }
2820 }