/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* camel-imap-command.c: IMAP command sending/parsing routines */
/*
* Authors:
* Dan Winship <danw@ximian.com>
* Jeffrey Stedfast <fejj@ximian.com>
*
* Copyright 2000, 2001 Ximian, Inc.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
* License as published by the Free Software Foundation.
*
* 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.
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include "camel-imap-command.h"
#include "camel-imap-utils.h"
#include "camel-imap-folder.h"
#include "camel-imap-store.h"
#include "camel-imap-private.h"
#include <camel/camel-exception.h>
static gboolean imap_command_start (CamelImapStore *store, CamelFolder *folder,
const char *cmd, CamelException *ex);
CamelImapResponse *imap_read_response (CamelImapStore *store,
CamelException *ex);
static char *imap_read_untagged (CamelImapStore *store, char *line,
CamelException *ex);
static char *imap_command_strdup_vprintf (CamelImapStore *store,
const char *fmt, va_list ap);
static char *imap_command_strdup_printf (CamelImapStore *store,
const char *fmt, ...);
/**
* camel_imap_command:
* @store: the IMAP store
* @folder: The folder to perform the operation in (or %NULL if not
* relevant).
* @ex: a CamelException
* @fmt: a sort of printf-style format string, followed by arguments
*
* This function calls camel_imap_command_start() to send the
* command, then reads the complete response to it using
* camel_imap_command_response() and returns a CamelImapResponse
* structure.
*
* As a special case, if @fmt is %NULL, it will just select @folder
* and return the response from doing so.
*
* See camel_imap_command_start() for details on @fmt.
*
* On success, the store's command_lock will be locked. It will be freed
* when you call camel_imap_response_free. (The lock is recursive, so
* callers can grab and release it themselves if they need to run
* multiple commands atomically.)
*
* Return value: %NULL if an error occurred (in which case @ex will
* be set). Otherwise, a CamelImapResponse describing the server's
* response, which the caller must free with camel_imap_response_free().
**/
CamelImapResponse *
camel_imap_command (CamelImapStore *store, CamelFolder *folder,
CamelException *ex, const char *fmt, ...)
{
va_list ap;
char *cmd;
CAMEL_IMAP_STORE_LOCK (store, command_lock);
if (fmt) {
va_start (ap, fmt);
cmd = imap_command_strdup_vprintf (store, fmt, ap);
va_end (ap);
} else {
if (store->current_folder) {
camel_object_unref (CAMEL_OBJECT (store->current_folder));
store->current_folder = NULL;
}
store->current_folder = folder;
camel_object_ref (CAMEL_OBJECT (folder));
cmd = imap_command_strdup_printf (store, "SELECT %F",
folder->full_name);
}
if (!imap_command_start (store, folder, cmd, ex)) {
g_free (cmd);
CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
return NULL;
}
g_free (cmd);
return imap_read_response (store, ex);
}
/**
* camel_imap_command_start:
* @store: the IMAP store
* @folder: The folder to perform the operation in (or %NULL if not
* relevant).
* @ex: a CamelException
* @fmt: a sort of printf-style format string, followed by arguments
*
* This function makes sure that @folder (if non-%NULL) is the
* currently-selected folder on @store and then sends the IMAP command
* specified by @fmt and the following arguments.
*
* @fmt can include the following %-escapes ONLY:
* %s, %d, %%: as with printf
* %S: an IMAP "string" (quoted string or literal)
* %F: an IMAP folder name
*
* %S strings will be passed as literals if the server supports LITERAL+
* and quoted strings otherwise. (%S does not support strings that
* contain newlines.)
*
* %F will have the imap store's namespace prepended and then be processed
* like %S.
*
* On success, the store's command_lock will be locked. It will be
* freed when %CAMEL_IMAP_RESPONSE_TAGGED or %CAMEL_IMAP_RESPONSE_ERROR
* is returned from camel_imap_command_response(). (The lock is
* recursive, so callers can grab and release it themselves if they
* need to run multiple commands atomically.)
*
* Return value: %TRUE if the command was sent successfully, %FALSE if
* an error occurred (in which case @ex will be set).
**/
gboolean
camel_imap_command_start (CamelImapStore *store, CamelFolder *folder,
CamelException *ex, const char *fmt, ...)
{
va_list ap;
char *cmd;
gboolean ok;
va_start (ap, fmt);
cmd = imap_command_strdup_vprintf (store, fmt, ap);
va_end (ap);
CAMEL_IMAP_STORE_LOCK (store, command_lock);
ok = imap_command_start (store, folder, cmd, ex);
g_free (cmd);
if (!ok)
CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
return ok;
}
static gboolean
imap_command_start (CamelImapStore *store, CamelFolder *folder,
const char *cmd, CamelException *ex)
{
/* Check for current folder */
if (folder && folder != store->current_folder) {
CamelImapResponse *response;
CamelException internal_ex;
response = camel_imap_command (store, folder, ex, NULL);
if (!response)
return FALSE;
camel_exception_init (&internal_ex);
camel_imap_folder_selected (folder, response, &internal_ex);
camel_imap_response_free (store, response);
if (camel_exception_is_set (&internal_ex)) {
camel_exception_xfer (ex, &internal_ex);
return FALSE;
}
}
/* Send the command */
return camel_remote_store_send_string (CAMEL_REMOTE_STORE (store), ex,
"%c%.5d %s\r\n",
store->tag_prefix,
store->command++, cmd) != -1;
}
/**
* camel_imap_command_continuation:
* @store: the IMAP store
* @cmd: buffer containing the response/request data
* @cmdlen: command length
* @ex: a CamelException
*
* This method is for sending continuing responses to the IMAP server
* after camel_imap_command() or camel_imap_command_response() returns
* a continuation response.
*
* This function assumes you have an exclusive lock on the remote stream.
*
* Return value: as for camel_imap_command(). On failure, the store's
* command_lock will be released.
**/
CamelImapResponse *
camel_imap_command_continuation (CamelImapStore *store, const char *cmd,
size_t cmdlen, CamelException *ex)
{
CamelStream *stream;
if (!camel_remote_store_connected (CAMEL_REMOTE_STORE (store), ex))
return NULL;
stream = CAMEL_REMOTE_STORE (store)->ostream;
if (camel_stream_write (stream, cmd, cmdlen) == -1 ||
camel_stream_write (stream, "\r\n", 2) == -1) {
if (errno == EINTR)
camel_exception_set (ex, CAMEL_EXCEPTION_USER_CANCEL,
_("Operation cancelled"));
else
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
g_strerror (errno));
camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
return NULL;
}
return imap_read_response (store, ex);
}
/**
* camel_imap_command_response:
* @store: the IMAP store
* @response: a pointer to pass back the response data in
* @ex: a CamelException
*
* This reads a single tagged, untagged, or continuation response from
* @store into *@response. The caller must free the string when it is
* done with it.
*
* Return value: One of %CAMEL_IMAP_RESPONSE_CONTINUATION,
* %CAMEL_IMAP_RESPONSE_UNTAGGED, %CAMEL_IMAP_RESPONSE_TAGGED, or
* %CAMEL_IMAP_RESPONSE_ERROR. If either of the last two, @store's
* command lock will be unlocked.
**/
CamelImapResponseType
camel_imap_command_response (CamelImapStore *store, char **response,
CamelException *ex)
{
CamelImapResponseType type;
char *respbuf;
if (camel_remote_store_recv_line (CAMEL_REMOTE_STORE (store),
&respbuf, ex) < 0) {
CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
return CAMEL_IMAP_RESPONSE_ERROR;
}
switch (*respbuf) {
case '*':
if (!g_strncasecmp (respbuf, "* BYE", 5)) {
/* Connection was lost, no more data to fetch */
camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("Server unexpectedly disconnected: %s"),
_("Unknown error")); /* g_strerror (104)); FIXME after 1.0 is released */
store->connected = FALSE;
g_free (respbuf);
respbuf = NULL;
type = CAMEL_IMAP_RESPONSE_ERROR;
break;
}
/* Read the rest of the response. */
type = CAMEL_IMAP_RESPONSE_UNTAGGED;
respbuf = imap_read_untagged (store, respbuf, ex);
if (!respbuf)
type = CAMEL_IMAP_RESPONSE_ERROR;
break;
case '+':
type = CAMEL_IMAP_RESPONSE_CONTINUATION;
break;
default:
type = CAMEL_IMAP_RESPONSE_TAGGED;
break;
}
*response = respbuf;
if (type == CAMEL_IMAP_RESPONSE_ERROR ||
type == CAMEL_IMAP_RESPONSE_TAGGED)
CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
return type;
}
CamelImapResponse *
imap_read_response (CamelImapStore *store, CamelException *ex)
{
CamelImapResponse *response;
CamelImapResponseType type;
char *respbuf, *p;
/* Get another lock so that when we reach the tagged
* response and camel_imap_command_response unlocks,
* we're still locked. This lock is owned by response
* and gets unlocked when response is freed.
*/
CAMEL_IMAP_STORE_LOCK (store, command_lock);
response = g_new0 (CamelImapResponse, 1);
if (store->current_folder && camel_disco_store_status (CAMEL_DISCO_STORE (store)) != CAMEL_DISCO_STORE_RESYNCING) {
response->folder = store->current_folder;
camel_object_ref (CAMEL_OBJECT (response->folder));
}
response->untagged = g_ptr_array_new ();
while ((type = camel_imap_command_response (store, &respbuf, ex))
== CAMEL_IMAP_RESPONSE_UNTAGGED)
g_ptr_array_add (response->untagged, respbuf);
if (type == CAMEL_IMAP_RESPONSE_ERROR) {
camel_imap_response_free_without_processing (store, response);
return NULL;
}
response->status = respbuf;
/* Check for OK or continuation response. */
if (*respbuf == '+')
return response;
p = strchr (respbuf, ' ');
if (p && !g_strncasecmp (p, " OK", 3))
return response;
/* We should never get BAD, or anything else but +, OK, or NO
* for that matter.
*/
if (!p || g_strncasecmp (p, " NO", 3) != 0) {
g_warning ("Unexpected response from IMAP server: %s",
respbuf);
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("Unexpected response from IMAP "
"server: %s"), respbuf);
camel_imap_response_free_without_processing (store, response);
return NULL;
}
p += 3;
if (!*p++)
p = NULL;
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("IMAP command failed: %s"),
p ? p : _("Unknown error"));
camel_imap_response_free_without_processing (store, response);
return NULL;
}
/* Given a line that is the start of an untagged response, read and
* return the complete response, which may include an arbitrary number
* of literals.
*/
static char *
imap_read_untagged (CamelImapStore *store, char *line, CamelException *ex)
{
int fulllen, length, ldigits, nread, i;
GPtrArray *data;
GString *str;
char *end, *p, *s, *d;
p = strrchr (line, '{');
if (!p)
return line;
data = g_ptr_array_new ();
fulllen = 0;
while (1) {
str = g_string_new (line);
g_free (line);
fulllen += str->len;
g_ptr_array_add (data, str);
p = strrchr (str->str, '{');
if (!p)
break;
length = strtoul (p + 1, &end, 10);
if (*end != '}' || *(end + 1) || end == p + 1)
break;
ldigits = end - (p + 1);
/* Read the literal */
str = g_string_sized_new (length + 2);
str->str[0] = '\n';
nread = camel_stream_read (CAMEL_REMOTE_STORE (store)->istream,
str->str + 1, length);
if (nread == -1) {
if (errno == EINTR)
camel_exception_set (ex, CAMEL_EXCEPTION_USER_CANCEL, _("Operation cancelled"));
else
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE, g_strerror (errno));
camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
goto lose;
}
if (nread < length) {
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("Server response ended too soon."));
camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
goto lose;
}
str->str[length + 1] = '\0';
/* Fix up the literal, turning CRLFs into LF. Also, if
* we find any embedded NULs, strip them. This is
* dubious, but:
* - The IMAP grammar says you can't have NULs here
* anyway, so this will not affect our behavior
* against any completely correct server.
* - WU-imapd 12.264 (at least) will cheerily pass
* NULs along if they are embedded in the message
* - The only cause of embedded NULs we've seen is an
* Evolution base64-encoder bug that sometimes
* inserts a NUL into the last line when it
* shouldn't.
*/
s = d = str->str + 1;
end = str->str + 1 + length;
while (s < end) {
while (s < end && *s == '\0') {
s++;
length--;
}
if (*s == '\r' && *(s + 1) == '\n') {
s++;
length--;
}
*d++ = *s++;
}
*d = '\0';
str->len = length + 1;
/* p points to the "{" in the line that starts the
* literal. The length of the CR-less response must be
* less than or equal to the length of the response
* with CRs, therefore overwriting the old value with
* the new value cannot cause an overrun. However, we
* don't want it to be shorter either, because then the
* GString's length would be off...
*/
sprintf (p, "{%0*d}", ldigits, length);
fulllen += str->len;
g_ptr_array_add (data, str);
/* Read the next line. */
if (camel_remote_store_recv_line (CAMEL_REMOTE_STORE (store),
&line, ex) < 0)
goto lose;
}
/* Now reassemble the data. */
p = line = g_malloc (fulllen + 1);
for (i = 0; i < data->len; i++) {
str = data->pdata[i];
memcpy (p, str->str, str->len);
p += str->len;
g_string_free (str, TRUE);
}
*p = '\0';
g_ptr_array_free (data, TRUE);
return line;
lose:
for (i = 0; i < data->len; i++)
g_string_free (data->pdata[i], TRUE);
g_ptr_array_free (data, TRUE);
return NULL;
}
/**
* camel_imap_response_free:
* @store: the CamelImapStore the response is from
* @response: a CamelImapResponse
*
* Frees all of the data in @response and processes any untagged
* EXPUNGE and EXISTS responses in it. Releases @store's command_lock.
**/
void
camel_imap_response_free (CamelImapStore *store, CamelImapResponse *response)
{
int i, number, exists = 0;
GArray *expunged = NULL;
char *resp, *p;
if (!response)
return;
for (i = 0; i < response->untagged->len; i++) {
resp = response->untagged->pdata[i];
if (response->folder) {
/* Check if it's something we need to handle. */
number = strtoul (resp + 2, &p, 10);
if (!g_strcasecmp (p, " EXISTS")) {
exists = number;
} else if (!g_strcasecmp (p, " EXPUNGE")) {
if (!expunged) {
expunged = g_array_new (FALSE, FALSE,
sizeof (int));
}
g_array_append_val (expunged, number);
}
}
g_free (resp);
}
g_ptr_array_free (response->untagged, TRUE);
g_free (response->status);
if (response->folder) {
if (exists > 0 || expunged) {
/* Update the summary */
camel_imap_folder_changed (response->folder,
exists, expunged, NULL);
if (expunged)
g_array_free (expunged, TRUE);
}
camel_object_unref (CAMEL_OBJECT (response->folder));
}
g_free (response);
CAMEL_IMAP_STORE_UNLOCK (store, command_lock);
}
/**
* camel_imap_response_free_without_processing:
* @store: the CamelImapStore the response is from.
* @response: a CamelImapResponse:
*
* Frees all of the data in @response without processing any untagged
* responses. Releases @store's command lock.
**/
void
camel_imap_response_free_without_processing (CamelImapStore *store,
CamelImapResponse *response)
{
if (response->folder) {
camel_object_unref (CAMEL_OBJECT (response->folder));
response->folder = NULL;
}
camel_imap_response_free (store, response);
}
/**
* 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 command_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_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;
}
/**
* camel_imap_response_extract_continuation:
* @store: the store the response came from
* @response: the response data returned from camel_imap_command
* @ex: a CamelException
*
* This checks that @response contains a continuation response, and
* returns just that data. If @response doesn't contain a continuation
* response, the function will set @ex, release @store's command_lock,
* and return %NULL. Either way, @response will be freed.
*
* Return value: the desired response string, which the caller must free.
**/
char *
camel_imap_response_extract_continuation (CamelImapStore *store,
CamelImapResponse *response,
CamelException *ex)
{
char *status;
if (response->status && *response->status == '+') {
status = response->status;
response->status = NULL;
camel_imap_response_free (store, response);
return status;
}
camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
_("Unexpected OK response from IMAP server: %s"),
response->status);
camel_imap_response_free (store, response);
return NULL;
}
static char *
imap_command_strdup_vprintf (CamelImapStore *store, const char *fmt,
va_list ap)
{
GPtrArray *args;
const char *p, *start;
char *out, *op, *string;
int num, len, i, arglen;
args = g_ptr_array_new ();
/* Determine the length of the data */
len = strlen (fmt);
p = start = fmt;
while (*p) {
p = strchr (start, '%');
if (!p)
break;
switch (*++p) {
case 'd':
num = va_arg (ap, int);
g_ptr_array_add (args, GINT_TO_POINTER (num));
start = p + 1;
len += 10;
break;
case 's':
string = va_arg (ap, char *);
g_ptr_array_add (args, string);
start = p + 1;
len += strlen (string);
break;
case 'S':
case 'F':
string = va_arg (ap, char *);
arglen = strlen (string);
if (*p == 'F') {
if (store->namespace == NULL) {
if (*string != '\0') /*ok if foldername is "" */
g_warning ("trying to list folder \"%s\" but no namespace. Hope for the best", string);
arglen += 2;
} else
arglen += strlen (store->namespace) + 1;
}
g_ptr_array_add (args, string);
if (imap_is_atom(string)) {
len += arglen;
} else {
if (store->capabilities & IMAP_CAPABILITY_LITERALPLUS)
len += arglen + 15;
else
len += arglen * 2;
}
start = p + 1;
break;
case '%':
start = p;
break;
default:
g_warning ("camel-imap-command is not printf. I don't "
"know what '%%%c' means.", *p);
start = *p ? p + 1 : p;
break;
}
}
/* Now write out the string */
op = out = g_malloc (len + 1);
p = start = fmt;
i = 0;
while (*p) {
p = strchr (start, '%');
if (!p) {
strcpy (op, start);
break;
} else {
strncpy (op, start, p - start);
op += p - start;
}
switch (*++p) {
case 'd':
num = GPOINTER_TO_INT (args->pdata[i++]);
op += sprintf (op, "%d", num);
break;
case 's':
string = args->pdata[i++];
op += sprintf (op, "%s", string);
break;
case 'S':
case 'F':
string = args->pdata[i++];
if (*p == 'F') {
char *mailbox;
mailbox = imap_namespace_concat (store, string);
string = imap_mailbox_encode (mailbox, strlen (mailbox));
g_free (mailbox);
}
if (imap_is_atom(string)) {
op += sprintf(op, "%s", string);
} else {
if (store->capabilities & IMAP_CAPABILITY_LITERALPLUS) {
op += sprintf (op, "{%d+}\r\n%s",
strlen (string), string);
} else {
char *quoted = imap_quote_string (string);
op += sprintf (op, "%s", quoted);
g_free (quoted);
}
}
if (*p == 'F')
g_free (string);
break;
default:
*op++ = '%';
*op++ = *p;
}
start = *p ? p + 1 : p;
}
return out;
}
static char *
imap_command_strdup_printf (CamelImapStore *store, const char *fmt, ...)
{
va_list ap;
char *result;
va_start (ap, fmt);
result = imap_command_strdup_vprintf (store, fmt, ap);
va_end (ap);
return result;
}
