imapfilter/imapfilter/request.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>

#include "config.h"
#include "imapfilter.h"
#include "data.h"


extern int sockpri, sockaux;
extern unsigned int options;
extern char charset[CHARSET_LEN];
extern unsigned int capabilities;

namesp_t nsppri, nspaux;        /* Primary and auxiliary namespace. */


#ifdef DEBUG
/*
 * Test/ping server.
 */
int
test(int *sock)
{
        return server_response(sock, imap_noop(sock));
}

#endif


/*
 * Check server's capabilities.
 */
int
check_capabilities(int *sock)
{
        capabilities = CAPABILITY_NONE;

        return capability_response(sock, imap_capability(sock));
}


/*
 * Get namespace of mail server's mailboxes.
 */
int
check_namespace(int *sock, namesp_t * nsp)
{
        nsp->prefix[0] = nsp->delim = '\0';

        if (!(options & OPTION_NAMESPACE) ||
            !(capabilities & CAPABILITY_NAMESPACE))
                return 0;
        else
                return namespace_response(sock, imap_namespace(sock), nsp);
}


/*
 * Login to server.
 */
int
login(int *sock, char *user, char *pass)
{
        return server_response(sock, imap_login(sock, user, pass));
}


/*
 * Check if a mailbox exists.
 */
int
check_mailbox(int *sock, char *mbox)
{
        return server_response(sock, imap_status(sock, mbox, "MESSAGES"));
}


/*
 * Open mailbox in read-write mode.
 */
int
select_mailbox(int *sock, char *mbox, namesp_t * nsp)
{
        int r;

        if (mailbox_status(sock, mbox, nsp) == -2)
                return -2;      /* No messages exist. No filters need to be
                                 * applied. */

        r = select_response(sock, imap_select(sock,
                apply_namespace(mbox, nsp->prefix,
                    nsp->delim)));

        log_info(LOG_MAILBOX, mbox);

        return r;
}


/*
 * Get mailbox's status.
 */
int
mailbox_status(int *sock, char *mbox, namesp_t * nsp)
{
        return status_response(sock, imap_status(sock,
                apply_namespace(mbox, nsp->prefix, nsp->delim),
                "MESSAGES RECENT UNSEEN"), mbox);
}


/*
 * Close examined/selected mailbox.
 */
int
close_mailbox(int *sock)
{
        return server_response(sock, imap_close(sock));
}


/*
 * Logout from server.
 */
int
logout(int *sock)
{
        return logout_response(sock, imap_logout(sock));
}


/*
 * Match and apply filters assigned to a mailbox.
 */
int
apply_filters(filter_t ** filters)
{
        int i;
        char *mesgs;

        for (i = 0; filters[i] != NULL; i++) {
                mesgs = NULL;

                if (match_filter(filters[i], &mesgs))
                        continue;

                log_info(LOG_FILTER, filters[i]->key);

                apply_action(mesgs, &(filters[i]->action.type),
                    filters[i]->action.raccount, filters[i]->action.destmbox,
                    &filters[i]->action.msgflags, filters[i]->action.args);

                xfree(mesgs);
        }

        return 0;
}


/*
 * Generate the search request by the masks of the filter and try to
 * match the generated filter.
 */
int
match_filter(filter_t * filter, char **mesgs)
{
        char *search;

        if (filter->mode == FILTER_MODE_OR)
                search = generate_filter_or(filter->masks, filter->masknum,
                    filter->masklen);
        else
                search = generate_filter_and(filter->masks, filter->masknum,
                    filter->masklen);

        search_response(&sockpri, imap_search(&sockpri, charset, search),
            mesgs);

        xfree(search);

        if (*mesgs == '\0')
                return 1;

        return 0;
}


/*
 * Empty the FIFO inventory.
 */
void
empty_fifo(mask_t ** mfifo)
{
        mfifo[0] = NULL;

        queue_fifo(NULL, NULL);
        dequeue_fifo(NULL);
}


/*
 * Add item to FIFO inventory.
 */
void
queue_fifo(mask_t ** mfifo, mask_t * mask)
{
        static unsigned int i;

        if (mfifo == NULL) {
                i = 0;
                return;
        }
        mfifo[i++] = mask;
        mfifo[i] = NULL;
}


/*
 * Get next item from FIFO inventory.
 */
mask_t *
dequeue_fifo(mask_t ** mfifo)
{
        static unsigned int j;

        if (mfifo == NULL) {
                j = 0;
                return NULL;
        }
        return mfifo[j++];
}


/*
 * Generate the filter search command from the masks, assuming that
 * masks are AND-ed.
 */
char *
generate_filter_and(mask_t * mask, unsigned int masknum,
    unsigned int masklen)
{
        const unsigned int searchbuf = masklen + masknum * 6 + 8;
        unsigned int len;
        char *search;
        mask_t *tmp;

        len = 0;

        search = (char *)xmalloc(sizeof(char) * searchbuf);
        search[0] = '\0';

        tmp = mask;
        if (tmp == NULL) {
                strncat(search, "ALL ", searchbuf - len - 1);
                len += 4;
        } else
                while ((tmp = tmp->next) != NULL) {
                        if (tmp->type != MASK_TYPE_OR) {
                                strncat(search, "ALL ", searchbuf - len - 1);
                                len += 4;
                                break;
                        }
                }

        tmp = NULL;
        while (mask != NULL) {
                tmp = mask;
                mask = mask->next;

                if (mask != NULL && mask->type == MASK_TYPE_OR) {
                        strncat(search, "OR (", searchbuf - len - 1);
                        len += 4;

                        strncat(search, tmp->body, searchbuf - len - 1);
                        len = strlen(search);
                        search[len] = ' ';
                        search[++len] = '\0';

                        search[len - 1] = ')';
                        search[len] = ' ';
                        search[++len] = '\0';

                        if (mask->next == NULL ||
                            mask->next->type != MASK_TYPE_OR) {
                                search[len] = '(';
                                search[++len] = '\0';
                                strncat(search, mask->body,
                                    searchbuf - len - 1);
                                len = strlen(search);
                                search[len] = ')';
                                search[++len] = ' ';
                                search[++len] = '\0';
                                mask = mask->next;
                        }
                } else {
                        strncat(search, tmp->body, searchbuf - len - 1);
                        len = strlen(search);
                        search[len] = ' ';
                        search[++len] = '\0';
                }
        }

        search[len - 1] = '\0';

        return search;
}


/*
 * Generate the filter search command from the masks, assuming that
 * masks are OR-ed.
 */
char *
generate_filter_or(mask_t * mask, unsigned int masknum,
    unsigned int masklen)
{
        const unsigned int searchbuf = masklen + masknum * 6 + 8;
        unsigned int len;
        char *search;
        mask_t **mfifo;         /* Mailbox FIFO queue. */
        mask_t *mf;             /* Mask returned from FIFO. */

        len = 0;

        search = (char *)xmalloc(sizeof(char) * searchbuf);
        mfifo = (mask_t **) xmalloc(sizeof(mask_t *) * (masknum + 1));

        search[0] = '\0';
        empty_fifo(mfifo);

        strncat(search, "ALL ", searchbuf - len - 1);
        len += 4;

        while (mask != NULL) {
                queue_fifo(mfifo, mask);
                mask = mask->next;

                while (mask != NULL && mask->type == MASK_TYPE_AND) {
                        queue_fifo(mfifo, mask);
                        mask = mask->next;
                }

                if (mask != NULL) {
                        if (len == 4 && search[0] == 'A') {
                                search[0] = '\0';
                                len = 0;
                        }
                        strncat(search, "OR ", searchbuf - len - 1);
                        len += 3;
                }
                if (search[0] != 'A') {
                        search[len] = '(';
                        search[++len] = '\0';
                }
                while ((mf = dequeue_fifo(mfifo)) != NULL) {
                        strncat(search, mf->body, searchbuf - len - 1);
                        len = strlen(search);
                        search[len] = ' ';
                        search[++len] = '\0';
                }

                if (strchr(search, '(')) {
                        search[len - 1] = ')';
                        search[len] = ' ';
                        search[++len] = '\0';
                }
                empty_fifo(mfifo);
        }

        search[len - 1] = '\0';

        xfree(mfifo);

        return search;
}


/*
 * Apply the appropriate action.
 */
int
apply_action(char *mesgs, unsigned int *type, account_t * raccount,
    char *destmbox, unsigned int *msgflags, char *args)
{
        unsigned int cnt;

        if (*mesgs == '\0')
                return 0;

        log_info(LOG_ACTION, type);
        log_info(LOG_DESTINATION_ACCOUNT, raccount->key);
        log_info(LOG_DESTINATION_MAILBOX, destmbox);

        cnt = count_messages(mesgs);

        switch (*type) {
        case FILTER_ACTION_DELETE:
                info("%d message%s deleted.\n", cnt, plural(cnt));
                action_delete(mesgs, args);
                break;
        case FILTER_ACTION_COPY:
                info("%d message%s copied to mailbox \"%s\".\n", cnt,
                    plural(cnt), destmbox);
                action_copy(mesgs, apply_namespace(destmbox, nsppri.prefix,
                        nsppri.delim), args);
                break;
        case FILTER_ACTION_MOVE:
                info("%d message%s moved to mailbox \"%s\".\n", cnt,
                    plural(cnt), destmbox);
                action_move(mesgs, apply_namespace(destmbox, nsppri.prefix,
                        nsppri.delim), args);
                break;
        case FILTER_ACTION_RCOPY:
                info("%d message%s copied to mailbox \"%s\" at account %s.\n",
                    cnt, plural(cnt), destmbox, raccount->key);
                action_rcopy(mesgs, raccount, destmbox, args);
                break;
        case FILTER_ACTION_RMOVE:
                info("%d message%s moved to mailbox \"%s\" at account %s.\n",
                    cnt, plural(cnt), destmbox, raccount->key);
                action_rmove(mesgs, raccount, destmbox, args);
                break;
        case FILTER_ACTION_FLAG_REPLACE:
        case FILTER_ACTION_FLAG_ADD:
        case FILTER_ACTION_FLAG_REMOVE:
                info("%d message%s flagged.\n", cnt, plural(cnt));
                action_flag(mesgs, type, msgflags, args);
                break;
        case FILTER_ACTION_LIST:
                info("%d message%s listed.\n", cnt, plural(cnt));
                action_list(mesgs, args);
                break;
        }

        if (*args == '\0')
                log_info(LOG_WRITE, NULL);

        return 0;
}


/*
 * Delete messages and optionally list some of their headers.
 */
int
action_delete(char *mesgs, char *args)
{
        char *tok, *m, *mcp;

        action_list(mesgs, args);

        m = mcp = convert_messages(mesgs);

        tok = strtok_r(m, " ", &m);
        while (tok) {
                server_response(&sockpri, imap_store(&sockpri, tok,
                        STORE_FLAG_ADD, "\\Deleted"));

                tok = strtok_r(NULL, " ", &m);
        }

        if (options & OPTION_EXPUNGE)
                server_response(&sockpri, imap_expunge(&sockpri));

        xfree(mcp);

        return 0;
}


/*
 * Copy messages to specified mailbox.
 */
int
action_copy(char *mesgs, char *destmbox, char *args)
{
        int r;
        char *tok, *mcp, *m;
        char dm[2][MBOX_NAME_LEN];

        r = 0;
        tok = NULL;

        action_list(mesgs, args);

        if (strchr(destmbox, '@'))
                m = mcp = xstrdup(mesgs);
        else
                m = mcp = convert_messages(mesgs);

        xstrncpy(dm[0], destmbox, MBOX_NAME_LEN - 1);
        current_date(dm[0]);
        tok = strtok_r(m, " ", &m);
        while (tok != NULL) {
                xstrncpy(dm[1], dm[0], MBOX_NAME_LEN - 1);
                message_date(tok, dm[1]);

                if ((r = copy_response(&sockpri, imap_copy(&sockpri, tok,
                                dm[1]))) == RESPONSE_TRYCREATE)
                        if (!server_response(&sockpri, imap_create(&sockpri,
                                    dm[1]))) {
                                if ((options & OPTION_SUBSCRIBE))
                                        server_response(&sockpri,
                                            imap_subscribe(&sockpri, dm[1]));
                                r = copy_response(&sockpri,
                                    imap_copy(&sockpri, tok, dm[1]));
                        }
                tok = strtok_r(NULL, " ", &m);
        }

        xfree(mcp);

        return r;
}


/*
 * Move messages to specified mailbox.
 */
int
action_move(char *mesgs, char *destmbox, char *args)
{
        if (!action_copy(mesgs, destmbox, args))
                action_delete(mesgs, "\0");

        return 0;
}


/*
 * Copy messages to the specified mailbox of another mail server.
 */
int
action_rcopy(char *mesgs, account_t * destacc, char *destmbox, char *args)
{
        int r, ta, tf;
        char *tok, *m, *mcp, *ndm;
        unsigned int n;
        char buf[RESPONSE_BUF * 2];
        char dm[3][MBOX_NAME_LEN];

        *dm[0] = *dm[1] = *dm[2] = '\0';

        if (init_connection(&sockaux, destacc->server, destacc->port,
                destacc->ssl))
                return ERROR_NETWORK;

        r = greeting_response(&sockaux);

        if (r == RESPONSE_BYE || check_capabilities(&sockaux))
                return ERROR_NETWORK;

#ifdef DEBUG
        test(&sockaux);
#endif

        if (r != RESPONSE_PREAUTH) {
                if (destacc->passwdattr == PASSWORD_NONE) {
                        printf("Enter password for %s@%s: ", destacc->username,
                            destacc->server);
                        get_password(destacc->password, PASSWORD_LEN);
                        destacc->passwdattr = PASSWORD_PLAIN;
                }
                if (login(&sockaux, destacc->username,
                        destacc->password) == RESPONSE_NO) {
                        error("username %s or password rejected at %s\n",
                            destacc->username, destacc->server);
                        return ERROR_NETWORK;
                }
        }
        check_namespace(&sockaux, &nspaux);

        m = mcp = xstrdup(mesgs);

        xstrncpy(dm[1], destmbox, MBOX_NAME_LEN - 1);
        current_date(dm[1]);

        tok = strtok_r(m, " ", &m);
        while (tok != NULL) {
                xstrncpy(dm[2], dm[1], MBOX_NAME_LEN - 1);
                message_date(tok, dm[2]);

                /* apply_namespace() returns a pointer to a static buffer. */
                ndm = apply_namespace(dm[2], nspaux.prefix, nspaux.delim);

                /* Check only if mailbox name is different from last one. */
                if (strncmp(dm[0], dm[2], strlen(dm[2]))) {
                        r = check_mailbox(&sockaux, ndm);
                        if (r == RESPONSE_NO) {
                                server_response(&sockaux,
                                    imap_create(&sockaux, ndm));
                                if ((options & OPTION_SUBSCRIBE))
                                        server_response(&sockaux,
                                            imap_subscribe(&sockaux, ndm));
                        }
                }
                xstrncpy(dm[0], dm[2], MBOX_NAME_LEN - 1);

                fetchsize_response(&sockpri, &n,
                    imap_fetch(&sockpri, tok, "RFC822.SIZE"));

                ta = imap_append(&sockaux, ndm, n);

                fetch_response(&sockpri, 0, 1, NULL);
                tf = imap_fetch(&sockpri, tok, "RFC822.HEADER");
                do {
                        r = fetch_response(&sockpri, tf, 0, buf);
                        socket_write(&sockaux, buf);
                } while (r == RESPONSE_NONE);

                socket_write(&sockaux, "\r\n");

                fetch_response(&sockpri, 0, 1, NULL);
                tf = imap_fetch(&sockpri, tok, "BODY[TEXT]");
                do {
                        r = fetch_response(&sockpri, tf, 0, buf);
                        if (r != RESPONSE_NULLBODY)
                                socket_write(&sockaux, buf);
                } while (r == RESPONSE_NONE);

                if (r != RESPONSE_NULLBODY)
                        socket_write(&sockaux, "\r\n\r\n");
                else
                        socket_write(&sockaux, "\r\n");

                append_response(&sockaux, ta);

                tok = strtok_r(NULL, " ", &m);
        }

        logout(&sockaux);

        action_list(mesgs, args);

        xfree(mcp);

        return 0;
}


/*
 * Move messages to the specified mailbox of another mail server.
 */
int
action_rmove(char *mesgs, account_t * destacc, char *destmbox, char *args)
{
        if (!action_rcopy(mesgs, destacc, destmbox, args))
                action_delete(mesgs, "\0");

        return 0;
}


/*
 * Flag messages by replacing, adding or removing specified flags.
 */
int
action_flag(char *mesgs, unsigned int *type, unsigned int *msgflags,
    char *args)
{
        unsigned int t;
        char s[STORE_FLAGS_BUF];
        char *tok, *m, *mcp;

        *s = 0;

        switch (*type) {
        case FILTER_ACTION_FLAG_ADD:
                t = STORE_FLAG_ADD;
                break;
        case FILTER_ACTION_FLAG_REMOVE:
                t = STORE_FLAG_REMOVE;
                break;
        default:
                t = STORE_FLAG_REPLACE;
        }

        if ((*msgflags != MESSAGE_FLAG_NONE)) {
                if ((*msgflags & MESSAGE_FLAG_SEEN))
                        strncat(s, "\\Seen ", STORE_FLAGS_BUF - strlen(s) - 1);
                if ((*msgflags & MESSAGE_FLAG_ANSWERED))
                        strncat(s, "\\Answered ",
                            STORE_FLAGS_BUF - strlen(s) - 1);
                if ((*msgflags & MESSAGE_FLAG_FLAGGED))
                        strncat(s, "\\Flagged ",
                            STORE_FLAGS_BUF - strlen(s) - 1);
                if ((*msgflags & MESSAGE_FLAG_DELETED))
                        strncat(s, "\\Deleted ",
                            STORE_FLAGS_BUF - strlen(s) - 1);
                if ((*msgflags & MESSAGE_FLAG_DRAFT))
                        strncat(s, "\\Draft", STORE_FLAGS_BUF - strlen(s) - 1);
                if ((s[strlen(s) - 1] == ' '))
                        s[strlen(s) - 1] = 0;
        }
        action_list(mesgs, args);

        m = mcp = convert_messages(mesgs);

        tok = strtok_r(m, " ", &m);
        while (tok != NULL) {
                server_response(&sockpri, imap_store(&sockpri, tok, t, s));

                tok = strtok_r(NULL, " ", &m);
        }

        if (options & OPTION_EXPUNGE)
                server_response(&sockpri, imap_expunge(&sockpri));

        xfree(mcp);

        return 0;
}

/*
 * List user selected headers of messages.
 */
int
action_list(char *mesgs, char *args)
{
        int r, t;
        char *tok, *mcp, *m;
        char s[ARGS_LEN + 27];
        char hdrs[RESPONSE_BUF];

        if (*args == '\0')
                return 0;

        m = mcp = xstrdup(mesgs);

        snprintf(s, ARGS_LEN + 27 - 1, "BODY.PEEK[HEADER.FIELDS (%s)]", args);

        tok = strtok_r(m, " ", &m);
        while (tok != NULL) {
                /* Reset internal fetch counter. */
                fetch_response(&sockpri, 0, 1, NULL);
                t = imap_fetch(&sockpri, tok, s);
                do {
                        r = fetch_response(&sockpri, t, 0, hdrs);
                } while (r == RESPONSE_NONE);

                if (*hdrs != '\0') {
                        if (options & OPTION_HEADERS)
                                info("%s\n", hdrs);
                        log_info(LOG_WRITE, hdrs);
                } else {
                        log_info(LOG_WRITE, NULL);
                }

                tok = strtok_r(NULL, " ", &m);
        }

        xfree(mcp);

        return 0;
}


/*
 * Count how many messages matched the filter.
 */
unsigned int
count_messages(char *mesgs)
{
        unsigned int cnt;
        char *c;

        cnt = 0;
        c = mesgs;

        while ((c = strchr(c, ' '))) {
                cnt++;
                c++;
        }

        return ++cnt;
}


/*
 * Convert messages with contiguous sequence number to the corresponding
 * number range, eg. 1 2 3 5 7 8 --> 1:3 5 7:8 and return a newly allocated
 * buffer with the results.
 */
char *
convert_messages(char *mesgs)
{
        int maxlen;
        unsigned int start, end, tmp;
        char *c, *cp, *tail;

        start = end = tmp = 0;
        maxlen = strlen(mesgs) + 1;
        tail = NULL;

        c = cp = xstrdup(mesgs);

        start = (unsigned int)strtoul(mesgs, &tail, 10);
        end = start;

        do {
                if (tail != NULL) {
                        tmp = (unsigned int)strtoul(tail, &tail, 10);
                        if (tmp == 0)
                                tail = NULL;
                }
                if (tmp == end + 1)
                        end++;
                else {
                        if (start == end) {
                                xstrncpy(c, ultostr(start, 10), maxlen);
                                c += strlen(c);
                        } else {
                                xstrncpy(c, ultostr(start, 10), maxlen - 1);
                                c += strlen(c);
                                *c = ':';
                                *++c = 0;
                                xstrncpy(c, ultostr(end, 10), maxlen);
                                c += strlen(c);
                        }

                        if (tail != NULL && c - cp < maxlen) {
                                *c = ' ';
                                *++c = 0;
                        }
                        start = end = tmp;
                }
        } while (tmp != 0);

        return cp;
}


/*
 * Substitute all occurences of the '@' character with the '%' character,
 * and any double '@' characters with a signle '@' character, returning the
 * number of replacements.
 */
int
substitute_date(char *str)
{
        int n;
        char *r, *w, *s;

        n = 0;

        s = xstrdup(str);

        for (r = s, w = str; *r != '\0'; r++, w++) {
                if (*r == '%') {
                        *w++ = '%';
                        *w = '%';
                } else if (*r == '@') {
                        if (*(r + 1) == '@') {
                                *w = *r++;
                        } else {
                                *w = '%';
                                n++;
                        }
                } else {
                        *w = *r;
                }
        }
        *w = '\0';

        free(s);

        return n;
}


/*
 * Format the destination mailbox according to the current date conversion
 * specifiers.
 */
void
current_date(char *destmbox)
{
        char s[MBOX_NAME_LEN];
        time_t te;
        struct tm *tl;

        if (!strchr(destmbox, '%'))
                return;

        te = time(NULL);
        tl = localtime(&te);

        if (strftime(s, MBOX_NAME_LEN - 1, destmbox, tl))
                xstrncpy(destmbox, s, MBOX_NAME_LEN - 1);
}


/*
 * Format the destination mailbox according to the message date conversion
 * specifiers.
 */
void
message_date(char *mesg, char *destmbox)
{
        unsigned int t;
        char s[MBOX_NAME_LEN];
        struct tm tl;
        char dbuf[RESPONSE_BUF];

        if (!strchr(destmbox, '@'))
                return;

        substitute_date(destmbox);

        fetch_response(&sockpri, 0, 1, NULL);
        t = imap_fetch(&sockpri, mesg, "BODY.PEEK[HEADER.FIELDS (DATE)]");

        while (fetch_response(&sockpri, t, 0, dbuf) == RESPONSE_NONE);

        if (strptime(dbuf, "Date: %a, %d %b %Y %H:%M:%S %z", &tl) &&
            strftime(s, MBOX_NAME_LEN - 1, destmbox, &tl))
                xstrncpy(destmbox, s, MBOX_NAME_LEN - 1);
}
1	#include <stdio.h>
2	#include <stdlib.h>
3	#include <string.h>
4	#include <errno.h>
5	#include <time.h>
6
7	#include "config.h"
8	#include "imapfilter.h"
9	#include "data.h"
10
11
12	extern int sockpri, sockaux;
13	extern unsigned int options;
14	extern char charset[CHARSET_LEN];
15	extern unsigned int capabilities;
16
17	namesp_t nsppri, nspaux; /* Primary and auxiliary namespace. */
18
19
20	#ifdef DEBUG
21	/*
22	* Test/ping server.
23	*/
24	int
25	test(int *sock)
26	{
27	return server_response(sock, imap_noop(sock));
28	}
29
30	#endif
31
32
33	/*
34	* Check server's capabilities.
35	*/
36	int
37	check_capabilities(int *sock)
38	{
39	capabilities = CAPABILITY_NONE;
40
41	return capability_response(sock, imap_capability(sock));
42	}
43
44
45	/*
46	* Get namespace of mail server's mailboxes.
47	*/
48	int
49	check_namespace(int sock, namesp_t nsp)
50	{
51	nsp->prefix[0] = nsp->delim = '\0';
52
53	if (!(options & OPTION_NAMESPACE) \|\|
54	!(capabilities & CAPABILITY_NAMESPACE))
55	return 0;
56	else
57	return namespace_response(sock, imap_namespace(sock), nsp);
58	}
59
60
61	/*
62	* Login to server.
63	*/
64	int
65	login(int sock, char user, char *pass)
66	{
67	return server_response(sock, imap_login(sock, user, pass));
68	}
69
70
71
72	/*
73	* Check if a mailbox exists.
74	*/
75	int
76	check_mailbox(int sock, char mbox)
77	{
78	return server_response(sock, imap_status(sock, mbox, "MESSAGES"));
79	}
80
81
82	/*
83	* Open mailbox in read-write mode.
84	*/
85	int
86	select_mailbox(int sock, char mbox, namesp_t * nsp)
87	{
88	int r;
89
90	if (mailbox_status(sock, mbox, nsp) == -2)
91	return -2; /* No messages exist. No filters need to be
92	* applied. */
93
94	r = select_response(sock, imap_select(sock,
95	apply_namespace(mbox, nsp->prefix,
96	nsp->delim)));
97
98	log_info(LOG_MAILBOX, mbox);
99
100	return r;
101	}
102
103
104	/*
105	* Get mailbox's status.
106	*/
107	int
108	mailbox_status(int sock, char mbox, namesp_t * nsp)
109	{
110	return status_response(sock, imap_status(sock,
111	apply_namespace(mbox, nsp->prefix, nsp->delim),
112	"MESSAGES RECENT UNSEEN"), mbox);
113	}
114
115
116	/*
117	* Close examined/selected mailbox.
118	*/
119	int
120	close_mailbox(int *sock)
121	{
122	return server_response(sock, imap_close(sock));
123	}
124
125
126	/*
127	* Logout from server.
128	*/
129	int
130	logout(int *sock)
131	{
132	return logout_response(sock, imap_logout(sock));
133	}
134
135
136	/*
137	* Match and apply filters assigned to a mailbox.
138	*/
139	int
140	apply_filters(filter_t ** filters)
141	{
142	int i;
143	char *mesgs;
144
145	for (i = 0; filters[i] != NULL; i++) {
146	mesgs = NULL;
147
148	if (match_filter(filters[i], &mesgs))
149	continue;
150
151	log_info(LOG_FILTER, filters[i]->key);
152
153	apply_action(mesgs, &(filters[i]->action.type),
154	filters[i]->action.raccount, filters[i]->action.destmbox,
155	&filters[i]->action.msgflags, filters[i]->action.args);
156
157	xfree(mesgs);
158	}
159
160	return 0;
161	}
162
163
164	/*
165	* Generate the search request by the masks of the filter and try to
166	* match the generated filter.
167	*/
168	int
169	match_filter(filter_t * filter, char **mesgs)
170	{
171	char *search;
172
173	if (filter->mode == FILTER_MODE_OR)
174	search = generate_filter_or(filter->masks, filter->masknum,
175	filter->masklen);
176	else
177	search = generate_filter_and(filter->masks, filter->masknum,
178	filter->masklen);
179
180	search_response(&sockpri, imap_search(&sockpri, charset, search),
181	mesgs);
182
183	xfree(search);
184
185	if (*mesgs == '\0')
186	return 1;
187
188	return 0;
189	}
190
191
192	/*
193	* Empty the FIFO inventory.
194	*/
195	void
196	empty_fifo(mask_t ** mfifo)
197	{
198	mfifo[0] = NULL;
199
200	queue_fifo(NULL, NULL);
201	dequeue_fifo(NULL);
202	}
203
204
205	/*
206	* Add item to FIFO inventory.
207	*/
208	void
209	queue_fifo(mask_t ** mfifo, mask_t * mask)
210	{
211	static unsigned int i;
212
213	if (mfifo == NULL) {
214	i = 0;
215	return;
216	}
217	mfifo[i++] = mask;
218	mfifo[i] = NULL;
219	}
220
221
222	/*
223	* Get next item from FIFO inventory.
224	*/
225	mask_t *
226	dequeue_fifo(mask_t ** mfifo)
227	{
228	static unsigned int j;
229
230	if (mfifo == NULL) {
231	j = 0;
232	return NULL;
233	}
234	return mfifo[j++];
235	}
236
237
238	/*
239	* Generate the filter search command from the masks, assuming that
240	* masks are AND-ed.
241	*/
242	char *
243	generate_filter_and(mask_t * mask, unsigned int masknum,
244	unsigned int masklen)
245	{
246	const unsigned int searchbuf = masklen + masknum * 6 + 8;
247	unsigned int len;
248	char *search;
249	mask_t *tmp;
250
251	len = 0;
252
253	search = (char )xmalloc(sizeof(char) searchbuf);
254	search[0] = '\0';
255
256	tmp = mask;
257	if (tmp == NULL) {
258	strncat(search, "ALL ", searchbuf - len - 1);
259	len += 4;
260	} else
261	while ((tmp = tmp->next) != NULL) {
262	if (tmp->type != MASK_TYPE_OR) {
263	strncat(search, "ALL ", searchbuf - len - 1);
264	len += 4;
265	break;
266	}
267	}
268
269	tmp = NULL;
270	while (mask != NULL) {
271	tmp = mask;
272	mask = mask->next;
273
274	if (mask != NULL && mask->type == MASK_TYPE_OR) {
275	strncat(search, "OR (", searchbuf - len - 1);
276	len += 4;
277
278	strncat(search, tmp->body, searchbuf - len - 1);
279	len = strlen(search);
280	search[len] = ' ';
281	search[++len] = '\0';
282
283	search[len - 1] = ')';
284	search[len] = ' ';
285	search[++len] = '\0';
286
287	if (mask->next == NULL \|\|
288	mask->next->type != MASK_TYPE_OR) {
289	search[len] = '(';
290	search[++len] = '\0';
291	strncat(search, mask->body,
292	searchbuf - len - 1);
293	len = strlen(search);
294	search[len] = ')';
295	search[++len] = ' ';
296	search[++len] = '\0';
297	mask = mask->next;
298	}
299	} else {
300	strncat(search, tmp->body, searchbuf - len - 1);
301	len = strlen(search);
302	search[len] = ' ';
303	search[++len] = '\0';
304	}
305	}
306
307	search[len - 1] = '\0';
308
309	return search;
310	}
311
312
313	/*
314	* Generate the filter search command from the masks, assuming that
315	* masks are OR-ed.
316	*/
317	char *
318	generate_filter_or(mask_t * mask, unsigned int masknum,
319	unsigned int masklen)
320	{
321	const unsigned int searchbuf = masklen + masknum * 6 + 8;
322	unsigned int len;
323	char *search;
324	mask_t *mfifo; / Mailbox FIFO queue. */
325	mask_t mf; / Mask returned from FIFO. */
326
327	len = 0;
328
329	search = (char )xmalloc(sizeof(char) searchbuf);
330	mfifo = (mask_t *) xmalloc(sizeof(mask_t ) * (masknum + 1));
331
332	search[0] = '\0';
333	empty_fifo(mfifo);
334
335	strncat(search, "ALL ", searchbuf - len - 1);
336	len += 4;
337
338	while (mask != NULL) {
339	queue_fifo(mfifo, mask);
340	mask = mask->next;
341
342	while (mask != NULL && mask->type == MASK_TYPE_AND) {
343	queue_fifo(mfifo, mask);
344	mask = mask->next;
345	}
346
347	if (mask != NULL) {
348	if (len == 4 && search[0] == 'A') {
349	search[0] = '\0';
350	len = 0;
351	}
352	strncat(search, "OR ", searchbuf - len - 1);
353	len += 3;
354	}
355	if (search[0] != 'A') {
356	search[len] = '(';
357	search[++len] = '\0';
358	}
359	while ((mf = dequeue_fifo(mfifo)) != NULL) {
360	strncat(search, mf->body, searchbuf - len - 1);
361	len = strlen(search);
362	search[len] = ' ';
363	search[++len] = '\0';
364	}
365
366	if (strchr(search, '(')) {
367	search[len - 1] = ')';
368	search[len] = ' ';
369	search[++len] = '\0';
370	}
371	empty_fifo(mfifo);
372	}
373
374	search[len - 1] = '\0';
375
376	xfree(mfifo);
377
378	return search;
379	}
380
381
382	/*
383	* Apply the appropriate action.
384	*/
385	int
386	apply_action(char mesgs, unsigned int type, account_t * raccount,
387	char destmbox, unsigned int msgflags, char *args)
388	{
389	unsigned int cnt;
390
391	if (*mesgs == '\0')
392	return 0;
393
394	log_info(LOG_ACTION, type);
395	log_info(LOG_DESTINATION_ACCOUNT, raccount->key);
396	log_info(LOG_DESTINATION_MAILBOX, destmbox);
397
398	cnt = count_messages(mesgs);
399
400	switch (*type) {
401	case FILTER_ACTION_DELETE:
402	info("%d message%s deleted.\n", cnt, plural(cnt));
403	action_delete(mesgs, args);
404	break;
405	case FILTER_ACTION_COPY:
406	info("%d message%s copied to mailbox \"%s\".\n", cnt,
407	plural(cnt), destmbox);
408	action_copy(mesgs, apply_namespace(destmbox, nsppri.prefix,
409	nsppri.delim), args);
410	break;
411	case FILTER_ACTION_MOVE:
412	info("%d message%s moved to mailbox \"%s\".\n", cnt,
413	plural(cnt), destmbox);
414	action_move(mesgs, apply_namespace(destmbox, nsppri.prefix,
415	nsppri.delim), args);
416	break;
417	case FILTER_ACTION_RCOPY:
418	info("%d message%s copied to mailbox \"%s\" at account %s.\n",
419	cnt, plural(cnt), destmbox, raccount->key);
420	action_rcopy(mesgs, raccount, destmbox, args);
421	break;
422	case FILTER_ACTION_RMOVE:
423	info("%d message%s moved to mailbox \"%s\" at account %s.\n",
424	cnt, plural(cnt), destmbox, raccount->key);
425	action_rmove(mesgs, raccount, destmbox, args);
426	break;
427	case FILTER_ACTION_FLAG_REPLACE:
428	case FILTER_ACTION_FLAG_ADD:
429	case FILTER_ACTION_FLAG_REMOVE:
430	info("%d message%s flagged.\n", cnt, plural(cnt));
431	action_flag(mesgs, type, msgflags, args);
432	break;
433	case FILTER_ACTION_LIST:
434	info("%d message%s listed.\n", cnt, plural(cnt));
435	action_list(mesgs, args);
436	break;
437	}
438
439	if (*args == '\0')
440	log_info(LOG_WRITE, NULL);
441
442	return 0;
443	}
444
445
446	/*
447	* Delete messages and optionally list some of their headers.
448	*/
449	int
450	action_delete(char mesgs, char args)
451	{
452	char tok, m, *mcp;
453
454	action_list(mesgs, args);
455
456	m = mcp = convert_messages(mesgs);
457
458	tok = strtok_r(m, " ", &m);
459	while (tok) {
460	server_response(&sockpri, imap_store(&sockpri, tok,
461	STORE_FLAG_ADD, "\\Deleted"));
462
463	tok = strtok_r(NULL, " ", &m);
464	}
465
466	if (options & OPTION_EXPUNGE)
467	server_response(&sockpri, imap_expunge(&sockpri));
468
469	xfree(mcp);
470
471	return 0;
472	}
473
474
475	/*
476	* Copy messages to specified mailbox.
477	*/
478	int
479	action_copy(char mesgs, char destmbox, char *args)
480	{
481	int r;
482	char tok, mcp, *m;
483	char dm[2][MBOX_NAME_LEN];
484
485	r = 0;
486	tok = NULL;
487
488	action_list(mesgs, args);
489
490	if (strchr(destmbox, '@'))
491	m = mcp = xstrdup(mesgs);
492	else
493	m = mcp = convert_messages(mesgs);
494
495	xstrncpy(dm[0], destmbox, MBOX_NAME_LEN - 1);
496	current_date(dm[0]);
497	tok = strtok_r(m, " ", &m);
498	while (tok != NULL) {
499	xstrncpy(dm[1], dm[0], MBOX_NAME_LEN - 1);
500	message_date(tok, dm[1]);
501
502	if ((r = copy_response(&sockpri, imap_copy(&sockpri, tok,
503	dm[1]))) == RESPONSE_TRYCREATE)
504	if (!server_response(&sockpri, imap_create(&sockpri,
505	dm[1]))) {
506	if ((options & OPTION_SUBSCRIBE))
507	server_response(&sockpri,
508	imap_subscribe(&sockpri, dm[1]));
509	r = copy_response(&sockpri,
510	imap_copy(&sockpri, tok, dm[1]));
511	}
512	tok = strtok_r(NULL, " ", &m);
513	}
514
515	xfree(mcp);
516
517	return r;
518	}
519
520
521	/*
522	* Move messages to specified mailbox.
523	*/
524	int
525	action_move(char mesgs, char destmbox, char *args)
526	{
527	if (!action_copy(mesgs, destmbox, args))
528	action_delete(mesgs, "\0");
529
530	return 0;
531	}
532
533
534	/*
535	* Copy messages to the specified mailbox of another mail server.
536	*/
537	int
538	action_rcopy(char mesgs, account_t destacc, char destmbox, char args)
539	{
540	int r, ta, tf;
541	char tok, m, mcp, ndm;
542	unsigned int n;
543	char buf[RESPONSE_BUF * 2];
544	char dm[3][MBOX_NAME_LEN];
545
546	dm[0] = dm[1] = *dm[2] = '\0';
547
548	if (init_connection(&sockaux, destacc->server, destacc->port,
549	destacc->ssl))
550	return ERROR_NETWORK;
551
552	r = greeting_response(&sockaux);
553
554	if (r == RESPONSE_BYE \|\| check_capabilities(&sockaux))
555	return ERROR_NETWORK;
556
557	#ifdef DEBUG
558	test(&sockaux);
559	#endif
560
561	if (r != RESPONSE_PREAUTH) {
562	if (destacc->passwdattr == PASSWORD_NONE) {
563	printf("Enter password for %s@%s: ", destacc->username,
564	destacc->server);
565	get_password(destacc->password, PASSWORD_LEN);
566	destacc->passwdattr = PASSWORD_PLAIN;
567	}
568	if (login(&sockaux, destacc->username,
569	destacc->password) == RESPONSE_NO) {
570	error("username %s or password rejected at %s\n",
571	destacc->username, destacc->server);
572	return ERROR_NETWORK;
573	}
574	}
575	check_namespace(&sockaux, &nspaux);
576
577	m = mcp = xstrdup(mesgs);
578
579	xstrncpy(dm[1], destmbox, MBOX_NAME_LEN - 1);
580	current_date(dm[1]);
581
582	tok = strtok_r(m, " ", &m);
583	while (tok != NULL) {
584	xstrncpy(dm[2], dm[1], MBOX_NAME_LEN - 1);
585	message_date(tok, dm[2]);
586
587	/* apply_namespace() returns a pointer to a static buffer. */
588	ndm = apply_namespace(dm[2], nspaux.prefix, nspaux.delim);
589
590	/* Check only if mailbox name is different from last one. */
591	if (strncmp(dm[0], dm[2], strlen(dm[2]))) {
592	r = check_mailbox(&sockaux, ndm);
593	if (r == RESPONSE_NO) {
594	server_response(&sockaux,
595	imap_create(&sockaux, ndm));
596	if ((options & OPTION_SUBSCRIBE))
597	server_response(&sockaux,
598	imap_subscribe(&sockaux, ndm));
599	}
600	}
601	xstrncpy(dm[0], dm[2], MBOX_NAME_LEN - 1);
602
603	fetchsize_response(&sockpri, &n,
604	imap_fetch(&sockpri, tok, "RFC822.SIZE"));
605
606	ta = imap_append(&sockaux, ndm, n);
607
608	fetch_response(&sockpri, 0, 1, NULL);
609	tf = imap_fetch(&sockpri, tok, "RFC822.HEADER");
610	do {
611	r = fetch_response(&sockpri, tf, 0, buf);
612	socket_write(&sockaux, buf);
613	} while (r == RESPONSE_NONE);
614
615	socket_write(&sockaux, "\r\n");
616
617	fetch_response(&sockpri, 0, 1, NULL);
618	tf = imap_fetch(&sockpri, tok, "BODY[TEXT]");
619	do {
620	r = fetch_response(&sockpri, tf, 0, buf);
621	if (r != RESPONSE_NULLBODY)
622	socket_write(&sockaux, buf);
623	} while (r == RESPONSE_NONE);
624
625	if (r != RESPONSE_NULLBODY)
626	socket_write(&sockaux, "\r\n\r\n");
627	else
628	socket_write(&sockaux, "\r\n");
629
630	append_response(&sockaux, ta);
631
632	tok = strtok_r(NULL, " ", &m);
633	}
634
635	logout(&sockaux);
636
637	action_list(mesgs, args);
638
639	xfree(mcp);
640
641	return 0;
642	}
643
644
645	/*
646	* Move messages to the specified mailbox of another mail server.
647	*/
648	int
649	action_rmove(char mesgs, account_t destacc, char destmbox, char args)
650	{
651	if (!action_rcopy(mesgs, destacc, destmbox, args))
652	action_delete(mesgs, "\0");
653
654	return 0;
655	}
656
657
658	/*
659	* Flag messages by replacing, adding or removing specified flags.
660	*/
661	int
662	action_flag(char mesgs, unsigned int type, unsigned int *msgflags,
663	char *args)
664	{
665	unsigned int t;
666	char s[STORE_FLAGS_BUF];
667	char tok, m, *mcp;
668
669	*s = 0;
670
671	switch (*type) {
672	case FILTER_ACTION_FLAG_ADD:
673	t = STORE_FLAG_ADD;
674	break;
675	case FILTER_ACTION_FLAG_REMOVE:
676	t = STORE_FLAG_REMOVE;
677	break;
678	default:
679	t = STORE_FLAG_REPLACE;
680	}
681
682	if ((*msgflags != MESSAGE_FLAG_NONE)) {
683	if ((*msgflags & MESSAGE_FLAG_SEEN))
684	strncat(s, "\\Seen ", STORE_FLAGS_BUF - strlen(s) - 1);
685	if ((*msgflags & MESSAGE_FLAG_ANSWERED))
686	strncat(s, "\\Answered ",
687	STORE_FLAGS_BUF - strlen(s) - 1);
688	if ((*msgflags & MESSAGE_FLAG_FLAGGED))
689	strncat(s, "\\Flagged ",
690	STORE_FLAGS_BUF - strlen(s) - 1);
691	if ((*msgflags & MESSAGE_FLAG_DELETED))
692	strncat(s, "\\Deleted ",
693	STORE_FLAGS_BUF - strlen(s) - 1);
694	if ((*msgflags & MESSAGE_FLAG_DRAFT))
695	strncat(s, "\\Draft", STORE_FLAGS_BUF - strlen(s) - 1);
696	if ((s[strlen(s) - 1] == ' '))
697	s[strlen(s) - 1] = 0;
698	}
699	action_list(mesgs, args);
700
701	m = mcp = convert_messages(mesgs);
702
703	tok = strtok_r(m, " ", &m);
704	while (tok != NULL) {
705	server_response(&sockpri, imap_store(&sockpri, tok, t, s));
706
707	tok = strtok_r(NULL, " ", &m);
708	}
709
710	if (options & OPTION_EXPUNGE)
711	server_response(&sockpri, imap_expunge(&sockpri));
712
713	xfree(mcp);
714
715	return 0;
716	}
717
718	/*
719	* List user selected headers of messages.
720	*/
721	int
722	action_list(char mesgs, char args)
723	{
724	int r, t;
725	char tok, mcp, *m;
726	char s[ARGS_LEN + 27];
727	char hdrs[RESPONSE_BUF];
728
729	if (*args == '\0')
730	return 0;
731
732	m = mcp = xstrdup(mesgs);
733
734	snprintf(s, ARGS_LEN + 27 - 1, "BODY.PEEK[HEADER.FIELDS (%s)]", args);
735
736	tok = strtok_r(m, " ", &m);
737	while (tok != NULL) {
738	/* Reset internal fetch counter. */
739	fetch_response(&sockpri, 0, 1, NULL);
740	t = imap_fetch(&sockpri, tok, s);
741	do {
742	r = fetch_response(&sockpri, t, 0, hdrs);
743	} while (r == RESPONSE_NONE);
744
745	if (*hdrs != '\0') {
746	if (options & OPTION_HEADERS)
747	info("%s\n", hdrs);
748	log_info(LOG_WRITE, hdrs);
749	} else {
750	log_info(LOG_WRITE, NULL);
751	}
752
753	tok = strtok_r(NULL, " ", &m);
754	}
755
756	xfree(mcp);
757
758	return 0;
759	}
760
761
762	/*
763	* Count how many messages matched the filter.
764	*/
765	unsigned int
766	count_messages(char *mesgs)
767	{
768	unsigned int cnt;
769	char *c;
770
771	cnt = 0;
772	c = mesgs;
773
774	while ((c = strchr(c, ' '))) {
775	cnt++;
776	c++;
777	}
778
779	return ++cnt;
780	}
781
782
783	/*
784	* Convert messages with contiguous sequence number to the corresponding
785	* number range, eg. 1 2 3 5 7 8 --> 1:3 5 7:8 and return a newly allocated
786	* buffer with the results.
787	*/
788	char *
789	convert_messages(char *mesgs)
790	{
791	int maxlen;
792	unsigned int start, end, tmp;
793	char c, cp, *tail;
794
795	start = end = tmp = 0;
796	maxlen = strlen(mesgs) + 1;
797	tail = NULL;
798
799	c = cp = xstrdup(mesgs);
800
801	start = (unsigned int)strtoul(mesgs, &tail, 10);
802	end = start;
803
804	do {
805	if (tail != NULL) {
806	tmp = (unsigned int)strtoul(tail, &tail, 10);
807	if (tmp == 0)
808	tail = NULL;
809	}
810	if (tmp == end + 1)
811	end++;
812	else {
813	if (start == end) {
814	xstrncpy(c, ultostr(start, 10), maxlen);
815	c += strlen(c);
816	} else {
817	xstrncpy(c, ultostr(start, 10), maxlen - 1);
818	c += strlen(c);
819	*c = ':';
820	*++c = 0;
821	xstrncpy(c, ultostr(end, 10), maxlen);
822	c += strlen(c);
823	}
824
825	if (tail != NULL && c - cp < maxlen) {
826	*c = ' ';
827	*++c = 0;
828	}
829	start = end = tmp;
830	}
831	} while (tmp != 0);
832
833	return cp;
834	}
835
836
837	/*
838	* Substitute all occurences of the '@' character with the '%' character,
839	* and any double '@' characters with a signle '@' character, returning the
840	* number of replacements.
841	*/
842	int
843	substitute_date(char *str)
844	{
845	int n;
846	char r, w, *s;
847
848	n = 0;
849
850	s = xstrdup(str);
851
852	for (r = s, w = str; *r != '\0'; r++, w++) {
853	if (*r == '%') {
854	*w++ = '%';
855	*w = '%';
856	} else if (*r == '@') {
857	if (*(r + 1) == '@') {
858	w = r++;
859	} else {
860	*w = '%';
861	n++;
862	}
863	} else {
864	w = r;
865	}
866	}
867	*w = '\0';
868
869	free(s);
870
871	return n;
872	}
873
874
875	/*
876	* Format the destination mailbox according to the current date conversion
877	* specifiers.
878	*/
879	void
880	current_date(char *destmbox)
881	{
882	char s[MBOX_NAME_LEN];
883	time_t te;
884	struct tm *tl;
885
886	if (!strchr(destmbox, '%'))
887	return;
888
889	te = time(NULL);
890	tl = localtime(&te);
891
892	if (strftime(s, MBOX_NAME_LEN - 1, destmbox, tl))
893	xstrncpy(destmbox, s, MBOX_NAME_LEN - 1);
894	}
895
896
897	/*
898	* Format the destination mailbox according to the message date conversion
899	* specifiers.
900	*/
901	void
902	message_date(char mesg, char destmbox)
903	{
904	unsigned int t;
905	char s[MBOX_NAME_LEN];
906	struct tm tl;
907	char dbuf[RESPONSE_BUF];
908
909	if (!strchr(destmbox, '@'))
910	return;
911
912	substitute_date(destmbox);
913
914	fetch_response(&sockpri, 0, 1, NULL);
915	t = imap_fetch(&sockpri, mesg, "BODY.PEEK[HEADER.FIELDS (DATE)]");
916
917	while (fetch_response(&sockpri, t, 0, dbuf) == RESPONSE_NONE);
918
919	if (strptime(dbuf, "Date: %a, %d %b %Y %H:%M:%S %z", &tl) &&
920	strftime(s, MBOX_NAME_LEN - 1, destmbox, &tl))
921	xstrncpy(destmbox, s, MBOX_NAME_LEN - 1);
922	}