imap/util.c

   1 /*
   2  * Copyright (C) 1996-8 Michael R. Elkins <me@mutt.org>
   3  * Copyright (C) 1996-9 Brandon Long <blong@fiction.net>
   4  * Copyright (C) 1999-2005 Brendan Cully <brendan@kublai.com>
   5  *
   6  *     This program is free software; you can redistribute it and/or modify
   7  *     it under the terms of the GNU General Public License as published by
   8  *     the Free Software Foundation; either version 2 of the License, or
   9  *     (at your option) any later version.
  10  *
  11  *     This program is distributed in the hope that it will be useful,
  12  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *     GNU General Public License for more details.
  15  *
  16  *     You should have received a copy of the GNU General Public License
  17  *     along with this program; if not, write to the Free Software
  18  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20
  21 /* general IMAP utility functions */
  22
  23 #include "config.h"
  24
  25 #include "mutt.h"
  26 #include "mx.h" /* for M_IMAP */
  27 #include "url.h"
  28 #include "imap_private.h"
  29 #include "mutt_ssl.h"
  30 #ifdef USE_HCACHE
  31 #include "message.h"
  32 #include "hcache.h"
  33 #endif
  34
  35 #include <stdlib.h>
  36 #include <ctype.h>
  37
  38 #include <sys/types.h>
  39 #include <sys/wait.h>
  40 #include <signal.h>
  41 #include <netdb.h>
  42 #include <netinet/in.h>
  43
  44 #include <errno.h>
  45
  46 /* -- public functions -- */
  47
  48 /* imap_expand_path: IMAP implementation of mutt_expand_path. Rewrite
  49  *   an IMAP path in canonical and absolute form.
  50  * Inputs: a buffer containing an IMAP path, and the number of bytes in
  51  *   that buffer.
  52  * Outputs: The buffer is rewritten in place with the canonical IMAP path.
  53  * Returns 0 on success, or -1 if imap_parse_path chokes or url_ciss_tostring
  54  *   fails, which it might if there isn't enough room in the buffer. */
  55 int imap_expand_path (char* path, size_t len)
  56 {
  57   IMAP_MBOX mx;
  58   ciss_url_t url;
  59   int rc;
  60
  61   if (imap_parse_path (path, &mx) < 0)
  62     return -1;
  63
  64   mutt_account_tourl (&mx.account, &url);
  65   url.path = mx.mbox;
  66
  67   rc = url_ciss_tostring (&url, path, len, U_DECODE_PASSWD);
  68   FREE (&mx.mbox);
  69
  70   return rc;
  71 }
  72
  73 #ifdef USE_HCACHE
  74 static int imap_hcache_namer (const char* path, char* dest, size_t dlen)
  75 {
  76   return snprintf (dest, dlen, "%s.hcache", path);
  77 }
  78
  79 header_cache_t* imap_hcache_open (IMAP_DATA* idata, const char* path)
  80 {
  81   IMAP_MBOX mx;
  82   ciss_url_t url;
  83   char cachepath[LONG_STRING];
  84   char mbox[LONG_STRING];
  85
  86   if (path)
  87     imap_cachepath (idata, path, mbox, sizeof (mbox));
  88   else
  89   {
  90     if (!idata->ctx || imap_parse_path (idata->ctx->path, &mx) < 0)
  91       return NULL;
  92
  93     imap_cachepath (idata, mx.mbox, mbox, sizeof (mbox));
  94     FREE (&mx.mbox);
  95   }
  96
  97   mutt_account_tourl (&idata->conn->account, &url);
  98   url.path = mbox;
  99   url_ciss_tostring (&url, cachepath, sizeof (cachepath), U_PATH);
 100
 101   return mutt_hcache_open (HeaderCache, cachepath, imap_hcache_namer);
 102 }
 103
 104 void imap_hcache_close (IMAP_DATA* idata)
 105 {
 106   if (!idata->hcache)
 107     return;
 108
 109   mutt_hcache_close (idata->hcache);
 110   idata->hcache = NULL;
 111 }
 112
 113 HEADER* imap_hcache_get (IMAP_DATA* idata, unsigned int uid)
 114 {
 115   char key[16];
 116   unsigned int* uv;
 117   HEADER* h = NULL;
 118
 119   if (!idata->hcache)
 120     return NULL;
 121
 122   sprintf (key, "/%u", uid);
 123   uv = (unsigned int*)mutt_hcache_fetch (idata->hcache, key,
 124                                          imap_hcache_keylen);
 125   if (uv)
 126   {
 127     if (*uv == idata->uid_validity)
 128       h = mutt_hcache_restore ((unsigned char*)uv, NULL);
 129     FREE (&uv);
 130   }
 131
 132   return h;
 133 }
 134
 135 int imap_hcache_put (IMAP_DATA* idata, HEADER* h)
 136 {
 137   char key[16];
 138
 139   if (!idata->hcache)
 140     return -1;
 141
 142   sprintf (key, "/%u", HEADER_DATA (h)->uid);
 143   return mutt_hcache_store (idata->hcache, key, h, idata->uid_validity,
 144                             imap_hcache_keylen);
 145 }
 146
 147 int imap_hcache_del (IMAP_DATA* idata, unsigned int uid)
 148 {
 149   char key[16];
 150
 151   if (!idata->hcache)
 152     return -1;
 153
 154   sprintf (key, "/%u", uid);
 155   return mutt_hcache_delete (idata->hcache, key, imap_hcache_keylen);
 156 }
 157 #endif
 158
 159 /* imap_parse_path: given an IMAP mailbox name, return host, port
 160  *   and a path IMAP servers will recognise.
 161  * mx.mbox is malloc'd, caller must free it */
 162 int imap_parse_path (const char* path, IMAP_MBOX* mx)
 163 {
 164   static unsigned short ImapPort = 0;
 165   static unsigned short ImapsPort = 0;
 166   struct servent* service;
 167   char tmp[128];
 168   ciss_url_t url;
 169   char *c;
 170   int n;
 171
 172   if (!ImapPort)
 173   {
 174     service = getservbyname ("imap", "tcp");
 175     if (service)
 176       ImapPort = ntohs (service->s_port);
 177     else
 178       ImapPort = IMAP_PORT;
 179     dprint (3, (debugfile, "Using default IMAP port %d\n", ImapPort));
 180   }
 181   if (!ImapsPort)
 182   {
 183     service = getservbyname ("imaps", "tcp");
 184     if (service)
 185       ImapsPort = ntohs (service->s_port);
 186     else
 187       ImapsPort = IMAP_SSL_PORT;
 188     dprint (3, (debugfile, "Using default IMAPS port %d\n", ImapsPort));
 189   }
 190
 191   /* Defaults */
 192   mx->account.flags = 0;
 193   mx->account.port = ImapPort;
 194   mx->account.type = M_ACCT_TYPE_IMAP;
 195
 196   c = safe_strdup (path);
 197   url_parse_ciss (&url, c);
 198   if (url.scheme == U_IMAP || url.scheme == U_IMAPS)
 199   {
 200     if (mutt_account_fromurl (&mx->account, &url) < 0 || !*mx->account.host)
 201     {
 202       FREE (&c);
 203       return -1;
 204     }
 205
 206     mx->mbox = safe_strdup (url.path);
 207
 208     if (url.scheme == U_IMAPS)
 209       mx->account.flags |= M_ACCT_SSL;
 210
 211     FREE (&c);
 212   }
 213   /* old PINE-compatibility code */
 214   else
 215   {
 216     FREE (&c);
 217     if (sscanf (path, "{%127[^}]}", tmp) != 1)
 218       return -1;
 219
 220     c = strchr (path, '}');
 221     if (!c)
 222       return -1;
 223     else
 224       /* walk past closing '}' */
 225       mx->mbox = safe_strdup (c+1);
 226
 227     if ((c = strrchr (tmp, '@')))
 228     {
 229       *c = '\0';
 230       strfcpy (mx->account.user, tmp, sizeof (mx->account.user));
 231       strfcpy (tmp, c+1, sizeof (tmp));
 232       mx->account.flags |= M_ACCT_USER;
 233     }
 234
 235     if ((n = sscanf (tmp, "%127[^:/]%127s", mx->account.host, tmp)) < 1)
 236     {
 237       dprint (1, (debugfile, "imap_parse_path: NULL host in %s\n", path));
 238       FREE (&mx->mbox);
 239       return -1;
 240     }
 241
 242     if (n > 1) {
 243       if (sscanf (tmp, ":%hu%127s", &(mx->account.port), tmp) >= 1)
 244         mx->account.flags |= M_ACCT_PORT;
 245       if (sscanf (tmp, "/%s", tmp) == 1)
 246       {
 247         if (!ascii_strncmp (tmp, "ssl", 3))
 248           mx->account.flags |= M_ACCT_SSL;
 249         else
 250         {
 251           dprint (1, (debugfile, "imap_parse_path: Unknown connection type in %s\n", path));
 252           FREE (&mx->mbox);
 253           return -1;
 254         }
 255       }
 256     }
 257   }
 258
 259   if ((mx->account.flags & M_ACCT_SSL) && !(mx->account.flags & M_ACCT_PORT))
 260     mx->account.port = ImapsPort;
 261
 262   return 0;
 263 }
 264
 265 /* silly helper for mailbox name string comparisons, because of INBOX */
 266 int imap_mxcmp (const char* mx1, const char* mx2)
 267 {
 268   if (!ascii_strcasecmp (mx1, "INBOX") && !ascii_strcasecmp (mx2, "INBOX"))
 269     return 0;
 270
 271   return mutt_strcmp (mx1, mx2);
 272 }
 273
 274 /* imap_pretty_mailbox: called by mutt_pretty_mailbox to make IMAP paths
 275  *   look nice. */
 276 void imap_pretty_mailbox (char* path)
 277 {
 278   IMAP_MBOX home, target;
 279   ciss_url_t url;
 280   char* delim;
 281   int tlen;
 282   int hlen = 0;
 283   char home_match = 0;
 284
 285   if (imap_parse_path (path, &target) < 0)
 286     return;
 287
 288   tlen = mutt_strlen (target.mbox);
 289   /* check whether we can do '=' substitution */
 290   if (mx_is_imap(Maildir) && !imap_parse_path (Maildir, &home))
 291   {
 292     hlen = mutt_strlen (home.mbox);
 293     if (tlen && mutt_account_match (&home.account, &target.account) &&
 294         !mutt_strncmp (home.mbox, target.mbox, hlen))
 295     {
 296       if (! hlen)
 297         home_match = 1;
 298       else
 299         for (delim = ImapDelimChars; *delim != '\0'; delim++)
 300           if (target.mbox[hlen] == *delim)
 301             home_match = 1;
 302     }
 303     FREE (&home.mbox);
 304   }
 305
 306   /* do the '=' substitution */
 307   if (home_match) {
 308     *path++ = '=';
 309     /* copy remaining path, skipping delimiter */
 310     if (! hlen)
 311       hlen = -1;
 312     memcpy (path, target.mbox + hlen + 1, tlen - hlen - 1);
 313     path[tlen - hlen - 1] = '\0';
 314   }
 315   else
 316   {
 317     mutt_account_tourl (&target.account, &url);
 318     url.path = target.mbox;
 319     /* FIXME: That hard-coded constant is bogus. But we need the actual
 320      *   size of the buffer from mutt_pretty_mailbox. And these pretty
 321      *   operations usually shrink the result. Still... */
 322     url_ciss_tostring (&url, path, 1024, 0);
 323   }
 324
 325   FREE (&target.mbox);
 326 }
 327
 328 /* -- library functions -- */
 329
 330 /* imap_continue: display a message and ask the user if she wants to
 331  *   go on. */
 332 int imap_continue (const char* msg, const char* resp)
 333 {
 334   imap_error (msg, resp);
 335   return mutt_yesorno (_("Continue?"), 0);
 336 }
 337
 338 /* imap_error: show an error and abort */
 339 void imap_error (const char *where, const char *msg)
 340 {
 341   mutt_error ("%s [%s]\n", where, msg);
 342   mutt_sleep (2);
 343 }
 344
 345 /* imap_new_idata: Allocate and initialise a new IMAP_DATA structure.
 346  *   Returns NULL on failure (no mem) */
 347 IMAP_DATA* imap_new_idata (void)
 348 {
 349   IMAP_DATA* idata = safe_calloc (1, sizeof (IMAP_DATA));
 350
 351   if (!idata)
 352     return NULL;
 353
 354   if (!(idata->cmdbuf = mutt_buffer_init (NULL)))
 355     FREE (&idata);
 356
 357   return idata;
 358 }
 359
 360 /* imap_free_idata: Release and clear storage in an IMAP_DATA structure. */
 361 void imap_free_idata (IMAP_DATA** idata)
 362 {
 363   if (!idata)
 364     return;
 365
 366   FREE (&(*idata)->capstr);
 367   mutt_free_list (&(*idata)->flags);
 368   imap_mboxcache_free (*idata);
 369   mutt_buffer_free(&(*idata)->cmdbuf);
 370   FREE (&(*idata)->buf);
 371   mutt_bcache_close (&(*idata)->bcache);
 372   FREE (idata);         /* __FREE_CHECKED__ */
 373 }
 374
 375 /*
 376  * Fix up the imap path.  This is necessary because the rest of mutt
 377  * assumes a hierarchy delimiter of '/', which is not necessarily true
 378  * in IMAP.  Additionally, the filesystem converts multiple hierarchy
 379  * delimiters into a single one, ie "///" is equal to "/".  IMAP servers
 380  * are not required to do this.
 381  * Moreover, IMAP servers may dislike the path ending with the delimiter.
 382  */
 383 char *imap_fix_path (IMAP_DATA *idata, char *mailbox, char *path,
 384     size_t plen)
 385 {
 386   int x = 0;
 387
 388   while (mailbox && *mailbox && (x < (plen - 1)))
 389   {
 390     if ((*mailbox == '/') || (*mailbox == idata->delim))
 391     {
 392       while ((*mailbox == '/') || (*mailbox == idata->delim)) mailbox++;
 393       path[x] = idata->delim;
 394     }
 395     else
 396     {
 397       path[x] = *mailbox;
 398       mailbox++;
 399     }
 400     x++;
 401   }
 402   if (x && path[--x] != idata->delim)
 403     x++;
 404   path[x] = '\0';
 405
 406   if (!path[0])
 407     strfcpy (path, "INBOX", plen);
 408
 409   return path;
 410 }
 411
 412 void imap_cachepath(IMAP_DATA* idata, const char* mailbox, char* dest,
 413                     size_t dlen)
 414 {
 415   char* s;
 416   const char* p = mailbox;
 417
 418   for (s = dest; p && *p && dlen; dlen--)
 419   {
 420     if (*p == idata->delim)
 421     {
 422       *s = '/';
 423       /* simple way to avoid collisions with UIDs */
 424       if (*(p + 1) >= '0' && *(p + 1) <= '9')
 425       {
 426         if (--dlen)
 427           *++s = '_';
 428       }
 429     }
 430     else
 431       *s = *p;
 432     p++;
 433     s++;
 434   }
 435   *s = '\0';
 436 }
 437
 438 /* imap_get_literal_count: write number of bytes in an IMAP literal into
 439  *   bytes, return 0 on success, -1 on failure. */
 440 int imap_get_literal_count(const char *buf, long *bytes)
 441 {
 442   char *pc;
 443   char *pn;
 444
 445   if (!buf || !(pc = strchr (buf, '{')))
 446     return -1;
 447
 448   pc++;
 449   pn = pc;
 450   while (isdigit ((unsigned char) *pc))
 451     pc++;
 452   *pc = 0;
 453   *bytes = atoi(pn);
 454
 455   return 0;
 456 }
 457
 458 /* imap_get_qualifier: in a tagged response, skip tag and status for
 459  *   the qualifier message. Used by imap_copy_message for TRYCREATE */
 460 char* imap_get_qualifier (char* buf)
 461 {
 462   char *s = buf;
 463
 464   /* skip tag */
 465   s = imap_next_word (s);
 466   /* skip OK/NO/BAD response */
 467   s = imap_next_word (s);
 468
 469   return s;
 470 }
 471
 472 /* imap_next_word: return index into string where next IMAP word begins */
 473 char *imap_next_word (char *s)
 474 {
 475   int quoted = 0;
 476
 477   while (*s) {
 478     if (*s == '\\') {
 479       s++;
 480       if (*s)
 481         s++;
 482       continue;
 483     }
 484     if (*s == '\"')
 485       quoted = quoted ? 0 : 1;
 486     if (!quoted && ISSPACE (*s))
 487       break;
 488     s++;
 489   }
 490
 491   SKIPWS (s);
 492   return s;
 493 }
 494
 495 /* imap_parse_date: date is of the form: DD-MMM-YYYY HH:MM:SS +ZZzz */
 496 time_t imap_parse_date (char *s)
 497 {
 498   struct tm t;
 499   time_t tz;
 500
 501   t.tm_mday = (s[0] == ' '? s[1] - '0' : (s[0] - '0') * 10 + (s[1] - '0'));
 502   s += 2;
 503   if (*s != '-')
 504     return 0;
 505   s++;
 506   t.tm_mon = mutt_check_month (s);
 507   s += 3;
 508   if (*s != '-')
 509     return 0;
 510   s++;
 511   t.tm_year = (s[0] - '0') * 1000 + (s[1] - '0') * 100 + (s[2] - '0') * 10 + (s[3] - '0') - 1900;
 512   s += 4;
 513   if (*s != ' ')
 514     return 0;
 515   s++;
 516
 517   /* time */
 518   t.tm_hour = (s[0] - '0') * 10 + (s[1] - '0');
 519   s += 2;
 520   if (*s != ':')
 521     return 0;
 522   s++;
 523   t.tm_min = (s[0] - '0') * 10 + (s[1] - '0');
 524   s += 2;
 525   if (*s != ':')
 526     return 0;
 527   s++;
 528   t.tm_sec = (s[0] - '0') * 10 + (s[1] - '0');
 529   s += 2;
 530   if (*s != ' ')
 531     return 0;
 532   s++;
 533
 534   /* timezone */
 535   tz = ((s[1] - '0') * 10 + (s[2] - '0')) * 3600 +
 536     ((s[3] - '0') * 10 + (s[4] - '0')) * 60;
 537   if (s[0] == '+')
 538     tz = -tz;
 539
 540   return (mutt_mktime (&t, 0) + tz);
 541 }
 542
 543 /* imap_qualify_path: make an absolute IMAP folder target, given IMAP_MBOX
 544  *   and relative path. */
 545 void imap_qualify_path (char *dest, size_t len, IMAP_MBOX *mx, char* path)
 546 {
 547   ciss_url_t url;
 548
 549   mutt_account_tourl (&mx->account, &url);
 550   url.path = path;
 551
 552   url_ciss_tostring (&url, dest, len, 0);
 553 }
 554
 555
 556 /* imap_quote_string: quote string according to IMAP rules:
 557  *   surround string with quotes, escape " and \ with \ */
 558 void imap_quote_string (char *dest, size_t dlen, const char *src)
 559 {
 560   char quote[] = "\"\\", *pt;
 561   const char *s;
 562
 563   pt = dest;
 564   s  = src;
 565
 566   *pt++ = '"';
 567   /* save room for trailing quote-char */
 568   dlen -= 2;
 569
 570   for (; *s && dlen; s++)
 571   {
 572     if (strchr (quote, *s))
 573     {
 574       dlen -= 2;
 575       if (!dlen)
 576         break;
 577       *pt++ = '\\';
 578       *pt++ = *s;
 579     }
 580     else
 581     {
 582       *pt++ = *s;
 583       dlen--;
 584     }
 585   }
 586   *pt++ = '"';
 587   *pt = 0;
 588 }
 589
 590 /* imap_unquote_string: equally stupid unquoting routine */
 591 void imap_unquote_string (char *s)
 592 {
 593   char *d = s;
 594
 595   if (*s == '\"')
 596     s++;
 597   else
 598     return;
 599
 600   while (*s)
 601   {
 602     if (*s == '\"')
 603     {
 604       *d = '\0';
 605       return;
 606     }
 607     if (*s == '\\')
 608     {
 609       s++;
 610     }
 611     if (*s)
 612     {
 613       *d = *s;
 614       d++;
 615       s++;
 616     }
 617   }
 618   *d = '\0';
 619 }
 620
 621 /*
 622  * Quoting and UTF-7 conversion
 623  */
 624
 625 void imap_munge_mbox_name (char *dest, size_t dlen, const char *src)
 626 {
 627   char *buf;
 628
 629   buf = safe_strdup (src);
 630   imap_utf7_encode (&buf);
 631
 632   imap_quote_string (dest, dlen, buf);
 633
 634   FREE (&buf);
 635 }
 636
 637 void imap_unmunge_mbox_name (char *s)
 638 {
 639   char *buf;
 640
 641   imap_unquote_string(s);
 642
 643   buf = safe_strdup (s);
 644   if (buf)
 645   {
 646     imap_utf7_decode (&buf);
 647     strncpy (s, buf, strlen (s));
 648   }
 649
 650   FREE (&buf);
 651 }
 652
 653 /* imap_wordcasecmp: find word a in word list b */
 654 int imap_wordcasecmp(const char *a, const char *b)
 655 {
 656   char tmp[SHORT_STRING];
 657   char *s = (char *)b;
 658   int i;
 659
 660   tmp[SHORT_STRING-1] = 0;
 661   for(i=0;i < SHORT_STRING-2;i++,s++)
 662   {
 663     if (!*s || ISSPACE(*s))
 664     {
 665       tmp[i] = 0;
 666       break;
 667     }
 668     tmp[i] = *s;
 669   }
 670   tmp[i+1] = 0;
 671
 672   return ascii_strcasecmp(a, tmp);
 673 }
 674
 675 /*
 676  * Imap keepalive: poll the current folder to keep the
 677  * connection alive.
 678  *
 679  */
 680
 681 static RETSIGTYPE alrm_handler (int sig)
 682 {
 683   /* empty */
 684 }
 685
 686 void imap_keepalive (void)
 687 {
 688   CONNECTION *conn;
 689   CONTEXT *ctx = NULL;
 690   IMAP_DATA *idata;
 691
 692   conn = mutt_socket_head ();
 693   while (conn)
 694   {
 695     if (conn->account.type == M_ACCT_TYPE_IMAP)
 696     {
 697       idata = (IMAP_DATA*) conn->data;
 698
 699       if (idata->state >= IMAP_AUTHENTICATED
 700           && time(NULL) >= idata->lastread + ImapKeepalive)
 701       {
 702         if (idata->ctx)
 703           ctx = idata->ctx;
 704         else
 705         {
 706           ctx = safe_calloc (1, sizeof (CONTEXT));
 707           ctx->data = idata;
 708         }
 709         imap_check_mailbox (ctx, NULL, 1);
 710         if (!idata->ctx)
 711           FREE (&ctx);
 712       }
 713     }
 714
 715     conn = conn->next;
 716   }
 717 }
 718
 719 int imap_wait_keepalive (pid_t pid)
 720 {
 721   struct sigaction oldalrm;
 722   struct sigaction act;
 723   sigset_t oldmask;
 724   int rc;
 725
 726   short imap_passive = option (OPTIMAPPASSIVE);
 727
 728   set_option (OPTIMAPPASSIVE);
 729   set_option (OPTKEEPQUIET);
 730
 731   sigprocmask (SIG_SETMASK, NULL, &oldmask);
 732
 733   sigemptyset (&act.sa_mask);
 734   act.sa_handler = alrm_handler;
 735 #ifdef SA_INTERRUPT
 736   act.sa_flags = SA_INTERRUPT;
 737 #else
 738   act.sa_flags = 0;
 739 #endif
 740
 741   sigaction (SIGALRM, &act, &oldalrm);
 742
 743   alarm (ImapKeepalive);
 744   while (waitpid (pid, &rc, 0) < 0 && errno == EINTR)
 745   {
 746     alarm (0); /* cancel a possibly pending alarm */
 747     imap_keepalive ();
 748     alarm (ImapKeepalive);
 749   }
 750
 751   alarm (0);    /* cancel a possibly pending alarm */
 752
 753   sigaction (SIGALRM, &oldalrm, NULL);
 754   sigprocmask (SIG_SETMASK, &oldmask, NULL);
 755
 756   unset_option (OPTKEEPQUIET);
 757   if (!imap_passive)
 758     unset_option (OPTIMAPPASSIVE);
 759
 760   return rc;
 761 }
 762
 763 /* Allow/disallow re-opening a folder upon expunge. */
 764
 765 void imap_allow_reopen (CONTEXT *ctx)
 766 {
 767   if (ctx && ctx->magic == M_IMAP && CTX_DATA->ctx == ctx)
 768     CTX_DATA->reopen |= IMAP_REOPEN_ALLOW;
 769 }
 770
 771 void imap_disallow_reopen (CONTEXT *ctx)
 772 {
 773   if (ctx && ctx->magic == M_IMAP && CTX_DATA->ctx == ctx)
 774     CTX_DATA->reopen &= ~IMAP_REOPEN_ALLOW;
 775 }