/* imap_get_qualifier: in a tagged response, skip tag and status for
* the qualifier message. Used by imap_copy_message for TRYCREATE */
char *imap_get_qualifier (char *buf)
{
char *s = buf;
/* skip tag */
s = imap_next_word (s);
/* skip OK/NO/BAD response */
s = imap_next_word (s);
return s;
}
/**
* camel_imap_response_extract:
* @store: the store the response came from
* @response: the response data returned from camel_imap_command
* @type: the response type to extract
* @ex: a CamelException
*
* This checks that @response contains a single untagged response of
* type @type and returns just that response data. If @response
* doesn't contain the right information, the function will set @ex
* and return %NULL. Either way, @response will be freed and the
* store's connect_lock released.
*
* Return value: the desired response string, which the caller must free.
**/
char *
camel_imap_response_extract (CamelImapStore *store,
CamelImapResponse *response,
const char *type,
CamelException *ex)
{
int len = strlen (type), i;
char *resp;
len = strlen (type);
for (i = 0; i < response->untagged->len; i++) {
resp = response->untagged->pdata[i];
/* Skip "* ", and initial sequence number, if present */
strtoul (resp + 2, &resp, 10);
if (*resp == ' ')
resp = (char *) imap_next_word (resp);
if (!g_ascii_strncasecmp (resp, type, len))
break;
}
if (i < response->untagged->len) {
resp = response->untagged->pdata[i];
g_ptr_array_remove_index (response->untagged, i);
} else {
resp = NULL;
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("IMAP server response did not contain "
"%s information"), type);
}
camel_imap_response_free (store, response);
return resp;
}
int imap_append_message (CONTEXT *ctx, MESSAGE *msg)
{
IMAP_DATA* idata;
FILE *fp;
char buf[LONG_STRING];
char mbox[LONG_STRING];
char mailbox[LONG_STRING];
char internaldate[IMAP_DATELEN];
char imap_flags[SHORT_STRING];
size_t len;
progress_t progressbar;
size_t sent;
int c, last;
IMAP_MBOX mx;
int rc;
idata = (IMAP_DATA*) ctx->data;
if (imap_parse_path (ctx->path, &mx))
return -1;
imap_fix_path (idata, mx.mbox, mailbox, sizeof (mailbox));
if (!*mailbox)
strfcpy (mailbox, "INBOX", sizeof (mailbox));
if ((fp = fopen (msg->path, "r")) == NULL)
{
mutt_perror (msg->path);
goto fail;
}
/* currently we set the \Seen flag on all messages, but probably we
* should scan the message Status header for flag info. Since we're
* already rereading the whole file for length it isn't any more
* expensive (it'd be nice if we had the file size passed in already
* by the code that writes the file, but that's a lot of changes.
* Ideally we'd have a HEADER structure with flag info here... */
for (last = EOF, len = 0; (c = fgetc(fp)) != EOF; last = c)
{
if(c == '\n' && last != '\r')
len++;
len++;
}
rewind (fp);
mutt_progress_init (&progressbar, _("Uploading message..."),
MUTT_PROGRESS_SIZE, NetInc, len);
imap_munge_mbox_name (idata, mbox, sizeof (mbox), mailbox);
imap_make_date (internaldate, msg->received);
imap_flags[0] = imap_flags[1] = 0;
if (msg->flags.read)
safe_strcat (imap_flags, sizeof (imap_flags), " \\Seen");
if (msg->flags.replied)
safe_strcat (imap_flags, sizeof (imap_flags), " \\Answered");
if (msg->flags.flagged)
safe_strcat (imap_flags, sizeof (imap_flags), " \\Flagged");
if (msg->flags.draft)
safe_strcat (imap_flags, sizeof (imap_flags), " \\Draft");
snprintf (buf, sizeof (buf), "APPEND %s (%s) \"%s\" {%lu}", mbox,
imap_flags + 1,
internaldate,
(unsigned long) len);
imap_cmd_start (idata, buf);
do
rc = imap_cmd_step (idata);
while (rc == IMAP_CMD_CONTINUE);
if (rc != IMAP_CMD_RESPOND)
{
char *pc;
dprint (1, (debugfile, "imap_append_message(): command failed: %s\n",
idata->buf));
pc = idata->buf + SEQLEN;
SKIPWS (pc);
pc = imap_next_word (pc);
mutt_error ("%s", pc);
mutt_sleep (1);
safe_fclose (&fp);
goto fail;
}
for (last = EOF, sent = len = 0; (c = fgetc(fp)) != EOF; last = c)
{
if (c == '\n' && last != '\r')
buf[len++] = '\r';
buf[len++] = c;
if (len > sizeof(buf) - 3)
{
sent += len;
flush_buffer(buf, &len, idata->conn);
mutt_progress_update (&progressbar, sent, -1);
}
}
if (len)
flush_buffer(buf, &len, idata->conn);
mutt_socket_write (idata->conn, "\r\n");
safe_fclose (&fp);
do
rc = imap_cmd_step (idata);
while (rc == IMAP_CMD_CONTINUE);
if (!imap_code (idata->buf))
{
char *pc;
dprint (1, (debugfile, "imap_append_message(): command failed: %s\n",
idata->buf));
pc = idata->buf + SEQLEN;
SKIPWS (pc);
pc = imap_next_word (pc);
mutt_error ("%s", pc);
mutt_sleep (1);
goto fail;
}
FREE (&mx.mbox);
return 0;
fail:
FREE (&mx.mbox);
return -1;
}
int imap_fetch_message (CONTEXT *ctx, MESSAGE *msg, int msgno)
{
IMAP_DATA* idata;
HEADER* h;
ENVELOPE* newenv;
char buf[LONG_STRING];
char path[_POSIX_PATH_MAX];
char *pc;
long bytes;
progress_t progressbar;
int uid;
int cacheno;
IMAP_CACHE *cache;
int read;
int rc;
/* Sam's weird courier server returns an OK response even when FETCH
* fails. Thanks Sam. */
short fetched = 0;
idata = (IMAP_DATA*) ctx->data;
h = ctx->hdrs[msgno];
if ((msg->fp = msg_cache_get (idata, h)))
{
if (HEADER_DATA(h)->parsed)
return 0;
else
goto parsemsg;
}
/* we still do some caching even if imap_cachedir is unset */
/* see if we already have the message in our cache */
cacheno = HEADER_DATA(h)->uid % IMAP_CACHE_LEN;
cache = &idata->cache[cacheno];
if (cache->path)
{
/* don't treat cache errors as fatal, just fall back. */
if (cache->uid == HEADER_DATA(h)->uid &&
(msg->fp = fopen (cache->path, "r")))
return 0;
else
{
unlink (cache->path);
FREE (&cache->path);
}
}
if (!isendwin())
mutt_message _("Fetching message...");
if (!(msg->fp = msg_cache_put (idata, h)))
{
cache->uid = HEADER_DATA(h)->uid;
mutt_mktemp (path, sizeof (path));
cache->path = safe_strdup (path);
if (!(msg->fp = safe_fopen (path, "w+")))
{
FREE (&cache->path);
return -1;
}
}
/* mark this header as currently inactive so the command handler won't
* also try to update it. HACK until all this code can be moved into the
* command handler */
h->active = 0;
snprintf (buf, sizeof (buf), "UID FETCH %u %s", HEADER_DATA(h)->uid,
(mutt_bit_isset (idata->capabilities, IMAP4REV1) ?
(option (OPTIMAPPEEK) ? "BODY.PEEK[]" : "BODY[]") :
"RFC822"));
imap_cmd_start (idata, buf);
do
{
if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE)
break;
pc = idata->buf;
pc = imap_next_word (pc);
pc = imap_next_word (pc);
if (!ascii_strncasecmp ("FETCH", pc, 5))
{
while (*pc)
{
pc = imap_next_word (pc);
if (pc[0] == '(')
pc++;
if (ascii_strncasecmp ("UID", pc, 3) == 0)
{
pc = imap_next_word (pc);
uid = atoi (pc);
if (uid != HEADER_DATA(h)->uid)
mutt_error (_("The message index is incorrect. Try reopening the mailbox."));
}
else if ((ascii_strncasecmp ("RFC822", pc, 6) == 0) ||
(ascii_strncasecmp ("BODY[]", pc, 6) == 0))
{
pc = imap_next_word (pc);
if (imap_get_literal_count(pc, &bytes) < 0)
{
imap_error ("imap_fetch_message()", buf);
goto bail;
}
mutt_progress_init (&progressbar, _("Fetching message..."),
MUTT_PROGRESS_SIZE, NetInc, bytes);
if (imap_read_literal (msg->fp, idata, bytes, &progressbar) < 0)
goto bail;
/* pick up trailing line */
if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE)
goto bail;
pc = idata->buf;
fetched = 1;
}
/* UW-IMAP will provide a FLAGS update here if the FETCH causes a
* change (eg from \Unseen to \Seen).
* Uncommitted changes in mutt take precedence. If we decide to
* incrementally update flags later, this won't stop us syncing */
else if ((ascii_strncasecmp ("FLAGS", pc, 5) == 0) && !h->changed)
{
if ((pc = imap_set_flags (idata, h, pc)) == NULL)
goto bail;
}
}
}
}
while (rc == IMAP_CMD_CONTINUE);
/* see comment before command start. */
h->active = 1;
fflush (msg->fp);
if (ferror (msg->fp))
{
mutt_perror (cache->path);
goto bail;
}
if (rc != IMAP_CMD_OK)
goto bail;
if (!fetched || !imap_code (idata->buf))
goto bail;
msg_cache_commit (idata, h);
parsemsg:
/* Update the header information. Previously, we only downloaded a
* portion of the headers, those required for the main display.
*/
rewind (msg->fp);
/* It may be that the Status header indicates a message is read, but the
* IMAP server doesn't know the message has been \Seen. So we capture
* the server's notion of 'read' and if it differs from the message info
* picked up in mutt_read_rfc822_header, we mark the message (and context
* changed). Another possibility: ignore Status on IMAP?*/
read = h->read;
newenv = mutt_read_rfc822_header (msg->fp, h, 0, 0);
mutt_merge_envelopes(h->env, &newenv);
/* see above. We want the new status in h->read, so we unset it manually
* and let mutt_set_flag set it correctly, updating context. */
if (read != h->read)
{
h->read = read;
mutt_set_flag (ctx, h, MUTT_NEW, read);
}
h->lines = 0;
fgets (buf, sizeof (buf), msg->fp);
while (!feof (msg->fp))
{
h->lines++;
fgets (buf, sizeof (buf), msg->fp);
}
h->content->length = ftell (msg->fp) - h->content->offset;
/* This needs to be done in case this is a multipart message */
#if defined(HAVE_PGP) || defined(HAVE_SMIME)
h->security = crypt_query (h->content);
#endif
mutt_clear_error();
rewind (msg->fp);
HEADER_DATA(h)->parsed = 1;
return 0;
bail:
safe_fclose (&msg->fp);
imap_cache_del (idata, h);
if (cache->path)
{
unlink (cache->path);
FREE (&cache->path);
}
return -1;
}
static int browse_get_namespace (IMAP_DATA* idata, char* nsbuf, int nsblen,
IMAP_NAMESPACE_INFO* nsi, int nsilen, int* nns)
{
char *s;
int n;
char ns[LONG_STRING];
char delim = '/';
int type;
int nsbused = 0;
int rc;
*nns = 0;
nsbuf[nsblen-1] = '\0';
imap_cmd_start (idata, "NAMESPACE");
do
{
if ((rc = imap_cmd_step (idata)) != IMAP_CMD_CONTINUE)
break;
s = imap_next_word (idata->cmd.buf);
if (ascii_strncasecmp ("NAMESPACE", s, 9) == 0)
{
/* There are three sections to the response, User, Other, Shared,
* and maybe more by extension */
for (type = IMAP_NS_PERSONAL; *s; type++)
{
s = imap_next_word (s);
if (*s && ascii_strncmp (s, "NIL", 3))
{
s++;
while (*s && *s != ')')
{
s++; /* skip ( */
/* copy namespace */
n = 0;
delim = '\0';
if (*s == '\"')
{
s++;
while (*s && *s != '\"')
{
if (*s == '\\')
s++;
ns[n++] = *s;
s++;
}
/* skip trailing ", if we found one, otherwise
* imap_next_word will get confused */
if (*s)
s++;
}
else
while (*s && !ISSPACE (*s))
{
ns[n++] = *s;
s++;
}
ns[n] = '\0';
/* delim? */
s = imap_next_word (s);
/* delimiter is meaningless if namespace is "". Why does
* Cyrus provide one?! */
if (n && *s && *s == '\"')
{
if (s[1] && s[2] == '\"')
delim = s[1];
else if (s[1] && s[1] == '\\' && s[2] && s[3] == '\"')
delim = s[2];
}
/* skip "" namespaces, they are already listed at the root */
if ((ns[0] != '\0') && (nsbused < nsblen) && (*nns < nsilen))
{
dprint (3, (debugfile, "browse_get_namespace: adding %s\n", ns));
nsi->type = type;
/* Cyrus doesn't append the delimiter to the namespace,
* but UW-IMAP does. We'll strip it here and add it back
* as if it were a normal directory, from the browser */
if (n && (ns[n-1] == delim))
ns[--n] = '\0';
strncpy (nsbuf+nsbused,ns,nsblen-nsbused-1);
nsi->prefix = nsbuf+nsbused;
nsbused += n+1;
nsi->delim = delim;
nsi++;
(*nns)++;
}
while (*s && *s != ')')
s++;
if (*s)
s++;
}
}
}
}
}
while (rc == IMAP_CMD_CONTINUE);
if (rc != IMAP_CMD_OK)
return -1;
return 0;
}
