/* $Id$ */ /* Copyright (c) 2011-2018 Pierre Pronchery */ /* This file is part of DeforaOS Desktop Mailer */ /* All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* FIXME: * - do not erroneously parse body/header data as potential command completion * - do not fetch messages when there are none available in the first place * - openssl should be more explicit when SSL_set_fd() is missing (no BIO) * - support multiple connections? */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "Mailer/account.h" #include "common.c" /* IMAP4 */ /* private */ /* types */ struct _AccountFolder { Folder * folder; char * name; AccountMessage ** messages; size_t messages_cnt; AccountFolder ** folders; size_t folders_cnt; }; struct _AccountMessage { Message * message; unsigned int id; }; typedef enum _IMAP4CommandStatus { I4CS_QUEUED = 0, I4CS_SENT, I4CS_ERROR, I4CS_PARSING, I4CS_OK } IMAP4CommandStatus; typedef enum _IMAP4ConfigValue { I4CV_USERNAME = 0, I4CV_PASSWORD, I4CV_HOSTNAME, I4CV_PORT, I4CV_SSL, I4CV_PADDING0, I4CV_PREFIX } IMAP4Config; #define I4CV_LAST I4CV_PREFIX #define I4CV_COUNT (I4CV_LAST + 1) typedef enum _IMAP4Context { I4C_INIT = 0, I4C_FETCH, I4C_LIST, I4C_LOGIN, I4C_NOOP, I4C_SELECT, I4C_STATUS } IMAP4Context; typedef enum _IMAP4FetchStatus { I4FS_ID = 0, I4FS_COMMAND, I4FS_FLAGS, I4FS_HEADERS, I4FS_BODY } IMAP4FetchStatus; typedef struct _IMAP4Command { uint16_t id; IMAP4CommandStatus status; IMAP4Context context; char * buf; size_t buf_cnt; union { struct { AccountFolder * folder; AccountMessage * message; unsigned int id; IMAP4FetchStatus status; unsigned int size; } fetch; struct { AccountFolder * parent; } list; struct { AccountFolder * folder; AccountMessage * message; } select; struct { AccountFolder * folder; } status; } data; } IMAP4Command; typedef struct _AccountPlugin { AccountPluginHelper * helper; AccountConfig * config; struct addrinfo * ai; struct addrinfo * aip; int fd; SSL * ssl; guint source; GIOChannel * channel; char * rd_buf; size_t rd_buf_cnt; guint rd_source; guint wr_source; IMAP4Command * queue; size_t queue_cnt; uint16_t queue_id; AccountFolder folders; } IMAP4; /* variables */ static char const _imap4_type[] = "IMAP4"; static char const _imap4_name[] = "IMAP4 server"; AccountConfig const _imap4_config[I4CV_COUNT + 1] = { { "username", "Username", ACT_STRING, NULL }, { "password", "Password", ACT_PASSWORD, NULL }, { "hostname", "Server hostname", ACT_STRING, NULL }, { "port", "Server port", ACT_UINT16, 143 }, { "ssl", "Use SSL", ACT_BOOLEAN, 0 }, #if 0 /* XXX not implemented yet */ { "sent", "Sent mails folder", ACT_NONE, NULL }, { "draft", "Draft mails folder", ACT_NONE, NULL }, #endif { NULL, NULL, ACT_SEPARATOR, NULL }, { "prefix", "Prefix", ACT_STRING, NULL }, { NULL, NULL, ACT_NONE, NULL } }; /* prototypes */ /* plug-in */ static IMAP4 * _imap4_init(AccountPluginHelper * helper); static int _imap4_destroy(IMAP4 * imap4); static AccountConfig * _imap4_get_config(IMAP4 * imap4); static int _imap4_start(IMAP4 * imap4); static void _imap4_stop(IMAP4 * imap4); static int _imap4_refresh(IMAP4 * imap4, AccountFolder * folder, AccountMessage * message); /* useful */ static IMAP4Command * _imap4_command(IMAP4 * imap4, IMAP4Context context, char const * command); static int _imap4_parse(IMAP4 * imap4); /* events */ static void _imap4_event(IMAP4 * imap4, AccountEventType type); static void _imap4_event_status(IMAP4 * imap4, AccountStatus status, char const * message); /* folders */ static AccountFolder * _imap4_folder_new(IMAP4 * imap4, AccountFolder * parent, char const * name); static void _imap4_folder_delete(IMAP4 * imap4, AccountFolder * folder); static AccountFolder * _imap4_folder_get_folder(IMAP4 * imap4, AccountFolder * folder, char const * name); static AccountMessage * _imap4_folder_get_message(IMAP4 * imap4, AccountFolder * folder, unsigned int id); /* messages */ static AccountMessage * _imap4_message_new(IMAP4 * imap4, AccountFolder * folder, unsigned int id); static void _imap4_message_delete(IMAP4 * imap4, AccountMessage * message); /* callbacks */ static gboolean _on_connect(gpointer data); static gboolean _on_noop(gpointer data); static gboolean _on_watch_can_connect(GIOChannel * source, GIOCondition condition, gpointer data); static gboolean _on_watch_can_handshake(GIOChannel * source, GIOCondition condition, gpointer data); static gboolean _on_watch_can_read(GIOChannel * source, GIOCondition condition, gpointer data); static gboolean _on_watch_can_read_ssl(GIOChannel * source, GIOCondition condition, gpointer data); static gboolean _on_watch_can_write(GIOChannel * source, GIOCondition condition, gpointer data); static gboolean _on_watch_can_write_ssl(GIOChannel * source, GIOCondition condition, gpointer data); /* public */ /* variables */ AccountPluginDefinition account_plugin = { _imap4_type, _imap4_name, NULL, NULL, _imap4_config, _imap4_init, _imap4_destroy, _imap4_get_config, NULL, _imap4_start, _imap4_stop, _imap4_refresh }; /* protected */ /* functions */ /* plug-in */ /* imap4_init */ static IMAP4 * _imap4_init(AccountPluginHelper * helper) { IMAP4 * imap4; if((imap4 = malloc(sizeof(*imap4))) == NULL) return NULL; memset(imap4, 0, sizeof(*imap4)); imap4->helper = helper; if((imap4->config = malloc(sizeof(_imap4_config))) == NULL) { free(imap4); return NULL; } memcpy(imap4->config, &_imap4_config, sizeof(_imap4_config)); imap4->ai = NULL; imap4->aip = NULL; imap4->fd = -1; return imap4; } /* imap4_destroy */ static int _imap4_destroy(IMAP4 * imap4) { size_t i; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif if(imap4 == NULL) /* XXX _imap4_destroy() may be called uninitialized */ return 0; _imap4_stop(imap4); #if 1 /* XXX anything wrong here? */ _imap4_folder_delete(imap4, &imap4->folders); #endif for(i = 0; i < sizeof(_imap4_config) / sizeof(*_imap4_config); i++) if(_imap4_config[i].type == ACT_STRING || _imap4_config[i].type == ACT_PASSWORD) free(imap4->config[i].value); free(imap4->config); free(imap4); return 0; } /* imap4_get_config */ static AccountConfig * _imap4_get_config(IMAP4 * imap4) { return imap4->config; } /* imap4_start */ static int _imap4_start(IMAP4 * imap4) { _imap4_event(imap4, AET_STARTED); if(imap4->fd >= 0 || imap4->source != 0) /* already started */ return 0; imap4->source = g_idle_add(_on_connect, imap4); return 0; } /* imap4_stop */ static void _imap4_stop(IMAP4 * imap4) { size_t i; if(imap4->ssl != NULL) SSL_free(imap4->ssl); imap4->ssl = NULL; if(imap4->rd_source != 0) g_source_remove(imap4->rd_source); imap4->rd_source = 0; if(imap4->wr_source != 0) g_source_remove(imap4->wr_source); imap4->wr_source = 0; if(imap4->source != 0) g_source_remove(imap4->source); imap4->source = 0; if(imap4->channel != NULL) { g_io_channel_shutdown(imap4->channel, TRUE, NULL); g_io_channel_unref(imap4->channel); imap4->fd = -1; } imap4->channel = NULL; for(i = 0; i < imap4->queue_cnt; i++) free(imap4->queue[i].buf); free(imap4->queue); imap4->queue = NULL; imap4->queue_cnt = 0; if(imap4->fd >= 0) close(imap4->fd); imap4->fd = -1; imap4->aip = NULL; if(imap4->ai != NULL) freeaddrinfo(imap4->ai); imap4->ai = NULL; _imap4_event(imap4, AET_STOPPED); } /* imap4_refresh */ static int _imap4_refresh(IMAP4 * imap4, AccountFolder * folder, AccountMessage * message) { IMAP4Command * cmd; int len; char * buf; #ifdef DEBUG fprintf(stderr, "DEBUG: %s() %u\n", __func__, (message != NULL) ? message->id : 0); #endif if((len = snprintf(NULL, 0, "EXAMINE \"%s\"", folder->name)) < 0 || (buf = malloc(++len)) == NULL) return -1; snprintf(buf, len, "EXAMINE \"%s\"", folder->name); cmd = _imap4_command(imap4, I4C_SELECT, buf); free(buf); if(cmd == NULL) return -1; cmd->data.select.folder = folder; cmd->data.select.message = message; return 0; } /* private */ /* functions */ /* useful */ /* imap4_command */ static IMAP4Command * _imap4_command(IMAP4 * imap4, IMAP4Context context, char const * command) { IMAP4Command * p; size_t len; #ifdef DEBUG fprintf(stderr, "DEBUG: %s(\"%s\", %p)\n", __func__, command, (void *)imap4->channel); #endif /* abort if the command is invalid */ if(command == NULL || (len = strlen(command)) == 0) return NULL; /* abort if there is no active connection */ if(imap4->channel == NULL) return NULL; /* queue the command */ len += 9; if((p = realloc(imap4->queue, sizeof(*p) * (imap4->queue_cnt + 1))) == NULL) return NULL; imap4->queue = p; p = &imap4->queue[imap4->queue_cnt]; p->id = imap4->queue_id++; p->context = context; p->status = I4CS_QUEUED; if((p->buf = malloc(len)) == NULL) return NULL; p->buf_cnt = snprintf(p->buf, len, "a%04x %s\r\n", p->id, command); memset(&p->data, 0, sizeof(p->data)); if(imap4->queue_cnt++ == 0) { if(imap4->source != 0) { /* cancel the pending NOOP operation */ g_source_remove(imap4->source); imap4->source = 0; } imap4->wr_source = g_io_add_watch(imap4->channel, G_IO_OUT, (imap4->ssl != NULL) ? _on_watch_can_write_ssl : _on_watch_can_write, imap4); } return p; } /* imap4_parse */ static int _parse_context(IMAP4 * imap4, char const * answer); static int _context_fetch(IMAP4 * imap4, char const * answer); static int _context_fetch_body(IMAP4 * imap4, char const * answer); static int _context_fetch_command(IMAP4 * imap4, char const * answer); static int _context_fetch_flags(IMAP4 * imap4, char const * answer); static int _context_fetch_headers(IMAP4 * imap4, char const * answer); static int _context_fetch_id(IMAP4 * imap4, char const * answer); static int _context_init(IMAP4 * imap4); static int _context_list(IMAP4 * imap4, char const * answer); static int _context_login(IMAP4 * imap4, char const * answer); static int _context_select(IMAP4 * imap4); static int _context_status(IMAP4 * imap4, char const * answer); static int _imap4_parse(IMAP4 * imap4) { AccountPluginHelper * helper = imap4->helper; size_t i; size_t j; IMAP4Command * cmd; char buf[8]; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif for(i = 0, j = 0;; j = ++i) { /* look for carriage return sequences */ for(; i < imap4->rd_buf_cnt; i++) if(imap4->rd_buf[i] == '\r' && i + 1 < imap4->rd_buf_cnt && imap4->rd_buf[++i] == '\n') break; /* if no carriage return was found wait for more input */ if(i == imap4->rd_buf_cnt) break; /* if no command was sent read more lines */ if(imap4->queue_cnt == 0) continue; imap4->rd_buf[i - 1] = '\0'; cmd = &imap4->queue[0]; /* if we have just sent a command match the answer */ if(cmd->status == I4CS_SENT) { snprintf(buf, sizeof(buf), "a%04x ", cmd->id); #ifdef DEBUG fprintf(stderr, "DEBUG: %s() expecting \"%s\"\n", __func__, buf); #endif if(strncmp(&imap4->rd_buf[j], "* ", 2) == 0) j += 2; else if(strncmp(&imap4->rd_buf[j], buf, 6) == 0) { j += 6; cmd->status = I4CS_PARSING; if(strncmp("BAD ", &imap4->rd_buf[j], 4) == 0) /* FIXME report and pop queue instead */ helper->error(NULL, &imap4->rd_buf[j + 4], 1); } } if(_parse_context(imap4, &imap4->rd_buf[j]) != 0) cmd->status = I4CS_ERROR; } if(j != 0) { imap4->rd_buf_cnt -= j; memmove(imap4->rd_buf, &imap4->rd_buf[j], imap4->rd_buf_cnt); } return 0; } static int _parse_context(IMAP4 * imap4, char const * answer) { int ret = -1; IMAP4Command * cmd = &imap4->queue[0]; #ifdef DEBUG fprintf(stderr, "DEBUG: %s(\"%s\") %u, %u\n", __func__, answer, cmd->context, cmd->status); #endif switch(cmd->context) { case I4C_FETCH: return _context_fetch(imap4, answer); case I4C_INIT: return _context_init(imap4); case I4C_LIST: return _context_list(imap4, answer); case I4C_LOGIN: return _context_login(imap4, answer); case I4C_NOOP: if(cmd->status != I4CS_PARSING) return 0; cmd->status = I4CS_OK; return 0; case I4C_SELECT: return _context_select(imap4); case I4C_STATUS: return _context_status(imap4, answer); } return ret; } static int _context_fetch(IMAP4 * imap4, char const * answer) { IMAP4Command * cmd = &imap4->queue[0]; #ifdef DEBUG fprintf(stderr, "DEBUG: %s(\"%s\")\n", __func__, answer); #endif if(cmd->status == I4CS_PARSING) { cmd->status = I4CS_OK; return 0; } switch(cmd->data.fetch.status) { case I4FS_ID: return _context_fetch_id(imap4, answer); case I4FS_COMMAND: return _context_fetch_command(imap4, answer); case I4FS_FLAGS: return _context_fetch_flags(imap4, answer); case I4FS_BODY: return _context_fetch_body(imap4, answer); case I4FS_HEADERS: return _context_fetch_headers(imap4, answer); } return -1; } static int _context_fetch_body(IMAP4 * imap4, char const * answer) { AccountPluginHelper * helper = imap4->helper; IMAP4Command * cmd = &imap4->queue[0]; AccountMessage * message = cmd->data.fetch.message; size_t i; /* check the size */ if(cmd->data.fetch.size == 0) { /* XXX may not be the case (flags...) */ if(strcmp(answer, ")") == 0) { cmd->data.fetch.status = I4FS_ID; return 0; } else { cmd->data.fetch.status = I4FS_COMMAND; return _context_fetch(imap4, answer); } } if((i = strlen(answer) + 2) <= cmd->data.fetch.size) cmd->data.fetch.size -= i; helper->message_set_body(message->message, answer, strlen(answer), 1); helper->message_set_body(message->message, "\r\n", 2, 1); return 0; } static int _context_fetch_command(IMAP4 * imap4, char const * answer) { IMAP4Command * cmd = &imap4->queue[0]; AccountFolder * folder = cmd->data.fetch.folder; AccountMessage * message = cmd->data.fetch.message; unsigned int id = cmd->data.fetch.id; char * p; size_t i; /* skip spaces */ for(i = 0; answer[i] == ' '; i++); if(strncmp(&answer[i], "FLAGS ", 6) == 0) { cmd->data.fetch.status = I4FS_FLAGS; return _context_fetch(imap4, answer); } /* XXX assumes this is going to be a message content */ /* skip the command's name */ for(; answer[i] != '\0' && answer[i] != ' '; i++); /* skip spaces */ for(; answer[i] == ' '; i++); /* obtain the size */ if(answer[i] != '{') return -1; cmd->data.fetch.size = strtoul(&answer[++i], &p, 10); if(answer[i] == '\0' || *p != '}' || cmd->data.fetch.size == 0) return -1; if((message = _imap4_folder_get_message(imap4, folder, id)) != NULL) { cmd->data.fetch.status = I4FS_HEADERS; cmd->data.fetch.message = message; } return (message != NULL) ? 0 : -1; } static int _context_fetch_flags(IMAP4 * imap4, char const * answer) { AccountPluginHelper * helper = imap4->helper; IMAP4Command * cmd = &imap4->queue[0]; AccountMessage * message = cmd->data.fetch.message; size_t i; size_t j; size_t k; struct { char const * name; MailerMessageFlag flag; } flags[] = { { "\\Answered", MMF_ANSWERED }, { "\\Draft", MMF_DRAFT } }; /* skip spaces */ for(i = 0; answer[i] == ' '; i++); if(strncmp(&answer[i], "FLAGS ", 6) != 0) { cmd->data.fetch.status = I4FS_ID; return -1; } /* skip spaces */ for(i += 6; answer[i] == ' '; i++); if(answer[i] != '(') return -1; for(i++; answer[i] != '\0' && answer[i] != ')';) { for(j = i; isalpha((unsigned char)answer[j]) || answer[j] == '\\' || answer[j] == '$'; j++); /* give up if there is no flag */ if(j == i) { for(; answer[i] != '\0' && answer[i] != ')'; i++); break; } /* apply the flag */ for(k = 0; k < sizeof(flags) / sizeof(*flags); k++) if(strncmp(&answer[i], flags[k].name, j - i) == 0) { /* FIXME make sure message != NULL */ if(message == NULL) continue; helper->message_set_flag(message->message, flags[k].flag); } /* skip spaces */ for(i = j; answer[i] == ' '; i++); } if(answer[i] != ')') return -1; /* skip spaces */ for(i++; answer[i] == ' '; i++); if(answer[i] == ')') { /* the current command seems to be completed */ cmd->data.fetch.status = I4FS_ID; return 0; } cmd->data.fetch.status = I4FS_COMMAND; return _context_fetch(imap4, &answer[i]); } static int _context_fetch_headers(IMAP4 * imap4, char const * answer) { AccountPluginHelper * helper = imap4->helper; IMAP4Command * cmd = &imap4->queue[0]; AccountMessage * message = cmd->data.fetch.message; size_t i; /* check the size */ if((i = strlen(answer) + 2) <= cmd->data.fetch.size) cmd->data.fetch.size -= i; if(strcmp(answer, "") == 0) { /* beginning of the body */ cmd->data.fetch.status = I4FS_BODY; helper->message_set_body(message->message, NULL, 0, 0); } /* XXX check this before parsing anything */ else if(cmd->data.fetch.size == 0 || i > cmd->data.fetch.size) return 0; else helper->message_set_header(message->message, answer); return 0; } static int _context_fetch_id(IMAP4 * imap4, char const * answer) { IMAP4Command * cmd = &imap4->queue[0]; unsigned int id = cmd->data.fetch.id; char * p; size_t i; id = strtol(answer, &p, 10); if(answer[0] == '\0' || *p != ' ') return 0; cmd->data.fetch.id = id; #ifdef DEBUG fprintf(stderr, "DEBUG: %s() id=%u\n", __func__, id); #endif answer = p; if(strncmp(answer, " FETCH ", 7) != 0) return -1; /* skip spaces */ for(i = 7; answer[i] == ' '; i++); if(answer[i++] != '(') return 0; /* fallback */ answer = &answer[i]; cmd->data.fetch.status = I4FS_COMMAND; return _context_fetch_command(imap4, answer); } static int _context_init(IMAP4 * imap4) { IMAP4Command * cmd = &imap4->queue[0]; char const * p; char const * q; gchar * r; cmd->status = I4CS_OK; if((p = imap4->config[I4CV_USERNAME].value) == NULL || *p == '\0') return -1; if((q = imap4->config[I4CV_PASSWORD].value) == NULL || *q == '\0') return -1; r = g_strdup_printf("%s %s %s", "LOGIN", p, q); cmd = _imap4_command(imap4, I4C_LOGIN, r); g_free(r); return (cmd != NULL) ? 0 : -1; } static int _context_list(IMAP4 * imap4, char const * answer) { IMAP4Command * cmd = &imap4->queue[0]; AccountFolder * folder; AccountFolder * parent = cmd->data.list.parent; char const * p = answer; gchar * q; char const haschildren[] = "\\HasChildren"; int recurse = 0; char reference = '\0'; char buf[64]; #ifdef DEBUG fprintf(stderr, "DEBUG: %s(\"%s\")\n", __func__, answer); #endif if(strncmp("OK", p, 2) == 0) { cmd->status = I4CS_OK; return 0; } if(strncmp("LIST ", p, 5) != 0) return -1; p += 5; if(*p == '(') /* parse flags */ { for(p++; *p == '\\';) { #ifdef DEBUG fprintf(stderr, "DEBUG: %s() flag \"%s\"\n", __func__, p); #endif if(strncmp(p, haschildren, sizeof(haschildren) - 1) == 0) { p += sizeof(haschildren) - 1; recurse = 1; } else /* skip until end of flag */ for(p++; isalnum((unsigned char)*p); p++); /* skip spaces */ for(; *p == ' '; p++); if(*p == ')') break; } if(*p != ')') return -1; p++; } if(*p == ' ') /* skip spaces */ for(p++; *p != '\0' && *p == ' '; p++); if(*p == '\"') /* skip reference */ { if(p[1] != '\0' && p[1] != '"' && p[2] == '"') reference = p[1]; for(p++; *p != '\0' && *p++ != '\"';); } if(*p == ' ') /* skip spaces */ for(p++; *p != '\0' && *p == ' '; p++); /* read the folder name */ buf[0] = '\0'; if(*p == '\"') sscanf(++p, "%63[^\"]", buf); else sscanf(p, "%63s", buf); buf[63] = '\0'; if(buf[0] != '\0' && (folder = _imap4_folder_get_folder(imap4, parent, buf)) != NULL /* FIXME escape the mailbox' name instead */ && strchr(buf, '"') == NULL) { q = g_strdup_printf("%s \"%s\" (%s)", "STATUS", buf, "MESSAGES RECENT UNSEEN"); if((cmd = _imap4_command(imap4, I4C_STATUS, q)) != NULL) cmd->data.status.folder = folder; g_free(q); if(cmd != NULL && recurse == 1 && reference != '\0') { q = g_strdup_printf("%s \"\" \"%s%c%%\"", "LIST", buf, reference); if((cmd = _imap4_command(imap4, I4C_LIST, q)) != NULL) cmd->data.list.parent = folder; g_free(q); } } return (cmd != NULL) ? 0 : -1; } static int _context_login(IMAP4 * imap4, char const * answer) { AccountPluginHelper * helper = imap4->helper; IMAP4Command * cmd = &imap4->queue[0]; char const * prefix = imap4->config[I4CV_PREFIX].value; gchar * q; if(cmd->status != I4CS_PARSING) return 0; if(strncmp("OK", answer, 2) != 0) return -helper->error(helper->account, "Authentication failed", 1); cmd->status = I4CS_OK; if((q = g_strdup_printf("%s \"\" \"%s%%\"", "LIST", (prefix != NULL) ? prefix : "")) == NULL) return -1; cmd = _imap4_command(imap4, I4C_LIST, q); g_free(q); if(cmd == NULL) return -1; cmd->data.list.parent = &imap4->folders; return 0; } static int _context_select(IMAP4 * imap4) { IMAP4Command * cmd = &imap4->queue[0]; AccountFolder * folder; AccountMessage * message; char buf[64]; if(cmd->status != I4CS_PARSING) return 0; cmd->status = I4CS_OK; if((folder = cmd->data.select.folder) == NULL) return 0; /* XXX really is an error */ if((message = cmd->data.select.message) == NULL) /* FIXME queue commands in batches instead */ snprintf(buf, sizeof(buf), "%s %s %s", "FETCH", "1:*", "(FLAGS BODY.PEEK[HEADER])"); else snprintf(buf, sizeof(buf), "%s %u %s", "FETCH", message->id, "BODY.PEEK[]"); if((cmd = _imap4_command(imap4, I4C_FETCH, buf)) == NULL) return -1; cmd->data.fetch.folder = folder; cmd->data.fetch.message = message; cmd->data.fetch.id = (message != NULL) ? message->id : 0; cmd->data.fetch.status = I4FS_ID; cmd->data.fetch.size = 0; return 0; } static int _context_status(IMAP4 * imap4, char const * answer) { IMAP4Command * cmd = &imap4->queue[0]; char const * p; char const messages[] = "MESSAGES"; char const recent[] = "RECENT"; char const unseen[] = "UNSEEN"; unsigned int u; #ifdef DEBUG fprintf(stderr, "DEBUG: %s(\"%s\")\n", __func__, answer); #endif p = answer; if(strncmp("OK", p, 2) == 0) { cmd->status = I4CS_OK; return 0; } else if(strncmp("NO", p, 2) == 0) { cmd->status = I4CS_ERROR; return 0; } if(strncmp("STATUS ", p, 7) != 0) return 0; p += 7; if(*p == '\"') /* skip reference */ for(p++; *p != '\0' && *p++ != '\"';); if(*p == ' ') /* skip spaces */ for(p++; *p != '\0' && *p == ' '; p++); if(*p == '(') /* parse the data items */ for(p++; *p != '\0' && *p != ')'; p++) { if(strncmp(p, messages, sizeof(messages) - 1) == 0 && p[sizeof(messages) - 1] == ' ') { /* number of messages in the mailbox */ p += sizeof(messages); sscanf(p, "%u", &u); /* FIXME really implement */ #ifdef DEBUG fprintf(stderr, "DEBUG: %s() %u messages\n", __func__, u); #endif } else if(strncmp(p, recent, sizeof(recent) - 1) == 0 && p[sizeof(recent) - 1] == ' ') { /* number of recent messages in the mailbox */ p += sizeof(recent); sscanf(p, "%u", &u); /* FIXME really implement */ #ifdef DEBUG fprintf(stderr, "DEBUG: %s() %u recent\n", __func__, u); #endif } else if(strncmp(p, unseen, sizeof(unseen) - 1) == 0 && p[sizeof(unseen) - 1] == ' ') { /* number of unseen messages in the mailbox */ p += sizeof(unseen); sscanf(p, "%u", &u); /* FIXME really implement */ #ifdef DEBUG fprintf(stderr, "DEBUG: %s() %u unseen\n", __func__, u); #endif } else /* skip until the next space */ for(; *p != '\0' && *p != ' ' && *p != ')'; p++); /* skip until the next space */ for(; *p != '\0' && *p != ' ' && *p != ')'; p++); } return 0; } /* imap4_event */ static void _imap4_event(IMAP4 * imap4, AccountEventType type) { AccountPluginHelper * helper = imap4->helper; AccountEvent event; memset(&event, 0, sizeof(event)); switch((event.status.type = type)) { case AET_STARTED: case AET_STOPPED: break; default: /* XXX not handled */ return; } helper->event(helper->account, &event); } /* imap4_event_status */ static void _imap4_event_status(IMAP4 * imap4, AccountStatus status, char const * message) { AccountPluginHelper * helper = imap4->helper; AccountEvent event; memset(&event, 0, sizeof(event)); event.status.type = AET_STATUS; event.status.status = status; event.status.message = message; helper->event(helper->account, &event); } /* imap4_folder_new */ static AccountFolder * _imap4_folder_new(IMAP4 * imap4, AccountFolder * parent, char const * name) { AccountPluginHelper * helper = imap4->helper; AccountFolder * folder; AccountFolder ** p; FolderType type = FT_FOLDER; struct { char const * name; FolderType type; } name_type[] = { { "Inbox", FT_INBOX }, { "Drafts", FT_DRAFTS }, { "Trash", FT_TRASH }, { "Sent", FT_SENT } }; size_t i; size_t len; if((p = realloc(parent->folders, sizeof(*p) * (parent->folders_cnt + 1))) == NULL) return NULL; parent->folders = p; if((folder = object_new(sizeof(*folder))) == NULL) return NULL; folder->name = strdup(name); if(parent == &imap4->folders) for(i = 0; i < sizeof(name_type) / sizeof(*name_type); i++) if(strcasecmp(name_type[i].name, name) == 0) { type = name_type[i].type; name = name_type[i].name; break; } /* shorten the name as required if has a parent */ if(parent->name != NULL && (len = strlen(parent->name)) > 0 && strncmp(name, parent->name, len) == 0) name = &name[len + 1]; folder->folder = helper->folder_new(helper->account, folder, parent->folder, type, name); folder->messages = NULL; folder->messages_cnt = 0; folder->folders = NULL; folder->folders_cnt = 0; if(folder->folder == NULL || folder->name == NULL) { _imap4_folder_delete(imap4, folder); return NULL; } parent->folders[parent->folders_cnt++] = folder; return folder; } /* imap4_folder_delete */ static void _imap4_folder_delete(IMAP4 * imap4, AccountFolder * folder) { size_t i; if(folder->folder != NULL) imap4->helper->folder_delete(folder->folder); free(folder->name); for(i = 0; i < folder->messages_cnt; i++) _imap4_message_delete(imap4, folder->messages[i]); free(folder->messages); for(i = 0; i < folder->folders_cnt; i++) _imap4_folder_delete(imap4, folder->folders[i]); free(folder->folders); /* XXX rather ugly */ if(folder != &imap4->folders) object_delete(folder); } /* imap4_folder_get_folder */ static AccountFolder * _imap4_folder_get_folder(IMAP4 * imap4, AccountFolder * folder, char const * name) { size_t i; #ifdef DEBUG fprintf(stderr, "DEBUG: %s(\"%s\", \"%s\")\n", __func__, folder->name, name); #endif for(i = 0; i < folder->folders_cnt; i++) if(strcmp(folder->folders[i]->name, name) == 0) return folder->folders[i]; return _imap4_folder_new(imap4, folder, name); } /* imap4_folder_get_message */ static AccountMessage * _imap4_folder_get_message(IMAP4 * imap4, AccountFolder * folder, unsigned int id) { size_t i; #ifdef DEBUG fprintf(stderr, "DEBUG: %s(\"%s\", %u)\n", __func__, folder->name, id); #endif for(i = 0; i < folder->messages_cnt; i++) if(folder->messages[i]->id == id) return folder->messages[i]; return _imap4_message_new(imap4, folder, id); } /* imap4_message_new */ static AccountMessage * _imap4_message_new(IMAP4 * imap4, AccountFolder * folder, unsigned int id) { AccountPluginHelper * helper = imap4->helper; AccountMessage * message; AccountMessage ** p; if((p = realloc(folder->messages, sizeof(*p) * (folder->messages_cnt + 1))) == NULL) return NULL; folder->messages = p; if((message = object_new(sizeof(*message))) == NULL) return NULL; message->id = id; if((message->message = helper->message_new(helper->account, folder->folder, message)) == NULL) { _imap4_message_delete(imap4, message); return NULL; } folder->messages[folder->messages_cnt++] = message; return message; } /* imap4_message_delete */ static void _imap4_message_delete(IMAP4 * imap4, AccountMessage * message) { if(message->message != NULL) imap4->helper->message_delete(message->message); object_delete(message); } /* callbacks */ /* on_idle */ static int _connect_address(IMAP4 * imap4, char const * hostname, struct addrinfo * ai); static int _connect_channel(IMAP4 * imap4); static gboolean _on_connect(gpointer data) { IMAP4 * imap4 = data; AccountPluginHelper * helper = imap4->helper; char const * hostname; char const * p; uint16_t port; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif imap4->source = 0; /* get the hostname and port */ if((hostname = imap4->config[I4CV_HOSTNAME].value) == NULL) { helper->error(helper->account, "No hostname set", 1); return FALSE; } if((p = imap4->config[I4CV_PORT].value) == NULL) return FALSE; port = (unsigned long)p; /* lookup the address */ if(_common_lookup(hostname, port, &imap4->ai) != 0) { helper->error(helper->account, error_get(NULL), 1); return FALSE; } for(imap4->aip = imap4->ai; imap4->aip != NULL; imap4->aip = imap4->aip->ai_next) if(_connect_address(imap4, hostname, imap4->aip) == 0) break; if(imap4->aip == NULL) _imap4_stop(imap4); return FALSE; } static int _connect_address(IMAP4 * imap4, char const * hostname, struct addrinfo * ai) { AccountPluginHelper * helper = imap4->helper; int res; char * q; char buf[128]; /* create the socket */ if((imap4->fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) == -1) return -helper->error(helper->account, strerror(errno), 1); if((res = fcntl(imap4->fd, F_GETFL)) >= 0 && fcntl(imap4->fd, F_SETFL, res | O_NONBLOCK) == -1) /* ignore this error */ /* FIXME report properly as a warning instead */ helper->error(NULL, strerror(errno), 1); /* report the current status */ if((q = _common_lookup_print(ai)) != NULL) snprintf(buf, sizeof(buf), "Connecting to %s (%s)", hostname, q); else snprintf(buf, sizeof(buf), "Connecting to %s", hostname); free(q); _imap4_event_status(imap4, AS_CONNECTING, buf); /* connect to the remote host */ if((connect(imap4->fd, ai->ai_addr, ai->ai_addrlen) != 0 && errno != EINPROGRESS && errno != EINTR) || _connect_channel(imap4) != 0) { snprintf(buf, sizeof(buf), "%s (%s)", "Connection failed", strerror(errno)); return -helper->error(helper->account, buf, 1); } imap4->wr_source = g_io_add_watch(imap4->channel, G_IO_OUT, _on_watch_can_connect, imap4); return 0; } static int _connect_channel(IMAP4 * imap4) { AccountPluginHelper * helper = imap4->helper; GError * error = NULL; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif /* prepare queue */ if((imap4->queue = malloc(sizeof(*imap4->queue))) == NULL) return -helper->error(helper->account, strerror(errno), 1); imap4->queue[0].id = 0; imap4->queue[0].context = I4C_INIT; imap4->queue[0].status = I4CS_SENT; imap4->queue[0].buf = NULL; imap4->queue[0].buf_cnt = 0; imap4->queue_cnt = 1; imap4->queue_id = 1; /* setup channel */ imap4->channel = g_io_channel_unix_new(imap4->fd); g_io_channel_set_encoding(imap4->channel, NULL, &error); g_io_channel_set_buffered(imap4->channel, FALSE); return 0; } /* on_noop */ static gboolean _on_noop(gpointer data) { IMAP4 * imap4 = data; _imap4_command(imap4, I4C_NOOP, "NOOP"); imap4->source = 0; return FALSE; } /* on_watch_can_connect */ static gboolean _on_watch_can_connect(GIOChannel * source, GIOCondition condition, gpointer data) { IMAP4 * imap4 = data; AccountPluginHelper * helper = imap4->helper; int res; socklen_t s = sizeof(res); char const * hostname = imap4->config[I4CV_HOSTNAME].value; SSL_CTX * ssl_ctx; char buf[128]; char * q; if(condition != G_IO_OUT || source != imap4->channel) return FALSE; /* should not happen */ #ifdef DEBUG fprintf(stderr, "DEBUG: %s() connected\n", __func__); #endif if(getsockopt(imap4->fd, SOL_SOCKET, SO_ERROR, &res, &s) != 0 || res != 0) { snprintf(buf, sizeof(buf), "%s (%s)", "Connection failed", strerror(res)); helper->error(helper->account, buf, 1); /* FIXME try the next address instead */ _imap4_stop(imap4); return FALSE; } if(imap4->aip != NULL && (q = _common_lookup_print(imap4->aip)) != NULL) { snprintf(buf, sizeof(buf), "Connected to %s (%s)", hostname, q); free(q); } else snprintf(buf, sizeof(buf), "Connected to %s", hostname); _imap4_event_status(imap4, AS_CONNECTED, buf); imap4->wr_source = 0; /* setup SSL */ if(imap4->config[I4CV_SSL].value != NULL) { if((ssl_ctx = helper->get_ssl_context(helper->account)) == NULL) /* FIXME report error */ return FALSE; if((imap4->ssl = SSL_new(ssl_ctx)) == NULL) { helper->error(helper->account, ERR_error_string( ERR_get_error(), buf), 1); return FALSE; } if(SSL_set_fd(imap4->ssl, imap4->fd) != 1) { ERR_error_string(ERR_get_error(), buf); SSL_free(imap4->ssl); imap4->ssl = NULL; helper->error(helper->account, buf, 1); return FALSE; } SSL_set_connect_state(imap4->ssl); /* perform initial handshake */ imap4->wr_source = g_io_add_watch(imap4->channel, G_IO_OUT, _on_watch_can_handshake, imap4); return FALSE; } /* wait for the server's banner */ imap4->rd_source = g_io_add_watch(imap4->channel, G_IO_IN, _on_watch_can_read, imap4); return FALSE; } /* on_watch_can_handshake */ static int _handshake_verify(IMAP4 * imap4); static gboolean _on_watch_can_handshake(GIOChannel * source, GIOCondition condition, gpointer data) { IMAP4 * imap4 = data; AccountPluginHelper * helper = imap4->helper; int res; int err; char buf[128]; if((condition != G_IO_IN && condition != G_IO_OUT) || source != imap4->channel || imap4->ssl == NULL) return FALSE; /* should not happen */ #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif imap4->wr_source = 0; imap4->rd_source = 0; if((res = SSL_do_handshake(imap4->ssl)) == 1) { if(_handshake_verify(imap4) != 0) { _imap4_stop(imap4); return FALSE; } /* wait for the server's banner */ imap4->rd_source = g_io_add_watch(imap4->channel, G_IO_IN, _on_watch_can_read_ssl, imap4); return FALSE; } err = SSL_get_error(imap4->ssl, res); ERR_error_string(err, buf); if(res == 0) { helper->error(helper->account, buf, 1); _imap4_stop(imap4); return FALSE; } if(err == SSL_ERROR_WANT_WRITE) imap4->wr_source = g_io_add_watch(imap4->channel, G_IO_OUT, _on_watch_can_handshake, imap4); else if(err == SSL_ERROR_WANT_READ) imap4->rd_source = g_io_add_watch(imap4->channel, G_IO_IN, _on_watch_can_handshake, imap4); else { helper->error(helper->account, buf, 1); _imap4_stop(imap4); return FALSE; } return FALSE; } static int _handshake_verify(IMAP4 * imap4) { AccountPluginHelper * helper = imap4->helper; X509 * x509; char buf[256] = ""; if(SSL_get_verify_result(imap4->ssl) != X509_V_OK) return helper->confirm(helper->account, "The certificate could" " not be verified.\nConnect anyway?"); x509 = SSL_get_peer_certificate(imap4->ssl); X509_NAME_get_text_by_NID(X509_get_subject_name(x509), NID_commonName, buf, sizeof(buf)); if(strcasecmp(buf, imap4->config[I4CV_HOSTNAME].value) != 0) return helper->confirm(helper->account, "The certificate could" " not be matched.\nConnect anyway?"); return 0; } /* on_watch_can_read */ static gboolean _on_watch_can_read(GIOChannel * source, GIOCondition condition, gpointer data) { IMAP4 * imap4 = data; AccountPluginHelper * helper = imap4->helper; char * p; gsize cnt = 0; GError * error = NULL; GIOStatus status; IMAP4Command * cmd; const int inc = 256; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif if(condition != G_IO_IN || source != imap4->channel) return FALSE; /* should not happen */ if((p = realloc(imap4->rd_buf, imap4->rd_buf_cnt + inc)) == NULL) return TRUE; /* XXX retries immediately (delay?) */ imap4->rd_buf = p; status = g_io_channel_read_chars(source, &imap4->rd_buf[imap4->rd_buf_cnt], inc, &cnt, &error); #ifdef DEBUG fprintf(stderr, "%s", "DEBUG: IMAP4 SERVER: "); fwrite(&imap4->rd_buf[imap4->rd_buf_cnt], sizeof(*p), cnt, stderr); #endif imap4->rd_buf_cnt += cnt; switch(status) { case G_IO_STATUS_NORMAL: break; case G_IO_STATUS_ERROR: helper->error(helper->account, error->message, 1); g_error_free(error); _imap4_stop(imap4); return FALSE; case G_IO_STATUS_EOF: default: _imap4_event_status(imap4, AS_DISCONNECTED, NULL); _imap4_stop(imap4); return FALSE; } if(_imap4_parse(imap4) != 0) { _imap4_stop(imap4); return FALSE; } if(imap4->queue_cnt == 0) return TRUE; cmd = &imap4->queue[0]; if(cmd->buf_cnt == 0) { if(cmd->status == I4CS_SENT || cmd->status == I4CS_PARSING) /* begin or keep parsing */ return TRUE; else if(cmd->status == I4CS_OK || cmd->status == I4CS_ERROR) /* the current command is completed */ memmove(cmd, &imap4->queue[1], sizeof(*cmd) * --imap4->queue_cnt); } if(imap4->queue_cnt == 0) { _imap4_event_status(imap4, AS_IDLE, NULL); imap4->source = g_timeout_add(30000, _on_noop, imap4); } else imap4->wr_source = g_io_add_watch(imap4->channel, G_IO_OUT, _on_watch_can_write, imap4); return TRUE; } /* on_watch_can_read_ssl */ static gboolean _on_watch_can_read_ssl(GIOChannel * source, GIOCondition condition, gpointer data) { IMAP4 * imap4 = data; char * p; int cnt; IMAP4Command * cmd; char buf[128]; const int inc = 16384; /* XXX not reliable with a smaller value */ #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif if((condition != G_IO_IN && condition != G_IO_OUT) || source != imap4->channel) return FALSE; /* should not happen */ if((p = realloc(imap4->rd_buf, imap4->rd_buf_cnt + inc)) == NULL) return TRUE; /* XXX retries immediately (delay?) */ imap4->rd_buf = p; if((cnt = SSL_read(imap4->ssl, &imap4->rd_buf[imap4->rd_buf_cnt], inc)) <= 0) { if(SSL_get_error(imap4->ssl, cnt) == SSL_ERROR_WANT_WRITE) /* call SSL_read() again when it can send data */ imap4->rd_source = g_io_add_watch(imap4->channel, G_IO_OUT, _on_watch_can_read_ssl, imap4); else if(SSL_get_error(imap4->ssl, cnt) == SSL_ERROR_WANT_READ) /* call SSL_read() again when it can read data */ imap4->rd_source = g_io_add_watch(imap4->channel, G_IO_IN, _on_watch_can_read_ssl, imap4); else { /* unknown error */ imap4->rd_source = 0; ERR_error_string(SSL_get_error(imap4->ssl, cnt), buf); _imap4_event_status(imap4, AS_DISCONNECTED, buf); _imap4_stop(imap4); } return FALSE; } #ifdef DEBUG fprintf(stderr, "%s", "DEBUG: IMAP4 SERVER: "); fwrite(&imap4->rd_buf[imap4->rd_buf_cnt], sizeof(*p), cnt, stderr); #endif imap4->rd_buf_cnt += cnt; if(_imap4_parse(imap4) != 0) { _imap4_stop(imap4); return FALSE; } if(imap4->queue_cnt == 0) return TRUE; cmd = &imap4->queue[0]; if(cmd->buf_cnt == 0) { if(cmd->status == I4CS_SENT || cmd->status == I4CS_PARSING) /* begin or keep parsing */ return TRUE; else if(cmd->status == I4CS_OK || cmd->status == I4CS_ERROR) /* the current command is completed */ memmove(cmd, &imap4->queue[1], sizeof(*cmd) * --imap4->queue_cnt); } if(imap4->queue_cnt == 0) { _imap4_event_status(imap4, AS_IDLE, NULL); imap4->source = g_timeout_add(30000, _on_noop, imap4); } else imap4->wr_source = g_io_add_watch(imap4->channel, G_IO_OUT, _on_watch_can_write_ssl, imap4); return TRUE; } /* on_watch_can_write */ static gboolean _on_watch_can_write(GIOChannel * source, GIOCondition condition, gpointer data) { IMAP4 * imap4 = data; AccountPluginHelper * helper = imap4->helper; IMAP4Command * cmd = &imap4->queue[0]; gsize cnt = 0; GError * error = NULL; GIOStatus status; char * p; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif if(condition != G_IO_OUT || source != imap4->channel || imap4->queue_cnt == 0 || cmd->buf_cnt == 0) return FALSE; /* should not happen */ status = g_io_channel_write_chars(source, cmd->buf, cmd->buf_cnt, &cnt, &error); #ifdef DEBUG fprintf(stderr, "%s", "DEBUG: IMAP4 CLIENT: "); fwrite(cmd->buf, sizeof(*p), cnt, stderr); #endif if(cnt != 0) { cmd->buf_cnt -= cnt; memmove(cmd->buf, &cmd->buf[cnt], cmd->buf_cnt); if((p = realloc(cmd->buf, cmd->buf_cnt)) != NULL) cmd->buf = p; /* we can ignore errors... */ else if(cmd->buf_cnt == 0) cmd->buf = NULL; /* ...except when it's not one */ } switch(status) { case G_IO_STATUS_NORMAL: break; case G_IO_STATUS_ERROR: helper->error(helper->account, error->message, 1); g_error_free(error); _imap4_stop(imap4); return FALSE; case G_IO_STATUS_EOF: default: _imap4_event_status(imap4, AS_DISCONNECTED, NULL); _imap4_stop(imap4); return FALSE; } if(cmd->buf_cnt > 0) return TRUE; cmd->status = I4CS_SENT; imap4->wr_source = 0; if(imap4->rd_source == 0) /* XXX should not happen */ imap4->rd_source = g_io_add_watch(imap4->channel, G_IO_IN, _on_watch_can_read, imap4); return FALSE; } /* on_watch_can_write_ssl */ static gboolean _on_watch_can_write_ssl(GIOChannel * source, GIOCondition condition, gpointer data) { IMAP4 * imap4 = data; IMAP4Command * cmd = &imap4->queue[0]; int cnt; char * p; char buf[128]; #ifdef DEBUG fprintf(stderr, "DEBUG: %s()\n", __func__); #endif if((condition != G_IO_IN && condition != G_IO_OUT) || source != imap4->channel || imap4->queue_cnt == 0 || cmd->buf_cnt == 0) return FALSE; /* should not happen */ if((cnt = SSL_write(imap4->ssl, cmd->buf, cmd->buf_cnt)) <= 0) { if(SSL_get_error(imap4->ssl, cnt) == SSL_ERROR_WANT_READ) imap4->wr_source = g_io_add_watch(imap4->channel, G_IO_IN, _on_watch_can_write_ssl, imap4); else if(SSL_get_error(imap4->ssl, cnt) == SSL_ERROR_WANT_WRITE) imap4->wr_source = g_io_add_watch(imap4->channel, G_IO_OUT, _on_watch_can_write_ssl, imap4); else { ERR_error_string(SSL_get_error(imap4->ssl, cnt), buf); _imap4_event_status(imap4, AS_DISCONNECTED, buf); _imap4_stop(imap4); } return FALSE; } #ifdef DEBUG fprintf(stderr, "%s", "DEBUG: IMAP4 CLIENT: "); fwrite(cmd->buf, sizeof(*p), cnt, stderr); #endif cmd->buf_cnt -= cnt; memmove(cmd->buf, &cmd->buf[cnt], cmd->buf_cnt); if((p = realloc(cmd->buf, cmd->buf_cnt)) != NULL) cmd->buf = p; /* we can ignore errors... */ else if(cmd->buf_cnt == 0) cmd->buf = NULL; /* ...except when it's not one */ if(cmd->buf_cnt > 0) return TRUE; cmd->status = I4CS_SENT; imap4->wr_source = 0; if(imap4->rd_source == 0) /* XXX should not happen */ imap4->rd_source = g_io_add_watch(imap4->channel, G_IO_IN, _on_watch_can_read_ssl, imap4); return FALSE; }