imapfilter/imapfilter/data.c

#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <regex.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/stat.h>
#include <ctype.h>
#include <time.h>

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


extern unsigned int options;
extern unsigned int flags;

account_t *accounts = NULL;     /* First node of accounts linked list. */
filter_t *filters = NULL;       /* First node of filters tree. */

static mboxgrp_t *mboxgrps = NULL;      /* First node of mailbox-groups tree. */

static account_t *cur_acct = NULL;      /* Current account. */
static filter_t *cur_fltr = NULL;       /* Current filter. */


/*
 * Set new account's variables to safe values.
 */
void init_account(account_t * node)
{
    node->next = NULL;
    node->key[0] = node->server[0] = node->username[0] = node->password[0] = 0;
    node->passwdattr = PASSWORD_NONE;
    node->port = 143;
    node->ssl = SSL_DISABLED;
    node->mboxes = NULL;
}


/*
 * Append account node to linked list.
 */
void append_account(account_t * node)
{
    account_t *pos;
    account_t **app;

    APPEND_LINKED_LIST(accounts, node, pos, app);
}


/*
 * A new account entry was declared. Create it and set it's variables
 * accordingly.
 */
int set_account(char *line, regmatch_t * match)
{
    int n;
    char p[6];
    account_t *node;

    node = (account_t *) create_node(sizeof(account_t));
    node->password = (char *)smalloc(PASSWORD_LEN);

    init_account(node);

    strncat(node->key, line + match[1].rm_so,
            min(match[1].rm_eo - match[1].rm_so, KEY_LEN - 1));
#ifdef DEBUG
    fprintf(stderr, "debug: ACCOUNT: '%s'\n", node->key);
#endif

    if (match[3].rm_so != -1) {
        strncat(node->username, line + match[3].rm_so,
                min(match[3].rm_eo - match[3].rm_so, USERNAME_LEN - 1));
    } else {
        strncat(node->username, line + match[5].rm_so,
                min(match[5].rm_eo - match[5].rm_so, USERNAME_LEN - 1));
    }
    if (strchr(node->username, '%'))
        if (string_decode(node->username))
            return ERROR_CONFIG_PARSE;
#ifdef DEBUG
    fprintf(stderr, "debug: USERNAME: '%s'\n", node->username);
#endif

    if (match[4].rm_so != -1) {
        strncat(node->password, line + match[4].rm_so,
                min(match[4].rm_eo - match[4].rm_so, PASSWORD_LEN - 1));
        if (strchr(node->password, '%'))
            if (string_decode(node->password))
                return ERROR_CONFIG_PARSE;
        node->passwdattr = PASSWORD_PLAIN;
    } else
        flags |= FLAG_BLANK_PASSWORD;
#ifdef DEBUG
    fprintf(stderr, "debug: PASSWORD: '%s'\n", node->password);
#endif

    strncat(node->server, line + match[6].rm_so,
            min(match[6].rm_eo - match[6].rm_so, SERVER_LEN - 1));
#ifdef DEBUG
    fprintf(stderr, "debug: SERVER: '%s'\n", node->server);
#endif

    if (match[7].rm_so != -1) {
        n = min(match[7].rm_eo - match[7].rm_so - 1, 5);
        xstrncpy(p, line + match[7].rm_so + 1, n);
        p[n] = 0;
        node->port = strtoul(p, NULL, 10);
#ifdef DEBUG
        fprintf(stderr, "debug: PORT: %d\n", node->port);
#endif
    }
    if (match[8].rm_so != -1) {
        if (match[7].rm_so == -1)
            node->port = 993;

        if (strcasestr(line + match[8].rm_so, "ssl3"))
            node->ssl = SSL_SSL_V3;
        else if (strcasestr(line + match[8].rm_so, "tls1"))
            node->ssl = SSL_TLS_V1;
        else
            node->ssl = SSL_SSL_V2;
    }
    append_account(node);
    cur_acct = node;

    return 0;
}


#ifdef ENCRYPTED_PASSWORDS
/*
 * Find accounts without a password (candicates for password encryption).
 */
char *find_password(char *user, char *serv)
{
    account_t *a;

    for (a = accounts; a; a = a->next)
        if (a->passwdattr == PASSWORD_NONE && !strcmp(a->server, serv) &&
            !strcmp(a->username, user)) {
            a->passwdattr = PASSWORD_ENCRYPTED;
            return a->password;
        }
    return NULL;
}

#endif

/*
 * Set new mailbox-group's variables to safe values.
 */
void init_mboxgrp(mboxgrp_t * node)
{
    node->left = node->right = NULL;
    node->key[0] = 0;
    node->mboxes[0] = NULL;
}


/*
 * Insert mailbox-group node in tree.
 */
void insert_mboxgrp(mboxgrp_t * node)
{
    int cmp;
    mboxgrp_t *pos;
    mboxgrp_t **ins;

    INSERT_TREE(mboxgrps, node, pos, ins, cmp);
}


/*
 * A new mailbox-group entry was declared. Create it and set it's variables
 * accordingly.
 */
int set_mboxgrp(char *line, regmatch_t * match)
{
    mboxgrp_t *node;
    char mboxs[LINE_MAX];

    mboxs[0] = 0;

    if (!accounts)
        return ERROR_CONFIG_PARSE;

    node = (mboxgrp_t *) create_node(sizeof(mboxgrp_t));

    init_mboxgrp(node);

    strncat(node->key, line + match[1].rm_so,
            min(match[1].rm_eo - match[1].rm_so, KEY_LEN - 1));

#ifdef DEBUG
    fprintf(stderr, "debug: FOLDER: '%s'\n", node->key);
#endif

    strncat(mboxs, line + match[2].rm_so,
            min(match[2].rm_eo - match[2].rm_so, LINE_MAX - 1));

    process_mboxgrp(node, mboxs);

    insert_mboxgrp(node);

    return 0;
}


/*
 * Calls set_mbox() in order to create mailboxes that are part of
 * the mailbox-group.
 */
void process_mboxgrp(mboxgrp_t * node, char *mboxs)
{
    unsigned int i = 0;
    char *tok;

    tok = strtok_r(mboxs, ",", &mboxs);
    while (i < MBOXGRP_MBOXES_MAX - 1 && tok) {
        node->mboxes[i] = (mbox_t *) set_mbox(tok);
        node->mboxes[++i] = NULL;

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


/*
 * Find in the mailbox-group tree, the node with the specified key,
 * and return a pointer to it.
 */
mboxgrp_t *find_mboxgrp(char *key)
{
    int cmp;
    mboxgrp_t *pos;

    FIND_TREE(mboxgrps, key, pos, cmp);
}


/*
 * Set new mailbox's variables to safe values.
 */
void init_mbox(mbox_t * node)
{
    node->next = NULL;
    node->name[0] = 0;
    node->filters[0] = NULL;
}


/*
 * Append mailbox node to linked list.
 */
void append_mbox(mbox_t * node)
{
    mbox_t *pos;
    mbox_t **ins;

    APPEND_LINKED_LIST(cur_acct->mboxes, node, pos, ins);
}


/*
 * A new mailbox was declared, create it and set it's variables accordingly.
 */
mbox_t *set_mbox(char *name)
{
    mbox_t *node;

    node = (mbox_t *) create_node(sizeof(mbox_t));

    init_mbox(node);

    if (*name == '"' && *(name + strlen(name) - 1) == '"')
        strncat(node->name, name + 1, min(strlen(name) - 2, MBOX_NAME_LEN - 1));
    else
        strncat(node->name, name, min(strlen(name), MBOX_NAME_LEN - 1));

#ifdef DEBUG
    fprintf(stderr, "debug: MBOX: '%s'\n", node->name);
#endif

    append_mbox(node);

    return node;
}


/*
 * Set new filter's variables to safe values.
 */
void init_filter(filter_t * node)
{
    node->left = node->right = NULL;
    node->key[0] = 0;
    node->mode = FILTER_MODE_AND;
    node->action.type = 0;
    node->action.raccount = NULL;
    node->action.destmbox[0] = node->action.args[0] = 0;
    node->masks = NULL;
    node->masknum = node->masklen = 0;
}


/*
 * Insert filter node to tree.
 */
void insert_filter(filter_t * node)
{
    int cmp;
    filter_t *pos;
    filter_t **ins;

    INSERT_TREE(filters, node, pos, ins, cmp);
}


/*
 * A filter entry was declared, create it and set it's variables accordingly.
 */
int set_filter(char *line, regmatch_t * match)
{
    filter_t *node;

    if (cur_fltr && !cur_fltr->action.type)
        return ERROR_CONFIG_PARSE;

    node = (filter_t *) create_node(sizeof(filter_t));

    init_filter(node);

    strncat(node->key, line + match[1].rm_so,
            min(match[1].rm_eo - match[1].rm_so, KEY_LEN - 1));

    if (match[2].rm_so != -1) {
        if (!strncasecmp(line + match[2].rm_so + 1, "or", 2))
            node->mode = FILTER_MODE_OR;
        else
            node->mode = FILTER_MODE_AND;
    }
#ifdef DEBUG
    fprintf(stderr, "debug: FILTER: '%s' %s\n", node->key,
           (node->mode == FILTER_MODE_OR ? "OR" : "AND"));
#endif

    insert_filter(node);
    cur_fltr = node;

    return 0;
}


/*
 * Find in the filter tree, the node with the specified key and
 * return a pointer to it.
 */
filter_t *find_filter(char *key)
{
    int cmp;
    filter_t *pos;

    FIND_TREE(filters, key, pos, cmp);
}


/*
 * Assign an action to the last declared filter.
 */
int set_action(char *line, regmatch_t * match)
{
    char *c, *cp, *t;
    account_t *a;
    char s[MBOX_NAME_LEN];
    time_t te;
    struct tm *tl;

    if (!cur_fltr)
        return ERROR_CONFIG_PARSE;

    if (!strncasecmp(line + match[1].rm_so, "delete", 6))
        cur_fltr->action.type = FILTER_ACTION_DELETE;
    else if (!strncasecmp(line + match[1].rm_so, "copy", 4)) {
        cur_fltr->action.type = FILTER_ACTION_COPY;
        if (*(line + match[2].rm_so) == '"' && *(line + match[2].rm_eo - 1) == '"')
            strncat(cur_fltr->action.destmbox, line + match[2].rm_so + 1,
               min(match[2].rm_eo - match[2].rm_so - 2, MBOX_NAME_LEN - 1));
        else
            strncat(cur_fltr->action.destmbox, line + match[2].rm_so,
                    min(match[2].rm_eo - match[2].rm_so, MBOX_NAME_LEN - 1));
    } else if (!strncasecmp(line + match[1].rm_so, "move", 4)) {
        cur_fltr->action.type = FILTER_ACTION_MOVE;
        if (*(line + match[3].rm_so) == '"' && *(line + match[3].rm_eo - 1) == '"')
            strncat(cur_fltr->action.destmbox, line + match[3].rm_so + 1,
               min(match[3].rm_eo - match[3].rm_so - 2, MBOX_NAME_LEN - 1));
        else
            strncat(cur_fltr->action.destmbox, line + match[3].rm_so,
                    min(match[3].rm_eo - match[3].rm_so, MBOX_NAME_LEN - 1));
    } else if (!strncasecmp(line + match[1].rm_so, "rcopy", 5)) {
        cur_fltr->action.type = FILTER_ACTION_RCOPY;
        for (a = accounts; a; a = a->next)
            if (!strncasecmp(line + match[4].rm_so, a->key, strlen(a->key)))
                cur_fltr->action.raccount = a;
        if (!cur_fltr->action.raccount)
            return ERROR_CONFIG_PARSE;

        if (*(line + match[5].rm_so) == '"' && *(line + match[5].rm_eo - 1) == '"')
            strncat(cur_fltr->action.destmbox, line + match[5].rm_so + 1,
               min(match[5].rm_eo - match[5].rm_so - 2, MBOX_NAME_LEN - 1));
        else
            strncat(cur_fltr->action.destmbox, line + match[5].rm_so,
                    min(match[5].rm_eo - match[5].rm_so, MBOX_NAME_LEN - 1));
    } else if (!strncasecmp(line + match[1].rm_so, "rmove", 5)) {
        cur_fltr->action.type = FILTER_ACTION_RMOVE;
        for (a = accounts; a; a = a->next)
            if (!strncasecmp(line + match[6].rm_so, a->key, strlen(a->key)))
                cur_fltr->action.raccount = a;
        if (!cur_fltr->action.raccount)
            return ERROR_CONFIG_PARSE;

        if (*(line + match[7].rm_so) == '"' && *(line + match[7].rm_eo - 1) == '"')
            strncat(cur_fltr->action.destmbox, line + match[7].rm_so + 1,
               min(match[7].rm_eo - match[7].rm_so - 2, MBOX_NAME_LEN - 1));
        else
            strncat(cur_fltr->action.destmbox, line + match[7].rm_so,
                    min(match[7].rm_eo - match[7].rm_so, MBOX_NAME_LEN - 1));
    } else if (!strncasecmp(line + match[1].rm_so, "flag", 4)) {
        if (!strncasecmp(line + match[8].rm_so, "replace", 7))
            cur_fltr->action.type = FILTER_ACTION_FLAG_REPLACE;
        else if (!strncasecmp(line + match[8].rm_so, "add", 3))
            cur_fltr->action.type = FILTER_ACTION_FLAG_ADD;
        else
            cur_fltr->action.type = FILTER_ACTION_FLAG_REMOVE;

        c = cp = (char *)malloc(match[9].rm_eo - match[9].rm_so + 1);
        xstrncpy(c, line + match[9].rm_so, match[9].rm_eo - match[9].rm_so);

        t = strtok_r(c, ",", &c);
        while (t) {
            if (!strcasecmp(t, "none")) {
                if (match[9].rm_eo - match[9].rm_so != strlen("none"))
                    return ERROR_CONFIG_PARSE;
            } else if (!strcasecmp(t, "seen"))
                cur_fltr->action.msgflags |= MESSAGE_FLAG_SEEN;
            else if (!strcasecmp(t, "answered"))
                cur_fltr->action.msgflags |= MESSAGE_FLAG_ANSWERED;
            else if (!strcasecmp(t, "flagged"))
                cur_fltr->action.msgflags |= MESSAGE_FLAG_FLAGGED;
            else if (!strcasecmp(t, "deleted"))
                cur_fltr->action.msgflags |= MESSAGE_FLAG_DELETED;
            else if (!strcasecmp(t, "draft"))
                cur_fltr->action.msgflags |= MESSAGE_FLAG_DRAFT;
            else
                return ERROR_CONFIG_PARSE;

            t = strtok_r(NULL, ",", &c);
        }
        xfree(cp);
    } else if (!strncasecmp(line + match[1].rm_so, "list", 4)) {
        cur_fltr->action.type = FILTER_ACTION_LIST;
    }
    if (match[10].rm_so != -1) {
        strncat(cur_fltr->action.args, line + match[10].rm_so,
                min(match[10].rm_eo - match[10].rm_so, ARGS_LEN - 2));
        while ((c = strchr(cur_fltr->action.args, ',')))
            *c = ' ';
    }
    if (cur_fltr->action.destmbox && strchr(cur_fltr->action.destmbox, '%')) {
        te = time(NULL);
        tl = localtime(&te);
        if (strftime(s, MBOX_NAME_LEN - 1, cur_fltr->action.destmbox, tl))
            xstrncpy(cur_fltr->action.destmbox, s, MBOX_NAME_LEN - 1);
    }
#ifdef DEBUG
    fprintf(stderr, "debug: ACTION: %d '%s' '%s' %d '%s'\n", cur_fltr->action.type,
           (cur_fltr->action.raccount ? cur_fltr->action.raccount->key : ""),
           cur_fltr->action.destmbox, cur_fltr->action.msgflags,
           cur_fltr->action.args);
#endif
    return 0;
}


/*
 * Set new mask's variables to safe values.
 */
void init_mask(mask_t * node)
{
    node->next = NULL;
    node->body[0] = 0;
    node->type = 0;
}


/*
 * Append mask node to linked list.
 */
void append_mask(mask_t * node)
{
    mask_t *pos;
    mask_t **app;

    APPEND_LINKED_LIST(cur_fltr->masks, node, pos, app);
}


/*
 * A new mask entry was declared, create it and set it's
 * variables accordingly.
 */
int set_mask(char *line, regmatch_t * match, int mmt)
{
    int n;
    mask_t *node;
    char *bp;

    if (!cur_fltr)
        return ERROR_CONFIG_PARSE;

    node = (mask_t *) create_node(sizeof(mask_t));

    init_mask(node);

    bp = node->body;

    /* If specified set mask's type. */
    if (match[2].rm_so != -1 && cur_fltr->masks) {
        if (!strncasecmp(line + match[2].rm_so, "or", 2)) {
            node->type = MASK_TYPE_OR;
        } else
            node->type = MASK_TYPE_AND;
    }
    /* Add NOT if specified. */
    if (match[3].rm_so != -1) {
        n = min(match[3].rm_eo - match[3].rm_so,
                MASK_BODY_LEN - (bp - node->body) - 1);
        xstrncpy(bp, line + match[3].rm_so, n);
        string_upper(bp, n);
        *(bp + n - 1) = ' ';    /* In case it's '\t'. */
        *(bp + n) = 0;
        bp += n;
    }
    /* Keyword of the search key. */
    n = min(match[4].rm_eo - match[4].rm_so,
            MASK_BODY_LEN - (bp - node->body) - 3);
    xstrncpy(bp, line + match[4].rm_so, n);
    string_upper(bp, n);
    *(bp + n) = 0;
    bp += n;

    if (mmt != MASK_MATCH_1) {
        *(bp++) = ' ';

        if (mmt != MASK_MATCH_4 && *(line + match[5].rm_so) != '"')
            *(bp++) = '"';
        *bp = 0;

        n = min(match[5].rm_eo - match[5].rm_so,
                MASK_BODY_LEN - (bp - node->body) - 2);
        xstrncpy(bp, line + match[5].rm_so, n);
        *(bp + n) = 0;
        bp += n;

        if (mmt != MASK_MATCH_4 && *(line + match[5].rm_so) != '"')
            *(bp++) = '"';
        *bp = 0;

        if (mmt == MASK_MATCH_3) {
            *(bp++) = ' ';

            if (*(line + match[6].rm_so) != '"')
                *(bp++) = '"';
            *bp = 0;

            n = min(match[6].rm_eo - match[6].rm_so,
                    MASK_BODY_LEN - (bp - node->body) - 2);
            xstrncpy(bp, line + match[6].rm_so, n);
            *(bp + n) = 0;
            bp += n;

            if (*(line + match[6].rm_so) != '"')
                *(bp++) = '"';
            *bp = 0;
        }
        if (mmt == MASK_MATCH_4 && (strstr(node->body, "OLDER") ||
                                    strstr(node->body, "NEWER"))) {
            convert_date(node);
            bp = node->body + strlen(node->body);
        }
    }
    append_mask(node);

    cur_fltr->masknum++;
    cur_fltr->masklen += (bp - node->body);


#ifdef DEBUG
    fprintf(stderr, "debug: MASK: '%s'\n", node->body);
#endif

    return 0;
}


/*
 * Converts masks related to date filtering, because IMAP servers do not
 * understand for example "OLDER 3", but "BEFORE 18-Oct-2001" (if
 * hypothetically current date was 21-Oct-2001).
 */
void convert_date(mask_t * node)
{
    char *cp, *c;
    char s[16];
    time_t te;
    struct tm *tl;

    cp = xstrdup(node->body);
    node->body[0] = 0;

    if (strstr(cp, "NOT"))
        strncat(node->body, "NOT ", 4);

    if ((c = strstr(cp, "OLDER")))
        strncat(node->body, "BEFORE ", 7);
    else if ((c = strstr(cp, "NEWER")))
        strncat(node->body, "SINCE ", 6);

    c += 6;

    te = time(NULL) - (time_t) (strtoul(c, NULL, 10) * 24 * 60 * 60);
    tl = localtime(&te);

    if (strftime(s, 15, "%d-%b-%Y", tl))
        strncat(node->body, s, 15);

    xfree(cp);
}


/*
 * A new job was declared, link filters with mailbox-groups.
 */
int set_job(char *line, regmatch_t * match)
{
    int n;
    char *ftok, *gtok, *fltr, *mbgrp, *f, *g;
    filter_t *cf;
    mboxgrp_t *cg;

    if (!accounts || !filters || !cur_fltr->action.type)
        return ERROR_CONFIG_PARSE;

    n = match[1].rm_eo - match[1].rm_so;
    fltr = (char *)xmalloc(n + 1);

    f = xstrncpy(fltr, line + match[1].rm_so, n);
    f[n] = 0;

    n = match[2].rm_eo - match[2].rm_so;
    mbgrp = (char *)xmalloc(n + 1);

    /* Go through filters. */
    ftok = strtok_r(f, ",", &f);
    while (ftok) {
        cf = (filter_t *) find_filter(ftok);
        if (!cf)
            return ERROR_CONFIG_PARSE;

        g = xstrncpy(mbgrp, line + match[2].rm_so, n);
        g[n] = 0;

        /* Go through mailbox groups. */
        gtok = strtok_r(g, ",", &g);
        while (gtok) {
            cg = (mboxgrp_t *) find_mboxgrp(gtok);
            if (!cg)
                return ERROR_CONFIG_PARSE;
            link_mbox_filter(cf, cg);

            gtok = strtok_r(NULL, ",", &g);
        }

        ftok = strtok_r(NULL, ",", &f);
    }

    xfree(fltr);
    xfree(mbgrp);

    return 0;
}


/*
 * Link a filter with a mailbox.
 */
void link_mbox_filter(filter_t * cf, mboxgrp_t * cg)
{
    int i, j, f;

    for (i = 0; cg->mboxes[i]; i++) {
        for (f = j = 0; cg->mboxes[i]->filters[j]; j++)
            if (j == MBOX_FILTERS_MAX - 1 ||
                !strcmp(cf->key, cg->mboxes[i]->filters[j]->key))
                f = 1;

        if (f)
            continue;

        cg->mboxes[i]->filters[j] = cf;
        cg->mboxes[i]->filters[j + 1] = NULL;

    }

#ifdef DEBUG
    fprintf(stderr, "debug: JOB: '%s' '%s'\n", cf->key, cg->key);
#endif
}


/*
 * Free allocated memory of data structures that are not needed anymore.
 */
void destroy_data(void)
{
    destroy_mboxgrp(mboxgrps);
}


/*
 * Go through the mailbox-group tree, and free the allocated memory of
 * each node.
 */
void destroy_mboxgrp(mboxgrp_t * node)
{
    if (!node)
        return;

    if (node->left) {
        destroy_mboxgrp(node->left);
        node->left = NULL;
    }
    if (node->right) {
        destroy_mboxgrp(node->right);
        node->right = NULL;
    }
#ifdef DEBUG
    fprintf(stderr, "debug: deleting FOLDER: '%s'\n", node->key);
#endif

    xfree(node);
}


/*
 * Convert a string of specified size to upper case.
 */
void string_upper(char *str, size_t size)
{
    unsigned int i;

    for (i = 0; i < size; i++, str++)
        *str = toupper(*str);
}


/*
 * Decode the character triplet, consisting of the character '%'
 * followed by two hexadecimal digits to its corresponding ASCII
 * character (described in Section 2.2 of RFC 1738).
 */
int string_decode(char *str)
{
    char *c;
    char hex[3];

    c = str;

    while (*c) {
        if (*c == '%') {
            if (!isxdigit((unsigned char)(*(c + 1))) ||
                !isxdigit((unsigned char)(*(c + 2))))
                return ERROR_CONFIG_PARSE;

            xstrncpy(hex, ++c, 2);
            hex[2] = 0;

            if (!isprint((unsigned char)(*str = (char)strtoul(hex, NULL, 16))))
                return ERROR_CONFIG_PARSE;

            str++;
            c += 2;
        } else
            *(str++) = *(c++);
    }
    *str = 0;

    return 0;
}


/*
 * Convert the names of personal mailboxes using the namespace specified
 * by the mail server.
 */
char *apply_namespace(char *mbox, char *prefix, char delim)
{
    static char m[MBOX_NAME_LEN];
    char *c;

    if ((!prefix[0] && !delim) || (!prefix[0] && delim == '/')
        || !strcasecmp(mbox, "INBOX"))
        return mbox;

    m[0] = 0;
    strncat(m, prefix, MBOX_NAME_LEN - 1);
    strncat(m, mbox, MBOX_NAME_LEN - strlen(m) - 1);

    c = m;
    while ((c = strchr(c, '/')))
        *(c++) = delim;

#ifdef DEBUG
    fprintf(stderr, "debug: MAILBOX: '%s'\n", m);
#endif

    return m;
}