imap/imap.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-2003 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  19  */
  20
  21 /* Support for IMAP4rev1, with the occasional nod to IMAP 4. */
  22
  23 #include "mutt.h"
  24 #include "mutt_curses.h"
  25 #include "mx.h"
  26 #include "mailbox.h"
  27 #include "globals.h"
  28 #include "sort.h"
  29 #include "browser.h"
  30 #include "message.h"
  31 #include "imap_private.h"
  32 #if defined(USE_SSL) || defined(USE_GNUTLS)
  33 # include "mutt_ssl.h"
  34 #endif
  35
  36 #include <unistd.h>
  37 #include <ctype.h>
  38 #include <string.h>
  39 #include <stdlib.h>
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42
  43 /* imap forward declarations */
  44 static int imap_get_delim (IMAP_DATA *idata);
  45 static char* imap_get_flags (LIST** hflags, char* s);
  46 static int imap_check_acl (IMAP_DATA *idata);
  47 static int imap_check_capabilities (IMAP_DATA* idata);
  48 static void imap_set_flag (IMAP_DATA* idata, int aclbit, int flag,
  49                            const char* str, char* flags, size_t flsize);
  50
  51 /* imap_access: Check permissions on an IMAP mailbox. */
  52 int imap_access (const char* path, int flags)
  53 {
  54   IMAP_DATA* idata;
  55   IMAP_MBOX mx;
  56   char buf[LONG_STRING];
  57   char mailbox[LONG_STRING];
  58   char mbox[LONG_STRING];
  59
  60   if (imap_parse_path (path, &mx))
  61     return -1;
  62
  63   if (!(idata = imap_conn_find (&mx.account,
  64     option (OPTIMAPPASSIVE) ? M_IMAP_CONN_NONEW : 0)))
  65   {
  66     FREE (&mx.mbox);
  67     return -1;
  68   }
  69
  70   imap_fix_path (idata, mx.mbox, mailbox, sizeof (mailbox));
  71   FREE (&mx.mbox);
  72   imap_munge_mbox_name (mbox, sizeof (mbox), mailbox);
  73
  74   /* TODO: ACL checks. Right now we assume if it exists we can mess with it. */
  75   if (mutt_bit_isset (idata->capabilities, IMAP4REV1))
  76     snprintf (buf, sizeof (buf), "STATUS %s (UIDVALIDITY)", mbox);
  77   else if (mutt_bit_isset (idata->capabilities, STATUS))
  78     snprintf (buf, sizeof (buf), "STATUS %s (UID-VALIDITY)", mbox);
  79   else
  80   {
  81     dprint (2, (debugfile, "imap_access: STATUS not supported?\n"));
  82     return -1;
  83   }
  84
  85   if (imap_exec (idata, buf, IMAP_CMD_FAIL_OK) < 0)
  86   {
  87     dprint (1, (debugfile, "imap_access: Can't check STATUS of %s\n", mbox));
  88     return -1;
  89   }
  90
  91   return 0;
  92 }
  93
  94 int imap_create_mailbox (IMAP_DATA* idata, char* mailbox)
  95 {
  96   char buf[LONG_STRING], mbox[LONG_STRING];
  97
  98   imap_munge_mbox_name (mbox, sizeof (mbox), mailbox);
  99   snprintf (buf, sizeof (buf), "CREATE %s", mbox);
 100
 101   if (imap_exec (idata, buf, 0) != 0)
 102     return -1;
 103
 104   return 0;
 105 }
 106
 107 int imap_delete_mailbox (CONTEXT* ctx, IMAP_MBOX mx)
 108 {
 109   char buf[LONG_STRING], mbox[LONG_STRING];
 110   IMAP_DATA *idata;
 111
 112   if (!ctx || !ctx->data) {
 113         if (!(idata = imap_conn_find (&mx.account,
 114                 option (OPTIMAPPASSIVE) ? M_IMAP_CONN_NONEW : 0)))
 115         {
 116                 FREE (&mx.mbox);
 117                 return -1;
 118         }
 119   } else {
 120           idata = ctx->data;
 121   }
 122
 123   imap_munge_mbox_name (mbox, sizeof (mbox), mx.mbox);
 124   snprintf (buf, sizeof (buf), "DELETE %s", mbox);
 125
 126   if (imap_exec ((IMAP_DATA*) idata, buf, 0) != 0)
 127     return -1;
 128
 129   return 0;
 130 }
 131
 132 /* imap_logout_all: close all open connections. Quick and dirty until we can
 133  *   make sure we've got all the context we need. */
 134 void imap_logout_all (void)
 135 {
 136   CONNECTION* conn;
 137   CONNECTION* tmp;
 138
 139   conn = mutt_socket_head ();
 140
 141   while (conn)
 142   {
 143     tmp = conn->next;
 144
 145     if (conn->account.type == M_ACCT_TYPE_IMAP && conn->fd >= 0)
 146     {
 147       mutt_message (_("Closing connection to %s..."), conn->account.host);
 148       imap_logout ((IMAP_DATA*) conn->data);
 149       mutt_clear_error ();
 150       mutt_socket_close (conn);
 151       mutt_socket_free (conn);
 152     }
 153
 154     conn = tmp;
 155   }
 156 }
 157
 158 /* imap_read_literal: read bytes bytes from server into file. Not explicitly
 159  *   buffered, relies on FILE buffering. NOTE: strips \r from \r\n.
 160  *   Apparently even literals use \r\n-terminated strings ?! */
 161 int imap_read_literal (FILE* fp, IMAP_DATA* idata, long bytes)
 162 {
 163   long pos;
 164   char c;
 165
 166   int r = 0;
 167
 168   dprint (2, (debugfile, "imap_read_literal: reading %ld bytes\n", bytes));
 169
 170   for (pos = 0; pos < bytes; pos++)
 171   {
 172     if (mutt_socket_readchar (idata->conn, &c) != 1)
 173     {
 174       dprint (1, (debugfile, "imap_read_literal: error during read, %ld bytes read\n", pos));
 175       idata->status = IMAP_FATAL;
 176
 177       return -1;
 178     }
 179
 180 #if 1
 181     if (r == 1 && c != '\n')
 182       fputc ('\r', fp);
 183
 184     if (c == '\r')
 185     {
 186       r = 1;
 187       continue;
 188     }
 189     else
 190       r = 0;
 191 #endif
 192     fputc (c, fp);
 193 #ifdef DEBUG
 194     if (debuglevel >= IMAP_LOG_LTRL)
 195       fputc (c, debugfile);
 196 #endif
 197   }
 198
 199   return 0;
 200 }
 201
 202 /* imap_expunge_mailbox: Purge IMAP portion of expunged messages from the
 203  *   context. Must not be done while something has a handle on any headers
 204  *   (eg inside pager or editor). That is, check IMAP_REOPEN_ALLOW. */
 205 void imap_expunge_mailbox (IMAP_DATA* idata)
 206 {
 207   HEADER* h;
 208   int i, cacheno;
 209
 210   for (i = 0; i < idata->ctx->msgcount; i++)
 211   {
 212     h = idata->ctx->hdrs[i];
 213
 214     if (h->index == -1)
 215     {
 216       dprint (2, (debugfile, "Expunging message UID %d.\n", HEADER_DATA (h)->uid));
 217
 218       h->active = 0;
 219
 220       /* free cached body from disk, if neccessary */
 221       cacheno = HEADER_DATA(h)->uid % IMAP_CACHE_LEN;
 222       if (idata->cache[cacheno].uid == HEADER_DATA(h)->uid &&
 223           idata->cache[cacheno].path)
 224       {
 225         unlink (idata->cache[cacheno].path);
 226         FREE (&idata->cache[cacheno].path);
 227       }
 228
 229       imap_free_header_data (&h->data);
 230     }
 231   }
 232
 233   /* We may be called on to expunge at any time. We can't rely on the caller
 234    * to always know to rethread */
 235   mx_update_tables (idata->ctx, 0);
 236   mutt_sort_headers (idata->ctx, 1);
 237 }
 238
 239 static int imap_get_delim (IMAP_DATA *idata)
 240 {
 241   char *s;
 242   int rc;
 243
 244   /* assume that the delim is /.  If this fails, we're in bigger trouble
 245    * than getting the delim wrong */
 246   idata->delim = '/';
 247
 248   imap_cmd_start (idata, "LIST \"\" \"\"");
 249
 250   do
 251   {
 252     if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE)
 253       break;
 254
 255     s = imap_next_word (idata->cmd.buf);
 256     if (ascii_strncasecmp ("LIST", s, 4) == 0)
 257     {
 258       s = imap_next_word (s);
 259       s = imap_next_word (s);
 260       if (s && s[0] == '\"' && s[1] && s[2] == '\"')
 261         idata->delim = s[1];
 262       else if (s && s[0] == '\"' && s[1] && s[1] == '\\' && s[2] && s[3] == '\"')
 263         idata->delim = s[2];
 264     }
 265   }
 266   while (rc == IMAP_CMD_CONTINUE);
 267
 268   if (rc != IMAP_CMD_OK)
 269   {
 270     dprint (1, (debugfile, "imap_get_delim: failed.\n"));
 271     return -1;
 272   }
 273
 274   dprint (2, (debugfile, "Delimiter: %c\n", idata->delim));
 275
 276   return -1;
 277 }
 278
 279 /* get rights for folder, let imap_handle_untagged do the rest */
 280 static int imap_check_acl (IMAP_DATA *idata)
 281 {
 282   char buf[LONG_STRING];
 283   char mbox[LONG_STRING];
 284
 285   imap_munge_mbox_name (mbox, sizeof(mbox), idata->mailbox);
 286   snprintf (buf, sizeof (buf), "MYRIGHTS %s", mbox);
 287   if (imap_exec (idata, buf, 0) != 0)
 288   {
 289     imap_error ("imap_check_acl", buf);
 290     return -1;
 291   }
 292   return 0;
 293 }
 294
 295 /* imap_check_capabilities: make sure we can log in to this server. */
 296 static int imap_check_capabilities (IMAP_DATA* idata)
 297 {
 298   if (imap_exec (idata, "CAPABILITY", 0) != 0)
 299   {
 300     imap_error ("imap_check_capabilities", idata->cmd.buf);
 301     return -1;
 302   }
 303
 304   if (!(mutt_bit_isset(idata->capabilities,IMAP4)
 305       ||mutt_bit_isset(idata->capabilities,IMAP4REV1)))
 306   {
 307     mutt_error _("This IMAP server is ancient. Mutt does not work with it.");
 308     mutt_sleep (2);     /* pause a moment to let the user see the error */
 309
 310     return -1;
 311   }
 312
 313   return 0;
 314 }
 315
 316 /* imap_conn_find: Find an open IMAP connection matching account, or open
 317  *   a new one if none can be found. */
 318 IMAP_DATA* imap_conn_find (const ACCOUNT* account, int flags)
 319 {
 320   CONNECTION* conn;
 321   IMAP_DATA* idata;
 322   ACCOUNT* creds;
 323
 324   if (!(conn = mutt_conn_find (NULL, account)))
 325     return NULL;
 326
 327   /* if opening a new UNSELECTED connection, preserve existing creds */
 328   creds = &(conn->account);
 329
 330   /* make sure this connection is not in SELECTED state, if neccessary */
 331   if (flags & M_IMAP_CONN_NOSELECT)
 332     while (conn->data && ((IMAP_DATA*) conn->data)->state == IMAP_SELECTED)
 333     {
 334       if (!(conn = mutt_conn_find (conn, account)))
 335         return NULL;
 336       memcpy (&(conn->account), creds, sizeof (ACCOUNT));
 337     }
 338
 339   idata = (IMAP_DATA*) conn->data;
 340
 341   /* don't open a new connection if one isn't wanted */
 342   if (flags & M_IMAP_CONN_NONEW)
 343   {
 344     if (!idata)
 345     {
 346       mutt_socket_free (conn);
 347       return NULL;
 348     }
 349     if (idata->state < IMAP_AUTHENTICATED)
 350       return NULL;
 351   }
 352
 353   if (!idata)
 354   {
 355     /* The current connection is a new connection */
 356     if (! (idata = imap_new_idata ()))
 357     {
 358       mutt_socket_free (conn);
 359       return NULL;
 360     }
 361
 362     conn->data = idata;
 363     idata->conn = conn;
 364   }
 365
 366   if (idata->state == IMAP_DISCONNECTED)
 367     imap_open_connection (idata);
 368   if (idata->state == IMAP_CONNECTED)
 369   {
 370     if (!imap_authenticate (idata))
 371     {
 372       idata->state = IMAP_AUTHENTICATED;
 373       if (idata->conn->ssf)
 374         dprint (2, (debugfile, "Communication encrypted at %d bits\n",
 375                     idata->conn->ssf));
 376     }
 377     else
 378       mutt_account_unsetpass (&idata->conn->account);
 379
 380     FREE (&idata->capstr);
 381   }
 382   if (idata->state == IMAP_AUTHENTICATED)
 383     imap_get_delim (idata);
 384
 385   return idata;
 386 }
 387
 388 int imap_open_connection (IMAP_DATA* idata)
 389 {
 390   char buf[LONG_STRING];
 391
 392   if (mutt_socket_open (idata->conn) < 0)
 393     return -1;
 394
 395   idata->state = IMAP_CONNECTED;
 396
 397   if (imap_cmd_step (idata) != IMAP_CMD_CONTINUE) {
 398     mutt_error (_("Unexpected response received from server: %s"), idata->cmd.buf);
 399     mutt_sleep (1);
 400
 401     mutt_socket_close (idata->conn);
 402     idata->state = IMAP_DISCONNECTED;
 403     return -1;
 404   }
 405
 406   if (ascii_strncasecmp ("* OK", idata->cmd.buf, 4) == 0)
 407   {
 408     /* TODO: Parse new tagged CAPABILITY data (* OK [CAPABILITY...]) */
 409     if (imap_check_capabilities (idata))
 410       goto bail;
 411 #if defined(USE_SSL) || defined(USE_GNUTLS)
 412     /* Attempt STARTTLS if available and desired. */
 413     if (mutt_bit_isset (idata->capabilities, STARTTLS) && !idata->conn->ssf)
 414     {
 415       int rc;
 416
 417       if ((rc = query_quadoption (OPT_SSLSTARTTLS,
 418         _("Secure connection with TLS?"))) == -1)
 419         goto err_close_conn;
 420       if (rc == M_YES) {
 421         if ((rc = imap_exec (idata, "STARTTLS", IMAP_CMD_FAIL_OK)) == -1)
 422           goto bail;
 423         if (rc != -2)
 424         {
 425 #ifdef USE_SSL
 426           if (mutt_ssl_starttls (idata->conn))
 427 #elif USE_GNUTLS
 428           if (mutt_gnutls_starttls (idata->conn))
 429 #endif
 430           {
 431             mutt_error (_("Could not negotiate TLS connection"));
 432             mutt_sleep (1);
 433             goto bail;
 434           }
 435           else
 436           {
 437             /* RFC 2595 demands we recheck CAPABILITY after TLS completes. */
 438             if (imap_exec (idata, "CAPABILITY", 0))
 439               goto bail;
 440           }
 441         }
 442       }
 443     }
 444 #endif
 445   }
 446   else if (ascii_strncasecmp ("* PREAUTH", idata->cmd.buf, 9) == 0)
 447   {
 448     idata->state = IMAP_AUTHENTICATED;
 449     if (imap_check_capabilities (idata) != 0)
 450       goto bail;
 451     FREE (&idata->capstr);
 452   }
 453   else
 454   {
 455     imap_error ("imap_open_connection()", buf);
 456     goto bail;
 457   }
 458
 459   return 0;
 460
 461  err_close_conn:
 462   mutt_socket_close (idata->conn);
 463  bail:
 464   FREE (&idata->capstr);
 465   return -1;
 466 }
 467
 468 /* imap_get_flags: Make a simple list out of a FLAGS response.
 469  *   return stream following FLAGS response */
 470 static char* imap_get_flags (LIST** hflags, char* s)
 471 {
 472   LIST* flags;
 473   char* flag_word;
 474   char ctmp;
 475
 476   /* sanity-check string */
 477   if (ascii_strncasecmp ("FLAGS", s, 5) != 0)
 478   {
 479     dprint (1, (debugfile, "imap_get_flags: not a FLAGS response: %s\n",
 480       s));
 481     return NULL;
 482   }
 483   s += 5;
 484   SKIPWS(s);
 485   if (*s != '(')
 486   {
 487     dprint (1, (debugfile, "imap_get_flags: bogus FLAGS response: %s\n",
 488       s));
 489     return NULL;
 490   }
 491
 492   /* create list, update caller's flags handle */
 493   flags = mutt_new_list();
 494   *hflags = flags;
 495
 496   while (*s && *s != ')')
 497   {
 498     s++;
 499     SKIPWS(s);
 500     flag_word = s;
 501     while (*s && (*s != ')') && !ISSPACE (*s))
 502       s++;
 503     ctmp = *s;
 504     *s = '\0';
 505     if (*flag_word)
 506       mutt_add_list (flags, flag_word);
 507     *s = ctmp;
 508   }
 509
 510   /* note bad flags response */
 511   if (*s != ')')
 512   {
 513     dprint (1, (debugfile,
 514       "imap_get_flags: Unterminated FLAGS response: %s\n", s));
 515     mutt_free_list (hflags);
 516
 517     return NULL;
 518   }
 519
 520   s++;
 521
 522   return s;
 523 }
 524
 525 int imap_open_mailbox (CONTEXT* ctx)
 526 {
 527   CONNECTION *conn;
 528   IMAP_DATA *idata;
 529   char buf[LONG_STRING];
 530   char bufout[LONG_STRING];
 531   int count = 0;
 532   IMAP_MBOX mx;
 533   int rc;
 534
 535   if (imap_parse_path (ctx->path, &mx))
 536   {
 537     mutt_error (_("%s is an invalid IMAP path"), ctx->path);
 538     return -1;
 539   }
 540
 541   /* we require a connection which isn't currently in IMAP_SELECTED state */
 542   if (!(idata = imap_conn_find (&(mx.account), M_IMAP_CONN_NOSELECT)))
 543     goto fail_noidata;
 544   if (idata->state < IMAP_AUTHENTICATED)
 545     goto fail;
 546
 547   conn = idata->conn;
 548
 549   /* once again the context is new */
 550   ctx->data = idata;
 551
 552   /* Clean up path and replace the one in the ctx */
 553   imap_fix_path (idata, mx.mbox, buf, sizeof (buf));
 554   FREE(&(idata->mailbox));
 555   idata->mailbox = safe_strdup (buf);
 556   imap_qualify_path (buf, sizeof (buf), &mx, idata->mailbox);
 557
 558   FREE (&(ctx->path));
 559   ctx->path = safe_strdup (buf);
 560
 561   idata->ctx = ctx;
 562
 563   /* clear mailbox status */
 564   idata->status = 0;
 565   memset (idata->rights, 0, (RIGHTSMAX+7)/8);
 566   idata->newMailCount = 0;
 567
 568   mutt_message (_("Selecting %s..."), idata->mailbox);
 569   imap_munge_mbox_name (buf, sizeof(buf), idata->mailbox);
 570   snprintf (bufout, sizeof (bufout), "%s %s",
 571     ctx->readonly ? "EXAMINE" : "SELECT", buf);
 572
 573   idata->state = IMAP_SELECTED;
 574
 575   imap_cmd_start (idata, bufout);
 576
 577   do
 578   {
 579     char *pc;
 580
 581     if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE)
 582       break;
 583
 584     pc = idata->cmd.buf + 2;
 585
 586     /* Obtain list of available flags here, may be overridden by a
 587      * PERMANENTFLAGS tag in the OK response */
 588     if (ascii_strncasecmp ("FLAGS", pc, 5) == 0)
 589     {
 590       /* don't override PERMANENTFLAGS */
 591       if (!idata->flags)
 592       {
 593         dprint (2, (debugfile, "Getting mailbox FLAGS\n"));
 594         if ((pc = imap_get_flags (&(idata->flags), pc)) == NULL)
 595           goto fail;
 596       }
 597     }
 598     /* PERMANENTFLAGS are massaged to look like FLAGS, then override FLAGS */
 599     else if (ascii_strncasecmp ("OK [PERMANENTFLAGS", pc, 18) == 0)
 600     {
 601       dprint (2, (debugfile, "Getting mailbox PERMANENTFLAGS\n"));
 602       /* safe to call on NULL */
 603       mutt_free_list (&(idata->flags));
 604       /* skip "OK [PERMANENT" so syntax is the same as FLAGS */
 605       pc += 13;
 606       if ((pc = imap_get_flags (&(idata->flags), pc)) == NULL)
 607         goto fail;
 608     }
 609     else
 610     {
 611       pc = imap_next_word (pc);
 612       if (!ascii_strncasecmp ("EXISTS", pc, 6))
 613       {
 614         count = idata->newMailCount;
 615         idata->newMailCount = 0;
 616       }
 617     }
 618   }
 619   while (rc == IMAP_CMD_CONTINUE);
 620
 621   if (rc == IMAP_CMD_NO)
 622   {
 623     char *s;
 624     s = imap_next_word (idata->cmd.buf); /* skip seq */
 625     s = imap_next_word (s); /* Skip response */
 626     mutt_error ("%s", s);
 627     mutt_sleep (2);
 628     goto fail;
 629   }
 630
 631   if (rc != IMAP_CMD_OK)
 632     goto fail;
 633
 634   /* check for READ-ONLY notification */
 635   if (!ascii_strncasecmp (imap_get_qualifier (idata->cmd.buf), "[READ-ONLY]", 11)  \
 636   && !mutt_bit_isset (idata->capabilities, ACL))
 637   {
 638     dprint (2, (debugfile, "Mailbox is read-only.\n"));
 639     ctx->readonly = 1;
 640   }
 641
 642 #ifdef DEBUG
 643   /* dump the mailbox flags we've found */
 644   if (debuglevel > 2)
 645   {
 646     if (!idata->flags)
 647       dprint (3, (debugfile, "No folder flags found\n"));
 648     else
 649     {
 650       LIST* t = idata->flags;
 651
 652       dprint (3, (debugfile, "Mailbox flags: "));
 653
 654       t = t->next;
 655       while (t)
 656       {
 657         dprint (3, (debugfile, "[%s] ", t->data));
 658         t = t->next;
 659       }
 660       dprint (3, (debugfile, "\n"));
 661     }
 662   }
 663 #endif
 664
 665   if (mutt_bit_isset (idata->capabilities, ACL))
 666   {
 667     if (imap_check_acl (idata))
 668       goto fail;
 669     if (!(mutt_bit_isset(idata->rights, IMAP_ACL_DELETE) ||
 670           mutt_bit_isset(idata->rights, IMAP_ACL_SEEN) ||
 671           mutt_bit_isset(idata->rights, IMAP_ACL_WRITE) ||
 672           mutt_bit_isset(idata->rights, IMAP_ACL_INSERT)))
 673        ctx->readonly = 1;
 674   }
 675   /* assume we have all rights if ACL is unavailable */
 676   else
 677   {
 678     mutt_bit_set (idata->rights, IMAP_ACL_LOOKUP);
 679     mutt_bit_set (idata->rights, IMAP_ACL_READ);
 680     mutt_bit_set (idata->rights, IMAP_ACL_SEEN);
 681     mutt_bit_set (idata->rights, IMAP_ACL_WRITE);
 682     mutt_bit_set (idata->rights, IMAP_ACL_INSERT);
 683     mutt_bit_set (idata->rights, IMAP_ACL_POST);
 684     mutt_bit_set (idata->rights, IMAP_ACL_CREATE);
 685     mutt_bit_set (idata->rights, IMAP_ACL_DELETE);
 686   }
 687
 688   ctx->hdrmax = count;
 689   ctx->hdrs = safe_calloc (count, sizeof (HEADER *));
 690   ctx->v2r = safe_calloc (count, sizeof (int));
 691   ctx->msgcount = 0;
 692   if (count && (imap_read_headers (idata, 0, count-1) < 0))
 693   {
 694     mutt_error _("Error opening mailbox");
 695     mutt_sleep (1);
 696     goto fail;
 697   }
 698
 699   dprint (2, (debugfile, "imap_open_mailbox: msgcount is %d\n", ctx->msgcount));
 700   FREE (&mx.mbox);
 701   return 0;
 702
 703  fail:
 704   if (idata->state == IMAP_SELECTED)
 705     idata->state = IMAP_AUTHENTICATED;
 706  fail_noidata:
 707   FREE (&mx.mbox);
 708   return -1;
 709 }
 710
 711 int imap_open_mailbox_append (CONTEXT *ctx)
 712 {
 713   CONNECTION *conn;
 714   IMAP_DATA *idata;
 715   char buf[LONG_STRING], mbox[LONG_STRING];
 716   char mailbox[LONG_STRING];
 717   int r;
 718   IMAP_MBOX mx;
 719
 720   if (imap_parse_path (ctx->path, &mx))
 721     return -1;
 722
 723   /* in APPEND mode, we appear to hijack an existing IMAP connection -
 724    * ctx is brand new and mostly empty */
 725
 726   if (!(idata = imap_conn_find (&(mx.account), 0)))
 727     goto fail;
 728   conn = idata->conn;
 729
 730   ctx->magic = M_IMAP;
 731   ctx->data = idata;
 732
 733   /* check mailbox existance */
 734
 735   imap_fix_path (idata, mx.mbox, mailbox, sizeof (mailbox));
 736
 737   imap_munge_mbox_name (mbox, sizeof (mbox), mailbox);
 738
 739   if (mutt_bit_isset(idata->capabilities,IMAP4REV1))
 740     snprintf (buf, sizeof (buf), "STATUS %s (UIDVALIDITY)", mbox);
 741   else if (mutt_bit_isset(idata->capabilities,STATUS))
 742     /* We have no idea what the other guy wants. UW imapd 8.3 wants this
 743      * (but it does not work if another mailbox is selected) */
 744     snprintf (buf, sizeof (buf), "STATUS %s (UID-VALIDITY)", mbox);
 745   else
 746   {
 747     /* STATUS not supported */
 748     mutt_message _("Unable to append to IMAP mailboxes at this server");
 749
 750     goto fail;
 751   }
 752
 753   r = imap_exec (idata, buf, IMAP_CMD_FAIL_OK);
 754   if (r == -2)
 755   {
 756     /* command failed cause folder doesn't exist */
 757     snprintf (buf, sizeof (buf), _("Create %s?"), mailbox);
 758     if (option (OPTCONFIRMCREATE) && mutt_yesorno (buf, 1) < 1)
 759       goto fail;
 760
 761     if (imap_create_mailbox (idata, mailbox) < 0)
 762       goto fail;
 763   }
 764   else if (r == -1)
 765     /* Hmm, some other failure */
 766     goto fail;
 767
 768   FREE (&mx.mbox);
 769   return 0;
 770
 771  fail:
 772   FREE (&mx.mbox);
 773   return -1;
 774 }
 775
 776 /* imap_logout: Gracefully log out of server. */
 777 void imap_logout (IMAP_DATA* idata)
 778 {
 779   /* we set status here to let imap_handle_untagged know we _expect_ to
 780    * receive a bye response (so it doesn't freak out and close the conn) */
 781   idata->status = IMAP_BYE;
 782   imap_cmd_start (idata, "LOGOUT");
 783   while (imap_cmd_step (idata) == IMAP_CMD_CONTINUE)
 784     ;
 785 }
 786
 787 int imap_close_connection (CONTEXT *ctx)
 788 {
 789   dprint (1, (debugfile, "imap_close_connection(): closing connection\n"));
 790   /* if the server didn't shut down on us, close the connection gracefully */
 791   if (CTX_DATA->status != IMAP_BYE)
 792   {
 793     mutt_message _("Closing connection to IMAP server...");
 794     imap_logout (CTX_DATA);
 795     mutt_clear_error ();
 796   }
 797   mutt_socket_close (CTX_DATA->conn);
 798   CTX_DATA->state = IMAP_DISCONNECTED;
 799   CTX_DATA->conn->data = NULL;
 800   return 0;
 801 }
 802
 803 /* imap_set_flag: append str to flags if we currently have permission
 804  *   according to aclbit */
 805 static void imap_set_flag (IMAP_DATA* idata, int aclbit, int flag,
 806   const char *str, char *flags, size_t flsize)
 807 {
 808   if (mutt_bit_isset (idata->rights, aclbit))
 809     if (flag)
 810       strncat (flags, str, flsize);
 811 }
 812
 813 /* imap_make_msg_set: make an IMAP4rev1 UID message set out of a set of
 814  *   headers, given a flag enum to filter on.
 815  * Params: idata: IMAP_DATA containing context containing header set
 816  *         buf: to write message set into
 817  *         buflen: length of buffer
 818  *         flag: enum of flag type on which to filter
 819  *         changed: include only changed messages in message set
 820  * Returns: number of messages in message set (0 if no matches) */
 821 int imap_make_msg_set (IMAP_DATA* idata, BUFFER* buf, int flag, int changed)
 822 {
 823   HEADER** hdrs;        /* sorted local copy */
 824   int count = 0;        /* number of messages in message set */
 825   int match = 0;        /* whether current message matches flag condition */
 826   unsigned int setstart = 0;    /* start of current message range */
 827   int n;
 828   short oldsort;        /* we clobber reverse, must restore it */
 829   /* assuming 32-bit UIDs */
 830   char uid[12];
 831   int started = 0;
 832
 833   /* make copy of header pointers to sort in natural order */
 834   hdrs = safe_calloc (idata->ctx->msgcount, sizeof (HEADER*));
 835   memcpy (hdrs, idata->ctx->hdrs, idata->ctx->msgcount * sizeof (HEADER*));
 836
 837   if (Sort != SORT_ORDER)
 838   {
 839     oldsort = Sort;
 840     Sort = SORT_ORDER;
 841     qsort ((void*) hdrs, idata->ctx->msgcount, sizeof (HEADER*),
 842       mutt_get_sort_func (SORT_ORDER));
 843     Sort = oldsort;
 844   }
 845
 846   for (n = 0; n < idata->ctx->msgcount; n++)
 847   {
 848     match = 0;
 849     /* don't include pending expunged messages */
 850     if (hdrs[n]->active)
 851       switch (flag)
 852       {
 853         case M_DELETE:
 854           if (hdrs[n]->deleted)
 855             match = 1;
 856           break;
 857         case M_TAG:
 858           if (hdrs[n]->tagged)
 859             match = 1;
 860           break;
 861       }
 862
 863     if (match && (!changed || hdrs[n]->changed))
 864     {
 865       count++;
 866       if (setstart == 0)
 867       {
 868         setstart = HEADER_DATA (hdrs[n])->uid;
 869         if (started == 0)
 870         {
 871           snprintf (uid, sizeof (uid), "%u", HEADER_DATA (hdrs[n])->uid);
 872           mutt_buffer_addstr (buf, uid);
 873           started = 1;
 874         }
 875         else
 876         {
 877           snprintf (uid, sizeof (uid), ",%u", HEADER_DATA (hdrs[n])->uid);
 878           mutt_buffer_addstr (buf, uid);
 879         }
 880       }
 881       /* tie up if the last message also matches */
 882       else if (n == idata->ctx->msgcount-1)
 883       {
 884         snprintf (uid, sizeof (uid), ":%u", HEADER_DATA (hdrs[n])->uid);
 885         mutt_buffer_addstr (buf, uid);
 886       }
 887     }
 888     /* this message is not expunged and doesn't match. End current set. */
 889     else if (setstart && hdrs[n]->active)
 890     {
 891       if (HEADER_DATA (hdrs[n-1])->uid > setstart)
 892       {
 893         snprintf (uid, sizeof (uid), ":%u", HEADER_DATA (hdrs[n-1])->uid);
 894         mutt_buffer_addstr (buf, uid);
 895       }
 896       setstart = 0;
 897     }
 898   }
 899
 900   FREE (&hdrs);
 901
 902   return count;
 903 }
 904
 905 /* update the IMAP server to reflect message changes done within mutt.
 906  * Arguments
 907  *   ctx: the current context
 908  *   expunge: 0 or 1 - do expunge?
 909  */
 910
 911 int imap_sync_mailbox (CONTEXT* ctx, int expunge, int* index_hint)
 912 {
 913   IMAP_DATA* idata;
 914   CONTEXT* appendctx = NULL;
 915   BUFFER cmd;
 916   char flags[LONG_STRING];
 917   char uid[11];
 918   int deleted;
 919   int n;
 920   int err_continue = M_NO;      /* continue on error? */
 921   int rc;
 922
 923   idata = (IMAP_DATA*) ctx->data;
 924
 925   if (idata->state != IMAP_SELECTED)
 926   {
 927     dprint (2, (debugfile, "imap_sync_mailbox: no mailbox selected\n"));
 928     return -1;
 929   }
 930
 931   /* CLOSE purges deleted messages. If we don't want to purge them, we must
 932    * tell imap_close_mailbox not to issue the CLOSE command */
 933   if (expunge)
 934     idata->noclose = 0;
 935   else
 936     idata->noclose = 1;
 937
 938   /* This function is only called when the calling code expects the context
 939    * to be changed. */
 940   imap_allow_reopen (ctx);
 941
 942   if ((rc = imap_check_mailbox (ctx, index_hint, 0)) != 0)
 943     return rc;
 944
 945   memset (&cmd, 0, sizeof (cmd));
 946
 947   /* if we are expunging anyway, we can do deleted messages very quickly... */
 948   if (expunge && mutt_bit_isset (idata->rights, IMAP_ACL_DELETE))
 949   {
 950     mutt_buffer_addstr (&cmd, "UID STORE ");
 951     deleted = imap_make_msg_set (idata, &cmd, M_DELETE, 1);
 952
 953     /* if we have a message set, then let's delete */
 954     if (deleted)
 955     {
 956       mutt_message (_("Marking %d messages deleted..."), deleted);
 957       mutt_buffer_addstr (&cmd, " +FLAGS.SILENT (\\Deleted)");
 958       /* mark these messages as unchanged so second pass ignores them. Done
 959        * here so BOGUS UW-IMAP 4.7 SILENT FLAGS updates are ignored. */
 960       for (n = 0; n < ctx->msgcount; n++)
 961         if (ctx->hdrs[n]->deleted && ctx->hdrs[n]->changed)
 962           ctx->hdrs[n]->active = 0;
 963       if (imap_exec (idata, cmd.data, 0) != 0)
 964       {
 965         mutt_error (_("Expunge failed"));
 966         mutt_sleep (1);
 967         rc = -1;
 968         goto out;
 969       }
 970     }
 971   }
 972
 973   /* save status changes */
 974   for (n = 0; n < ctx->msgcount; n++)
 975   {
 976     if (ctx->hdrs[n]->active && ctx->hdrs[n]->changed)
 977     {
 978       ctx->hdrs[n]->changed = 0;
 979
 980       mutt_message (_("Saving message status flags... [%d/%d]"), n+1,
 981         ctx->msgcount);
 982
 983       snprintf (uid, sizeof (uid), "%u", HEADER_DATA(ctx->hdrs[n])->uid);
 984       cmd.dptr = cmd.data;
 985       mutt_buffer_addstr (&cmd, "UID STORE ");
 986       mutt_buffer_addstr (&cmd, uid);
 987
 988       /* if the message has been rethreaded or attachments have been deleted
 989        * we delete the message and reupload it.
 990        * This works better if we're expunging, of course. */
 991       if (ctx->hdrs[n]->refs_changed || ctx->hdrs[n]->irt_changed ||
 992           ctx->hdrs[n]->attach_del)
 993       {
 994         dprint (3, (debugfile, "imap_sync_mailbox: Attachments to be deleted, falling back to _mutt_save_message\n"));
 995         if (!appendctx)
 996           appendctx = mx_open_mailbox (ctx->path, M_APPEND | M_QUIET, NULL);
 997         if (!appendctx)
 998         {
 999           dprint (1, (debugfile, "imap_sync_mailbox: Error opening mailbox in append mode\n"));
1000         }
1001         else
1002           _mutt_save_message (ctx->hdrs[n], appendctx, 1, 0, 0);
1003       }
1004       flags[0] = '\0';
1005
1006       imap_set_flag (idata, IMAP_ACL_SEEN, ctx->hdrs[n]->read, "\\Seen ",
1007         flags, sizeof (flags));
1008       imap_set_flag (idata, IMAP_ACL_WRITE, ctx->hdrs[n]->flagged,
1009         "\\Flagged ", flags, sizeof (flags));
1010       imap_set_flag (idata, IMAP_ACL_WRITE, ctx->hdrs[n]->replied,
1011         "\\Answered ", flags, sizeof (flags));
1012       imap_set_flag (idata, IMAP_ACL_DELETE, ctx->hdrs[n]->deleted,
1013         "\\Deleted ", flags, sizeof (flags));
1014
1015       /* now make sure we don't lose custom tags */
1016       if (mutt_bit_isset (idata->rights, IMAP_ACL_WRITE))
1017         imap_add_keywords (flags, ctx->hdrs[n], idata->flags, sizeof (flags));
1018
1019       mutt_remove_trailing_ws (flags);
1020
1021       /* UW-IMAP is OK with null flags, Cyrus isn't. The only solution is to
1022        * explicitly revoke all system flags (if we have permission) */
1023       if (!*flags)
1024       {
1025         imap_set_flag (idata, IMAP_ACL_SEEN, 1, "\\Seen ", flags, sizeof (flags));
1026         imap_set_flag (idata, IMAP_ACL_WRITE, 1, "\\Flagged ", flags, sizeof (flags));
1027         imap_set_flag (idata, IMAP_ACL_WRITE, 1, "\\Answered ", flags, sizeof (flags));
1028         imap_set_flag (idata, IMAP_ACL_DELETE, 1, "\\Deleted ", flags, sizeof (flags));
1029
1030         mutt_remove_trailing_ws (flags);
1031
1032         mutt_buffer_addstr (&cmd, " -FLAGS.SILENT (");
1033       }
1034       else
1035         mutt_buffer_addstr (&cmd, " FLAGS.SILENT (");
1036
1037       mutt_buffer_addstr (&cmd, flags);
1038       mutt_buffer_addstr (&cmd, ")");
1039
1040       /* dumb hack for bad UW-IMAP 4.7 servers spurious FLAGS updates */
1041       ctx->hdrs[n]->active = 0;
1042
1043       /* after all this it's still possible to have no flags, if you
1044        * have no ACL rights */
1045       if (*flags && (imap_exec (idata, cmd.data, 0) != 0) &&
1046         (err_continue != M_YES))
1047       {
1048         err_continue = imap_continue ("imap_sync_mailbox: STORE failed",
1049           idata->cmd.buf);
1050         if (err_continue != M_YES)
1051         {
1052           rc = -1;
1053           goto out;
1054         }
1055       }
1056
1057       ctx->hdrs[n]->active = 1;
1058     }
1059   }
1060   ctx->changed = 0;
1061
1062   /* We must send an EXPUNGE command if we're not closing. */
1063   if (expunge && !(ctx->closing) &&
1064       mutt_bit_isset(idata->rights, IMAP_ACL_DELETE))
1065   {
1066     mutt_message _("Expunging messages from server...");
1067     /* Set expunge bit so we don't get spurious reopened messages */
1068     idata->reopen |= IMAP_EXPUNGE_EXPECTED;
1069     if (imap_exec (idata, "EXPUNGE", 0) != 0)
1070     {
1071       imap_error (_("imap_sync_mailbox: EXPUNGE failed"), idata->cmd.buf);
1072       rc = -1;
1073       goto out;
1074     }
1075   }
1076
1077   rc = 0;
1078  out:
1079   if (cmd.data)
1080     FREE (&cmd.data);
1081   if (appendctx)
1082   {
1083     mx_fastclose_mailbox (appendctx);
1084     FREE (&appendctx);
1085   }
1086   return rc;
1087 }
1088
1089 /* imap_close_mailbox: issue close command if neccessary, reset IMAP_DATA */
1090 void imap_close_mailbox (CONTEXT* ctx)
1091 {
1092   IMAP_DATA* idata;
1093   int i;
1094
1095   idata = (IMAP_DATA*) ctx->data;
1096   /* Check to see if the mailbox is actually open */
1097   if (!idata)
1098     return;
1099
1100   if ((idata->status != IMAP_FATAL) &&
1101       (idata->state == IMAP_SELECTED) &&
1102       (ctx == idata->ctx))
1103   {
1104     if (!(idata->noclose) && imap_exec (idata, "CLOSE", 0))
1105       mutt_error (_("CLOSE failed"));
1106
1107     idata->reopen &= IMAP_REOPEN_ALLOW;
1108     idata->state = IMAP_AUTHENTICATED;
1109     FREE (&(idata->mailbox));
1110     mutt_free_list (&idata->flags);
1111     idata->ctx = NULL;
1112   }
1113
1114   /* free IMAP part of headers */
1115   for (i = 0; i < ctx->msgcount; i++)
1116     imap_free_header_data (&(ctx->hdrs[i]->data));
1117
1118   for (i = 0; i < IMAP_CACHE_LEN; i++)
1119   {
1120     if (idata->cache[i].path)
1121     {
1122       unlink (idata->cache[i].path);
1123       FREE (&idata->cache[i].path);
1124     }
1125   }
1126 }
1127
1128 /* use the NOOP command to poll for new mail
1129  *
1130  * return values:
1131  *      M_REOPENED      mailbox has been externally modified
1132  *      M_NEW_MAIL      new mail has arrived!
1133  *      0               no change
1134  *      -1              error
1135  */
1136 int imap_check_mailbox (CONTEXT *ctx, int *index_hint, int force)
1137 {
1138   /* overload keyboard timeout to avoid many mailbox checks in a row.
1139    * Most users don't like having to wait exactly when they press a key. */
1140   IMAP_DATA* idata;
1141   int result = 0;
1142
1143   idata = (IMAP_DATA*) ctx->data;
1144
1145   if ((force || time(NULL) > idata->lastread + Timeout)
1146       && imap_exec (idata, "NOOP", 0) != 0)
1147     return -1;
1148
1149   /* We call this even when we haven't run NOOP in case we have pending
1150    * changes to process, since we can reopen here. */
1151   imap_cmd_finish (idata);
1152
1153   if (idata->check_status & IMAP_EXPUNGE_PENDING)
1154     result = M_REOPENED;
1155   else if (idata->check_status & IMAP_NEWMAIL_PENDING)
1156     result = M_NEW_MAIL;
1157   else if (idata->check_status & IMAP_FLAGS_PENDING)
1158     result = M_FLAGS;
1159
1160   idata->check_status = 0;
1161
1162   return result;
1163 }
1164
1165 /* returns count of recent messages if new = 1, else count of total messages.
1166  * (useful for at least postponed function)
1167  * Question of taste: use RECENT or UNSEEN for new?
1168  *   0+   number of messages in mailbox
1169  *  -1    error while polling mailboxes
1170  */
1171 int imap_mailbox_check (char* path, int new)
1172 {
1173   CONNECTION *conn;
1174   IMAP_DATA *idata;
1175   char buf[LONG_STRING];
1176   char mbox[LONG_STRING];
1177   char mbox_unquoted[LONG_STRING];
1178   char *s;
1179   int msgcount = 0;
1180   int connflags = 0;
1181   IMAP_MBOX mx;
1182   int rc;
1183
1184   if (imap_parse_path (path, &mx))
1185     return -1;
1186
1187   /* If imap_passive is set, don't open a connection to check for new mail */
1188   if (option (OPTIMAPPASSIVE))
1189     connflags = M_IMAP_CONN_NONEW;
1190
1191   if (!(idata = imap_conn_find (&(mx.account), connflags)))
1192   {
1193     FREE (&mx.mbox);
1194     return -1;
1195   }
1196   conn = idata->conn;
1197
1198   imap_fix_path (idata, mx.mbox, buf, sizeof (buf));
1199   FREE (&mx.mbox);
1200
1201   imap_munge_mbox_name (mbox, sizeof(mbox), buf);
1202   strfcpy (mbox_unquoted, buf, sizeof (mbox_unquoted));
1203
1204   /* The draft IMAP implementor's guide warns againts using the STATUS
1205    * command on a mailbox that you have selected
1206    */
1207
1208   if (mutt_strcmp (mbox_unquoted, idata->mailbox) == 0
1209       || (ascii_strcasecmp (mbox_unquoted, "INBOX") == 0
1210           && mutt_strcasecmp (mbox_unquoted, idata->mailbox) == 0))
1211   {
1212     strfcpy (buf, "NOOP", sizeof (buf));
1213   }
1214   else if (mutt_bit_isset(idata->capabilities,IMAP4REV1) ||
1215            mutt_bit_isset(idata->capabilities,STATUS))
1216   {
1217     snprintf (buf, sizeof (buf), "STATUS %s (%s)", mbox,
1218       new ? "RECENT" : "MESSAGES");
1219   }
1220   else
1221     /* Server does not support STATUS, and this is not the current mailbox.
1222      * There is no lightweight way to check recent arrivals */
1223     return -1;
1224
1225   imap_cmd_start (idata, buf);
1226
1227   do
1228   {
1229     if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE)
1230       break;
1231
1232     s = imap_next_word (idata->cmd.buf);
1233     if (ascii_strncasecmp ("STATUS", s, 6) == 0)
1234     {
1235       s = imap_next_word (s);
1236       /* The mailbox name may or may not be quoted here. We could try to
1237        * munge the server response and compare with quoted (or vise versa)
1238        * but it is probably more efficient to just strncmp against both. */
1239       if (mutt_strncmp (mbox_unquoted, s, mutt_strlen (mbox_unquoted)) == 0
1240           || mutt_strncmp (mbox, s, mutt_strlen (mbox)) == 0)
1241       {
1242         s = imap_next_word (s);
1243         s = imap_next_word (s);
1244         if (isdigit ((unsigned char) *s))
1245         {
1246           if (*s != '0')
1247           {
1248             msgcount = atoi(s);
1249             dprint (2, (debugfile, "%d new messages in %s\n", msgcount, path));
1250           }
1251         }
1252       }
1253       else
1254         dprint (1, (debugfile, "imap_mailbox_check: STATUS response doesn't match requested mailbox.\n"));
1255     }
1256   }
1257   while (rc == IMAP_CMD_CONTINUE);
1258
1259   return msgcount;
1260 }
1261
1262 /* all this listing/browsing is a mess. I don't like that name is a pointer
1263  *   into idata->buf (used to be a pointer into the passed in buffer, just
1264  *   as bad), nor do I like the fact that the fetch is done here. This
1265  *   code can't possibly handle non-LIST untagged responses properly.
1266  *   FIXME. ?! */
1267 int imap_parse_list_response(IMAP_DATA* idata, char **name, int *noselect,
1268   int *noinferiors, char *delim)
1269 {
1270   char *s;
1271   long bytes;
1272   int rc;
1273
1274   *name = NULL;
1275
1276   rc = imap_cmd_step (idata);
1277   if (rc == IMAP_CMD_OK)
1278     return 0;
1279   if (rc != IMAP_CMD_CONTINUE)
1280     return -1;
1281
1282   s = imap_next_word (idata->cmd.buf);
1283   if ((ascii_strncasecmp ("LIST", s, 4) == 0) ||
1284       (ascii_strncasecmp ("LSUB", s, 4) == 0))
1285   {
1286     *noselect = 0;
1287     *noinferiors = 0;
1288
1289     s = imap_next_word (s); /* flags */
1290     if (*s == '(')
1291     {
1292       char *ep;
1293
1294       s++;
1295       ep = s;
1296       while (*ep && *ep != ')') ep++;
1297       do
1298       {
1299         if (!ascii_strncasecmp (s, "\\NoSelect", 9))
1300           *noselect = 1;
1301         if (!ascii_strncasecmp (s, "\\NoInferiors", 12))
1302           *noinferiors = 1;
1303         /* See draft-gahrns-imap-child-mailbox-?? */
1304         if (!ascii_strncasecmp (s, "\\HasNoChildren", 14))
1305           *noinferiors = 1;
1306         if (*s != ')')
1307           s++;
1308         while (*s && *s != '\\' && *s != ')') s++;
1309       } while (s != ep);
1310     }
1311     else
1312       return 0;
1313     s = imap_next_word (s); /* delim */
1314     /* Reset the delimiter, this can change */
1315     if (ascii_strncasecmp (s, "NIL", 3))
1316     {
1317       if (s && s[0] == '\"' && s[1] && s[2] == '\"')
1318         *delim = s[1];
1319       else if (s && s[0] == '\"' && s[1] && s[1] == '\\' && s[2] && s[3] == '\"')
1320         *delim = s[2];
1321     }
1322     s = imap_next_word (s); /* name */
1323     if (s && *s == '{') /* Literal */
1324     {
1325       if (imap_get_literal_count(idata->cmd.buf, &bytes) < 0)
1326         return -1;
1327       if (imap_cmd_step (idata) != IMAP_CMD_CONTINUE)
1328         return -1;
1329       *name = idata->cmd.buf;
1330     }
1331     else
1332       *name = s;
1333   }
1334
1335   return 0;
1336 }
1337
1338 int imap_subscribe (char *path, int subscribe)
1339 {
1340   CONNECTION *conn;
1341   IMAP_DATA *idata;
1342   char buf[LONG_STRING];
1343   char mbox[LONG_STRING];
1344   IMAP_MBOX mx;
1345
1346   if (!mx_is_imap (path) || imap_parse_path (path, &mx))
1347   {
1348     mutt_error (_("Bad mailbox name"));
1349     return -1;
1350   }
1351
1352
1353   if (!(idata = imap_conn_find (&(mx.account), 0)))
1354     goto fail;
1355
1356   conn = idata->conn;
1357
1358   imap_fix_path (idata, mx.mbox, buf, sizeof (buf));
1359   if (subscribe)
1360     mutt_message (_("Subscribing to %s..."), buf);
1361   else
1362     mutt_message (_("Unsubscribing to %s..."), buf);
1363   imap_munge_mbox_name (mbox, sizeof(mbox), buf);
1364
1365   snprintf (buf, sizeof (buf), "%s %s", subscribe ? "SUBSCRIBE" :
1366     "UNSUBSCRIBE", mbox);
1367
1368   if (imap_exec (idata, buf, 0) < 0)
1369     goto fail;
1370
1371   FREE (&mx.mbox);
1372   return 0;
1373
1374  fail:
1375   FREE (&mx.mbox);
1376   return -1;
1377 }
1378
1379 /* imap_complete: given a partial IMAP folder path, return a string which
1380  *   adds as much to the path as is unique */
1381 int imap_complete(char* dest, size_t dlen, char* path) {
1382   CONNECTION* conn;
1383   IMAP_DATA* idata;
1384   char list[LONG_STRING];
1385   char buf[LONG_STRING];
1386   char* list_word = NULL;
1387   int noselect, noinferiors;
1388   char delim;
1389   char completion[LONG_STRING];
1390   int clen, matchlen = 0;
1391   int completions = 0;
1392   int pos = 0;
1393   IMAP_MBOX mx;
1394
1395   /* verify passed in path is an IMAP path */
1396   if (imap_parse_path (path, &mx))
1397   {
1398     dprint(2, (debugfile, "imap_complete: bad path %s\n", path));
1399     return -1;
1400   }
1401
1402   /* don't open a new socket just for completion */
1403   if (!(idata = imap_conn_find (&(mx.account), M_IMAP_CONN_NONEW)))
1404     goto fail;
1405   conn = idata->conn;
1406
1407   /* reformat path for IMAP list, and append wildcard */
1408   /* don't use INBOX in place of "" */
1409   if (mx.mbox && mx.mbox[0])
1410     imap_fix_path (idata, mx.mbox, list, sizeof(list));
1411   else
1412     list[0] = '\0';
1413
1414   /* fire off command */
1415   snprintf (buf, sizeof(buf), "%s \"\" \"%s%%\"",
1416     option (OPTIMAPLSUB) ? "LSUB" : "LIST", list);
1417
1418   imap_cmd_start (idata, buf);
1419
1420   /* and see what the results are */
1421   strfcpy (completion, NONULL(mx.mbox), sizeof(completion));
1422   do
1423   {
1424     if (imap_parse_list_response(idata, &list_word, &noselect, &noinferiors,
1425         &delim))
1426       break;
1427
1428     if (list_word)
1429     {
1430       /* store unquoted */
1431       imap_unmunge_mbox_name (list_word);
1432
1433       /* if the folder isn't selectable, append delimiter to force browse
1434        * to enter it on second tab. */
1435       if (noselect)
1436       {
1437         clen = strlen(list_word);
1438         list_word[clen++] = delim;
1439         list_word[clen] = '\0';
1440       }
1441       /* copy in first word */
1442       if (!completions)
1443       {
1444         strfcpy (completion, list_word, sizeof(completion));
1445         matchlen = strlen (completion);
1446         completions++;
1447         continue;
1448       }
1449
1450       pos = 0;
1451       while (pos < matchlen && list_word[pos] &&
1452           completion[pos] == list_word[pos])
1453         pos++;
1454       completion[pos] = '\0';
1455       matchlen = pos;
1456
1457       completions++;
1458     }
1459   }
1460   while (ascii_strncmp(idata->cmd.seq, idata->cmd.buf, SEQLEN));
1461
1462   if (completions)
1463   {
1464     /* reformat output */
1465     imap_qualify_path (dest, dlen, &mx, completion);
1466     mutt_pretty_mailbox (dest);
1467
1468     FREE (&mx.mbox);
1469     return 0;
1470   }
1471
1472  fail:
1473   FREE (&mx.mbox);
1474   return -1;
1475 }