#include <glib.h>
#include <glib/gi18n.h>
#include <ctype.h>
+#include <errno.h>
#include "claws.h"
#include "account.h"
+#include "passwordstore.h"
#include "gtk/inputdialog.h"
#include "md5.h"
#include "utils.h"
static void command_free(SieveCommand *cmd);
static void command_abort(SieveCommand *cmd);
static void command_cb(SieveCommand *cmd, gpointer result);
+static gint sieve_session_recv_chunk(SieveSession *, guint len);
+static void sieve_read_chunk(SieveSession *, gchar *data, guint len);
+static gint sieve_read_chunk_done(SieveSession *session);
void sieve_sessions_close()
{
if (sessions) {
- g_slist_free_full(sessions, (GDestroyNotify)session_destroy);
+ GSList *list = sessions;
sessions = NULL;
+ g_slist_free_full(list, (GDestroyNotify)session_destroy);
}
}
session->on_connected(session, connected, session->cb_data);
}
+static gboolean sieve_read_chunk_cb(SockInfo *source,
+ GIOCondition condition, gpointer data)
+{
+ SieveSession *sieve_session = SIEVE_SESSION(data);
+ Session *session = &sieve_session->session;
+ gint data_len;
+ gint ret;
+
+ cm_return_val_if_fail(condition == G_IO_IN, FALSE);
+
+ session_set_timeout(session, session->timeout_interval);
+
+ if (session->read_buf_len == 0) {
+ gint read_len = -1;
+
+ if (session->sock)
+ read_len = sock_read(session->sock,
+ session->read_buf,
+ SESSION_BUFFSIZE - 1);
+
+ if (read_len == -1 &&
+ session->state == SESSION_DISCONNECTED) {
+ g_warning ("sock_read: session disconnected");
+ if (session->io_tag > 0) {
+ g_source_remove(session->io_tag);
+ session->io_tag = 0;
+ }
+ return FALSE;
+ }
+
+ if (read_len == 0) {
+ g_warning("sock_read: received EOF");
+ session->state = SESSION_EOF;
+ return FALSE;
+ }
+
+ if (read_len < 0) {
+ switch (errno) {
+ case EAGAIN:
+ return TRUE;
+ default:
+ g_warning("sock_read: %s",
+ g_strerror(errno));
+ session->state = SESSION_ERROR;
+ return FALSE;
+ }
+ }
+
+ session->read_buf_len = read_len;
+ }
+
+ data_len = MIN(session->read_buf_len,
+ sieve_session->octets_remaining);
+ sieve_session->octets_remaining -= data_len;
+ session->read_buf_len -= data_len;
+ session->read_buf_p[data_len] = '\0';
+
+ /* progress callback */
+ sieve_read_chunk(sieve_session, session->read_buf_p, data_len);
+
+ if (session->read_buf_len == 0) {
+ session->read_buf_p = session->read_buf;
+ } else {
+ session->read_buf_p += data_len;
+ }
+
+ /* incomplete read */
+ if (sieve_session->octets_remaining > 0)
+ return TRUE;
+
+ /* complete */
+ if (session->io_tag > 0) {
+ g_source_remove(session->io_tag);
+ session->io_tag = 0;
+ }
+
+ /* completion callback */
+ ret = sieve_read_chunk_done(sieve_session);
+
+ if (ret < 0)
+ session->state = SESSION_ERROR;
+
+ return FALSE;
+}
+
+static gboolean sieve_read_chunk_idle_cb(gpointer data)
+{
+ Session *session = SESSION(data);
+ gboolean ret;
+
+ ret = sieve_read_chunk_cb(session->sock, G_IO_IN, session);
+
+ if (ret == TRUE)
+ session->io_tag = sock_add_watch(session->sock, G_IO_IN,
+ sieve_read_chunk_cb, session);
+
+ return FALSE;
+}
+
+/* Get data of specified length.
+ * If needed elsewhere, this should be put in session.c */
+static gint sieve_session_recv_chunk(SieveSession *sieve_session,
+ guint bytes)
+{
+ Session *session = &sieve_session->session;
+ cm_return_val_if_fail(session->read_msg_buf->len == 0, -1);
+
+ session->state = SESSION_RECV;
+ sieve_session->octets_remaining = bytes;
+
+ if (session->read_buf_len > 0)
+ g_idle_add(sieve_read_chunk_idle_cb, session);
+ else
+ session->io_tag = sock_add_watch(session->sock, G_IO_IN,
+ sieve_read_chunk_cb, session);
+ return 0;
+}
+
+
static gint sieve_auth_recv(SieveSession *session, const gchar *msg)
{
gchar buf[MESSAGEBUFSIZE], *tmp;
static void sieve_session_putscript_cb(SieveSession *session, SieveResult *result)
{
/* Remove script name from the beginning the response,
- * which are added by Dovecot/Pigeonhole */
+ * which is added by Dovecot/Pigeonhole */
gchar *start, *desc = result->description;
- if (desc) {
+ gchar *end = NULL;
+ if (!desc) {
+ /* callback just for the status */
+ command_cb(session->current_cmd, result);
+ }
+ while (desc && desc[0]) {
+ if ((end = strchr(desc, '\r')) ||
+ (end = strchr(desc, '\n')))
+ while (*end == '\n' || *end == '\r')
+ *end++ = '\0';
if (g_str_has_prefix(desc, "NULL_") && (start = strchr(desc+5, ':'))) {
desc = start+1;
while (*desc == ' ')
desc = start+2;
}
result->description = desc;
+ command_cb(session->current_cmd, result);
+ desc = end;
}
- /* pass along the callback */
- command_cb(session->current_cmd, result);
}
static inline gboolean response_is_ok(const char *msg)
{
gchar *end;
+ cm_return_if_fail(msg != NULL);
+
/* response status */
if (isalpha(msg[0])) {
end = strchr(msg, ' ');
}
/* response code */
- if (msg[0] == '(' && (end = strchr(msg, ')'))) {
+ if (msg && msg[0] == '(' && (end = strchr(msg, ')'))) {
msg++;
*end++ = '\0';
result->code =
}
/* s2c octets */
- if (msg[0] == '{' && (end = strchr(msg, '}'))) {
+ if (msg && msg[0] == '{' && (end = strchr(msg, '}'))) {
msg++;
*end++ = '\0';
if (msg[0] == '0' && msg+1 == end) {
}
/* text */
- if (*msg) {
+ if (msg && *msg) {
unquote_inplace(msg);
result->description = msg;
} else {
SieveResult result;
gint ret = SE_OK;
- switch (sieve_session->state) {
- case SIEVE_GETSCRIPT_DATA:
- log_print(LOG_PROTOCOL, "Sieve< [GETSCRIPT data]\n");
- break;
- default:
- log_print(LOG_PROTOCOL, "Sieve< %s\n", msg);
- if (response_is_bye(msg)) {
- gchar *status;
- parse_response((gchar *)msg, &result);
- if (!result.description)
- status = g_strdup(_("Disconnected"));
- else if (g_str_has_prefix(result.description, "Disconnected"))
- status = g_strdup(result.description);
- else
- status = g_strdup_printf(_("Disconnected: %s"), result.description);
- sieve_session->error = SE_ERROR;
- sieve_error(sieve_session, status);
- sieve_session->state = SIEVE_DISCONNECTED;
- g_free(status);
- return -1;
- }
+ log_print(LOG_PROTOCOL, "Sieve< %s\n", msg);
+ if (response_is_bye(msg)) {
+ gchar *status;
+ parse_response((gchar *)msg, &result);
+ if (!result.description)
+ status = g_strdup(_("Disconnected"));
+ else if (g_str_has_prefix(result.description, "Disconnected"))
+ status = g_strdup(result.description);
+ else
+ status = g_strdup_printf(_("Disconnected: %s"), result.description);
+ sieve_session->error = SE_ERROR;
+ sieve_error(sieve_session, status);
+ sieve_session->state = SIEVE_DISCONNECTED;
+ g_free(status);
+ return -1;
}
switch (sieve_session->state) {
}
break;
case SIEVE_READY:
+ if (!msg[0])
+ break;
log_warning(LOG_PROTOCOL,
_("unhandled message on Sieve session: %s\n"), msg);
break;
sieve_session->state = SIEVE_READY;
break;
case SIEVE_SETACTIVE:
- if (response_is_no(msg)) {
- /* error */
+ parse_response((gchar *)msg, &result);
+ if (result.success) {
+ /* clear status possibly set when setting another
+ * script active. TODO: give textual feedback */
+ sieve_error(sieve_session, "");
+
command_cb(sieve_session->current_cmd, NULL);
- } else if (response_is_ok(msg)) {
- command_cb(sieve_session->current_cmd, (void*)TRUE);
+ } else if (result.description) {
+ command_cb(sieve_session->current_cmd,
+ result.description);
} else {
log_warning(LOG_PROTOCOL, _("error occurred on SIEVE session\n"));
}
- sieve_session->state = SIEVE_READY;
+ if (result.has_octets) {
+ return sieve_session_recv_chunk(sieve_session,
+ result.octets);
+ } else {
+ sieve_session->state = SIEVE_READY;
+ }
break;
case SIEVE_GETSCRIPT:
if (response_is_no(msg)) {
} else {
parse_response((gchar *)msg, &result);
sieve_session->state = SIEVE_GETSCRIPT_DATA;
- /* account for newline */
- sieve_session->octets_remaining = result.octets + 1;
+ return sieve_session_recv_chunk(sieve_session,
+ result.octets);
}
break;
case SIEVE_GETSCRIPT_DATA:
- if (sieve_session->octets_remaining > 0) {
- command_cb(sieve_session->current_cmd, (gchar *)msg);
- sieve_session->octets_remaining -= strlen(msg) + 1;
- } else if (response_is_ok(msg)) {
- sieve_session->state = SIEVE_READY;
+ if (!msg[0])
+ break;
+ sieve_session->state = SIEVE_READY;
+ if (response_is_ok(msg)) {
command_cb(sieve_session->current_cmd, NULL);
- } else {
+ } else if (msg[0]) {
log_warning(LOG_PROTOCOL, _("error occurred on SIEVE session\n"));
}
break;
case SIEVE_PUTSCRIPT:
+ if (!msg[0])
+ break;
parse_response((gchar *)msg, &result);
+ sieve_session_putscript_cb(sieve_session, &result);
if (result.has_octets) {
- sieve_session->state = SIEVE_PUTSCRIPT_DATA;
+ return sieve_session_recv_chunk(sieve_session,
+ result.octets);
} else {
sieve_session->state = SIEVE_READY;
}
- sieve_session_putscript_cb(sieve_session, &result);
- break;
- case SIEVE_PUTSCRIPT_DATA:
- if (!msg[0]) {
- sieve_session->state = SIEVE_READY;
- } else {
- result.has_status = FALSE;
- result.has_octets = FALSE;
- result.success = -1;
- result.code = SIEVE_CODE_NONE;
- result.description = (gchar *)msg;
- sieve_session_putscript_cb(sieve_session, &result);
- }
break;
case SIEVE_DELETESCRIPT:
parse_response((gchar *)msg, &result);
return 0;
}
+static void sieve_read_chunk(SieveSession *session, gchar *data, guint len)
+{
+ log_print(LOG_PROTOCOL, "Sieve< [%u bytes]\n", len);
+
+ switch (session->state) {
+ case SIEVE_GETSCRIPT_DATA:
+ command_cb(session->current_cmd, (gchar *)data);
+ break;
+ case SIEVE_SETACTIVE:
+ /* Dovecot shows a script's warnings when making it active */
+ /* TODO: append message in case it is very long*/
+ strretchomp(data);
+ sieve_error(session, data);
+ break;
+ case SIEVE_PUTSCRIPT: {
+ SieveResult result = {.description = (gchar *)data};
+ sieve_session_putscript_cb(session, &result);
+ break;
+ }
+ default:
+ log_warning(LOG_PROTOCOL,
+ _("error occurred on SIEVE session\n"));
+ }
+}
+
+static gint sieve_read_chunk_done(SieveSession *session)
+{
+ gint ret = SE_OK;
+
+ switch (session->state) {
+ case SIEVE_GETSCRIPT_DATA:
+ /* wait for ending "OK" response */
+ break;
+ case SIEVE_SETACTIVE:
+ case SIEVE_PUTSCRIPT:
+ session->state = SIEVE_READY;
+ break;
+ default:
+ log_warning(LOG_PROTOCOL,
+ _("error occurred on SIEVE session\n"));
+ }
+
+ if (ret == SE_OK && session->state == SIEVE_READY)
+ ret = sieve_pop_send_queue(session);
+
+ if (ret == SE_OK)
+ return session_recv_msg(SESSION(session));
+
+ return 0;
+}
+
static gint sieve_cmd_noop(SieveSession *session)
{
log_print(LOG_PROTOCOL, "Sieve> NOOP\n");
{
session->state = SIEVE_CAPABILITIES;
session->authenticated = FALSE;
+#ifdef USE_GNUTLS
session->tls_init_done = FALSE;
+#endif
return session_connect(SESSION(session), session->host,
session->port);
}
session->current_cmd = NULL;
session->send_queue = NULL;
session->state = SIEVE_CAPABILITIES;
+#ifdef USE_GNUTLS
session->tls_init_done = FALSE;
+#endif
session->avail_auth_type = 0;
session->auth_type = 0;
session->config = config;
g_free(session->pass);
if (config->auth == SIEVEAUTH_NONE) {
session->pass = NULL;
- } else if (reuse_auth && account->passwd) {
- session->pass = g_strdup(account->passwd);
- } else if (config->passwd && config->passwd[0]) {
- session->pass = g_strdup(config->passwd);
+ } else if (reuse_auth && (session->pass = passwd_store_get_account(
+ account->account_id, PWS_ACCOUNT_RECV))) {
+ } else if ((session->pass = passwd_store_get_account(
+ account->account_id, "sieve"))) {
} else if (password_get(session->user, session->host, "sieve",
session->port, &session->pass)) {
} else {
sieve_queue_send(session, SIEVE_LISTSCRIPTS, msg, cb, data);
}
-void sieve_session_add_script(SieveSession *session, const gchar *filter_name,
- sieve_session_data_cb_fn cb, gpointer data)
-{
-/*
- gchar *msg = g_strdup("LISTSCRIPTS");
- sieve_queue_send(session, SIEVE_LISTSCRIPTS, msg, cb, data);
-*/
-}
-
void sieve_session_set_active_script(SieveSession *session,
const gchar *filter_name,
sieve_session_data_cb_fn cb, gpointer data)
sieve_session_data_cb_fn cb, gpointer data)
{
/* TODO: refactor so don't have to copy the whole script here */
- gchar *msg = g_strdup_printf("PUTSCRIPT \"%s\" {%u+}\r\n%s",
- filter_name, len, script_contents);
+ gchar *msg = g_strdup_printf("PUTSCRIPT \"%s\" {%u+}%s%s",
+ filter_name, len, len > 0 ? "\r\n" : "",
+ script_contents);
sieve_queue_send(session, SIEVE_PUTSCRIPT, msg, cb, data);
}
gint len, const gchar *script_contents,
sieve_session_data_cb_fn cb, gpointer data)
{
- gchar *msg = g_strdup_printf("CHECKSCRIPT {%u+}\r\n%s",
- len, script_contents);
+ gchar *msg = g_strdup_printf("CHECKSCRIPT {%u+}%s%s",
+ len, len > 0 ? "\r\n" : "", script_contents);
sieve_queue_send(session, SIEVE_PUTSCRIPT, msg, cb, data);
}
projects / claws.git / blobdiff