lobo/isync
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d228fae394
isync/imap.c
Michael Elkins d228fae394 Updated the copyright notice to allow an exception for linking with OpenSSL, 
which has a non-GPL compatible license.
2002-10-30 02:31:20 +00:00

1373 lines
28 KiB
C
Raw Blame History

/* $Id$
*
* isync - IMAP4 to maildir mailbox synchronizer
* Copyright (C) 2000-2 Michael R. Elkins <me@mutt.org>
*
* 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-1307 USA
*
* As a special exception, isync may be linked with the OpenSSL library,
* despite that library's more restrictive license.
*/
#include <assert.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/time.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#if HAVE_LIBSSL
#include <openssl/err.h>
#endif
#include "isync.h"
const char *Flags[] = {
"\\Seen",
"\\Answered",
"\\Deleted",
"\\Flagged",
"\\Recent",
"\\Draft"
};
void
free_message (message_t * msg)
{
message_t *tmp;
while (msg)
{
tmp = msg;
msg = msg->next;
if (tmp->file)
free (tmp->file);
free (tmp);
}
}
#if HAVE_LIBSSL
#define MAX_DEPTH 1
SSL_CTX *SSLContext = 0;
/* this gets called when a certificate is to be verified */
static int
verify_cert (SSL * ssl)
{
X509 *cert;
int err;
char buf[256];
int ret = -1;
BIO *bio;
cert = SSL_get_peer_certificate (ssl);
if (!cert)
{
fprintf (stderr, "Error, no server certificate\n");
return -1;
}
err = SSL_get_verify_result (ssl);
if (err == X509_V_OK)
return 0;
fprintf (stderr, "Error, can't verify certificate: %s (%d)\n",
X509_verify_cert_error_string (err), err);
X509_NAME_oneline (X509_get_subject_name (cert), buf, sizeof (buf));
info ("\nSubject: %s\n", buf);
X509_NAME_oneline (X509_get_issuer_name (cert), buf, sizeof (buf));
info ("Issuer: %s\n", buf);
bio = BIO_new (BIO_s_mem ());
ASN1_TIME_print (bio, X509_get_notBefore (cert));
memset (buf, 0, sizeof (buf));
BIO_read (bio, buf, sizeof (buf) - 1);
info ("Valid from: %s\n", buf);
ASN1_TIME_print (bio, X509_get_notAfter (cert));
memset (buf, 0, sizeof (buf));
BIO_read (bio, buf, sizeof (buf) - 1);
BIO_free (bio);
info (" to: %s\n", buf);
fprintf (stderr,
"\n*** WARNING *** There is no way to verify this certificate. It is\n"
" possible that a hostile attacker has replaced the\n"
" server certificate. Continue at your own risk!\n"
"\nAccept this certificate anyway? [no]: ");
if (fgets (buf, sizeof (buf), stdin) && (buf[0] == 'y' || buf[0] == 'Y'))
{
ret = 0;
fprintf (stderr, "\n*** Fine, but don't say I didn't warn you!\n\n");
}
return ret;
}
static int
init_ssl (config_t * conf)
{
SSL_METHOD *method;
int options = 0;
if (!conf->cert_file)
{
fprintf (stderr, "Error, CertificateFile not defined\n");
return -1;
}
SSL_library_init ();
SSL_load_error_strings ();
if (conf->use_tlsv1 && !conf->use_sslv2 && !conf->use_sslv3)
method = TLSv1_client_method ();
else
method = SSLv23_client_method ();
SSLContext = SSL_CTX_new (method);
if (access (conf->cert_file, F_OK))
{
if (errno != ENOENT)
{
perror ("access");
return -1;
}
fprintf (stderr,
"*** Warning, CertificateFile doesn't exist, can't verify server certificates\n");
}
else
if (!SSL_CTX_load_verify_locations
(SSLContext, conf->cert_file, NULL))
{
fprintf (stderr, "Error, SSL_CTX_load_verify_locations: %s\n",
ERR_error_string (ERR_get_error (), 0));
return -1;
}
if (!conf->use_sslv2)
options |= SSL_OP_NO_SSLv2;
if (!conf->use_sslv3)
options |= SSL_OP_NO_SSLv3;
if (!conf->use_tlsv1)
options |= SSL_OP_NO_TLSv1;
SSL_CTX_set_options (SSLContext, options);
/* we check the result of the verification after SSL_connect() */
SSL_CTX_set_verify (SSLContext, SSL_VERIFY_NONE, 0);
return 0;
}
#endif /* HAVE_LIBSSL */
static int
socket_read (Socket_t * sock, char *buf, size_t len)
{
#if HAVE_LIBSSL
if (sock->use_ssl)
return SSL_read (sock->ssl, buf, len);
#endif
return read (sock->fd, buf, len);
}
static int
socket_write (Socket_t * sock, char *buf, size_t len)
{
#if HAVE_LIBSSL
if (sock->use_ssl)
return SSL_write (sock->ssl, buf, len);
#endif
return write (sock->fd, buf, len);
}
static void
socket_perror (const char *func, Socket_t *sock, int ret)
{
#if HAVE_LIBSSL
int err;
if (sock->use_ssl)
{
switch ((err = SSL_get_error (sock->ssl, ret)))
{
case SSL_ERROR_SYSCALL:
case SSL_ERROR_SSL:
if ((err = ERR_get_error ()) == 0)
{
if (ret == 0)
fprintf (stderr, "SSL_%s:got EOF\n", func);
else
fprintf (stderr, "SSL_%s:%d:%s\n", func,
errno, strerror (errno));
}
else
fprintf (stderr, "SSL_%s:%d:%s\n", func, err,
ERR_error_string (err, 0));
return;
default:
fprintf (stderr, "SSL_%s:%d:unhandled SSL error\n", func, err);
break;
}
return;
}
#else
(void) sock;
#endif
if (ret)
perror (func);
else
fprintf (stderr, "%s: unexpected EOF\n", func);
}
/* simple line buffering */
static int
buffer_gets (buffer_t * b, char **s)
{
int n;
int start = b->offset;
*s = b->buf + start;
for (;;)
{
/* make sure we have enough data to read the \r\n sequence */
if (b->offset + 1 >= b->bytes)
{
if (start != 0)
{
/* shift down used bytes */
*s = b->buf;
assert (start <= b->bytes);
n = b->bytes - start;
if (n)
memmove (b->buf, b->buf + start, n);
b->offset -= start;
b->bytes = n;
start = 0;
}
n =
socket_read (b->sock, b->buf + b->bytes,
sizeof (b->buf) - b->bytes);
if (n <= 0)
{
socket_perror ("read", b->sock, n);
return -1;
}
b->bytes += n;
}
if (b->buf[b->offset] == '\r')
{
assert (b->offset + 1 < b->bytes);
if (b->buf[b->offset + 1] == '\n')
{
b->buf[b->offset] = 0; /* terminate the string */
b->offset += 2; /* next line */
return 0;
}
}
b->offset++;
}
/* not reached */
}
static int
parse_fetch (imap_t * imap, list_t * list)
{
list_t *tmp;
unsigned int uid = 0;
unsigned int mask = 0;
unsigned int size = 0;
message_t *cur;
if (!is_list (list))
return -1;
for (tmp = list->child; tmp; tmp = tmp->next)
{
if (is_atom (tmp))
{
if (!strcmp ("UID", tmp->val))
{
tmp = tmp->next;
if (is_atom (tmp))
{
uid = atoi (tmp->val);
if (uid < imap->minuid)
{
/* already saw this message */
return 0;
}
else if (uid > imap->maxuid)
imap->maxuid = uid;
}
else
fprintf (stderr, "IMAP error: unable to parse UID\n");
}
else if (!strcmp ("FLAGS", tmp->val))
{
tmp = tmp->next;
if (is_list (tmp))
{
list_t *flags = tmp->child;
for (; flags; flags = flags->next)
{
if (is_atom (flags))
{
if (!strcmp ("\\Seen", flags->val))
mask |= D_SEEN;
else if (!strcmp ("\\Flagged", flags->val))
mask |= D_FLAGGED;
else if (!strcmp ("\\Deleted", flags->val))
mask |= D_DELETED;
else if (!strcmp ("\\Answered", flags->val))
mask |= D_ANSWERED;
else if (!strcmp ("\\Draft", flags->val))
mask |= D_DRAFT;
else if (!strcmp ("\\Recent", flags->val))
mask |= D_RECENT;
else
fprintf (stderr, "IMAP error: unknown flag %s\n",
flags->val);
}
else
fprintf (stderr, "IMAP error: unable to parse FLAGS list\n");
}
}
else
fprintf (stderr, "IMAP error: unable to parse FLAGS\n");
}
else if (!strcmp ("RFC822.SIZE", tmp->val))
{
tmp = tmp->next;
if (is_atom (tmp))
size = atol (tmp->val);
}
}
}
cur = calloc (1, sizeof (message_t));
cur->next = imap->msgs;
imap->msgs = cur;
if (mask & D_DELETED)
imap->deleted++;
cur->uid = uid;
cur->flags = mask;
cur->size = size;
return 0;
}
static void
parse_response_code (imap_t * imap, char *s)
{
char *arg;
if (*s != '[')
return; /* no response code */
s++;
arg = next_arg (&s);
if (!strcmp ("UIDVALIDITY", arg))
{
arg = next_arg (&s);
imap->uidvalidity = atol (arg);
}
else if (!strcmp ("ALERT", arg))
{
/* RFC2060 says that these messages MUST be displayed
* to the user
*/
fprintf (stderr, "*** IMAP ALERT *** %s\n", s);
}
}
static int
imap_exec (imap_t * imap, const char *fmt, ...)
{
va_list ap;
char tmp[256];
char buf[256];
char *cmd;
char *arg;
char *arg1;
config_t *box;
int n;
va_start (ap, fmt);
vsnprintf (tmp, sizeof (tmp), fmt, ap);
va_end (ap);
snprintf (buf, sizeof (buf), "%d %s\r\n", ++Tag, tmp);
if (Verbose)
printf (">>> %s", buf);
n = socket_write (imap->sock, buf, strlen (buf));
if (n <= 0)
{
socket_perror ("write", imap->sock, n);
return -1;
}
for (;;)
{
next:
if (buffer_gets (imap->buf, &cmd))
return -1;
if (Verbose)
puts (cmd);
arg = next_arg (&cmd);
if (*arg == '*')
{
arg = next_arg (&cmd);
if (!arg)
{
fprintf (stderr, "IMAP error: unable to parse untagged response\n");
return -1;
}
if (!strcmp ("NAMESPACE", arg))
{
imap->ns_personal = parse_list (cmd, &cmd);
imap->ns_other = parse_list (cmd, &cmd);
imap->ns_shared = parse_list (cmd, 0);
}
else if (!strcmp ("OK", arg) || !strcmp ("BAD", arg) ||
!strcmp ("NO", arg) || !strcmp ("BYE", arg) ||
!strcmp ("PREAUTH", arg))
{
parse_response_code (imap, cmd);
}
else if (!strcmp ("CAPABILITY", arg))
{
while ((arg = next_arg (&cmd)))
{
if (!strcmp ("UIDPLUS", arg))
imap->have_uidplus = 1;
#if HAVE_LIBSSL
else if (!strcmp ("STARTTLS", arg))
imap->have_starttls = 1;
else if (!strcmp ("AUTH=CRAM-MD5", arg))
imap->have_cram = 1;
else if (!strcmp ("NAMESPACE", arg))
imap->have_namespace = 1;
#endif
}
}
else if (!strcmp ("LIST", arg))
{
list_t *list, *lp;
int l;
list = parse_list (cmd, &cmd);
if (list->val == LIST)
for (lp = list->child; lp; lp = lp->next)
if (is_atom (lp) &&
!strcasecmp (lp->val, "\\NoSelect"))
{
free_list (list);
goto next;
}
free_list (list);
(void) next_arg (&cmd); /* skip delimiter */
arg = next_arg (&cmd);
l = strlen (global.folder);
if (memcmp (arg, global.folder, l))
goto next;
arg += l;
for (box = boxes; box; box = box->next)
if (!strcmp (box->box, arg))
goto next;
box = malloc (sizeof (config_t));
memcpy (box, &global, sizeof (config_t));
box->path = strdup (arg);
box->box = box->path;
box->next = boxes;
boxes = box;
}
else if ((arg1 = next_arg (&cmd)))
{
if (!strcmp ("EXISTS", arg1))
imap->count = atoi (arg);
else if (!strcmp ("RECENT", arg1))
imap->recent = atoi (arg);
else if (!strcmp ("FETCH", arg1))
{
list_t *list;
list = parse_list (cmd, 0);
if (parse_fetch (imap, list))
{
free_list (list);
return -1;
}
free_list (list);
}
}
else
{
fprintf (stderr, "IMAP error: unable to parse untagged response\n");
return -1;
}
}
#if HAVE_LIBSSL
else if (*arg == '+')
{
char *resp;
if (!imap->cram)
{
fprintf (stderr, "IMAP error, not doing CRAM-MD5 authentication\n");
return -1;
}
resp = cram (cmd, imap->box->user, imap->box->pass);
n = socket_write (imap->sock, resp, strlen (resp));
if (n <= 0)
{
socket_perror ("write", imap->sock, n);
return -1;
}
if (Verbose)
puts (resp);
n = socket_write (imap->sock, "\r\n", 2);
if (n <= 0)
{
socket_perror ("write", imap->sock, n);
return -1;
}
free (resp);
imap->cram = 0;
}
#endif
else if ((size_t) atol (arg) != Tag)
{
fprintf (stderr, "IMAP error: wrong tag\n");
return -1;
}
else
{
arg = next_arg (&cmd);
parse_response_code (imap, cmd);
if (!strcmp ("OK", arg))
return 0;
return -1;
}
}
/* not reached */
}
imap_t *
imap_connect (config_t * cfg)
{
int s, ret;
struct sockaddr_in addr;
struct hostent *he;
imap_t *imap;
char *arg, *rsp;
int preauth = 0;
#if HAVE_LIBSSL
int use_ssl = 0;
#endif
int a[2];
imap = calloc (1, sizeof (imap_t));
imap->box = cfg;
imap->sock = calloc (1, sizeof (Socket_t));
imap->buf = calloc (1, sizeof (buffer_t));
imap->buf->sock = imap->sock;
imap->sock->fd = -1;
/* open connection to IMAP server */
if (cfg->tunnel)
{
info ("Starting tunnel '%s'...", cfg->tunnel);
fflush (stdout);
if (socketpair (PF_UNIX, SOCK_STREAM, 0, a))
{
perror ("socketpair");
exit (1);
}
if (fork () == 0)
{
if (dup2 (a[0], 0) == -1 || dup2 (a[0], 1) == -1)
{
_exit (127);
}
close (a[0]);
close (a[1]);
execl ("/bin/sh", "sh", "-c", cfg->tunnel, 0);
_exit (127);
}
close (a[0]);
imap->sock->fd = a[1];
info ("ok\n");
}
else
{
memset (&addr, 0, sizeof (addr));
addr.sin_port = htons (cfg->port);
addr.sin_family = AF_INET;
info ("Resolving %s... ", cfg->host);
fflush (stdout);
he = gethostbyname (cfg->host);
if (!he)
{
perror ("gethostbyname");
goto bail;
}
info ("ok\n");
addr.sin_addr.s_addr = *((int *) he->h_addr_list[0]);
s = socket (PF_INET, SOCK_STREAM, 0);
info ("Connecting to %s:%hu... ", inet_ntoa (addr.sin_addr),
ntohs (addr.sin_port));
fflush (stdout);
if (connect (s, (struct sockaddr *) &addr, sizeof (addr)))
{
close (s);
perror ("connect");
goto bail;
}
info ("ok\n");
imap->sock->fd = s;
}
/* read the greeting string */
if (buffer_gets (imap->buf, &rsp))
{
fprintf (stderr, "IMAP error: no greeting response\n");
goto bail;
}
if (Verbose)
puts (rsp);
arg = next_arg (&rsp);
if (!arg || *arg != '*' || (arg = next_arg (&rsp)) == NULL)
{
fprintf (stderr, "IMAP error: invalid greeting response\n");
goto bail;
}
if (!strcmp ("PREAUTH", arg))
preauth = 1;
else if (strcmp ("OK", arg) != 0)
{
fprintf (stderr, "IMAP error: unknown greeting response\n");
goto bail;
}
#if HAVE_LIBSSL
if (cfg->use_imaps)
use_ssl = 1;
else
{
/* let's see what this puppy can do... */
if (imap_exec (imap, "CAPABILITY"))
goto bail;
if (cfg->use_sslv2 || cfg->use_sslv3 || cfg->use_tlsv1)
{
/* always try to select SSL support if available */
if (imap->have_starttls)
{
if (imap_exec (imap, "STARTTLS"))
goto bail;
use_ssl = 1;
}
}
}
if (!use_ssl)
{
if (cfg->require_ssl)
{
fprintf (stderr, "IMAP error: SSL support not available\n");
goto bail;
}
else if (cfg->use_sslv2 || cfg->use_sslv3 || cfg->use_tlsv1)
fprintf (stderr, "IMAP warning: SSL support not available\n");
}
else
{
/* initialize SSL */
if (init_ssl (cfg))
goto bail;
imap->sock->ssl = SSL_new (SSLContext);
SSL_set_fd (imap->sock->ssl, imap->sock->fd);
if ((ret = SSL_connect (imap->sock->ssl)) <= 0)
{
socket_perror ("connect", imap->sock, ret);
goto bail;
}
/* verify the server certificate */
if (verify_cert (imap->sock->ssl))
goto bail;
/* to conform to RFC2595 we need to forget all information
* retrieved from CAPABILITY invocations before STARTTLS.
*/
imap->have_uidplus = 0;
imap->have_namespace = 0;
imap->have_cram = 0;
imap->have_starttls = 0;
imap->sock->use_ssl = 1;
puts ("SSL support enabled");
if (imap_exec (imap, "CAPABILITY"))
goto bail;
}
#else
if (imap_exec (imap, "CAPABILITY"))
goto bail;
#endif
if (!preauth)
{
info ("Logging in...\n");
if (!cfg->pass)
{
/*
* if we don't have a global password set, prompt the user for
* it now.
*/
if (!global.pass)
{
global.pass = getpass ("Password:");
if (!global.pass)
{
perror ("getpass");
exit (1);
}
if (!*global.pass)
{
fprintf (stderr, "Skipping %s, no password\n", cfg->path);
global.pass = NULL; /* force retry */
goto bail;
}
/*
* getpass() returns a pointer to a static buffer. make a copy
* for long term storage.
*/
global.pass = strdup (global.pass);
}
cfg->pass = strdup (global.pass);
}
#if HAVE_LIBSSL
if (imap->have_cram)
{
info ("Authenticating with CRAM-MD5\n");
imap->cram = 1;
if (imap_exec (imap, "AUTHENTICATE CRAM-MD5"))
goto bail;
}
else if (imap->box->require_cram)
{
fprintf (stderr, "IMAP error: CRAM-MD5 authentication is not supported by server\n");
goto bail;
}
else
#endif
{
#if HAVE_LIBSSL
if (!use_ssl)
#endif
fprintf (stderr, "*** IMAP Warning *** Password is being sent in the clear\n");
if (imap_exec (imap, "LOGIN \"%s\" \"%s\"", cfg->user, cfg->pass))
{
fprintf (stderr, "IMAP error: LOGIN failed\n");
goto bail;
}
}
}
/* get NAMESPACE info */
if (cfg->use_namespace && imap->have_namespace)
{
if (imap_exec (imap, "NAMESPACE"))
goto bail;
}
return imap;
bail:
imap_close (imap);
return 0;
}
/* `box' is the config info for the maildrop to sync. `minuid' is the
* minimum UID to consider. in normal mode this will be 1, but in --fast
* mode we only fetch messages newer than the last one seen in the local
* mailbox.
*/
imap_t *
imap_open (config_t * box, unsigned int minuid, imap_t * imap, int imap_create)
{
if (imap)
{
/* determine whether or not we can reuse the existing session */
if (strcmp (box->host, imap->box->host) ||
strcmp (box->user, imap->box->user) ||
box->port != imap->box->port
#if HAVE_LIBSSL
/* ensure that security requirements are met */
|| (box->require_ssl ^ imap->box->require_ssl)
|| (box->require_cram ^ imap->box->require_cram)
#endif
)
{
/* can't reuse */
imap_close (imap);
}
else
{
/* reset mailbox-specific state info */
imap->box = box;
imap->recent = 0;
imap->deleted = 0;
imap->count = 0;
imap->maxuid = 0;
free_message (imap->msgs);
imap->msgs = 0;
goto gotimap;
}
}
if (!(imap = imap_connect (box)))
return 0;
gotimap:
if (global.folder)
imap->prefix = !strcmp (box->box, "INBOX") ? "" : global.folder;
else
{
imap->prefix = "";
/* XXX for now assume personal namespace */
if (imap->box->use_namespace &&
is_list (imap->ns_personal) &&
is_list (imap->ns_personal->child) &&
is_atom (imap->ns_personal->child->child))
imap->prefix = imap->ns_personal->child->child->val;
}
info ("Selecting IMAP mailbox... ");
fflush (stdout);
if (imap_exec (imap, "SELECT \"%s%s\"", imap->prefix, box->box)) {
if (imap_create) {
if (imap_exec (imap, "CREATE \"%s%s\"", imap->prefix, box->box))
goto bail;
if (imap_exec (imap, "SELECT \"%s%s\"", imap->prefix, box->box))
goto bail;
} else
goto bail;
}
info ("%d messages, %d recent\n", imap->count, imap->recent);
info ("Reading IMAP mailbox index\n");
imap->minuid = minuid;
if (imap->count > 0)
{
if (imap_exec (imap, "UID FETCH %d:* (FLAGS RFC822.SIZE)", minuid))
goto bail;
}
return imap;
bail:
imap_close (imap);
return 0;
}
void
imap_close (imap_t * imap)
{
if (imap)
{
if (imap->sock->fd != -1)
{
imap_exec (imap, "LOGOUT");
close (imap->sock->fd);
}
free (imap->sock);
free (imap->buf);
free_message (imap->msgs);
memset (imap, 0xff, sizeof (imap_t));
free (imap);
}
}
/* write a buffer stripping all \r bytes */
static int
write_strip (int fd, char *buf, size_t len)
{
size_t start = 0;
size_t end = 0;
ssize_t n;
while (start < len)
{
while (end < len && buf[end] != '\r')
end++;
n = write (fd, buf + start, end - start);
if (n == -1)
{
perror ("write");
return -1;
}
else if ((size_t) n != end - start)
{
/* short write, try again */
start += n;
}
else
{
/* write complete */
end++;
start = end;
}
}
return 0;
}
static int
send_server (Socket_t * sock, const char *fmt, ...)
{
char buf[128];
char cmd[128];
va_list ap;
int n;
va_start (ap, fmt);
vsnprintf (buf, sizeof (buf), fmt, ap);
va_end (ap);
snprintf (cmd, sizeof (cmd), "%d %s\r\n", ++Tag, buf);
n = socket_write (sock, cmd, strlen (cmd));
if (n <= 0)
{
socket_perror ("write", sock, n);
return -1;
}
if (Verbose)
fputs (cmd, stdout);
return 0;
}
int
imap_fetch_message (imap_t * imap, unsigned int uid, int fd)
{
char *cmd;
char *arg;
size_t bytes;
size_t n;
char buf[1024];
send_server (imap->sock, "UID FETCH %d BODY.PEEK[]", uid);
for (;;)
{
if (buffer_gets (imap->buf, &cmd))
return -1;
if (Verbose)
puts (cmd);
if (*cmd == '*')
{
/* need to figure out how long the message is
* * <msgno> FETCH (RFC822 {<size>}
*/
next_arg (&cmd); /* * */
next_arg (&cmd); /* <msgno> */
arg = next_arg (&cmd); /* FETCH */
if (strcasecmp ("FETCH", arg) != 0)
{
/* this is likely an untagged response, such as when new
* mail arrives in the middle of the session. just skip
* it for now.
*
* eg.,
* "* 4000 EXISTS"
* "* 2 RECENT"
*
*/
info ("IMAP info: skipping untagged response: %s\n", arg);
continue;
}
while ((arg = next_arg (&cmd)) && *arg != '{')
;
if (!arg)
{
fprintf (stderr, "IMAP error: parse error getting size\n");
return -1;
}
bytes = strtol (arg + 1, 0, 10);
/* dump whats left over in the input buffer */
n = imap->buf->bytes - imap->buf->offset;
if (n > bytes)
{
/* the entire message fit in the buffer */
n = bytes;
}
/* ick. we have to strip out the \r\n line endings, so
* i can't just dump the raw bytes to disk.
*/
if (write_strip (fd, imap->buf->buf + imap->buf->offset, n))
{
/* write failed, message is not delivered */
return -1;
}
bytes -= n;
/* mark that we used part of the buffer */
imap->buf->offset += n;
/* now read the rest of the message */
while (bytes > 0)
{
n = bytes;
if (n > sizeof (buf))
n = sizeof (buf);
n = socket_read (imap->sock, buf, n);
if (n > 0)
{
if (write_strip (fd, buf, n))
{
/* write failed */
return -1;
}
bytes -= n;
}
else
{
socket_perror ("read", imap->sock, n);
return -1;
}
}
buffer_gets (imap->buf, &cmd);
if (Verbose)
puts (cmd); /* last part of line */
}
else
{
arg = next_arg (&cmd);
if (!arg || (size_t) atoi (arg) != Tag)
{
fprintf (stderr, "IMAP error: wrong tag\n");
return -1;
}
arg = next_arg (&cmd);
if (!strcmp ("OK", arg))
return 0;
return -1;
}
}
/* not reached */
}
/* add flags to existing flags */
int
imap_set_flags (imap_t * imap, unsigned int uid, unsigned int flags)
{
char buf[256];
int i;
buf[0] = 0;
for (i = 0; i < D_MAX; i++)
{
if (flags & (1 << i))
snprintf (buf + strlen (buf),
sizeof (buf) - strlen (buf), "%s%s",
(buf[0] != 0) ? " " : "", Flags[i]);
}
return imap_exec (imap, "UID STORE %d +FLAGS.SILENT (%s)", uid, buf);
}
int
imap_expunge (imap_t * imap)
{
return imap_exec (imap, "EXPUNGE");
}
int
imap_copy_message (imap_t * imap, unsigned int uid, const char *mailbox)
{
return imap_exec (imap, "UID COPY %u \"%s%s\"", uid, imap->prefix,
mailbox);
}
int
imap_append_message (imap_t * imap, int fd, message_t * msg)
{
char *fmap;
int extra, uid, tuidl = 0;
char flagstr[128], tuid[128];
char *s;
size_t i;
size_t start;
size_t len, sbreak = 0, ebreak = 0;
char *arg;
struct timeval tv;
pid_t pid = getpid();
len = msg->size;
/* ugh, we need to count the number of newlines */
fmap = (char *)mmap (0, len, PROT_READ, MAP_PRIVATE, fd, 0);
if (!fmap)
{
perror ("mmap");
return -1;
}
extra = 0, i = 0;
if (!imap->have_uidplus)
{
nloop:
start = i;
while (i < len)
if (fmap[i++] == '\n')
{
extra++;
if (i - 1 == start)
{
sbreak = ebreak = i - 1;
goto mktid;
}
if (!memcmp (fmap + start, "X-TUID: ", 8))
{
extra -= (ebreak = i) - (sbreak = start) + 1;
goto mktid;
}
goto nloop;
}
/* invalid mesasge */
goto bail;
mktid:
gettimeofday (&tv, 0);
tuidl = sprintf (tuid, "X-TUID: %08lx%05lx%04x\r\n",
tv.tv_sec, tv.tv_usec, pid);
extra += tuidl;
}
for (; i < len; i++)
if (fmap[i] == '\n')
extra++;
flagstr[0] = 0;
if (msg->flags)
{
if (msg->flags & D_DELETED)
strcat (flagstr," \\Deleted");
if (msg->flags & D_ANSWERED)
strcat (flagstr," \\Answered");
if (msg->flags & D_SEEN)
strcat (flagstr," \\Seen");
if (msg->flags & D_FLAGGED)
strcat (flagstr," \\Flagged");
if (msg->flags & D_DRAFT)
strcat (flagstr," \\Draft");
flagstr[0] = '(';
strcat (flagstr,") ");
}
send_server (imap->sock, "APPEND %s%s %s{%d}",
imap->prefix, imap->box->box, flagstr, len + extra);
if (buffer_gets (imap->buf, &s))
goto bail;
if (Verbose)
puts (s);
if (*s != '+')
{
fprintf (stderr, "IMAP error: expected `+' from server (aborting)\n");
goto bail;
}
i = 0;
if (!imap->have_uidplus)
{
n1loop:
start = i;
while (i < sbreak)
if (fmap[i++] == '\n')
{
socket_write (imap->sock, fmap + start, i - 1 - start);
socket_write (imap->sock, "\r\n", 2);
goto n1loop;
}
socket_write (imap->sock, tuid, tuidl);
i = ebreak;
}
n2loop:
start = i;
while (i < len)
if (fmap[i++] == '\n')
{
socket_write (imap->sock, fmap + start, i - 1 - start);
socket_write (imap->sock, "\r\n", 2);
goto n2loop;
}
socket_write (imap->sock, fmap + start, len - start);
socket_write (imap->sock, "\r\n", 2);
munmap (fmap, len);
for (;;)
{
if (buffer_gets (imap->buf, &s))
return -1;
if (Verbose)
puts (s);
arg = next_arg (&s);
if (*arg == '*')
{
/* XXX just ignore it for now */
}
else if (atoi (arg) != (int) Tag)
{
fprintf (stderr, "IMAP error: wrong tag\n");
return -1;
}
else
{
arg = next_arg (&s);
if (strcmp (arg, "OK"))
return -1;
arg = next_arg (&s);
if (*arg != '[')
break;
arg++;
if (strcasecmp ("APPENDUID", arg))
{
fprintf (stderr, "IMAP error: expected APPENDUID\n");
break;
}
arg = next_arg (&s);
if (!arg)
break;
if (atoi (arg) != (int) imap->uidvalidity)
{
fprintf (stderr, "IMAP error: UIDVALIDITY doesn't match APPENDUID\n");
return -1;
}
arg = next_arg (&s);
if (!arg)
break;
uid = strtol (arg, &s, 10);
if (*s != ']')
{
/* parse error */
break;
}
return uid;
}
}
/* didn't receive an APPENDUID */
send_server (imap->sock,
"UID SEARCH HEADER X-TUID %08lx%05lx%04x",
tv.tv_sec, tv.tv_usec, pid);
uid = 0;
for (;;)
{
if (buffer_gets (imap->buf, &s))
return -1;
if (Verbose)
puts (s);
arg = next_arg (&s);
if (*arg == '*')
{
arg = next_arg (&s);
if (!strcmp (arg, "SEARCH"))
{
arg = next_arg (&s);
if (!arg)
{
fprintf (stderr, "IMAP error: incomplete SEARCH response\n");
return -1;
}
uid = atoi (arg);
}
}
else if (atoi (arg) != (int) Tag)
{
fprintf (stderr, "IMAP error: wrong tag\n");
return -1;
}
else
{
arg = next_arg (&s);
if (strcmp (arg, "OK"))
return -1;
return uid;
}
}
return 0;
bail:
munmap (fmap, len);
return -1;
}
int
imap_list (imap_t * imap)
{
return imap_exec (imap, "LIST \"\" \"%s*\"", global.folder);
}
Reference in New Issue View Git Blame Copy Permalink