X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=imap%2Fimap.c;h=4f0395f7148ad5e09d6f35dbab5bf500536b520b;hp=20c396083d252655dc3c4fae15a93640634a81ac;hb=a0aa3d4bba449529dfed997214b34e309ce451dd;hpb=3d937534e7b1ee723f86594b5e4c64c95158a933 diff --git a/imap/imap.c b/imap/imap.c index 20c3960..4f0395f 100644 --- a/imap/imap.c +++ b/imap/imap.c @@ -1,29 +1,24 @@ /* + * Copyright notice from original mutt: * Copyright (C) 1996-8 Michael R. Elkins * Copyright (C) 1996-9 Brandon Long - * Copyright (C) 1999-2003 Brendan Cully - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. - */ + * Copyright (C) 1999-2005 Brendan Cully + * + * This file is part of mutt-ng, see http://www.muttng.org/. + * It's licensed under the GNU General Public License, + * please see the file GPL in the top level source directory. + */ /* Support for IMAP4rev1, with the occasional nod to IMAP 4. */ +#if HAVE_CONFIG_H +# include "config.h" +#endif + #include "mutt.h" -#include "mutt_curses.h" +#include "ascii.h" +#include "buffer.h" #include "mx.h" -#include "mailbox.h" #include "globals.h" #include "sort.h" #include "browser.h" @@ -32,6 +27,12 @@ #if defined(USE_SSL) || defined(USE_GNUTLS) # include "mutt_ssl.h" #endif +#include "buffy.h" + +#include "lib/mem.h" +#include "lib/intl.h" +#include "lib/str.h" +#include "lib/debug.h" #include #include @@ -41,17 +42,19 @@ #include /* imap forward declarations */ -static int imap_get_delim (IMAP_DATA *idata); -static char* imap_get_flags (LIST** hflags, char* s); -static int imap_check_acl (IMAP_DATA *idata); -static int imap_check_capabilities (IMAP_DATA* idata); -static void imap_set_flag (IMAP_DATA* idata, int aclbit, int flag, - const char* str, char* flags, size_t flsize); - -/* imap_access: Check permissions on an IMAP mailbox. */ -int imap_access (const char* path, int flags) +static int imap_get_delim (IMAP_DATA * idata); +static char *imap_get_flags (LIST ** hflags, char *s); +static int imap_check_acl (IMAP_DATA * idata); +static int imap_check_capabilities (IMAP_DATA * idata); +static void imap_set_flag (IMAP_DATA * idata, int aclbit, int flag, + const char *str, char *flags, size_t flsize); + +/* imap_access: Check permissions on an IMAP mailbox. + * TODO: ACL checks. Right now we assume if it exists we can + * mess with it. */ +int imap_access (const char *path, int flags) { - IMAP_DATA* idata; + IMAP_DATA *idata; IMAP_MBOX mx; char buf[LONG_STRING]; char mailbox[LONG_STRING]; @@ -61,69 +64,92 @@ int imap_access (const char* path, int flags) return -1; if (!(idata = imap_conn_find (&mx.account, - option (OPTIMAPPASSIVE) ? M_IMAP_CONN_NONEW : 0))) - { - FREE (&mx.mbox); + option (OPTIMAPPASSIVE) ? M_IMAP_CONN_NONEW : + 0))) { + mem_free (&mx.mbox); return -1; } imap_fix_path (idata, mx.mbox, mailbox, sizeof (mailbox)); - FREE (&mx.mbox); + + /* we may already be in the folder we're checking */ + if (!ascii_strcmp(idata->mailbox, mx.mbox)) { + mem_free (&mx.mbox); + return 0; + } + + mem_free (&mx.mbox); imap_munge_mbox_name (mbox, sizeof (mbox), mailbox); - /* TODO: ACL checks. Right now we assume if it exists we can mess with it. */ if (mutt_bit_isset (idata->capabilities, IMAP4REV1)) snprintf (buf, sizeof (buf), "STATUS %s (UIDVALIDITY)", mbox); else if (mutt_bit_isset (idata->capabilities, STATUS)) snprintf (buf, sizeof (buf), "STATUS %s (UID-VALIDITY)", mbox); - else - { - dprint (2, (debugfile, "imap_access: STATUS not supported?\n")); + else { + debug_print (2, ("STATUS not supported?\n")); return -1; } - if (imap_exec (idata, buf, IMAP_CMD_FAIL_OK) < 0) - { - dprint (1, (debugfile, "imap_access: Can't check STATUS of %s\n", mbox)); + if (imap_exec (idata, buf, IMAP_CMD_FAIL_OK) < 0) { + debug_print (1, ("Can't check STATUS of %s\n", mbox)); return -1; } return 0; } -int imap_create_mailbox (IMAP_DATA* idata, char* mailbox) +int imap_create_mailbox (IMAP_DATA * idata, char *mailbox) { char buf[LONG_STRING], mbox[LONG_STRING]; imap_munge_mbox_name (mbox, sizeof (mbox), mailbox); snprintf (buf, sizeof (buf), "CREATE %s", mbox); - + + if (imap_exec (idata, buf, 0) != 0) + return -1; + + return 0; +} + +int imap_rename_mailbox (IMAP_DATA * idata, IMAP_MBOX * mx, + const char *newname) +{ + char oldmbox[LONG_STRING]; + char newmbox[LONG_STRING]; + char buf[LONG_STRING]; + + imap_munge_mbox_name (oldmbox, sizeof (oldmbox), mx->mbox); + imap_munge_mbox_name (newmbox, sizeof (newmbox), newname); + + snprintf (buf, sizeof (buf), "RENAME %s %s", oldmbox, newmbox); + if (imap_exec (idata, buf, 0) != 0) return -1; return 0; } -int imap_delete_mailbox (CONTEXT* ctx, IMAP_MBOX mx) +int imap_delete_mailbox (CONTEXT * ctx, IMAP_MBOX mx) { char buf[LONG_STRING], mbox[LONG_STRING]; IMAP_DATA *idata; if (!ctx || !ctx->data) { - if (!(idata = imap_conn_find (&mx.account, - option (OPTIMAPPASSIVE) ? M_IMAP_CONN_NONEW : 0))) - { - FREE (&mx.mbox); - return -1; - } - } else { - idata = ctx->data; + if (!(idata = imap_conn_find (&mx.account, + option (OPTIMAPPASSIVE) ? M_IMAP_CONN_NONEW + : 0))) { + mem_free (&mx.mbox); + return -1; + } + } + else { + idata = ctx->data; } imap_munge_mbox_name (mbox, sizeof (mbox), mx.mbox); snprintf (buf, sizeof (buf), "DELETE %s", mbox); - if (imap_exec ((IMAP_DATA*) idata, buf, 0) != 0) + if (imap_exec ((IMAP_DATA *) idata, buf, 0) != 0) return -1; return 0; @@ -131,21 +157,19 @@ int imap_delete_mailbox (CONTEXT* ctx, IMAP_MBOX mx) /* imap_logout_all: close all open connections. Quick and dirty until we can * make sure we've got all the context we need. */ -void imap_logout_all (void) +void imap_logout_all (void) { - CONNECTION* conn; - CONNECTION* tmp; + CONNECTION *conn; + CONNECTION *tmp; conn = mutt_socket_head (); - while (conn) - { + while (conn) { tmp = conn->next; - if (conn->account.type == M_ACCT_TYPE_IMAP && conn->fd >= 0) - { + if (conn->account.type == M_ACCT_TYPE_IMAP && conn->fd >= 0) { mutt_message (_("Closing connection to %s..."), conn->account.host); - imap_logout ((IMAP_DATA*) conn->data); + imap_logout ((IMAP_DATA *) conn->data); mutt_clear_error (); mutt_socket_close (conn); mutt_socket_free (conn); @@ -158,22 +182,20 @@ void imap_logout_all (void) /* imap_read_literal: read bytes bytes from server into file. Not explicitly * buffered, relies on FILE buffering. NOTE: strips \r from \r\n. * Apparently even literals use \r\n-terminated strings ?! */ -int imap_read_literal (FILE* fp, IMAP_DATA* idata, long bytes) +int imap_read_literal (FILE * fp, IMAP_DATA * idata, long bytes, progress_t* bar) { long pos; char c; int r = 0; - dprint (2, (debugfile, "imap_read_literal: reading %ld bytes\n", bytes)); - - for (pos = 0; pos < bytes; pos++) - { - if (mutt_socket_readchar (idata->conn, &c) != 1) - { - dprint (1, (debugfile, "imap_read_literal: error during read, %ld bytes read\n", pos)); + debug_print (2, ("reading %ld bytes\n", bytes)); + + for (pos = 0; pos < bytes; pos++) { + if (mutt_socket_readchar (idata->conn, &c) != 1) { + debug_print (1, ("error during read, %ld bytes read\n", pos)); idata->status = IMAP_FATAL; - + return -1; } @@ -181,8 +203,7 @@ int imap_read_literal (FILE* fp, IMAP_DATA* idata, long bytes) if (r == 1 && c != '\n') fputc ('\r', fp); - if (c == '\r') - { + if (c == '\r') { r = 1; continue; } @@ -190,9 +211,13 @@ int imap_read_literal (FILE* fp, IMAP_DATA* idata, long bytes) r = 0; #endif fputc (c, fp); +#ifdef USE_SOCKET + if (bar && pos % 1024) + mutt_progress_bar (bar, pos); +#endif #ifdef DEBUG - if (debuglevel >= IMAP_LOG_LTRL) - fputc (c, debugfile); + if (DebugLevel >= IMAP_LOG_LTRL) + fputc (c, DebugFile); #endif } @@ -202,28 +227,25 @@ int imap_read_literal (FILE* fp, IMAP_DATA* idata, long bytes) /* imap_expunge_mailbox: Purge IMAP portion of expunged messages from the * context. Must not be done while something has a handle on any headers * (eg inside pager or editor). That is, check IMAP_REOPEN_ALLOW. */ -void imap_expunge_mailbox (IMAP_DATA* idata) +void imap_expunge_mailbox (IMAP_DATA * idata) { - HEADER* h; + HEADER *h; int i, cacheno; - for (i = 0; i < idata->ctx->msgcount; i++) - { + for (i = 0; i < idata->ctx->msgcount; i++) { h = idata->ctx->hdrs[i]; - if (h->index == -1) - { - dprint (2, (debugfile, "Expunging message UID %d.\n", HEADER_DATA (h)->uid)); + if (h->index == -1) { + debug_print (2, ("Expunging message UID %d.\n", HEADER_DATA (h)->uid)); h->active = 0; /* free cached body from disk, if neccessary */ - cacheno = HEADER_DATA(h)->uid % IMAP_CACHE_LEN; - if (idata->cache[cacheno].uid == HEADER_DATA(h)->uid && - idata->cache[cacheno].path) - { - unlink (idata->cache[cacheno].path); - FREE (&idata->cache[cacheno].path); + cacheno = HEADER_DATA (h)->uid % IMAP_CACHE_LEN; + if (idata->cache[cacheno].uid == HEADER_DATA (h)->uid && + idata->cache[cacheno].path) { + unlink (idata->cache[cacheno].path); + mem_free (&idata->cache[cacheno].path); } imap_free_header_data (&h->data); @@ -236,7 +258,7 @@ void imap_expunge_mailbox (IMAP_DATA* idata) mutt_sort_headers (idata->ctx, 1); } -static int imap_get_delim (IMAP_DATA *idata) +static int imap_get_delim (IMAP_DATA * idata) { char *s; int rc; @@ -247,45 +269,42 @@ static int imap_get_delim (IMAP_DATA *idata) imap_cmd_start (idata, "LIST \"\" \"\""); - do - { + do { if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE) break; s = imap_next_word (idata->cmd.buf); - if (ascii_strncasecmp ("LIST", s, 4) == 0) - { + if (ascii_strncasecmp ("LIST", s, 4) == 0) { s = imap_next_word (s); s = imap_next_word (s); if (s && s[0] == '\"' && s[1] && s[2] == '\"') - idata->delim = s[1]; - else if (s && s[0] == '\"' && s[1] && s[1] == '\\' && s[2] && s[3] == '\"') - idata->delim = s[2]; + idata->delim = s[1]; + else if (s && s[0] == '\"' && s[1] && s[1] == '\\' && s[2] + && s[3] == '\"') + idata->delim = s[2]; } } while (rc == IMAP_CMD_CONTINUE); - if (rc != IMAP_CMD_OK) - { - dprint (1, (debugfile, "imap_get_delim: failed.\n")); + if (rc != IMAP_CMD_OK) { + debug_print (1, ("failed.\n")); return -1; } - dprint (2, (debugfile, "Delimiter: %c\n", idata->delim)); + debug_print (2, ("Delimiter: %c\n", idata->delim)); return -1; } /* get rights for folder, let imap_handle_untagged do the rest */ -static int imap_check_acl (IMAP_DATA *idata) +static int imap_check_acl (IMAP_DATA * idata) { char buf[LONG_STRING]; char mbox[LONG_STRING]; - imap_munge_mbox_name (mbox, sizeof(mbox), idata->mailbox); + imap_munge_mbox_name (mbox, sizeof (mbox), idata->mailbox); snprintf (buf, sizeof (buf), "MYRIGHTS %s", mbox); - if (imap_exec (idata, buf, 0) != 0) - { + if (imap_exec (idata, buf, 0) != 0) { imap_error ("imap_check_acl", buf); return -1; } @@ -293,19 +312,18 @@ static int imap_check_acl (IMAP_DATA *idata) } /* imap_check_capabilities: make sure we can log in to this server. */ -static int imap_check_capabilities (IMAP_DATA* idata) +static int imap_check_capabilities (IMAP_DATA * idata) { - if (imap_exec (idata, "CAPABILITY", 0) != 0) - { + if (imap_exec (idata, "CAPABILITY", 0) != 0) { imap_error ("imap_check_capabilities", idata->cmd.buf); return -1; } - if (!(mutt_bit_isset(idata->capabilities,IMAP4) - ||mutt_bit_isset(idata->capabilities,IMAP4REV1))) - { + if (!(mutt_bit_isset (idata->capabilities, IMAP4) + || mutt_bit_isset (idata->capabilities, IMAP4REV1))) { mutt_error _("This IMAP server is ancient. Mutt does not work with it."); - mutt_sleep (2); /* pause a moment to let the user see the error */ + + mutt_sleep (2); /* pause a moment to let the user see the error */ return -1; } @@ -315,11 +333,12 @@ static int imap_check_capabilities (IMAP_DATA* idata) /* imap_conn_find: Find an open IMAP connection matching account, or open * a new one if none can be found. */ -IMAP_DATA* imap_conn_find (const ACCOUNT* account, int flags) +IMAP_DATA *imap_conn_find (const ACCOUNT * account, int flags) { - CONNECTION* conn; - IMAP_DATA* idata; - ACCOUNT* creds; + CONNECTION *conn; + IMAP_DATA *idata; + ACCOUNT *creds; + int new = 0; if (!(conn = mutt_conn_find (NULL, account))) return NULL; @@ -329,63 +348,61 @@ IMAP_DATA* imap_conn_find (const ACCOUNT* account, int flags) /* make sure this connection is not in SELECTED state, if neccessary */ if (flags & M_IMAP_CONN_NOSELECT) - while (conn->data && ((IMAP_DATA*) conn->data)->state == IMAP_SELECTED) - { + while (conn->data && ((IMAP_DATA *) conn->data)->state == IMAP_SELECTED) { if (!(conn = mutt_conn_find (conn, account))) - return NULL; + return NULL; memcpy (&(conn->account), creds, sizeof (ACCOUNT)); } - - idata = (IMAP_DATA*) conn->data; + + idata = (IMAP_DATA *) conn->data; /* don't open a new connection if one isn't wanted */ - if (flags & M_IMAP_CONN_NONEW) - { - if (!idata) - { + if (flags & M_IMAP_CONN_NONEW) { + if (!idata) { mutt_socket_free (conn); return NULL; } if (idata->state < IMAP_AUTHENTICATED) return NULL; } - - if (!idata) - { + + if (!idata) { /* The current connection is a new connection */ - if (! (idata = imap_new_idata ())) - { + if (!(idata = imap_new_idata ())) { mutt_socket_free (conn); return NULL; } conn->data = idata; idata->conn = conn; + new = 1; } if (idata->state == IMAP_DISCONNECTED) imap_open_connection (idata); - if (idata->state == IMAP_CONNECTED) - { - if (!imap_authenticate (idata)) - { + if (idata->state == IMAP_CONNECTED) { + if (!imap_authenticate (idata)) { idata->state = IMAP_AUTHENTICATED; if (idata->conn->ssf) - dprint (2, (debugfile, "Communication encrypted at %d bits\n", - idata->conn->ssf)); + debug_print (2, ("Communication encrypted at %d bits\n", idata->conn->ssf)); } else mutt_account_unsetpass (&idata->conn->account); - - FREE (&idata->capstr); + + mem_free (&idata->capstr); } - if (idata->state == IMAP_AUTHENTICATED) + if (new && idata->state == IMAP_AUTHENTICATED) { imap_get_delim (idata); - + if (option (OPTIMAPCHECKSUBSCRIBED)) { + mutt_message _("Checking mailbox subscriptions"); + imap_exec (idata, "LSUB \"\" \"*\"", 0); + } + } + return idata; } -int imap_open_connection (IMAP_DATA* idata) +int imap_open_connection (IMAP_DATA * idata) { char buf[LONG_STRING]; @@ -395,109 +412,102 @@ int imap_open_connection (IMAP_DATA* idata) idata->state = IMAP_CONNECTED; if (imap_cmd_step (idata) != IMAP_CMD_CONTINUE) { - mutt_error (_("Unexpected response received from server: %s"), idata->cmd.buf); - mutt_sleep (1); - mutt_socket_close (idata->conn); idata->state = IMAP_DISCONNECTED; return -1; } - if (ascii_strncasecmp ("* OK", idata->cmd.buf, 4) == 0) - { + if (ascii_strncasecmp ("* OK", idata->cmd.buf, 4) == 0) { /* TODO: Parse new tagged CAPABILITY data (* OK [CAPABILITY...]) */ if (imap_check_capabilities (idata)) goto bail; #if defined(USE_SSL) || defined(USE_GNUTLS) /* Attempt STARTTLS if available and desired. */ - if (mutt_bit_isset (idata->capabilities, STARTTLS) && !idata->conn->ssf) - { + if (!idata->conn->ssf && (option(OPTSSLFORCETLS) || + mutt_bit_isset (idata->capabilities, STARTTLS))) { int rc; - if ((rc = query_quadoption (OPT_SSLSTARTTLS, - _("Secure connection with TLS?"))) == -1) - goto err_close_conn; + if (option (OPTSSLFORCETLS)) + rc = M_YES; + else if ((rc = query_quadoption (OPT_SSLSTARTTLS, + _("Secure connection with TLS?"))) == -1) + goto err_close_conn; if (rc == M_YES) { - if ((rc = imap_exec (idata, "STARTTLS", IMAP_CMD_FAIL_OK)) == -1) - goto bail; - if (rc != -2) - { -#ifdef USE_SSL - if (mutt_ssl_starttls (idata->conn)) -#elif USE_GNUTLS - if (mutt_gnutls_starttls (idata->conn)) + if ((rc = imap_exec (idata, "STARTTLS", IMAP_CMD_FAIL_OK)) == -1) + goto bail; + if (rc != -2) { +#if defined (USE_SSL) || defined (USE_GNUTLS) + if (mutt_ssl_starttls (idata->conn)) #endif - { - mutt_error (_("Could not negotiate TLS connection")); - mutt_sleep (1); - goto err_close_conn; - } - else - { - /* RFC 2595 demands we recheck CAPABILITY after TLS completes. */ - if (imap_exec (idata, "CAPABILITY", 0)) - goto bail; - } - } + { + mutt_error (_("Could not negotiate TLS connection")); + mutt_sleep (1); + goto err_close_conn; + } + else { + /* RFC 2595 demands we recheck CAPABILITY after TLS completes. */ + if (imap_exec (idata, "CAPABILITY", 0)) + goto bail; + } + } } } -#endif + + if (option(OPTSSLFORCETLS) && ! idata->conn->ssf) { + mutt_error _("Encrypted connection unavailable"); + mutt_sleep (1); + goto err_close_conn; + } +#endif } - else if (ascii_strncasecmp ("* PREAUTH", idata->cmd.buf, 9) == 0) - { + else if (ascii_strncasecmp ("* PREAUTH", idata->cmd.buf, 9) == 0) { idata->state = IMAP_AUTHENTICATED; if (imap_check_capabilities (idata) != 0) goto bail; - FREE (&idata->capstr); - } - else - { + mem_free (&idata->capstr); + } + else { imap_error ("imap_open_connection()", buf); goto bail; } return 0; - err_close_conn: +err_close_conn: mutt_socket_close (idata->conn); idata->state = IMAP_DISCONNECTED; - bail: - FREE (&idata->capstr); +bail: + mem_free (&idata->capstr); return -1; } /* imap_get_flags: Make a simple list out of a FLAGS response. * return stream following FLAGS response */ -static char* imap_get_flags (LIST** hflags, char* s) +static char *imap_get_flags (LIST ** hflags, char *s) { - LIST* flags; - char* flag_word; + LIST *flags; + char *flag_word; char ctmp; /* sanity-check string */ - if (ascii_strncasecmp ("FLAGS", s, 5) != 0) - { - dprint (1, (debugfile, "imap_get_flags: not a FLAGS response: %s\n", - s)); + if (ascii_strncasecmp ("FLAGS", s, 5) != 0) { + debug_print (1, ("not a FLAGS response: %s\n", s)); return NULL; } s += 5; - SKIPWS(s); - if (*s != '(') - { - dprint (1, (debugfile, "imap_get_flags: bogus FLAGS response: %s\n", - s)); + SKIPWS (s); + if (*s != '(') { + debug_print (1, ("bogus FLAGS response: %s\n", s)); return NULL; } /* create list, update caller's flags handle */ - flags = mutt_new_list(); + flags = mutt_new_list (); *hflags = flags; - while (*s && *s != ')') - { + while (*s && *s != ')') { s++; - SKIPWS(s); + SKIPWS (s); flag_word = s; while (*s && (*s != ')') && !ISSPACE (*s)) s++; @@ -509,10 +519,8 @@ static char* imap_get_flags (LIST** hflags, char* s) } /* note bad flags response */ - if (*s != ')') - { - dprint (1, (debugfile, - "imap_get_flags: Unterminated FLAGS response: %s\n", s)); + if (*s != ')') { + debug_print (1, ("Unterminated FLAGS response: %s\n", s)); mutt_free_list (hflags); return NULL; @@ -523,7 +531,7 @@ static char* imap_get_flags (LIST** hflags, char* s) return s; } -int imap_open_mailbox (CONTEXT* ctx) +int imap_open_mailbox (CONTEXT * ctx) { CONNECTION *conn; IMAP_DATA *idata; @@ -532,9 +540,8 @@ int imap_open_mailbox (CONTEXT* ctx) int count = 0; IMAP_MBOX mx; int rc; - - if (imap_parse_path (ctx->path, &mx)) - { + + if (imap_parse_path (ctx->path, &mx)) { mutt_error (_("%s is an invalid IMAP path"), ctx->path); return -1; } @@ -552,33 +559,32 @@ int imap_open_mailbox (CONTEXT* ctx) /* Clean up path and replace the one in the ctx */ imap_fix_path (idata, mx.mbox, buf, sizeof (buf)); - FREE(&(idata->mailbox)); - idata->mailbox = safe_strdup (buf); + mem_free (&(idata->mailbox)); + idata->mailbox = str_dup (buf); imap_qualify_path (buf, sizeof (buf), &mx, idata->mailbox); - FREE (&(ctx->path)); - ctx->path = safe_strdup (buf); + mem_free (&(ctx->path)); + ctx->path = str_dup (buf); idata->ctx = ctx; /* clear mailbox status */ idata->status = 0; - memset (idata->rights, 0, (RIGHTSMAX+7)/8); + memset (idata->rights, 0, (RIGHTSMAX + 7) / 8); idata->newMailCount = 0; mutt_message (_("Selecting %s..."), idata->mailbox); - imap_munge_mbox_name (buf, sizeof(buf), idata->mailbox); + imap_munge_mbox_name (buf, sizeof (buf), idata->mailbox); snprintf (bufout, sizeof (bufout), "%s %s", - ctx->readonly ? "EXAMINE" : "SELECT", buf); + ctx->readonly ? "EXAMINE" : "SELECT", buf); idata->state = IMAP_SELECTED; imap_cmd_start (idata, bufout); - do - { + do { char *pc; - + if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE) break; @@ -586,55 +592,49 @@ int imap_open_mailbox (CONTEXT* ctx) /* Obtain list of available flags here, may be overridden by a * PERMANENTFLAGS tag in the OK response */ - if (ascii_strncasecmp ("FLAGS", pc, 5) == 0) - { + if (ascii_strncasecmp ("FLAGS", pc, 5) == 0) { /* don't override PERMANENTFLAGS */ - if (!idata->flags) - { - dprint (2, (debugfile, "Getting mailbox FLAGS\n")); - if ((pc = imap_get_flags (&(idata->flags), pc)) == NULL) - goto fail; + if (!idata->flags) { + debug_print (2, ("Getting mailbox FLAGS\n")); + if ((pc = imap_get_flags (&(idata->flags), pc)) == NULL) + goto fail; } } /* PERMANENTFLAGS are massaged to look like FLAGS, then override FLAGS */ - else if (ascii_strncasecmp ("OK [PERMANENTFLAGS", pc, 18) == 0) - { - dprint (2, (debugfile, "Getting mailbox PERMANENTFLAGS\n")); + else if (ascii_strncasecmp ("OK [PERMANENTFLAGS", pc, 18) == 0) { + debug_print (2, ("Getting mailbox PERMANENTFLAGS\n")); /* safe to call on NULL */ mutt_free_list (&(idata->flags)); /* skip "OK [PERMANENT" so syntax is the same as FLAGS */ pc += 13; if ((pc = imap_get_flags (&(idata->flags), pc)) == NULL) - goto fail; + goto fail; } #ifdef USE_HCACHE /* save UIDVALIDITY for the header cache */ - else if (ascii_strncasecmp("OK [UIDVALIDITY", pc, 14) == 0) - { - dprint(2, (debugfile, "Getting mailbox UIDVALIDITY\n")); - pc += 3; - pc = imap_next_word(pc); + else if (ascii_strncasecmp ("OK [UIDVALIDITY", pc, 14) == 0) { + debug_print (2, ("Getting mailbox UIDVALIDITY\n")); + pc += 3; + pc = imap_next_word (pc); - sscanf(pc, "%u", &(idata->uid_validity)); + sscanf (pc, "%lu", &(idata->uid_validity)); } #endif - else - { + else { pc = imap_next_word (pc); - if (!ascii_strncasecmp ("EXISTS", pc, 6)) - { - count = idata->newMailCount; - idata->newMailCount = 0; + if (!ascii_strncasecmp ("EXISTS", pc, 6)) { + count = idata->newMailCount; + idata->newMailCount = 0; } } } while (rc == IMAP_CMD_CONTINUE); - if (rc == IMAP_CMD_NO) - { + if (rc == IMAP_CMD_NO) { char *s; - s = imap_next_word (idata->cmd.buf); /* skip seq */ - s = imap_next_word (s); /* Skip response */ + + s = imap_next_word (idata->cmd.buf); /* skip seq */ + s = imap_next_word (s); /* Skip response */ mutt_error ("%s", s); mutt_sleep (2); goto fail; @@ -644,89 +644,82 @@ int imap_open_mailbox (CONTEXT* ctx) goto fail; /* check for READ-ONLY notification */ - if (!ascii_strncasecmp (imap_get_qualifier (idata->cmd.buf), "[READ-ONLY]", 11) \ - && !mutt_bit_isset (idata->capabilities, ACL)) - { - dprint (2, (debugfile, "Mailbox is read-only.\n")); + if (!ascii_strncasecmp + (imap_get_qualifier (idata->cmd.buf), "[READ-ONLY]", 11) + && !mutt_bit_isset (idata->capabilities, ACL)) { + debug_print (2, ("Mailbox is read-only.\n")); ctx->readonly = 1; } #ifdef DEBUG /* dump the mailbox flags we've found */ - if (debuglevel > 2) - { + if (DebugLevel > 2) { if (!idata->flags) - dprint (3, (debugfile, "No folder flags found\n")); - else - { - LIST* t = idata->flags; + debug_print (3, ("No folder flags found\n")); + else { + LIST *t = idata->flags; - dprint (3, (debugfile, "Mailbox flags: ")); + debug_print (3, ("Mailbox flags:\n")); t = t->next; - while (t) - { - dprint (3, (debugfile, "[%s] ", t->data)); + while (t) { + debug_print (3, ("[%s]\n", t->data)); t = t->next; } - dprint (3, (debugfile, "\n")); } } #endif - if (mutt_bit_isset (idata->capabilities, ACL)) - { + if (mutt_bit_isset (idata->capabilities, ACL)) { if (imap_check_acl (idata)) goto fail; - if (!(mutt_bit_isset(idata->rights, IMAP_ACL_DELETE) || - mutt_bit_isset(idata->rights, IMAP_ACL_SEEN) || - mutt_bit_isset(idata->rights, IMAP_ACL_WRITE) || - mutt_bit_isset(idata->rights, IMAP_ACL_INSERT))) - ctx->readonly = 1; + if (!(mutt_bit_isset (idata->rights, ACL_DELETE) || + mutt_bit_isset (idata->rights, ACL_SEEN) || + mutt_bit_isset (idata->rights, ACL_WRITE) || + mutt_bit_isset (idata->rights, ACL_INSERT))) + ctx->readonly = 1; } /* assume we have all rights if ACL is unavailable */ - else - { - mutt_bit_set (idata->rights, IMAP_ACL_LOOKUP); - mutt_bit_set (idata->rights, IMAP_ACL_READ); - mutt_bit_set (idata->rights, IMAP_ACL_SEEN); - mutt_bit_set (idata->rights, IMAP_ACL_WRITE); - mutt_bit_set (idata->rights, IMAP_ACL_INSERT); - mutt_bit_set (idata->rights, IMAP_ACL_POST); - mutt_bit_set (idata->rights, IMAP_ACL_CREATE); - mutt_bit_set (idata->rights, IMAP_ACL_DELETE); + else { + mutt_bit_set (idata->rights, ACL_LOOKUP); + mutt_bit_set (idata->rights, ACL_READ); + mutt_bit_set (idata->rights, ACL_SEEN); + mutt_bit_set (idata->rights, ACL_WRITE); + mutt_bit_set (idata->rights, ACL_INSERT); + mutt_bit_set (idata->rights, ACL_POST); + mutt_bit_set (idata->rights, ACL_CREATE); + mutt_bit_set (idata->rights, ACL_DELETE); } ctx->hdrmax = count; - ctx->hdrs = safe_calloc (count, sizeof (HEADER *)); - ctx->v2r = safe_calloc (count, sizeof (int)); + ctx->hdrs = mem_calloc (count, sizeof (HEADER *)); + ctx->v2r = mem_calloc (count, sizeof (int)); ctx->msgcount = 0; - if (count && (imap_read_headers (idata, 0, count-1) < 0)) - { + if (count && (imap_read_headers (idata, 0, count - 1) < 0)) { mutt_error _("Error opening mailbox"); + mutt_sleep (1); goto fail; } - dprint (2, (debugfile, "imap_open_mailbox: msgcount is %d\n", ctx->msgcount)); - FREE (&mx.mbox); + debug_print (2, ("msgcount is %d\n", ctx->msgcount)); + mem_free (&mx.mbox); return 0; - fail: +fail: if (idata->state == IMAP_SELECTED) idata->state = IMAP_AUTHENTICATED; - fail_noidata: - FREE (&mx.mbox); +fail_noidata: + mem_free (&mx.mbox); return -1; } -int imap_open_mailbox_append (CONTEXT *ctx) +int imap_open_mailbox_append (CONTEXT * ctx) { CONNECTION *conn; IMAP_DATA *idata; - char buf[LONG_STRING], mbox[LONG_STRING]; + char buf[LONG_STRING]; char mailbox[LONG_STRING]; - int r; IMAP_MBOX mx; if (imap_parse_path (ctx->path, &mx)) @@ -735,73 +728,49 @@ int imap_open_mailbox_append (CONTEXT *ctx) /* in APPEND mode, we appear to hijack an existing IMAP connection - * ctx is brand new and mostly empty */ - if (!(idata = imap_conn_find (&(mx.account), 0))) - goto fail; + if (!(idata = imap_conn_find (&(mx.account), 0))) { + mem_free(&mx.mbox); + return (-1); + } conn = idata->conn; ctx->magic = M_IMAP; ctx->data = idata; - /* check mailbox existance */ - imap_fix_path (idata, mx.mbox, mailbox, sizeof (mailbox)); - imap_munge_mbox_name (mbox, sizeof (mbox), mailbox); - - if (mutt_bit_isset(idata->capabilities,IMAP4REV1)) - snprintf (buf, sizeof (buf), "STATUS %s (UIDVALIDITY)", mbox); - else if (mutt_bit_isset(idata->capabilities,STATUS)) - /* We have no idea what the other guy wants. UW imapd 8.3 wants this - * (but it does not work if another mailbox is selected) */ - snprintf (buf, sizeof (buf), "STATUS %s (UID-VALIDITY)", mbox); - else - { - /* STATUS not supported */ - mutt_message _("Unable to append to IMAP mailboxes at this server"); - - goto fail; - } + mem_free(&mx.mbox); - r = imap_exec (idata, buf, IMAP_CMD_FAIL_OK); - if (r == -2) - { - /* command failed cause folder doesn't exist */ - snprintf (buf, sizeof (buf), _("Create %s?"), mailbox); - if (option (OPTCONFIRMCREATE) && mutt_yesorno (buf, 1) < 1) - goto fail; + /* really we should also check for W_OK */ + if (!imap_access (ctx->path, F_OK)) + return 0; - if (imap_create_mailbox (idata, mailbox) < 0) - goto fail; - } - else if (r == -1) - /* Hmm, some other failure */ - goto fail; + snprintf (buf, sizeof (buf), _("Create %s?"), mailbox); + if (option (OPTCONFIRMCREATE) && mutt_yesorno (buf, 1) < 1) + return -1; - FREE (&mx.mbox); - return 0; + if (imap_create_mailbox (idata, mailbox) < 0) + return -1; - fail: - FREE (&mx.mbox); - return -1; + return (0); } /* imap_logout: Gracefully log out of server. */ -void imap_logout (IMAP_DATA* idata) +void imap_logout (IMAP_DATA * idata) { /* we set status here to let imap_handle_untagged know we _expect_ to * receive a bye response (so it doesn't freak out and close the conn) */ idata->status = IMAP_BYE; imap_cmd_start (idata, "LOGOUT"); - while (imap_cmd_step (idata) == IMAP_CMD_CONTINUE) - ; - FREE(& idata->cmd.buf); - FREE(& idata); + while (imap_cmd_step (idata) == IMAP_CMD_CONTINUE); + mem_free (&idata->cmd.buf); + mem_free (&idata); } /* int imap_close_connection (CONTEXT *ctx) { - dprint (1, (debugfile, "imap_close_connection(): closing connection\n")); + debug_print (1, (debugfile, "imap_close_connection(): closing connection\n")); if (CTX_DATA->status != IMAP_BYE) { mutt_message _("Closing connection to IMAP server..."); @@ -817,12 +786,12 @@ int imap_close_connection (CONTEXT *ctx) /* imap_set_flag: append str to flags if we currently have permission * according to aclbit */ -static void imap_set_flag (IMAP_DATA* idata, int aclbit, int flag, - const char *str, char *flags, size_t flsize) +static void imap_set_flag (IMAP_DATA * idata, int aclbit, int flag, + const char *str, char *flags, size_t flsize) { if (mutt_bit_isset (idata->rights, aclbit)) if (flag) - safe_strcat (flags, flsize, str); + str_cat (flags, flsize, str); } /* imap_make_msg_set: make an IMAP4rev1 UID message set out of a set of @@ -833,124 +802,175 @@ static void imap_set_flag (IMAP_DATA* idata, int aclbit, int flag, * flag: enum of flag type on which to filter * changed: include only changed messages in message set * Returns: number of messages in message set (0 if no matches) */ -int imap_make_msg_set (IMAP_DATA* idata, BUFFER* buf, int flag, int changed) +int imap_make_msg_set (IMAP_DATA * idata, BUFFER * buf, int flag, int changed) { - HEADER** hdrs; /* sorted local copy */ - int count = 0; /* number of messages in message set */ - int match = 0; /* whether current message matches flag condition */ - unsigned int setstart = 0; /* start of current message range */ + HEADER **hdrs; /* sorted local copy */ + int count = 0; /* number of messages in message set */ + int match = 0; /* whether current message matches flag condition */ + unsigned int setstart = 0; /* start of current message range */ int n; - short oldsort; /* we clobber reverse, must restore it */ + short oldsort; /* we clobber reverse, must restore it */ + /* assuming 32-bit UIDs */ char uid[12]; int started = 0; /* make copy of header pointers to sort in natural order */ - hdrs = safe_calloc (idata->ctx->msgcount, sizeof (HEADER*)); - memcpy (hdrs, idata->ctx->hdrs, idata->ctx->msgcount * sizeof (HEADER*)); + hdrs = mem_calloc (idata->ctx->msgcount, sizeof (HEADER *)); + memcpy (hdrs, idata->ctx->hdrs, idata->ctx->msgcount * sizeof (HEADER *)); - if (Sort != SORT_ORDER) - { + if (Sort != SORT_ORDER) { oldsort = Sort; Sort = SORT_ORDER; - qsort ((void*) hdrs, idata->ctx->msgcount, sizeof (HEADER*), - mutt_get_sort_func (SORT_ORDER)); + qsort ((void *) hdrs, idata->ctx->msgcount, sizeof (HEADER *), + mutt_get_sort_func (SORT_ORDER)); Sort = oldsort; } - - for (n = 0; n < idata->ctx->msgcount; n++) - { + + for (n = 0; n < idata->ctx->msgcount; n++) { match = 0; /* don't include pending expunged messages */ if (hdrs[n]->active) - switch (flag) - { - case M_DELETE: - if (hdrs[n]->deleted) - match = 1; - break; - case M_TAG: - if (hdrs[n]->tagged) - match = 1; - break; + switch (flag) { + case M_DELETE: + if (hdrs[n]->deleted) + match = 1; + break; + case M_TAG: + if (hdrs[n]->tagged) + match = 1; + break; } - if (match && (!changed || hdrs[n]->changed)) - { + if (match && (!changed || hdrs[n]->changed)) { count++; - if (setstart == 0) - { + if (setstart == 0) { setstart = HEADER_DATA (hdrs[n])->uid; - if (started == 0) - { - snprintf (uid, sizeof (uid), "%u", HEADER_DATA (hdrs[n])->uid); - mutt_buffer_addstr (buf, uid); - started = 1; - } - else - { - snprintf (uid, sizeof (uid), ",%u", HEADER_DATA (hdrs[n])->uid); - mutt_buffer_addstr (buf, uid); + if (started == 0) { + snprintf (uid, sizeof (uid), "%u", HEADER_DATA (hdrs[n])->uid); + mutt_buffer_addstr (buf, uid); + started = 1; + } + else { + snprintf (uid, sizeof (uid), ",%u", HEADER_DATA (hdrs[n])->uid); + mutt_buffer_addstr (buf, uid); } } /* tie up if the last message also matches */ - else if (n == idata->ctx->msgcount-1) - { - snprintf (uid, sizeof (uid), ":%u", HEADER_DATA (hdrs[n])->uid); - mutt_buffer_addstr (buf, uid); + else if (n == idata->ctx->msgcount - 1) { + snprintf (uid, sizeof (uid), ":%u", HEADER_DATA (hdrs[n])->uid); + mutt_buffer_addstr (buf, uid); } } /* this message is not expunged and doesn't match. End current set. */ - else if (setstart && hdrs[n]->active) - { - if (HEADER_DATA (hdrs[n-1])->uid > setstart) - { - snprintf (uid, sizeof (uid), ":%u", HEADER_DATA (hdrs[n-1])->uid); - mutt_buffer_addstr (buf, uid); + else if (setstart && hdrs[n]->active) { + if (HEADER_DATA (hdrs[n - 1])->uid > setstart) { + snprintf (uid, sizeof (uid), ":%u", HEADER_DATA (hdrs[n - 1])->uid); + mutt_buffer_addstr (buf, uid); } setstart = 0; } } - FREE (&hdrs); + mem_free (&hdrs); return count; } +/* Update the IMAP server to reflect the flags a single message. */ + +int imap_sync_message (IMAP_DATA *idata, HEADER *hdr, BUFFER *cmd, + int *err_continue) +{ + char flags[LONG_STRING]; + char uid[11]; + + hdr->changed = 0; + + snprintf (uid, sizeof (uid), "%u", HEADER_DATA(hdr)->uid); + cmd->dptr = cmd->data; + mutt_buffer_addstr (cmd, "UID STORE "); + mutt_buffer_addstr (cmd, uid); + + flags[0] = '\0'; + + imap_set_flag (idata, ACL_SEEN, hdr->read, "\\Seen ", + flags, sizeof (flags)); + imap_set_flag (idata, ACL_WRITE, hdr->flagged, + "\\Flagged ", flags, sizeof (flags)); + imap_set_flag (idata, ACL_WRITE, hdr->replied, + "\\Answered ", flags, sizeof (flags)); + imap_set_flag (idata, ACL_DELETE, hdr->deleted, + "\\Deleted ", flags, sizeof (flags)); + + /* now make sure we don't lose custom tags */ + if (mutt_bit_isset (idata->rights, ACL_WRITE)) + imap_add_keywords (flags, hdr, idata->flags, sizeof (flags)); + + str_skip_trailws (flags); + + /* UW-IMAP is OK with null flags, Cyrus isn't. The only solution is to + * explicitly revoke all system flags (if we have permission) */ + if (!*flags) + { + imap_set_flag (idata, ACL_SEEN, 1, "\\Seen ", flags, sizeof (flags)); + imap_set_flag (idata, ACL_WRITE, 1, "\\Flagged ", flags, sizeof (flags)); + imap_set_flag (idata, ACL_WRITE, 1, "\\Answered ", flags, sizeof (flags)); + imap_set_flag (idata, ACL_DELETE, 1, "\\Deleted ", flags, sizeof (flags)); + + str_skip_trailws (flags); + + mutt_buffer_addstr (cmd, " -FLAGS.SILENT ("); + } else + mutt_buffer_addstr (cmd, " FLAGS.SILENT ("); + + mutt_buffer_addstr (cmd, flags); + mutt_buffer_addstr (cmd, ")"); + + /* dumb hack for bad UW-IMAP 4.7 servers spurious FLAGS updates */ + hdr->active = 0; + + /* after all this it's still possible to have no flags, if you + * have no ACL rights */ + if (*flags && (imap_exec (idata, cmd->data, 0) != 0) && + err_continue && (*err_continue != M_YES)) + { + *err_continue = imap_continue ("imap_sync_message: STORE failed", + idata->cmd.buf); + if (*err_continue != M_YES) + return -1; + } + + hdr->active = 1; + idata->ctx->changed--; + + return 0; +} + /* update the IMAP server to reflect message changes done within mutt. * Arguments * ctx: the current context * expunge: 0 or 1 - do expunge? */ -int imap_sync_mailbox (CONTEXT* ctx, int expunge, int* index_hint) +int imap_sync_mailbox (CONTEXT * ctx, int expunge, int *index_hint) { - IMAP_DATA* idata; - CONTEXT* appendctx = NULL; + IMAP_DATA *idata; + CONTEXT *appendctx = NULL; BUFFER cmd; - char flags[LONG_STRING]; - char uid[11]; int deleted; int n; - int err_continue = M_NO; /* continue on error? */ + int err_continue = M_NO; /* continue on error? */ int rc; - idata = (IMAP_DATA*) ctx->data; + idata = (IMAP_DATA *) ctx->data; - if (idata->state != IMAP_SELECTED) - { - dprint (2, (debugfile, "imap_sync_mailbox: no mailbox selected\n")); + if (idata->state != IMAP_SELECTED) { + debug_print (2, ("no mailbox selected\n")); return -1; } - /* CLOSE purges deleted messages. If we don't want to purge them, we must - * tell imap_close_mailbox not to issue the CLOSE command */ - if (expunge) - idata->noclose = 0; - else - idata->noclose = 1; - - /* This function is only called when the calling code expects the context + /* This function is only called when the calling code expects the context * to be changed. */ imap_allow_reopen (ctx); @@ -960,168 +980,111 @@ int imap_sync_mailbox (CONTEXT* ctx, int expunge, int* index_hint) memset (&cmd, 0, sizeof (cmd)); /* if we are expunging anyway, we can do deleted messages very quickly... */ - if (expunge && mutt_bit_isset (idata->rights, IMAP_ACL_DELETE)) - { + if (expunge && mutt_bit_isset (idata->rights, ACL_DELETE)) { mutt_buffer_addstr (&cmd, "UID STORE "); deleted = imap_make_msg_set (idata, &cmd, M_DELETE, 1); /* if we have a message set, then let's delete */ - if (deleted) - { + if (deleted) { mutt_message (_("Marking %d messages deleted..."), deleted); mutt_buffer_addstr (&cmd, " +FLAGS.SILENT (\\Deleted)"); /* mark these messages as unchanged so second pass ignores them. Done * here so BOGUS UW-IMAP 4.7 SILENT FLAGS updates are ignored. */ for (n = 0; n < ctx->msgcount; n++) - if (ctx->hdrs[n]->deleted && ctx->hdrs[n]->changed) - ctx->hdrs[n]->active = 0; - if (imap_exec (idata, cmd.data, 0) != 0) - { - mutt_error (_("Expunge failed")); - mutt_sleep (1); - rc = -1; - goto out; + if (ctx->hdrs[n]->deleted && ctx->hdrs[n]->changed) + ctx->hdrs[n]->active = 0; + if (imap_exec (idata, cmd.data, 0) != 0) { + mutt_error (_("Expunge failed")); + mutt_sleep (1); + rc = -1; + goto out; } } } /* save status changes */ - for (n = 0; n < ctx->msgcount; n++) - { - if (ctx->hdrs[n]->active && ctx->hdrs[n]->changed) - { - ctx->hdrs[n]->changed = 0; + for (n = 0; n < ctx->msgcount; n++) { + if (ctx->hdrs[n]->active && ctx->hdrs[n]->changed) { - mutt_message (_("Saving message status flags... [%d/%d]"), n+1, - ctx->msgcount); - - snprintf (uid, sizeof (uid), "%u", HEADER_DATA(ctx->hdrs[n])->uid); - cmd.dptr = cmd.data; - mutt_buffer_addstr (&cmd, "UID STORE "); - mutt_buffer_addstr (&cmd, uid); + mutt_message (_("Saving message status flags... [%d/%d]"), n + 1, + ctx->msgcount); /* if the message has been rethreaded or attachments have been deleted * we delete the message and reupload it. * This works better if we're expunging, of course. */ - if (ctx->hdrs[n]->refs_changed || ctx->hdrs[n]->irt_changed || - ctx->hdrs[n]->attach_del) - { - dprint (3, (debugfile, "imap_sync_mailbox: Attachments to be deleted, falling back to _mutt_save_message\n")); - if (!appendctx) - appendctx = mx_open_mailbox (ctx->path, M_APPEND | M_QUIET, NULL); - if (!appendctx) - { - dprint (1, (debugfile, "imap_sync_mailbox: Error opening mailbox in append mode\n")); - } - else - _mutt_save_message (ctx->hdrs[n], appendctx, 1, 0, 0); - } - flags[0] = '\0'; - - imap_set_flag (idata, IMAP_ACL_SEEN, ctx->hdrs[n]->read, "\\Seen ", - flags, sizeof (flags)); - imap_set_flag (idata, IMAP_ACL_WRITE, ctx->hdrs[n]->flagged, - "\\Flagged ", flags, sizeof (flags)); - imap_set_flag (idata, IMAP_ACL_WRITE, ctx->hdrs[n]->replied, - "\\Answered ", flags, sizeof (flags)); - imap_set_flag (idata, IMAP_ACL_DELETE, ctx->hdrs[n]->deleted, - "\\Deleted ", flags, sizeof (flags)); - - /* now make sure we don't lose custom tags */ - if (mutt_bit_isset (idata->rights, IMAP_ACL_WRITE)) - imap_add_keywords (flags, ctx->hdrs[n], idata->flags, sizeof (flags)); - - mutt_remove_trailing_ws (flags); - - /* UW-IMAP is OK with null flags, Cyrus isn't. The only solution is to - * explicitly revoke all system flags (if we have permission) */ - if (!*flags) - { - imap_set_flag (idata, IMAP_ACL_SEEN, 1, "\\Seen ", flags, sizeof (flags)); - imap_set_flag (idata, IMAP_ACL_WRITE, 1, "\\Flagged ", flags, sizeof (flags)); - imap_set_flag (idata, IMAP_ACL_WRITE, 1, "\\Answered ", flags, sizeof (flags)); - imap_set_flag (idata, IMAP_ACL_DELETE, 1, "\\Deleted ", flags, sizeof (flags)); - - mutt_remove_trailing_ws (flags); - - mutt_buffer_addstr (&cmd, " -FLAGS.SILENT ("); - } - else - mutt_buffer_addstr (&cmd, " FLAGS.SILENT ("); - - mutt_buffer_addstr (&cmd, flags); - mutt_buffer_addstr (&cmd, ")"); - - /* dumb hack for bad UW-IMAP 4.7 servers spurious FLAGS updates */ - ctx->hdrs[n]->active = 0; - - /* after all this it's still possible to have no flags, if you - * have no ACL rights */ - if (*flags && (imap_exec (idata, cmd.data, 0) != 0) && - (err_continue != M_YES)) - { - err_continue = imap_continue ("imap_sync_mailbox: STORE failed", - idata->cmd.buf); - if (err_continue != M_YES) - { - rc = -1; - goto out; - } + if ((ctx->hdrs[n]->env && (ctx->hdrs[n]->env->refs_changed || ctx->hdrs[n]->env->irt_changed)) || + ctx->hdrs[n]->attach_del) { + debug_print (3, ("Attachments to be deleted, falling back to _mutt_save_message\n")); + if (!appendctx) + appendctx = mx_open_mailbox (ctx->path, M_APPEND | M_QUIET, NULL); + if (!appendctx) { + debug_print (1, ("Error opening mailbox in append mode\n")); + } + else + _mutt_save_message (ctx->hdrs[n], appendctx, 1, 0, 0); } - ctx->hdrs[n]->active = 1; + if (imap_sync_message (idata, ctx->hdrs[n], &cmd, &err_continue) < 0) { + rc = -1; + goto out; + } } } ctx->changed = 0; /* We must send an EXPUNGE command if we're not closing. */ if (expunge && !(ctx->closing) && - mutt_bit_isset(idata->rights, IMAP_ACL_DELETE)) - { + mutt_bit_isset (idata->rights, ACL_DELETE)) { mutt_message _("Expunging messages from server..."); + /* Set expunge bit so we don't get spurious reopened messages */ idata->reopen |= IMAP_EXPUNGE_EXPECTED; - if (imap_exec (idata, "EXPUNGE", 0) != 0) - { + if (imap_exec (idata, "EXPUNGE", 0) != 0) { imap_error (_("imap_sync_mailbox: EXPUNGE failed"), idata->cmd.buf); - rc = -1; + rc = imap_reconnect (ctx); goto out; } } + if (expunge && ctx->closing) { + if (imap_exec (idata, "CLOSE", 0)) + mutt_error (_("CLOSE failed")); + idata->state = IMAP_AUTHENTICATED; + } + rc = 0; - out: +out: if (cmd.data) - FREE (&cmd.data); - if (appendctx) - { + mem_free (&cmd.data); + if (appendctx) { mx_fastclose_mailbox (appendctx); - FREE (&appendctx); + mem_free (&appendctx); } return rc; } -/* imap_close_mailbox: issue close command if neccessary, reset IMAP_DATA */ -void imap_close_mailbox (CONTEXT* ctx) +/* imap_close_mailbox: clean up IMAP data in CONTEXT */ +void imap_close_mailbox (CONTEXT * ctx) { - IMAP_DATA* idata; + IMAP_DATA *idata; int i; - idata = (IMAP_DATA*) ctx->data; + idata = (IMAP_DATA *) ctx->data; /* Check to see if the mailbox is actually open */ if (!idata) return; - if ((idata->status != IMAP_FATAL) && - (idata->state == IMAP_SELECTED) && - (ctx == idata->ctx)) - { - if (!(idata->noclose) && imap_exec (idata, "CLOSE", 0)) - mutt_error (_("CLOSE failed")); + if (ctx == idata->ctx) { + if (idata->state != IMAP_FATAL && idata->state == IMAP_SELECTED) { + /* mx_close_mailbox won't sync if there are no deleted messages + * and the mailbox is unchanged, so we may have to close here */ + if (!ctx->deleted && imap_exec (idata, "CLOSE", 0)) + mutt_error (_("CLOSE failed")); + idata->state = IMAP_AUTHENTICATED; + } idata->reopen &= IMAP_REOPEN_ALLOW; - idata->state = IMAP_AUTHENTICATED; - FREE (&(idata->mailbox)); + mem_free (&(idata->mailbox)); mutt_free_list (&idata->flags); idata->ctx = NULL; } @@ -1130,12 +1093,10 @@ void imap_close_mailbox (CONTEXT* ctx) for (i = 0; i < ctx->msgcount; i++) imap_free_header_data (&(ctx->hdrs[i]->data)); - for (i = 0; i < IMAP_CACHE_LEN; i++) - { - if (idata->cache[i].path) - { + for (i = 0; i < IMAP_CACHE_LEN; i++) { + if (idata->cache[i].path) { unlink (idata->cache[i].path); - FREE (&idata->cache[i].path); + mem_free (&idata->cache[i].path); } } } @@ -1148,16 +1109,16 @@ void imap_close_mailbox (CONTEXT* ctx) * 0 no change * -1 error */ -int imap_check_mailbox (CONTEXT *ctx, int *index_hint, int force) +int imap_check_mailbox (CONTEXT * ctx, int *index_hint, int force) { /* overload keyboard timeout to avoid many mailbox checks in a row. * Most users don't like having to wait exactly when they press a key. */ - IMAP_DATA* idata; + IMAP_DATA *idata; int result = 0; - idata = (IMAP_DATA*) ctx->data; + idata = (IMAP_DATA *) ctx->data; - if ((force || time(NULL) > idata->lastread + Timeout) + if ((force || time (NULL) >= idata->lastread + Timeout) && imap_exec (idata, "NOOP", 0) != 0) return -1; @@ -1183,7 +1144,7 @@ int imap_check_mailbox (CONTEXT *ctx, int *index_hint, int force) * 0+ number of messages in mailbox * -1 error while polling mailboxes */ -int imap_mailbox_check (char* path, int new) +int imap_mailbox_check (char *path, int new) { CONNECTION *conn; IMAP_DATA *idata; @@ -1195,7 +1156,7 @@ int imap_mailbox_check (char* path, int new) int connflags = 0; IMAP_MBOX mx; int rc; - + if (imap_parse_path (path, &mx)) return -1; @@ -1203,34 +1164,31 @@ int imap_mailbox_check (char* path, int new) if (option (OPTIMAPPASSIVE)) connflags = M_IMAP_CONN_NONEW; - if (!(idata = imap_conn_find (&(mx.account), connflags))) - { - FREE (&mx.mbox); + if (!(idata = imap_conn_find (&(mx.account), connflags))) { + mem_free (&mx.mbox); return -1; } conn = idata->conn; imap_fix_path (idata, mx.mbox, buf, sizeof (buf)); - FREE (&mx.mbox); + mem_free (&mx.mbox); - imap_munge_mbox_name (mbox, sizeof(mbox), buf); + imap_munge_mbox_name (mbox, sizeof (mbox), buf); strfcpy (mbox_unquoted, buf, sizeof (mbox_unquoted)); /* The draft IMAP implementor's guide warns againts using the STATUS * command on a mailbox that you have selected */ - if (mutt_strcmp (mbox_unquoted, idata->mailbox) == 0 + if (str_cmp (mbox_unquoted, idata->mailbox) == 0 || (ascii_strcasecmp (mbox_unquoted, "INBOX") == 0 - && mutt_strcasecmp (mbox_unquoted, idata->mailbox) == 0)) - { + && str_casecmp (mbox_unquoted, idata->mailbox) == 0)) { strfcpy (buf, "NOOP", sizeof (buf)); } - else if (mutt_bit_isset(idata->capabilities,IMAP4REV1) || - mutt_bit_isset(idata->capabilities,STATUS)) - { + else if (mutt_bit_isset (idata->capabilities, IMAP4REV1) || + mutt_bit_isset (idata->capabilities, STATUS)) { snprintf (buf, sizeof (buf), "STATUS %s (%s)", mbox, - new ? "RECENT" : "MESSAGES"); + new ? "RECENT" : "MESSAGES"); } else /* Server does not support STATUS, and this is not the current mailbox. @@ -1239,34 +1197,29 @@ int imap_mailbox_check (char* path, int new) imap_cmd_start (idata, buf); - do - { + do { if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE) break; s = imap_next_word (idata->cmd.buf); - if (ascii_strncasecmp ("STATUS", s, 6) == 0) - { + if (ascii_strncasecmp ("STATUS", s, 6) == 0) { s = imap_next_word (s); /* The mailbox name may or may not be quoted here. We could try to * munge the server response and compare with quoted (or vise versa) * but it is probably more efficient to just strncmp against both. */ - if (mutt_strncmp (mbox_unquoted, s, mutt_strlen (mbox_unquoted)) == 0 - || mutt_strncmp (mbox, s, mutt_strlen (mbox)) == 0) - { - s = imap_next_word (s); - s = imap_next_word (s); - if (isdigit ((unsigned char) *s)) - { - if (*s != '0') - { - msgcount = atoi(s); - dprint (2, (debugfile, "%d new messages in %s\n", msgcount, path)); - } - } + if (str_ncmp (mbox_unquoted, s, str_len (mbox_unquoted)) == 0 + || str_ncmp (mbox, s, str_len (mbox)) == 0) { + s = imap_next_word (s); + s = imap_next_word (s); + if (isdigit ((unsigned char) *s)) { + if (*s != '0') { + msgcount = atoi (s); + debug_print (2, ("%d new messages in %s\n", msgcount, path)); + } + } } else - dprint (1, (debugfile, "imap_mailbox_check: STATUS response doesn't match requested mailbox.\n")); + debug_print (1, ("STATUS response doesn't match requested mailbox.\n")); } } while (rc == IMAP_CMD_CONTINUE); @@ -1274,13 +1227,146 @@ int imap_mailbox_check (char* path, int new) return msgcount; } +/* returns number of patterns in the search that should be done server-side + * (eg are full-text) */ +static int do_search (const pattern_t* search, int allpats) +{ + int rc = 0; + const pattern_t* pat; + + for (pat = search; pat; pat = pat->next) { + switch (pat->op) { + case M_BODY: + case M_HEADER: + case M_WHOLE_MSG: + if (pat->stringmatch) + rc++; + break; + default: + if (pat->child && do_search (pat->child, 1)) + rc++; + } + + if (!allpats) + break; + } + + return rc; +} + +/* convert mutt pattern_t to IMAP SEARCH command containing only elements +* that require full-text search (mutt already has what it needs for most +* match types, and does a better job (eg server doesn't support regexps). */ +static int imap_compile_search (const pattern_t* pat, BUFFER* buf) +{ + char term[STRING]; + + if (! do_search (pat, 0)) + return 0; + + if (pat->not) + mutt_buffer_addstr (buf, "NOT "); + + if (pat->child) { + int clauses; + + if ((clauses = do_search (pat->child, 1)) > 0) { + const pattern_t* clause = pat->child; + + mutt_buffer_addch (buf, '('); + + while (clauses) { + if (do_search (clause, 0)) { + if (pat->op == M_OR && clauses > 1) + mutt_buffer_addstr (buf, "OR "); + clauses--; + if (imap_compile_search (clause, buf) < 0) + return -1; + + if (clauses) + mutt_buffer_addch (buf, ' '); + + clause = clause->next; + } + } + + mutt_buffer_addch (buf, ')'); + } + } else { + char *delim; + + switch (pat->op) { + case M_HEADER: + mutt_buffer_addstr (buf, "HEADER "); + + /* extract header name */ + if (! (delim = strchr (pat->str, ':'))) { + mutt_error (_("Header search without header name: %s"), pat->str); + return -1; + } + *delim = '\0'; + imap_quote_string (term, sizeof (term), pat->str); + mutt_buffer_addstr (buf, term); + mutt_buffer_addch (buf, ' '); + + /* and field */ + *delim = ':'; + delim++; + SKIPWS(delim); + imap_quote_string (term, sizeof (term), delim); + mutt_buffer_addstr (buf, term); + break; + + case M_BODY: + mutt_buffer_addstr (buf, "BODY "); + imap_quote_string (term, sizeof (term), pat->str); + mutt_buffer_addstr (buf, term); + break; + + case M_WHOLE_MSG: + mutt_buffer_addstr (buf, "TEXT "); + imap_quote_string (term, sizeof (term), pat->str); + mutt_buffer_addstr (buf, term); + break; + } + } + + return 0; +} + +int imap_search (CONTEXT* ctx, const pattern_t* pat) { + BUFFER buf; + IMAP_DATA* idata = (IMAP_DATA*)ctx->data; + int i; + + for (i = 0; i < ctx->msgcount; i++) + ctx->hdrs[i]->matched = 0; + + if (!do_search (pat, 1)) + return 0; + + memset (&buf, 0, sizeof (buf)); + mutt_buffer_addstr (&buf, "UID SEARCH "); + if (imap_compile_search (pat, &buf) < 0) { + mem_free (&buf.data); + return -1; + } + if (imap_exec (idata, buf.data, 0) < 0) { + mem_free (&buf.data); + return -1; + } + + mem_free (&buf.data); + return 0; +} + /* all this listing/browsing is a mess. I don't like that name is a pointer * into idata->buf (used to be a pointer into the passed in buffer, just * as bad), nor do I like the fact that the fetch is done here. This * code can't possibly handle non-LIST untagged responses properly. * FIXME. ?! */ -int imap_parse_list_response(IMAP_DATA* idata, char **name, int *noselect, - int *noinferiors, char *delim) +int imap_parse_list_response (IMAP_DATA * idata, char **name, int *noselect, + int *noinferiors, char *delim) { char *s; long bytes; @@ -1296,51 +1382,49 @@ int imap_parse_list_response(IMAP_DATA* idata, char **name, int *noselect, s = imap_next_word (idata->cmd.buf); if ((ascii_strncasecmp ("LIST", s, 4) == 0) || - (ascii_strncasecmp ("LSUB", s, 4) == 0)) - { + (ascii_strncasecmp ("LSUB", s, 4) == 0)) { *noselect = 0; *noinferiors = 0; - - s = imap_next_word (s); /* flags */ - if (*s == '(') - { + + s = imap_next_word (s); /* flags */ + if (*s == '(') { char *ep; s++; ep = s; - while (*ep && *ep != ')') ep++; - do - { - if (!ascii_strncasecmp (s, "\\NoSelect", 9)) - *noselect = 1; - if (!ascii_strncasecmp (s, "\\NoInferiors", 12)) - *noinferiors = 1; - /* See draft-gahrns-imap-child-mailbox-?? */ - if (!ascii_strncasecmp (s, "\\HasNoChildren", 14)) - *noinferiors = 1; - if (*s != ')') - s++; - while (*s && *s != '\\' && *s != ')') s++; + while (*ep && *ep != ')') + ep++; + do { + if (!ascii_strncasecmp (s, "\\NoSelect", 9)) + *noselect = 1; + if (!ascii_strncasecmp (s, "\\NoInferiors", 12)) + *noinferiors = 1; + /* See draft-gahrns-imap-child-mailbox-?? */ + if (!ascii_strncasecmp (s, "\\HasNoChildren", 14)) + *noinferiors = 1; + if (*s != ')') + s++; + while (*s && *s != '\\' && *s != ')') + s++; } while (s != ep); } else return 0; - s = imap_next_word (s); /* delim */ + s = imap_next_word (s); /* delim */ /* Reset the delimiter, this can change */ - if (ascii_strncasecmp (s, "NIL", 3)) - { + if (ascii_strncasecmp (s, "NIL", 3)) { if (s && s[0] == '\"' && s[1] && s[2] == '\"') - *delim = s[1]; - else if (s && s[0] == '\"' && s[1] && s[1] == '\\' && s[2] && s[3] == '\"') - *delim = s[2]; + *delim = s[1]; + else if (s && s[0] == '\"' && s[1] && s[1] == '\\' && s[2] + && s[3] == '\"') + *delim = s[2]; } - s = imap_next_word (s); /* name */ - if (s && *s == '{') /* Literal */ - { - if (imap_get_literal_count(idata->cmd.buf, &bytes) < 0) - return -1; + s = imap_next_word (s); /* name */ + if (s && *s == '{') { /* Literal */ + if (imap_get_literal_count (idata->cmd.buf, &bytes) < 0) + return -1; if (imap_cmd_step (idata) != IMAP_CMD_CONTINUE) - return -1; + return -1; *name = idata->cmd.buf; } else @@ -1356,152 +1440,218 @@ int imap_subscribe (char *path, int subscribe) IMAP_DATA *idata; char buf[LONG_STRING]; char mbox[LONG_STRING]; + char errstr[STRING]; + BUFFER err, token; IMAP_MBOX mx; - if (!mx_is_imap (path) || imap_parse_path (path, &mx)) - { + if (mx_get_magic (path) == M_IMAP || imap_parse_path (path, &mx)) { mutt_error (_("Bad mailbox name")); return -1; } - if (!(idata = imap_conn_find (&(mx.account), 0))) goto fail; - + conn = idata->conn; imap_fix_path (idata, mx.mbox, buf, sizeof (buf)); + + if (option (OPTIMAPCHECKSUBSCRIBED)) { + memset (&token, 0, sizeof (token)); + err.data = errstr; + err.dsize = sizeof (errstr); + snprintf (mbox, sizeof (mbox), "%smailboxes \"%s\"", + subscribe ? "" : "un", path); + if (mutt_parse_rc_line (mbox, &token, &err)) + debug_print (1, ("Error adding subscribed mailbox: %s\n", errstr)); + mem_free (&token.data); + } + if (subscribe) mutt_message (_("Subscribing to %s..."), buf); else mutt_message (_("Unsubscribing to %s..."), buf); - imap_munge_mbox_name (mbox, sizeof(mbox), buf); + imap_munge_mbox_name (mbox, sizeof (mbox), buf); - snprintf (buf, sizeof (buf), "%s %s", subscribe ? "SUBSCRIBE" : - "UNSUBSCRIBE", mbox); + snprintf (buf, sizeof (buf), "%sSUBSCRIBE %s", subscribe ? "" : "UN", mbox); if (imap_exec (idata, buf, 0) < 0) goto fail; - FREE (&mx.mbox); + mem_free (&mx.mbox); return 0; - fail: - FREE (&mx.mbox); +fail: + mem_free (&mx.mbox); return -1; } +/* trim dest to the length of the longest prefix it shares with src, + * returning the length of the trimmed string */ +static int longest_common_prefix (char *dest, const char* src, + int start, size_t dlen) { + int pos = start; + + while (pos < dlen && dest[pos] && dest[pos] == src[pos]) + pos++; + dest[pos] = '\0'; + + return pos; +} + +/* look for IMAP URLs to complete from defined mailboxes. Could be extended + * to complete over open connections and account/folder hooks too. */ +static int imap_complete_hosts (char *dest, size_t len) { + BUFFY* mailbox; + CONNECTION* conn; + int rc = -1; + int matchlen; + int i = 0; + + matchlen = str_len (dest); + if (list_empty (Incoming)) + return (-1); + for (i = 0; i < Incoming->length; i++) { + mailbox = (BUFFY*) Incoming->data[i]; + if (!str_ncmp (dest, mailbox->path, matchlen)) { + if (rc) { + strfcpy (dest, mailbox->path, len); + rc = 0; + } else + longest_common_prefix (dest, mailbox->path, matchlen, len); + } + } + + for (conn = mutt_socket_head (); conn->next; conn = conn->next) { + ciss_url_t url; + char urlstr[LONG_STRING]; + + if (conn->account.type != M_ACCT_TYPE_IMAP) + continue; + + mutt_account_tourl (&conn->account, &url); + /* FIXME: how to handle multiple users on the same host? */ + url.user = NULL; + url.path = NULL; + url_ciss_tostring (&url, urlstr, sizeof (urlstr), 0); + if (!str_ncmp (dest, urlstr, matchlen)) { + if (rc) { + strfcpy (dest, urlstr, len); + rc = 0; + } else + longest_common_prefix (dest, urlstr, matchlen, len); + } + } + + return rc; +} + /* imap_complete: given a partial IMAP folder path, return a string which * adds as much to the path as is unique */ -int imap_complete(char* dest, size_t dlen, char* path) { - CONNECTION* conn; - IMAP_DATA* idata; +int imap_complete (char *dest, size_t dlen, char *path) { + CONNECTION *conn; + IMAP_DATA *idata; char list[LONG_STRING]; char buf[LONG_STRING]; - char* list_word = NULL; + char *list_word = NULL; int noselect, noinferiors; char delim; char completion[LONG_STRING]; int clen, matchlen = 0; int completions = 0; - int pos = 0; IMAP_MBOX mx; - /* verify passed in path is an IMAP path */ - if (imap_parse_path (path, &mx)) - { - dprint(2, (debugfile, "imap_complete: bad path %s\n", path)); - return -1; + if (imap_parse_path (path, &mx) || !mx.mbox) { + strfcpy (dest, path, dlen); + return imap_complete_hosts (dest, dlen); } - /* don't open a new socket just for completion */ - if (!(idata = imap_conn_find (&(mx.account), M_IMAP_CONN_NONEW))) - goto fail; + /* don't open a new socket just for completion. Instead complete over + * known mailboxes/hooks/etc */ + if (!(idata = imap_conn_find (&(mx.account), M_IMAP_CONN_NONEW))) { + mem_free (&mx.mbox); + strfcpy (dest, path, dlen); + return imap_complete_hosts (dest, dlen); + } conn = idata->conn; /* reformat path for IMAP list, and append wildcard */ /* don't use INBOX in place of "" */ if (mx.mbox && mx.mbox[0]) - imap_fix_path (idata, mx.mbox, list, sizeof(list)); + imap_fix_path (idata, mx.mbox, list, sizeof (list)); else list[0] = '\0'; /* fire off command */ - snprintf (buf, sizeof(buf), "%s \"\" \"%s%%\"", - option (OPTIMAPLSUB) ? "LSUB" : "LIST", list); + snprintf (buf, sizeof (buf), "%s \"\" \"%s%%\"", + option (OPTIMAPLSUB) ? "LSUB" : "LIST", list); imap_cmd_start (idata, buf); /* and see what the results are */ - strfcpy (completion, NONULL(mx.mbox), sizeof(completion)); - do - { - if (imap_parse_list_response(idata, &list_word, &noselect, &noinferiors, - &delim)) + strfcpy (completion, NONULL (mx.mbox), sizeof (completion)); + do { + if (imap_parse_list_response (idata, &list_word, &noselect, &noinferiors, + &delim)) break; - if (list_word) - { + if (list_word) { /* store unquoted */ imap_unmunge_mbox_name (list_word); /* if the folder isn't selectable, append delimiter to force browse * to enter it on second tab. */ - if (noselect) - { - clen = strlen(list_word); + if (noselect) { + clen = str_len (list_word); list_word[clen++] = delim; list_word[clen] = '\0'; } /* copy in first word */ - if (!completions) - { - strfcpy (completion, list_word, sizeof(completion)); - matchlen = strlen (completion); + if (!completions) { + strfcpy (completion, list_word, sizeof (completion)); + matchlen = str_len (completion); completions++; continue; } - pos = 0; - while (pos < matchlen && list_word[pos] && - completion[pos] == list_word[pos]) - pos++; - completion[pos] = '\0'; - matchlen = pos; - + matchlen = longest_common_prefix (completion, list_word, 0, matchlen); completions++; } } - while (ascii_strncmp(idata->cmd.seq, idata->cmd.buf, SEQLEN)); + while (ascii_strncmp (idata->cmd.seq, idata->cmd.buf, SEQLEN)); - if (completions) - { + if (completions) { /* reformat output */ imap_qualify_path (dest, dlen, &mx, completion); mutt_pretty_mailbox (dest); - FREE (&mx.mbox); + mem_free (&mx.mbox); return 0; } - fail: - FREE (&mx.mbox); return -1; } /* reconnect if connection was lost */ -int imap_reconnect(CONTEXT* ctx) { - IMAP_DATA* imap_data = (IMAP_DATA *)ctx->data; +int imap_reconnect (CONTEXT * ctx) +{ + IMAP_DATA *imap_data; + + if (!ctx) + return (-1); + + imap_data = (IMAP_DATA *) ctx->data; if (imap_data) { if (imap_data->status == IMAP_CONNECTED) return -1; } - if (query_quadoption(OPT_IMAPRECONNECT,_("Connection lost. Reconnect to IMAP server?")) != M_YES) + if (query_quadoption + (OPT_IMAPRECONNECT, + _("Connection lost. Reconnect to IMAP server?")) != M_YES) return -1; - mx_open_mailbox(ctx->path,0,ctx); + mx_open_mailbox (ctx->path, 0, ctx); return 0; } -