imap_cache.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ A cache for IMAP.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2014 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
   6  */
   7 /*
   8  * Copyright (c) 2004
   9  * Gunnar Ritter.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *    This product includes software developed by Gunnar Ritter
  22  *    and his contributors.
  23  * 4. Neither the name of Gunnar Ritter nor the names of his contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY GUNNAR RITTER AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL GUNNAR RITTER OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  */
  39
  40 #ifndef HAVE_AMALGAMATION
  41 # include "nail.h"
  42 #endif
  43
  44 EMPTY_FILE(imap_cache)
  45 #ifdef HAVE_IMAP
  46 # include <dirent.h>
  47
  48 static char *           encname(struct mailbox *mp, const char *name, int same,
  49                            const char *box);
  50 static char *           encuid(struct mailbox *mp, unsigned long uid);
  51 static FILE *           clean(struct mailbox *mp, struct cw *cw);
  52 static unsigned long *  builds(long *contentelem);
  53 static void             purge(struct mailbox *mp, struct message *m, long mc,
  54                            struct cw *cw, const char *name);
  55 static int              longlt(const void *a, const void *b);
  56 static void             remve(unsigned long n);
  57 static FILE *           cache_queue1(struct mailbox *mp, char const *mode,
  58                            char **xname);
  59 static enum okay        dequeue1(struct mailbox *mp);
  60
  61 static const char infofmt[] = "%c %lu %d %lu %ld";
  62 #define INITSKIP 128L
  63 #define USEBITS(f)  \
  64    ((f) & (MSAVED|MDELETED|MREAD|MBOXED|MNEW|MFLAGGED|MANSWERED|MDRAFTED))
  65
  66 static const char README1[] = "\
  67 This is a cache directory maintained by " UAGENT "(1).\n\
  68 You should not change any files within.\n\
  69 Nevertheless, the structure is as follows: Each subdirectory of the\n\
  70 current directory represents an IMAP account, and each subdirectory\n\
  71 below that represents a mailbox. Each mailbox directory contains a file\n\
  72 named UIDVALIDITY which describes the validity in relation to the version\n\
  73 on the server. Other files have names corresponding to their IMAP UID.\n";
  74 static const char README2[] = "\n\
  75 The first 128 bytes of these files are used to store message attributes; the\n\
  76 following data is equivalent to compress(1) output. So if you have to save a\n\
  77 message by hand because of an emergency, throw away the first 128 bytes and\n\
  78 decompress the rest, as e.g. 'dd if=MESSAGEFILE skip=1 bs=128 | zcat' does.\n";
  79 static const char README3[] = "\n\
  80 Files named QUEUE contain data that will be sent do the IMAP server next\n\
  81 time a connection is made in online mode.\n";
  82 static const char README4[] = "\n\
  83 You can safely delete any file or directory here, unless it contains a QUEUE\n\
  84 file that is not empty; " UAGENT " will download the data again and will also\n\
  85 write new cache entries if configured in this way. If you do not wish to use\n\
  86 the cache anymore, delete the entire directory and unset the 'imap-cache'\n\
  87 variable in " UAGENT "(1).\n";
  88 static const char README5[] = "\n\
  89 For more information about " UAGENT "(1), visit\n\
  90 <http://sdaoden.users.sourceforge.net/code.html>.\n"; /* TODO MAGIC CONSTANT */
  91
  92 static char *
  93 encname(struct mailbox *mp, const char *name, int same, const char *box)
  94 {
  95    char *cachedir, *eaccount, *ename, *res;
  96    char const *emailbox;
  97    int resz;
  98    NYD_ENTER;
  99
 100    ename = urlxenc(name);
 101    if (mp->mb_cache_directory && same && box == NULL) {
 102       res = salloc(resz = strlen(mp->mb_cache_directory) + strlen(ename) + 2);
 103       snprintf(res, resz, "%s%s%s", mp->mb_cache_directory,
 104          (*ename ? "/" : ""), ename);
 105    } else {
 106       if ((cachedir = ok_vlook(imap_cache)) == NULL ||
 107             (cachedir = file_expand(cachedir)) == NULL) {
 108          res = NULL;
 109          goto jleave;
 110       }
 111       eaccount = urlxenc(mp->mb_imap_account);
 112       if (box)
 113          emailbox = urlxenc(box);
 114       else if (asccasecmp(mp->mb_imap_mailbox, "INBOX"))
 115          emailbox = urlxenc(mp->mb_imap_mailbox);
 116       else
 117          emailbox = "INBOX";
 118       res = salloc(resz = strlen(cachedir) + strlen(eaccount) +
 119             strlen(emailbox) + strlen(ename) + 4);
 120       snprintf(res, resz, "%s/%s/%s%s%s", cachedir, eaccount, emailbox,
 121             (*ename ? "/" : ""), ename);
 122    }
 123 jleave:
 124    NYD_LEAVE;
 125    return res;
 126 }
 127
 128 static char *
 129 encuid(struct mailbox *mp, unsigned long uid)
 130 {
 131    char buf[30], *cp;
 132    NYD_ENTER;
 133
 134    snprintf(buf, sizeof buf, "%lu", uid);
 135    cp = encname(mp, buf, 1, NULL);
 136    NYD_LEAVE;
 137    return cp;
 138 }
 139
 140 FL enum okay
 141 getcache1(struct mailbox *mp, struct message *m, enum needspec need,
 142    int setflags)
 143 {
 144    FILE *fp;
 145    long n = 0, size = 0, xsize, xtime, xlines = -1, lines = 0;
 146    int lastc = EOF, i, xflag, inheader = 1;
 147    char b, iob[32768];
 148    off_t offset;
 149    void *zp;
 150    enum okay rv = STOP;
 151    NYD_ENTER;
 152
 153    if (setflags == 0 && ((mp->mb_type != MB_IMAP && mp->mb_type != MB_CACHE) ||
 154          m->m_uid == 0))
 155       goto jleave;
 156    if ((fp = Fopen(encuid(mp, m->m_uid), "r")) == NULL)
 157       goto jleave;
 158
 159    fcntl_lock(fileno(fp), FLOCK_READ);
 160    if (fscanf(fp, infofmt, &b, (unsigned long*)&xsize, &xflag,
 161          (unsigned long*)&xtime, &xlines) < 4)
 162       goto jfail;
 163    if (need != NEED_UNSPEC) {
 164       switch (b) {
 165       case 'H':
 166          if (need == NEED_HEADER)
 167             goto jsuccess;
 168          goto jfail;
 169       case 'B':
 170          if (need == NEED_HEADER || need == NEED_BODY)
 171             goto jsuccess;
 172          goto jfail;
 173       default:
 174          goto jfail;
 175       }
 176    }
 177 jsuccess:
 178    if (b == 'N')
 179       goto jflags;
 180    if (fseek(fp, INITSKIP, SEEK_SET) < 0)
 181       goto jfail;
 182    zp = zalloc(fp);
 183    if (fseek(mp->mb_otf, 0L, SEEK_END) < 0) {
 184       zfree(zp);
 185       goto jfail;
 186    }
 187    offset = ftell(mp->mb_otf);
 188    while (inheader && (n = zread(zp, iob, sizeof iob)) > 0) {
 189       size += n;
 190       for (i = 0; i < n; i++) {
 191          if (iob[i] == '\n') {
 192             lines++;
 193             if (lastc == '\n')
 194                inheader = 0;
 195          }
 196          lastc = iob[i]&0377;
 197       }
 198       fwrite(iob, 1, n, mp->mb_otf);
 199    }
 200    if (n > 0 && need == NEED_BODY) {
 201       while ((n = zread(zp, iob, sizeof iob)) > 0) {
 202          size += n;
 203          for (i = 0; i < n; i++)
 204             if (iob[i] == '\n')
 205                lines++;
 206          fwrite(iob, 1, n, mp->mb_otf);
 207       }
 208    }
 209    fflush(mp->mb_otf);
 210    if (zfree(zp) < 0 || n < 0 || ferror(fp) || ferror(mp->mb_otf))
 211       goto jfail;
 212
 213    m->m_size = size;
 214    m->m_lines = lines;
 215    m->m_block = mailx_blockof(offset);
 216    m->m_offset = mailx_offsetof(offset);
 217 jflags:
 218    if (setflags) {
 219       m->m_xsize = xsize;
 220       m->m_time = xtime;
 221       if (setflags & 2) {
 222          m->m_flag = xflag | MNOFROM;
 223          if (b != 'B')
 224             m->m_flag |= MHIDDEN;
 225       }
 226    }
 227    if (xlines > 0 && m->m_xlines <= 0)
 228       m->m_xlines = xlines;
 229    switch (b) {
 230    case 'B':
 231       m->m_xsize = xsize;
 232       if (xflag == MREAD && xlines > 0)
 233          m->m_flag |= MFULLYCACHED;
 234       if (need == NEED_BODY) {
 235          m->m_have |= HAVE_HEADER | HAVE_BODY;
 236          if (m->m_lines > 0)
 237             m->m_xlines = m->m_lines;
 238          break;
 239       }
 240       /*FALLTHRU*/
 241    case 'H':
 242       m->m_have |= HAVE_HEADER;
 243       break;
 244    case 'N':
 245       break;
 246    }
 247    rv = OKAY;
 248 jfail:
 249    Fclose(fp);
 250 jleave:
 251    NYD_LEAVE;
 252    return rv;
 253 }
 254
 255 FL enum okay
 256 getcache(struct mailbox *mp, struct message *m, enum needspec need)
 257 {
 258    enum okay rv;
 259    NYD_ENTER;
 260
 261    rv = getcache1(mp, m, need, 0);
 262    NYD_LEAVE;
 263    return rv;
 264 }
 265
 266 FL void
 267 putcache(struct mailbox *mp, struct message *m)
 268 {
 269    char iob[32768], *name, ob;
 270    FILE *ibuf, *obuf;
 271    int c, oflag;
 272    long n, cnt, oldoffset, osize, otime, olines = -1;
 273    void *zp;
 274    NYD_ENTER;
 275
 276    if ((mp->mb_type != MB_IMAP && mp->mb_type != MB_CACHE) || m->m_uid == 0 ||
 277          m->m_time == 0 || (m->m_flag & (MTOUCH|MFULLYCACHED)) == MFULLYCACHED)
 278       goto jleave;
 279    if (m->m_have & HAVE_BODY)
 280       c = 'B';
 281    else if (m->m_have & HAVE_HEADER)
 282       c = 'H';
 283    else if (m->m_have == HAVE_NOTHING)
 284       c = 'N';
 285    else
 286       goto jleave;
 287    if ((oldoffset = ftell(mp->mb_itf)) < 0) /* XXX weird err hdling */
 288       oldoffset = 0;
 289    if ((obuf = Fopen(name = encuid(mp, m->m_uid), "r+")) == NULL) {
 290       if ((obuf = Fopen(name, "w")) == NULL)
 291          goto jleave;
 292       fcntl_lock(fileno(obuf), FLOCK_WRITE); /* XXX err hdl */
 293    } else {
 294       fcntl_lock(fileno(obuf), FLOCK_READ); /* XXX err hdl */
 295       if (fscanf(obuf, infofmt, &ob, (unsigned long*)&osize, &oflag,
 296             (unsigned long*)&otime, &olines) >= 4 && ob != '\0' &&
 297             (ob == 'B' || (ob == 'H' && c != 'B'))) {
 298          if (m->m_xlines <= 0 && olines > 0)
 299             m->m_xlines = olines;
 300          if ((c != 'N' && (size_t)osize != m->m_xsize) ||
 301                oflag != (int)USEBITS(m->m_flag) || otime != m->m_time ||
 302                (m->m_xlines > 0 && olines != m->m_xlines)) {
 303             fflush(obuf);
 304             rewind(obuf);
 305             fprintf(obuf, infofmt, ob, (unsigned long)m->m_xsize,
 306                USEBITS(m->m_flag), (unsigned long)m->m_time, m->m_xlines);
 307             putc('\n', obuf);
 308          }
 309          Fclose(obuf);
 310          goto jleave;
 311       }
 312       fflush(obuf);
 313       rewind(obuf);
 314       ftruncate(fileno(obuf), 0);
 315    }
 316    if ((ibuf = setinput(mp, m, NEED_UNSPEC)) == NULL) {
 317       Fclose(obuf);
 318       goto jleave;
 319    }
 320    if (c == 'N')
 321       goto jdone;
 322    fseek(obuf, INITSKIP, SEEK_SET);
 323    zp = zalloc(obuf);
 324    cnt = m->m_size;
 325    while (cnt > 0) {
 326       n = (cnt > (long)sizeof iob) ? (long)sizeof iob : cnt;
 327       cnt -= n;
 328       if ((size_t)n != fread(iob, 1, n, ibuf) ||
 329             n != (long)zwrite(zp, iob, n)) {
 330          unlink(name);
 331          zfree(zp);
 332          goto jout;
 333       }
 334    }
 335    if (zfree(zp) < 0) {
 336       unlink(name);
 337       goto jout;
 338    }
 339 jdone:
 340    rewind(obuf);
 341    fprintf(obuf, infofmt, c, (unsigned long)m->m_xsize, USEBITS(m->m_flag),
 342          (unsigned long)m->m_time, m->m_xlines);
 343    putc('\n', obuf);
 344    if (ferror(obuf)) {
 345       unlink(name);
 346       goto jout;
 347    }
 348    if (c == 'B' && USEBITS(m->m_flag) == MREAD)
 349       m->m_flag |= MFULLYCACHED;
 350 jout:
 351    if (Fclose(obuf) != 0) {
 352       m->m_flag &= ~MFULLYCACHED;
 353       unlink(name);
 354    }
 355    (void)fseek(mp->mb_itf, oldoffset, SEEK_SET);
 356 jleave:
 357    NYD_LEAVE;
 358 }
 359
 360 FL void
 361 initcache(struct mailbox *mp)
 362 {
 363    char *name, *uvname;
 364    FILE *uvfp;
 365    unsigned long uv;
 366    struct cw cw;
 367    NYD_ENTER;
 368
 369    if (mp->mb_cache_directory != NULL)
 370       free(mp->mb_cache_directory);
 371    mp->mb_cache_directory = NULL;
 372    if ((name = encname(mp, "", 1, NULL)) == NULL)
 373       goto jleave;
 374    mp->mb_cache_directory = sstrdup(name);
 375    if ((uvname = encname(mp, "UIDVALIDITY", 1, NULL)) == NULL)
 376       goto jleave;
 377    if (cwget(&cw) == STOP)
 378       goto jleave;
 379    if ((uvfp = Fopen(uvname, "r+")) == NULL ||
 380          (fcntl_lock(fileno(uvfp), FLOCK_READ), 0) ||
 381          fscanf(uvfp, "%lu", &uv) != 1 || uv != mp->mb_uidvalidity) {
 382       if ((uvfp = clean(mp, &cw)) == NULL)
 383          goto jout;
 384    } else {
 385       fflush(uvfp);
 386       rewind(uvfp);
 387    }
 388    fcntl_lock(fileno(uvfp), FLOCK_WRITE);
 389    fprintf(uvfp, "%lu\n", mp->mb_uidvalidity);
 390    if (ferror(uvfp) || Fclose(uvfp) != 0) {
 391       unlink(uvname);
 392       mp->mb_uidvalidity = 0;
 393    }
 394 jout:
 395    cwrelse(&cw);
 396 jleave:
 397    NYD_LEAVE;
 398 }
 399
 400 FL void
 401 purgecache(struct mailbox *mp, struct message *m, long mc)
 402 {
 403    char *name;
 404    struct cw cw;
 405    NYD_ENTER;
 406
 407    if ((name = encname(mp, "", 1, NULL)) == NULL)
 408       goto jleave;
 409    if (cwget(&cw) == STOP)
 410       goto jleave;
 411    purge(mp, m, mc, &cw, name);
 412    cwrelse(&cw);
 413 jleave:
 414    NYD_LEAVE;
 415 }
 416
 417 static FILE *
 418 clean(struct mailbox *mp, struct cw *cw)
 419 {
 420    char *cachedir, *eaccount, *buf;
 421    char const *emailbox;
 422    int bufsz;
 423    DIR *dirp;
 424    struct dirent *dp;
 425    FILE *fp = NULL;
 426    NYD_ENTER;
 427
 428    if ((cachedir = ok_vlook(imap_cache)) == NULL ||
 429          (cachedir = file_expand(cachedir)) == NULL)
 430       goto jleave;
 431    eaccount = urlxenc(mp->mb_imap_account);
 432    if (asccasecmp(mp->mb_imap_mailbox, "INBOX"))
 433       emailbox = urlxenc(mp->mb_imap_mailbox);
 434    else
 435       emailbox = "INBOX";
 436    buf = salloc(bufsz = strlen(cachedir) + strlen(eaccount) +
 437          strlen(emailbox) + 40);
 438    if (makedir(cachedir) != OKAY)
 439       goto jleave;
 440    snprintf(buf, bufsz, "%s/README", cachedir);
 441    if ((fp = Fopen(buf, "wx")) != NULL) {
 442       fputs(README1, fp);
 443       fputs(README2, fp);
 444       fputs(README3, fp);
 445       fputs(README4, fp);
 446       fputs(README5, fp);
 447       Fclose(fp);
 448    }
 449    fp = NULL;
 450    snprintf(buf, bufsz, "%s/%s", cachedir, eaccount);
 451    if (makedir(buf) != OKAY)
 452       goto jleave;
 453    snprintf(buf, bufsz, "%s/%s/%s", cachedir, eaccount, emailbox);
 454    if (makedir(buf) != OKAY)
 455       goto jleave;
 456    if (chdir(buf) < 0)
 457       goto jleave;
 458    if ((dirp = opendir(".")) == NULL)
 459       goto jout;
 460    while ((dp = readdir(dirp)) != NULL) {
 461       if (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' ||
 462             (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
 463          continue;
 464       unlink(dp->d_name);
 465    }
 466    closedir(dirp);
 467    fp = Fopen("UIDVALIDITY", "w");
 468 jout:
 469    if (cwret(cw) == STOP) {
 470       fputs("Fatal: Cannot change back to current directory.\n", stderr);
 471       abort();
 472    }
 473 jleave:
 474    NYD_LEAVE;
 475    return fp;
 476 }
 477
 478 static unsigned long *
 479 builds(long *contentelem)
 480 {
 481    unsigned long n, *contents = NULL;
 482    long contentalloc = 0;
 483    char *x;
 484    DIR *dirp;
 485    struct dirent *dp;
 486    NYD_ENTER;
 487
 488    *contentelem = 0;
 489    if ((dirp = opendir(".")) == NULL)
 490       goto jleave;
 491    while ((dp = readdir(dirp)) != NULL) {
 492       if (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' ||
 493             (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
 494          continue;
 495       n = strtoul(dp->d_name, &x, 10);
 496       if (*x != '\0')
 497          continue;
 498       if (*contentelem >= contentalloc - 1)
 499          contents = srealloc(contents,
 500                (contentalloc += 200) * sizeof *contents);
 501       contents[(*contentelem)++] = n;
 502    }
 503    closedir(dirp);
 504    if (*contentelem > 0) {
 505       contents[*contentelem] = 0;
 506       qsort(contents, *contentelem, sizeof *contents, longlt);
 507    }
 508 jleave:
 509    NYD_LEAVE;
 510    return contents;
 511 }
 512
 513 static void
 514 purge(struct mailbox *mp, struct message *m, long mc, struct cw *cw,
 515    const char *name)
 516 {
 517    unsigned long *contents;
 518    long i, j, contentelem;
 519    NYD_ENTER;
 520    UNUSED(mp);
 521
 522    if (chdir(name) < 0)
 523       goto jleave;
 524    contents = builds(&contentelem);
 525    if (contents) {
 526       i = j = 0;
 527       while (j < contentelem) {
 528          if (i < mc && m[i].m_uid == contents[j]) {
 529             i++;
 530             j++;
 531          } else if (i < mc && m[i].m_uid < contents[j])
 532             i++;
 533          else
 534             remve(contents[j++]);
 535       }
 536    }
 537    if (cwret(cw) == STOP) {
 538       fputs("Fatal: Cannot change back to current directory.\n", stderr);
 539       abort();
 540    }
 541    if (contents != NULL)
 542       free(contents);
 543 jleave:
 544    NYD_LEAVE;
 545 }
 546
 547 static int
 548 longlt(const void *a, const void *b)
 549 {
 550    union {long l; int i;} u;
 551    NYD_ENTER;
 552
 553    u.l = *(long const*)a - *(long const*)b;
 554    u.i = (u.l < 0) ? -1 : ((u.l > 0) ? 1 : 0);
 555    NYD_LEAVE;
 556    return u.i;
 557 }
 558
 559 static void
 560 remve(unsigned long n)
 561 {
 562    char buf[30];
 563    NYD_ENTER;
 564
 565    snprintf(buf, sizeof buf, "%lu", n);
 566    unlink(buf);
 567    NYD_LEAVE;
 568 }
 569
 570 FL void
 571 delcache(struct mailbox *mp, struct message *m)
 572 {
 573    char *fn;
 574    NYD_ENTER;
 575
 576    fn = encuid(mp, m->m_uid);
 577    if (fn && unlink(fn) == 0)
 578       m->m_flag |= MUNLINKED;
 579    NYD_LEAVE;
 580 }
 581
 582 FL enum okay
 583 cache_setptr(int transparent)
 584 {
 585    struct cw cw;
 586    int i, omsgCount = 0;
 587    char *name;
 588    unsigned long *contents;
 589    long contentelem;
 590    struct message *omessage = NULL;
 591    enum okay rv = STOP;
 592    NYD_ENTER;
 593
 594    if (transparent) {
 595       omessage = message;
 596       omsgCount = msgCount;
 597    }
 598    free(mb.mb_cache_directory);
 599    mb.mb_cache_directory = NULL;
 600    if ((name = encname(&mb, "", 1, NULL)) == NULL)
 601       goto jleave;
 602    mb.mb_cache_directory = sstrdup(name);
 603    if (cwget(&cw) == STOP)
 604       goto jleave;
 605    if (chdir(name) < 0)
 606       goto jleave;
 607    contents = builds(&contentelem);
 608    msgCount = contentelem;
 609    message = scalloc(msgCount + 1, sizeof *message);
 610    if (cwret(&cw) == STOP) {
 611       fputs("Fatal: Cannot change back to current directory.\n", stderr);
 612       abort();
 613    }
 614    cwrelse(&cw);
 615    for (i = 0; i < msgCount; i++) {
 616       message[i].m_uid = contents[i];
 617       getcache1(&mb, &message[i], NEED_UNSPEC, 3);
 618    }
 619    mb.mb_type = MB_CACHE;
 620    mb.mb_perm = (options & OPT_R_FLAG) ? 0 : MB_DELE;
 621    if (transparent)
 622       transflags(omessage, omsgCount, 1);
 623    else
 624       setdot(message);
 625    rv = OKAY;
 626 jleave:
 627    NYD_LEAVE;
 628    return rv;
 629 }
 630
 631 FL enum okay
 632 cache_list(struct mailbox *mp, const char *base, int strip, FILE *fp)
 633 {
 634    char *name, *cachedir, *eaccount;
 635    DIR *dirp;
 636    struct dirent *dp;
 637    const char *cp, *bp, *sp;
 638    int namesz;
 639    enum okay rv = STOP;
 640    NYD_ENTER;
 641
 642    if ((cachedir = ok_vlook(imap_cache)) == NULL ||
 643          (cachedir = file_expand(cachedir)) == NULL)
 644       goto jleave;
 645    eaccount = urlxenc(mp->mb_imap_account);
 646    name = salloc(namesz = strlen(cachedir) + strlen(eaccount) + 2);
 647    snprintf(name, namesz, "%s/%s", cachedir, eaccount);
 648    if ((dirp = opendir(name)) == NULL)
 649       goto jleave;
 650    while ((dp = readdir(dirp)) != NULL) {
 651       if (dp->d_name[0] == '.')
 652          continue;
 653       cp = sp = urlxdec(dp->d_name);
 654       for (bp = base; *bp && *bp == *sp; bp++)
 655          sp++;
 656       if (*bp)
 657          continue;
 658       cp = strip ? sp : cp;
 659       fprintf(fp, "%s\n", *cp ? cp : "INBOX");
 660    }
 661    closedir(dirp);
 662    rv = OKAY;
 663 jleave:
 664    NYD_LEAVE;
 665    return rv;
 666 }
 667
 668 FL enum okay
 669 cache_remove(const char *name)
 670 {
 671    struct stat st;
 672    DIR *dirp;
 673    struct dirent *dp;
 674    char *path, *dir;
 675    int pathsize, pathend, n;
 676    enum okay rv = OKAY;
 677    NYD_ENTER;
 678
 679    if ((dir = encname(&mb, "", 0, imap_fileof(name))) == NULL)
 680       goto jleave;
 681    pathend = strlen(dir);
 682    path = smalloc(pathsize = pathend + 30);
 683    memcpy(path, dir, pathend);
 684    path[pathend++] = '/';
 685    path[pathend] = '\0';
 686    if ((dirp = opendir(path)) == NULL) {
 687       free(path);
 688       goto jleave;
 689    }
 690    while ((dp = readdir(dirp)) != NULL) {
 691       if (dp->d_name[0] == '.' && (dp->d_name[1] == '\0' ||
 692             (dp->d_name[1] == '.' && dp->d_name[2] == '\0')))
 693          continue;
 694       n = strlen(dp->d_name) + 1;
 695       if (pathend + n > pathsize)
 696          path = srealloc(path, pathsize = pathend + n + 30);
 697       memcpy(path + pathend, dp->d_name, n);
 698       if (stat(path, &st) < 0 || (st.st_mode & S_IFMT) != S_IFREG)
 699          continue;
 700       if (unlink(path) < 0) {
 701          perror(path);
 702          closedir(dirp);
 703          free(path);
 704          rv = STOP;
 705          goto jleave;
 706       }
 707    }
 708    closedir(dirp);
 709    path[pathend] = '\0';
 710    rmdir(path);   /* no error on failure, might contain submailboxes */
 711    free(path);
 712 jleave:
 713    NYD_LEAVE;
 714    return rv;
 715 }
 716
 717 FL enum okay
 718 cache_rename(const char *old, const char *new)
 719 {
 720    char *olddir, *newdir;
 721    enum okay rv = OKAY;
 722    NYD_ENTER;
 723
 724    if ((olddir = encname(&mb, "", 0, imap_fileof(old))) == NULL ||
 725          (newdir = encname(&mb, "",0, imap_fileof(new))) == NULL)
 726       goto jleave;
 727    if (rename(olddir, newdir) < 0) {
 728       perror(olddir);
 729       rv = STOP;
 730    }
 731 jleave:
 732    NYD_LEAVE;
 733    return rv;
 734 }
 735
 736 FL unsigned long
 737 cached_uidvalidity(struct mailbox *mp)
 738 {
 739    FILE *uvfp;
 740    char *uvname;
 741    unsigned long uv;
 742    NYD_ENTER;
 743
 744    if ((uvname = encname(mp, "UIDVALIDITY", 1, NULL)) == NULL) {
 745       uv = 0;
 746       goto jleave;
 747    }
 748    if ((uvfp = Fopen(uvname, "r")) == NULL ||
 749          (fcntl_lock(fileno(uvfp), FLOCK_READ), 0) ||
 750          fscanf(uvfp, "%lu", &uv) != 1)
 751       uv = 0;
 752    if (uvfp != NULL)
 753       Fclose(uvfp);
 754 jleave:
 755    NYD_LEAVE;
 756    return uv;
 757 }
 758
 759 static FILE *
 760 cache_queue1(struct mailbox *mp, char const *mode, char **xname)
 761 {
 762    char *name;
 763    FILE *fp = NULL;
 764    NYD_ENTER;
 765
 766    if ((name = encname(mp, "QUEUE", 0, NULL)) == NULL)
 767       goto jleave;
 768    if ((fp = Fopen(name, mode)) != NULL)
 769       fcntl_lock(fileno(fp), FLOCK_WRITE);
 770    if (xname)
 771       *xname = name;
 772 jleave:
 773    NYD_LEAVE;
 774    return fp;
 775 }
 776
 777 FL FILE *
 778 cache_queue(struct mailbox *mp)
 779 {
 780    FILE *fp;
 781    NYD_ENTER;
 782
 783    fp = cache_queue1(mp, "a", NULL);
 784    if (fp == NULL)
 785       fputs("Cannot queue IMAP command. Retry when online.\n", stderr);
 786    NYD_LEAVE;
 787    return fp;
 788 }
 789
 790 FL enum okay
 791 cache_dequeue(struct mailbox *mp)
 792 {
 793    int bufsz;
 794    char *cachedir, *eaccount, *buf, *oldbox;
 795    DIR *dirp;
 796    struct dirent *dp;
 797    enum okay rv = OKAY;
 798    NYD_ENTER;
 799
 800    if ((cachedir = ok_vlook(imap_cache)) == NULL ||
 801          (cachedir = file_expand(cachedir)) == NULL)
 802       goto jleave;
 803    eaccount = urlxenc(mp->mb_imap_account);
 804    buf = salloc(bufsz = strlen(cachedir) + strlen(eaccount) + 2);
 805    snprintf(buf, bufsz, "%s/%s", cachedir, eaccount);
 806    if ((dirp = opendir(buf)) == NULL)
 807       goto jleave;
 808    oldbox = mp->mb_imap_mailbox;
 809    while ((dp = readdir(dirp)) != NULL) {
 810       if (dp->d_name[0] == '.')
 811          continue;
 812       mp->mb_imap_mailbox = urlxdec(dp->d_name);
 813       dequeue1(mp);
 814    }
 815    closedir(dirp);
 816    mp->mb_imap_mailbox = oldbox;
 817 jleave:
 818    NYD_LEAVE;
 819    return rv;
 820 }
 821
 822 static enum okay
 823 dequeue1(struct mailbox *mp)
 824 {
 825    FILE *fp = NULL, *uvfp = NULL;
 826    char *qname, *uvname;
 827    unsigned long uv;
 828    off_t is_size;
 829    int is_count;
 830    enum okay rv = OKAY;
 831    NYD_ENTER;
 832
 833    fp = cache_queue1(mp, "r+", &qname);
 834    if (fp != NULL && fsize(fp) > 0) {
 835       if (imap_select(mp, &is_size, &is_count, mp->mb_imap_mailbox) != OKAY) {
 836          fprintf(stderr, "Cannot select \"%s\" for dequeuing.\n",
 837             mp->mb_imap_mailbox);
 838          goto jsave;
 839       }
 840       if ((uvname = encname(mp, "UIDVALIDITY", 0, NULL)) == NULL ||
 841             (uvfp = Fopen(uvname, "r")) == NULL ||
 842             (fcntl_lock(fileno(uvfp), FLOCK_READ), 0) ||
 843             fscanf(uvfp, "%lu", &uv) != 1 || uv != mp->mb_uidvalidity) {
 844          fprintf(stderr, "Unique identifiers for \"%s\" are out of date. "
 845             "Cannot commit IMAP commands.\n", mp->mb_imap_mailbox);
 846 jsave:
 847          fputs("Saving IMAP commands to dead.letter\n", stderr);
 848          savedeadletter(fp, 0);
 849          ftruncate(fileno(fp), 0);
 850          Fclose(fp);
 851          if (uvfp)
 852             Fclose(uvfp);
 853          rv = STOP;
 854          goto jleave;
 855       }
 856       Fclose(uvfp);
 857       printf("Committing IMAP commands for \"%s\"\n", mp->mb_imap_mailbox);
 858       imap_dequeue(mp, fp);
 859    }
 860    if (fp) {
 861       Fclose(fp);
 862       unlink(qname);
 863    }
 864 jleave:
 865    NYD_LEAVE;
 866    return rv;
 867 }
 868 #endif /* HAVE_IMAP */
 869
 870 /* vim:set fenc=utf-8:s-it-mode */