cmd/mailx/imap.c

/***********************************************************************
*                                                                      *
*               This software is part of the BSD package               *
*Copyright (c) 1978-2012 The Regents of the University of California an*
*                                                                      *
* Redistribution and use in source and binary forms, with or           *
* without modification, are permitted provided that the following      *
* conditions are met:                                                  *
*                                                                      *
*    1. Redistributions of source code must retain the above           *
*       copyright notice, this list of conditions and the              *
*       following disclaimer.                                          *
*                                                                      *
*    2. Redistributions in binary form must reproduce the above        *
*       copyright notice, this list of conditions and the              *
*       following disclaimer in the documentation and/or other         *
*       materials provided with the distribution.                      *
*                                                                      *
*    3. Neither the name of The Regents of the University of California*
*       names of its contributors may be used to endorse or            *
*       promote products derived from this software without            *
*       specific prior written permission.                             *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND               *
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,          *
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF             *
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE             *
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS    *
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,             *
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED      *
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,        *
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    *
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,      *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY       *
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE              *
* POSSIBILITY OF SUCH DAMAGE.                                          *
*                                                                      *
* Redistribution and use in source and binary forms, with or without   *
* modification, are permitted provided that the following conditions   *
* are met:                                                             *
* 1. Redistributions of source code must retain the above copyright    *
*    notice, this list of conditions and the following disclaimer.     *
* 2. Redistributions in binary form must reproduce the above copyright *
*    notice, this list of conditions and the following disclaimer in   *
*    the documentation and/or other materials provided with the        *
*    distribution.                                                     *
* 3. Neither the name of the University nor the names of its           *
*    contributors may be used to endorse or promote products derived   *
*    from this software without specific prior written permission.     *
*                                                                      *
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS"    *
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED    *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A      *
* PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS    *
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,      *
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT     *
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF     *
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND  *
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,   *
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT   *
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF   *
* SUCH DAMAGE.                                                         *
*                                                                      *
*                          Kurt Shoens (UCB)                           *
*                                 gsf                                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * IMAP4rev1 client
 *
 * Glenn Fowler
 * AT&T Research
 */

#include "mailx.h"

#if _PACKAGE_ast

#include <css.h>
#include <tm.h>
#include <vmalloc.h>

#define imapfree(sp,op) ((op)->state=(op)->retain=0)

#define IMAP        ((Imap_t*)state.msg.imap.state)

#define IMAP_VERSION    4       /* at least this        */
#define IMAP_REVISION   1       /* at least this        */

#define IMAP_data   1       /* data item            */
#define IMAP_list   2       /* list item            */
#define IMAP_name   3       /* name (atom) item     */
#define IMAP_number 4       /* number item          */
#define IMAP_string 5       /* string item          */

struct Imaparg_s; typedef struct Imaparg_s Imaparg_t;
struct Imapblock_s; typedef struct Imapblock_s Imapblock_t;
struct Imappart_s; typedef struct Imappart_s Imappart_t;

typedef struct {            /* IMAP_data item       */
    char*       buffer;
    size_t      length;
} Imapdata_t;

typedef struct {            /* IMAP_list item       */
    Imaparg_t*  head;
    Imaparg_t*  tail;
} Imaplist_t;

typedef union {             /* list item value      */
    Imapdata_t  data;
    Imaplist_t  list;
    long        number;
    char*       name;
    char*       string;
} Imapvalue_t;

struct Imaparg_s {          /* response arg list element    */
    Imaparg_t*  next;
    int     type;
    Imapvalue_t value;
};

typedef struct {            /* flag table element       */
    const char* name;       /* canonical flag name      */
    int     code;       /* IMAP_* code          */
    int     flag;       /* mailx M* flag        */
} Imapflag_t;

typedef struct {            /* lex table element        */
    const char* name;       /* canonical name       */
    int     code;       /* IMAP_* code          */
} Imaplex_t;

typedef struct {            /* IMAP Msg_t.m_info info   */
    char*       from;       /* from address         */
    char*       date;       /* localized date       */
    char*       subject;    /* subject          */
    Imappart_t* parts;      /* multipart parts      */
    int     attachments;    /* attachment count     */
} Imapmsg_t;

struct Imappart_s {         /* message part         */
    Imappart_t* next;       /* next part            */
    short       content;    /* IMAP_CONTENT_* type      */
    short       attachment; /* attachment ordinal       */
    int     lines;      /* # lines          */
    size_t      size;       /* # octets         */
    char*       id;     /* IMAP BODY[id]        */
    char*       type;       /* MIME type/subtype        */
    char*       encoding;   /* MIME encoding        */
    char*       name;       /* attachment name      */
    char*       options;    /* encoding options     */
    Imapmsg_t*  msg;        /* IMAP_CONTENT_message info    */
};

typedef struct {            /* imap_BODYSTRUCTURE discipline*/
    Imappart_t* lastpart;   /* part list tail       */
    int     prestack;   /* one before stack is ok   */
    int     idstack[64];    /* for nested message ids   */
    int*        id;     /* top of idstack       */
} Imapbody_t;

struct Imapblock_s {            /* multiline response cache */
    Imapblock_t*    next;       /* next in list         */
    size_t      length;     /* length of this block     */
    char*       data;       /* data for this block      */
};

typedef struct {            /* response info        */
    int     state;      /* IMAP_OP_* state      */
    int     code;       /* IMAP_* code          */
    int     count;      /* optional count prefix    */
    int     retain;     /* retain until imapfree()  */
    char        msg[32];    /* first part of last message   */
    Vmalloc_t*  vm;     /* local store          */
    Imaplist_t  args;       /* arg list         */
    Imapblock_t*    blocks;     /* multiline cache      */
} Imapop_t;

typedef struct
{
    Imapop_t    op[8];      /* pending ops          */
    Sfio_t*     mp;     /* tmp message stream       */
    Sfio_t*     np;     /* tmp normalization stream */
    Sfio_t*     rp;     /* IMAP service recv stream */
    Sfio_t*     sp;     /* IMAP service send stream */
    Sfio_t*     tp;     /* tmp string stream        */
    Vmdisc_t    vmdisc;     /* vmopen() discipline      */
    Vmalloc_t*  gm;     /* IMAP global store        */
    Vmalloc_t*  vm;     /* IMAP mailbox store       */
    int     auth;       /* IMAP_AUTH_* methods      */
    int     authenticated;  /* connection authenticated */
    int     connected;  /* connected to server      */
    int     exiting;    /* attempting to logout     */
    char*       host;       /* IMAP server host     */
    Msg_t*      index;      /* last SEARCH message index    */
    char*       meth;       /* IMAP authentication method   */
    int     revision;   /* IMAP service revision    */
    int     selected;   /* mailbox selected     */
    int     tag;        /* last op tag (index)      */
    char*       user;       /* IMAP user name       */
    int     version;    /* IMAP service version     */

    struct
    {
    Sfio_t*     fp;     /* output stream        */
    char*       prefix;     /* line prefix          */
    short       prefixlen;  /* line prefix length       */
    short       emptylen;   /* empty line prefix length */
    }       copy;       /* imap_copy() state for FETCH  */

    struct
    {
    int     delimiter;  /* mailbox hierarchy delimiter  */
    int     exists;     /* # messages           */
    int     recent;     /* first recent message     */
    int     read_only;  /* no updates           */
    int     trycreate;  /* op may work after CREATE */
    int     uidnext;    /* next expected message UID    */
    int     uidvalidity;    /* UID validation       */
    int     unseen;     /* first unseen message     */
    }       mailbox;    /* mailbox state        */
} Imap_t;

/*
 * imap dump <item> table
 */

#define IMAP_DUMP_FLAGS         1
#define IMAP_DUMP_FOLDER        2
#define IMAP_DUMP_MESSAGE       3
#define IMAP_DUMP_QUEUE         4
#define IMAP_DUMP_STATE         5

static const Imaplex_t  imapdump[] =
{
    "fl[ags]",          IMAP_DUMP_FLAGS,
    "f[older]",         IMAP_DUMP_FOLDER,
    "m[essage]",            IMAP_DUMP_MESSAGE,
    "q[ueue]",          IMAP_DUMP_QUEUE,
    "s[tate]",          IMAP_DUMP_STATE,
};

/*
 * operation states
 */

#define IMAP_STATE_free         0   /* must be 0 */
#define IMAP_STATE_sent         1
#define IMAP_STATE_more         2
#define IMAP_STATE_done         3

static const Imaplex_t  imapstate[] =
{
    "free",             IMAP_STATE_free,
    "sent",             IMAP_STATE_sent,
    "more",             IMAP_STATE_more,
    "done",             IMAP_STATE_done,
};

/*
 * part content types
 */

#define IMAP_CONTENT_data   0   /* must be 0            */
#define IMAP_CONTENT_attachment 1   /* part is an attachment    */
#define IMAP_CONTENT_header 2   /* part is a header     */
#define IMAP_CONTENT_message    3   /* part is an embeded message   */
#define IMAP_CONTENT_multipart  4   /* part is an embeded message   */
#define IMAP_CONTENT_text   5   /* part is plain text       */

static const Imaplex_t  imapcontent[] =
{
    "attachment",       IMAP_CONTENT_attachment,
    "data",         IMAP_CONTENT_data,
    "header",       IMAP_CONTENT_header,
    "message",      IMAP_CONTENT_message,
    "multipart",        IMAP_CONTENT_multipart,
    "text",         IMAP_CONTENT_text,
};

/*
 * message flags
 */

static const Imaplex_t  imapmflags[] =
{
    "DELETE",       MDELETE,
    "INIT",         MINIT,
    "MARK",         MMARK,
    "MBOX",         MBOX,
    "MODIFY",       MODIFY,
    "NEW",          MNEW,
    "NONE",         MNONE,
    "PRESERVE",     MPRESERVE,
    "READ",         MREAD,
    "SAVE",         MSAVE,
    "SCAN",         MSCAN,
    "SPAM",         MSPAM,
    "STATUS",       MSTATUS,
    "TOUCH",        MTOUCH,
    "USED",         MUSED,
    "ZOMBIE",       MZOMBIE,
};

/*
 * the rest define the parts of the protocol used by this implementation
 */

#define IMAP_UNKNOWN            0   /* must be 0 */
#define IMAP_OK             1
#define IMAP_NO             2
#define IMAP_BAD            3
#define IMAP_BYE            4
#define IMAP_CAPABILITY         5
#define IMAP_COPY           6
#define IMAP_EXISTS         7
#define IMAP_EXPUNGE            8
#define IMAP_FETCH          9
#define IMAP_FLAGS          10
#define IMAP_LIST           11
#define IMAP_LSUB           12
#define IMAP_MORE           13
#define IMAP_PREAUTH            14
#define IMAP_RECENT         15
#define IMAP_SEARCH         16

static const Imaplex_t  imapresponse[] =
{
    "+",                IMAP_MORE,
    "BAD",              IMAP_BAD,
    "BYE",              IMAP_BYE,
    "CAPABILITY",           IMAP_CAPABILITY,
    "COPY",             IMAP_COPY,
    "EXISTS",           IMAP_EXISTS,
    "EXPUNGE",          IMAP_EXPUNGE,
    "FETCH",            IMAP_FETCH,
    "FLAGS",            IMAP_FLAGS,
    "LIST",             IMAP_LIST,
    "LSUB",             IMAP_LSUB,
    "NO",               IMAP_NO,
    "OK",               IMAP_OK,
    "PREAUTH",          IMAP_PREAUTH,
    "RECENT",           IMAP_RECENT,
    "SEARCH",           IMAP_SEARCH,
    "STORE",            IMAP_FETCH,
    "UNKNOWN",          IMAP_UNKNOWN,
};

#define IMAP_AUTH_ANONYMOUS     (1<<0)
#define IMAP_AUTH_KERBEROS_V4       (1<<1)
#define IMAP_AUTH_LOGIN         (1<<2)
#define IMAP_AUTH_XFILE         (1<<3)

static const Imaplex_t  imapauth[] =
{
    "ANONYMOUS",            IMAP_AUTH_ANONYMOUS,
    "KERBEROS_V4",          IMAP_AUTH_KERBEROS_V4,
    "LOGIN",            IMAP_AUTH_LOGIN,
    "XFILE",            IMAP_AUTH_XFILE,
};

#define IMAP_STATUS_ALERT       1
#define IMAP_STATUS_NEWNAME     2
#define IMAP_STATUS_PARSE       3
#define IMAP_STATUS_PERMANENTFLAGS  4
#define IMAP_STATUS_READ_ONLY       5
#define IMAP_STATUS_READ_WRITE      6
#define IMAP_STATUS_TRYCREATE       7
#define IMAP_STATUS_UIDNEXT     8
#define IMAP_STATUS_UIDVALIDITY     9
#define IMAP_STATUS_UNSEEN      10

static const Imaplex_t  imapstatus[] =
{
    "ALERT",            IMAP_STATUS_ALERT,
    "NEWNAME",          IMAP_STATUS_NEWNAME,
    "PARSE",            IMAP_STATUS_PARSE,
    "PERMANENTFLAGS",       IMAP_STATUS_PERMANENTFLAGS,
    "READ-ONLY",            IMAP_STATUS_READ_ONLY,
    "READ-WRITE",           IMAP_STATUS_READ_WRITE,
    "TRYCREATE",            IMAP_STATUS_TRYCREATE,
    "UIDNEXT",          IMAP_STATUS_UIDNEXT,
    "UIDVALIDITY",          IMAP_STATUS_UIDVALIDITY,
    "UNSEEN",           IMAP_STATUS_UNSEEN,
};

#define IMAP_FETCH_BODY         1
#define IMAP_FETCH_BODYSTRUCTURE    2
#define IMAP_FETCH_ENVELOPE     3
#define IMAP_FETCH_FLAGS        4
#define IMAP_FETCH_INTERNALDATE     5
#define IMAP_FETCH_RFC822_SIZE      6
#define IMAP_FETCH_UID          7

static const Imaplex_t  imapfetch[] =
{
    "BODY",             IMAP_FETCH_BODY,
    "BODYSTRUCTURE",        IMAP_FETCH_BODYSTRUCTURE,
    "ENVELOPE",         IMAP_FETCH_ENVELOPE,
    "FLAGS",            IMAP_FETCH_FLAGS,
    "INTERNALDATE",         IMAP_FETCH_INTERNALDATE,
    "RFC822.SIZE",          IMAP_FETCH_RFC822_SIZE,
    "UID",              IMAP_FETCH_UID,
};

#define IMAP_FLAG_APPLICABLE        (1<<0)
#define IMAP_FLAG_PERMANENT     (1<<1)

#define IMAP_FLAG_ANSWERED      (1<<2)
#define IMAP_FLAG_DELETED       (1<<3)
#define IMAP_FLAG_DRAFT         (1<<4)
#define IMAP_FLAG_FLAGGED       (1<<5)
#define IMAP_FLAG_RECENT        (1<<6)
#define IMAP_FLAG_SCAN          (1<<7)
#define IMAP_FLAG_SEEN          (1<<8)
#define IMAP_FLAG_SPAM          (1<<9)

#define IMAP_FLAG_LOCAL         (IMAP_FLAG_SCAN|IMAP_FLAG_SPAM)

static Imapflag_t   imapflags[] =
{
    "/Scan",        IMAP_FLAG_SCAN,     MSCAN,
    "/Spam",        IMAP_FLAG_SPAM,     MSPAM,
    "\\*",          IMAP_FLAG_LOCAL,    0,
    "\\Answered",       IMAP_FLAG_ANSWERED, 0,
    "\\Deleted",        IMAP_FLAG_DELETED,  MDELETE|MZOMBIE,
    "\\Draft",      IMAP_FLAG_DRAFT,    0,
    "\\Flagged",        IMAP_FLAG_FLAGGED,  0,
    "\\Recent",     IMAP_FLAG_RECENT,   MNEW,
    "\\Seen",       IMAP_FLAG_SEEN,     MREAD,
};

static int  imapconnect(Imap_t*);

/*
 * return the name for the given code in table tab with n elements
 */

static char*
imapname(register const Imaplex_t* tab, int n, int code)
{
    register const Imaplex_t*   end;

    for (end = tab + n; tab < end; tab++)
        if (code == tab->code)
            return (char*)tab->name;
    return "[ERROR]";
}

/*
 * return the list of flag names set in flags in the string stream sp
 */

static char*
imapflagnames(register Sfio_t* sp, register const Imaplex_t* tab, int n, register int flags)
{
    register const Imaplex_t*   end;
    register int            sep;

    sep = 0;
    for (end = tab + n; tab < end; tab++)
        if (flags & tab->code)
        {
            if (sep)
                sfputc(sp, ' ');
            else
                sep = 1;
            sfputr(sp, tab->name, -1);
        }
    if (!sep)
        sfputc(sp, '0');
    return struse(sp);
}

/*
 * list arg value on sfstdout
 */

static void
imapdumparg(Imap_t* imap, Imaparg_t* ap, int level)
{
    switch (ap->type)
    {
    case IMAP_data:
        sfprintf(sfstdout, " {%d}%.*s", ap->value.data.length, ap->value.data.length, ap->value.data.buffer);
        break;
    case IMAP_list:
        if (ap = ap->value.list.head)
        {
            sfprintf(sfstdout, " (");
            do {
                imapdumparg(imap, ap, level + 1);
            } while (ap = ap->next);
            sfprintf(sfstdout, " )");
        }
        else
            sfprintf(sfstdout, " NIL");
        break;
    case IMAP_name:
        sfprintf(sfstdout, " %s", ap->value.name);
        break;
    case IMAP_number:
        sfprintf(sfstdout, " %ld", ap->value.number);
        break;
    case IMAP_string:
        sfprintf(sfstdout, " \"%s\"", ap->value.string);
        break;
    }
    if (!level)
        sfprintf(sfstdout, "\n");
}

/*
 * set mailbox flag capabilities
 */

static void
imapset(Imap_t* imap, register Imaparg_t* ap, int code)
{
    register int        i;
    register Imapflag_t*    fp;

    for (i = 0; i < elementsof(imapflags); i++)
        imapflags[i].code &= ~code;
    for (; ap; ap = ap->next)
        if (ap->type == IMAP_name && (fp = (Imapflag_t*)strsearch(imapflags, elementsof(imapflags), sizeof(imapflags[0]), stracmp, ap->value.name, NiL)))
        {
            if (fp->code == IMAP_FLAG_LOCAL)
                for (i = 0; i < elementsof(imapflags); i++)
                    if (imapflags[i].code & IMAP_FLAG_LOCAL)
                        imapflags[i].code |= code;
            fp->code |= code;
        }
}

/*
 * parse a response arg
 */

static char*
imapgetarg(Imap_t* imap, register Imapop_t* op, register Imaplist_t* lp, int* ep, register char* s)
{
    register int        c;
    register char*      b;
    register Imaparg_t* ap;
    register int        eol;
    int         m;
    char*           e;

    eol = ep ? *ep : 0;
    for (;;)
    {
        for (; isspace(*s); s++);
        if (*s)
        {
            if (*s == eol)
            {
                *ep = 0;
                return s + 1;
            }
            if (!(ap = vmnewof(op->vm, 0, Imaparg_t, 1, 0)))
                note(FATAL|SYSTEM, "Out of space [imap token]");
            if (lp->tail)
                lp->tail->next = ap;
            else
                lp->head = ap;
            lp->tail = ap;
            if (!eol && op->code <= IMAP_BYE && *s != '[')
            {
                ap->type = IMAP_string;
                ap->value.string = s;
                return 0;
            }
            switch (*s)
            {
            case '{':
                ap->type = IMAP_data;
                ap->value.data.length = strtol(s + 1, &e, 10);
                if (*e != '}' || !op->blocks || !(op->blocks = op->blocks->next))
                    goto name;
                ap->value.data.buffer = op->blocks->data;
                return e + 1;
            case '"':
                for (b = ++s; *s && *s != '"'; s++);
                if (*s)
                    *s++ = 0;
                ap->type = IMAP_string;
                ap->value.string = b;
                return s;
            case '[':
                m = ']';
                goto list;
            case '(':
                m = ')';
            list:
                ap->type = IMAP_list;
                ap->value.list.head = ap->value.list.tail = 0;
                s++;
                while ((s = imapgetarg(imap, op, &ap->value.list, &m, s)) && m);
                return s;
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                ap->type = IMAP_number;
                ap->value.number = strtol(s, &e, 10);
                return e;
            case 'N':
                if (*(s + 1) == 'I' && *(s + 2) == 'L' && !isalnum(*(s + 3)))
                {
                    ap->type = IMAP_list;
                    ap->value.list.head = 0;
                    return s + 3;
                }
                /*FALLTHROUGH*/
            default:
            name:
                m = 0;
                for (b = s; (c = *s); s++)
                    if (c == '[')
                        m = c;
                    else if (c == ']')
                        m = 0;
                    else if (m == 0)
                    {
                        if (c == eol)
                        {
                            *ep = 0;
                            break;
                        }
                        else if (isspace(c))
                            break;
                    }
                if (c)
                    *s++ = 0;
                ap->type = IMAP_name;
                ap->value.name = b;
                return s;
            }
        }
        if (!op->blocks || !(op->blocks = op->blocks->next))
            break;
        s = op->blocks->data;
    }
    return 0;
}

/*
 * output an arg value converting \r\n => \n
 */

static void
imapputarg(register Imap_t* imap, register Imaparg_t* ap)
{
    register char*  e;
    register char*  s;
    register char*  t;
    register int    n;

    switch (ap->type)
    {
    case IMAP_data:
        t = s = ap->value.data.buffer;
        e = s + ap->value.data.length;
        while (t = (char*)memchr(t, '\r', e - t))
        {
            if (++t >= e)
                break;
            if (*t != '\n')
                continue;
            *(t - 1) = '\n';
            n = t - s;
            if (imap->copy.prefix)
                sfwrite(imap->copy.fp, imap->copy.prefix, n > 1 ? imap->copy.prefixlen : imap->copy.emptylen);
            sfwrite(imap->copy.fp, s, n);
            if ((s = ++t) >= e)
                break;
        }
        if ((n = e - s) > 0)
        {
            if (imap->copy.prefix)
                sfwrite(imap->copy.fp, imap->copy.prefix, n > 1 ? imap->copy.prefixlen : imap->copy.emptylen);
            sfwrite(imap->copy.fp, s, e - s);
        }
        break;
    case IMAP_string:
        sfputr(imap->copy.fp, ap->value.string, '\n');
        break;
    }
}

/*
 * read and parse an IMAP server response
 */

static Imapop_t*
imapop(register Imap_t* imap)
{
    register char*      s;
    register char*      z;
    register size_t     n;
    register Imapop_t*  op;
    register Imapblock_t*   bp;
    register Imapblock_t*   bt;
    char*           b;
    char*           e;
    Imapblock_t*        bh;
    Imaplex_t*      xp;

    /*
     * read the first (possibly only) line of the response
     */

    if (!(s = sfgetr(imap->rp, '\n', 1)))
        return 0;
    if ((z = s + sfvalue(imap->rp)) > s && --z > s && *(z - 1) == '\r')
        *--z = 0;
    if (TRACING('m'))
        note(ERROR, "imap: mesg %s", s);

    /*
     * tag or *
     */

    for (; isspace(*s); s++);
    if (*s == '*')
    {
        for (; *++s && !isspace(*s););
        op = imap->op;
        op->state = IMAP_STATE_sent;
    }
    else
    {
        n = (int)strtol(s, &e, 10);
        s = e;
        op = imap->op + n;
    }
    if (op->state != IMAP_STATE_sent)
        note(ERROR, "imap: %d: internal error -- unknown operation", n);

    /*
     * clear/allocate the local response vm
     */

    if (op->vm)
        vmclear(op->vm);
    else if (!(op->vm = vmopen(&imap->vmdisc, Vmlast, 0)))
        note(FATAL|SYSTEM, "Out of space [imap vm]");

    /*
     * optional count
     */

    for (; isspace(*s); s++);
    if (isdigit(*s))
    {
        n = (int)strtol(s, &e, 10);
        for (s = e; isspace(*s); s++);
    }
    else
        n = 0;

    /*
     * response code
     */

    for (b = s; *s && !isspace(*s); s++);
    if (*s)
        for (*s++ = 0; isspace(*s); s++);
    op->code = (xp = (Imaplex_t*)strsearch(imapresponse, elementsof(imapresponse), sizeof(Imaplex_t), stracmp, b, NiL)) ? xp->code : IMAP_UNKNOWN;
    op->count = n;
    if (TRACING('r'))
        note(ERROR, "imap: recv %d %s %d %s", op - imap->op, imapname(imapresponse, elementsof(imapresponse), op->code), op->count, s);

    /*
     * if the message has imbedded literals there's
     * more input to consume and we have to cache what's
     * already been read
     */

    bt = 0;
    while (z > s && *(z - 1) == '}')
    {
        n = z - s + 1;
        if (!(bp = vmnewof(op->vm, 0, Imapblock_t, 1, n)))
            note(FATAL|SYSTEM, "Out of space [imap block]");
        memcpy(bp->data = (char*)(bp + 1), s, n);
        if (bt)
            bt->next = bp;
        else
            bh = bp;
        bt = bp;
        for (z -= 2; z > s && *z != '{'; z--);
        n = (size_t)strtol(z + 1, NiL, 10);
        if (!(bp = vmnewof(op->vm, 0, Imapblock_t, 1, n)))
            note(FATAL|SYSTEM, "Out of space [imap block]");
        if ((bp->length = n) && sfread(imap->rp, bp->data = (char*)(bp + 1), n) != n)
            return 0;
        bt = bt->next = bp;
        if (!(s = sfgetr(imap->rp, '\n', 1)))
            return 0;
        if ((z = s + sfvalue(imap->rp)) > s && --z > s && *(z - 1) == '\r')
            *--z = 0;
        if (TRACING('m'))
            note(ERROR, "imap: mesg %s", s);
    }
    if (bt)
    {
        if (!(bp = vmnewof(op->vm, 0, Imapblock_t, 1, n)))
            note(FATAL|SYSTEM, "Out of space [imap block]");
        bp->length = z - s;
        bp->data = s;
        bt->next = bp;
        s = bh->data;
    }
    else
        bh = 0;
    op->blocks = bh;
    op->args.head = op->args.tail = 0;
    while (s = imapgetarg(imap, op, &op->args, NiL, s));
    return op;
}

/*
 * handle EXPUNGE response
 */

static void
imap_EXPUNGE(Imap_t* imap, register Imapop_t* op)
{
}

/*
 * consume ENVELOPE response
 */

static void
imap_ENVELOPE(register Imap_t* imap, register Imaparg_t* vp, Msg_t* mp)
{
    register Imapmsg_t* ip;
    register char*      s;

    ip = (Imapmsg_t*)mp->m_info;
    if (!vp)
        return;
    if (s = vp->value.string)
    {
        s = fmttime("%a %b %e %H:%M %Z %Y", tmdate(s, NiL, NiL));
        if (ip->date)
            strcpy(ip->date, s);
        else
            ip->date = vmstrdup(imap->vm, s);
    }
    if (!(vp = vp->next))
        return;
    if (s = vp->value.string)
        ip->subject = vmstrdup(imap->vm, s);
    if (!(vp = vp->next) ||
        !(vp = vp->value.list.head) ||
        !(vp = vp->value.list.head) ||
        !(vp = vp->next) ||
        !(vp = vp->next))
        return;
    ip->from = vp->value.string;
    if (!(vp = vp->next))
        return;
    if ((s = vp->value.string) && state.var.local)
        s = localize(s);
    if (s && *s)
    {
        sfprintf(imap->tp, "%s@%s", ip->from, s);
        ip->from = struse(imap->tp);
    }
    ip->from = vmstrdup(imap->vm, ip->from);
}

/*
 * consume BODYSTRUCTURE response
 */

static void
imap_BODYSTRUCTURE(register Imap_t* imap, register Imaparg_t* ap, register Msg_t* mp, register Imapbody_t* bp)
{
    register char*      s;
    register Imappart_t*    pp;
    register Imaparg_t* vp;
    int*            id;

    if (!ap)
        return;
    if (!(pp = vmnewof(imap->vm, 0, Imappart_t, 1, 0)))
        note(FATAL, "out of space [imap part]");
    if (bp->lastpart)
        bp->lastpart->next = pp;
    else
        ((Imapmsg_t*)mp->m_info)->parts = pp;
    bp->lastpart = pp;
    (*bp->id)++;
    if (ap->type == IMAP_list)
    {
        pp->content = IMAP_CONTENT_multipart;
        if (bp->id >= &bp->idstack[elementsof(bp->idstack) - 1])
            note(FATAL, "imap: multipart nesting too deep -- %d max", elementsof(bp->idstack));
        *++bp->id = 0;
        do {
            imap_BODYSTRUCTURE(imap, ap->value.list.head, mp, bp);
        } while ((ap = ap->next) && ap->type == IMAP_list);
        bp->id--;
        sfputr(imap->tp, "multipart", -1);
        if (ap && ap->type == IMAP_string)
            sfprintf(imap->tp, "/%s", strlower(ap->value.string));
        pp->type = vmstrdup(imap->vm, struse(imap->tp));
        pp->id = "";
    }
    else
    {
        id = bp->idstack;
        sfprintf(imap->tp, "%d", *id);
        while (++id <= bp->id)
            sfprintf(imap->tp, ".%d", *id);
        pp->id = vmstrdup(imap->vm, struse(imap->tp));
        if (s = ap->value.string)
        {
            s = strlower(s);
            if (streq(s, "text"))
                pp->content = IMAP_CONTENT_text;
            else if (streq(s, "message"))
                pp->content = IMAP_CONTENT_message;
            else
                pp->content = IMAP_CONTENT_data;
            sfputr(imap->tp, s, -1);
        }
        if ((ap = ap->next) && (s = ap->value.string))
            sfprintf(imap->tp, "/%s", strlower(s));
        pp->type = vmstrdup(imap->vm, struse(imap->tp));
        if (!ap || !(ap = ap->next))
            return;
        if (vp = ap->value.list.head)
            do {
                s = vp->value.string;
                if (!(vp = vp->next))
                    break;
                if (s && streq(s, "NAME") && vp->value.string)
                {
                    pp->name = vmstrdup(imap->vm, vp->value.string);
                    break;
                }
            } while (vp = vp->next);
        if (!(ap = ap->next) ||
            !(ap = ap->next) ||
            !(ap = ap->next))
            return;
        if (ap->type == IMAP_string && ap->value.string)
            pp->encoding = vmstrdup(imap->vm, strlower(ap->value.string));
        if (!(ap = ap->next))
            return;
        pp->size = ap->value.number;
        if (!(ap = ap->next))
            return;
        switch (pp->content)
        {
        case IMAP_CONTENT_message:
            if (bp->id >= &bp->idstack[elementsof(bp->idstack) - 1])
                note(FATAL, "imap: message nesting too deep -- %d max", elementsof(bp->idstack));
            *++bp->id = 0;
            imap_ENVELOPE(imap, ap->value.list.head, mp);
            ap = ap->next;
            imap_BODYSTRUCTURE(imap, ap->value.list.head, mp, bp);
            bp->id--;
            break;
        case IMAP_CONTENT_text:
            pp->lines = ap->value.number;
            if (!pp->name)
            {
                if (!(ap = ap->next) || !(ap = ap->next))
                    return;
                if (ap->type == IMAP_list &&
                    (ap = ap->value.list.head) &&
                    (s = ap->value.string) &&
                    streq(s, "ATTACHMENT") &&
                    (ap = ap->next) &&
                    (ap = ap->value.list.head))
                    while ((s = ap->value.name) &&
                           (ap = ap->next))
                    {
                        if (streq(s, "FILENAME"))
                        {
                            pp->name = vmstrdup(imap->vm, ap->value.string);
                            break;
                        }
                        if (!(ap = ap->next))
                            break;
                    }
            }
            break;
        case IMAP_CONTENT_data:
            if (!pp->name)
            {
                sfprintf(imap->tp, "%d.att", ((Imapmsg_t*)mp->m_info)->attachments + 1);
                pp->name = vmstrdup(imap->vm, struse(imap->tp));
            }
            break;
        }
        if (pp->name)
        {
            mp->m_lines += 2;
            pp->content = IMAP_CONTENT_attachment;
            pp->attachment = ++((Imapmsg_t*)mp->m_info)->attachments;
        }
        else
            mp->m_lines += pp->lines;
    }
}

/*
 * handle FETCH response
 */

static void
imap_FETCH(Imap_t* imap, register Imapop_t* op)
{
    register Msg_t*     mp;
    register Imaparg_t* ap;
    register Imaparg_t* vp;
    register Imapmsg_t* ip;
    Imaplex_t*      xp;
    Imapflag_t*     fp;
    char*           s;
    Imapbody_t      body;

    if (op->count > state.msg.count)
        note(FATAL, "imap: %d: unknown message -- expected %d max", op->count, state.msg.count);
    mp = state.msg.list + op->count - 1;
    ip = (Imapmsg_t*)mp->m_info;
    if (ap = op->args.head)
    {
        if (ap->type == IMAP_list)
            ap = ap->value.list.head;
        while (ap)
        {
            if (ap->type != IMAP_name)
                xp = 0;
            else if (!(xp = (Imaplex_t*)strsearch(imapfetch, elementsof(imapfetch), sizeof(Imaplex_t), stracmp, ap->value.name, NiL)))
            {
                if (s = strchr(ap->value.name, '['))
                {
                    *s = 0;
                    xp = (Imaplex_t*)strsearch(imapfetch, elementsof(imapfetch), sizeof(Imaplex_t), stracmp, ap->value.name, NiL);
                    *s = '[';
                }
                if ((TRACING('u')) && !xp)
                    note(ERROR, "imap: %s: unknown response", ap->value.name);
            }
            if (ap = ap->next)
            {
                if (xp) switch (xp->code)
                {
                case IMAP_FETCH_BODY:
                    imapputarg(imap, ap);
                    break;
                case IMAP_FETCH_BODYSTRUCTURE:
                    memset(&body, 0, sizeof(body));
                    body.id = body.idstack - 1;
                    *body.idstack = 1;
                    imap_BODYSTRUCTURE(imap, ap->value.list.head, mp, &body);
                    break;
                case IMAP_FETCH_ENVELOPE:
                    imap_ENVELOPE(imap, ap->value.list.head, mp);
                    break;
                case IMAP_FETCH_FLAGS:
                    for (vp = ap->value.list.head; vp; vp = vp->next)
                        if (vp->type == IMAP_name && (fp = (Imapflag_t*)strsearch(imapflags, elementsof(imapflags), sizeof(imapflags[0]), stracmp, vp->value.name, NiL)))
                            mp->m_flag |= fp->flag;
                    break;
                case IMAP_FETCH_INTERNALDATE:
                    if (!ip->date && (s = ap->value.string))
                        ip->date = vmstrdup(imap->vm, fmttime("%a %b %e %H:%M %Z %Y", tmdate(s, NiL, NiL)));
                    break;
                case IMAP_FETCH_RFC822_SIZE:
                    mp->m_size = ap->value.number;
                    break;
                }
                else if (TRACING('u'))
                    note(ERROR, "imap: %s: unknown FETCH response", ap->value.name);
                ap = ap->next;
            }
        }
    }
}

/*
 * sync the state.msg.list from the server
 */

static void
imapsync(register Imap_t* imap)
{
    register Msg_t* mp;
    int     dot;

    dot = state.msg.dot ? (state.msg.dot - state.msg.list) : 0;
    while (state.msg.count < imap->mailbox.exists)
    {
        mp = newmsg(0);
        if (state.msg.count < imap->mailbox.unseen || !imap->mailbox.unseen)
            mp->m_flag = MUSED|MREAD;
    }
    if (imap->mailbox.unseen < 0)
        imap->mailbox.unseen = 1;
    else if (imap->mailbox.unseen > state.msg.count)
        imap->mailbox.unseen = state.msg.count;
    state.msg.dot = state.msg.list + dot;
}

/*
 * consume IMAP server info until tag is complete
 * tag<0 for any tag completed
 */

static Imapop_t*
imaprecv(register Imap_t* imap, register Imapop_t* wp)
{
    register int        n;
    register Imapop_t*  op;
    register Imaparg_t* ap;
    register Imaparg_t* sp;
    Imaplex_t*      xp;
    int         to;
    int         i;
    char*           s;

    if (!wp || wp == imap->op)
    {
        for (op = imap->op + 1;; op++)
            if (op >= &imap->op[elementsof(imap->op)])
                return 0;
            else if (op->state == IMAP_STATE_sent)
                break;
    }
    if (!wp)
        to = 0;
    else if (wp->state != IMAP_STATE_sent && wp != imap->op)
    {
        if (wp->code)
            return wp;
        note(ERROR, "imap: %d: operation never sent", wp - imap->op);
        return 0;
    }
    else
        to = -1;
    for (;;)
    {
        switch (sfpoll(&imap->rp, 1, to))
        {
        case 0:
            if (wp)
                note(ERROR, "imap: %d: operation not completed", wp - imap->op);
            break;
        case 1:
            if (op = imapop(imap))
            {
                if (TRACING('a'))
                {
                    note(ERROR, "imap: exec op %d count %d", op->code, op->count);
                    for (ap = op->args.head; ap; ap = ap->next)
                        imapdumparg(imap, ap, 0);
                }
                switch (op->code)
                {
                case IMAP_BAD:
                case IMAP_NO:
                    n = 1;
                    goto status;
                case IMAP_BYE:
                    n = !imap->exiting;
                    imap->connected = 0;
                    wp = op;
                    goto status;
                case IMAP_CAPABILITY:
                    for (ap = op->args.head; ap; ap = ap->next)
                        if (ap->type == IMAP_name)
                        {
                            s = ap->value.name;
                            /*UNDENT...*/

    if (strneq(s, "IMAP", 4))
    {
        s += 4;
        if ((i = (int)strtol(s, &s, 10)) >= imap->version)
        {
            if (i > imap->version)
                imap->revision = 0;
            imap->version = i;
            for (; *s && !isdigit(*s); s++);
            i = (int)strtol(s, NiL, 10);
            if (i > imap->revision)
                imap->revision = i;
        }
    }
    else if (strneq(s, "AUTH=", 5))
        if (xp = (Imaplex_t*)strsearch(imapauth, elementsof(imapauth), sizeof(Imaplex_t), stracmp, s + 5, NiL))
            imap->auth |= xp->code;

                            /*...INDENT*/
                        }
                    break;
                case IMAP_EXISTS:
                    if (imap->mailbox.exists < 0)
                        imap->mailbox.exists = op->count;
                    else
                    {
                        n = op->count - imap->mailbox.exists;
                        if (n > 0)
                            note(ERROR, "(NOTE %d new message%s incorporated)", n, n == 1 ? "" : "s");
                        else if (n < 0)
                        {
                            n = -n;
                            note(ERROR, "(NOTE %d message%s delected by another session)", n, n == 1 ? "" : "s");
                            vmclear(imap->vm);
                            state.msg.count = 0;
                        }
                        imap->mailbox.exists = op->count;
                        imapsync(imap);
                    }
                    break;
                case IMAP_EXPUNGE:
                    imap_EXPUNGE(imap, op);
                    break;
                case IMAP_FETCH:
                    imap_FETCH(imap, op);
                    break;
                case IMAP_FLAGS:
                    if ((ap = op->args.head) && ap->type == IMAP_list)
                        imapset(imap, ap->value.list.head, IMAP_FLAG_APPLICABLE);
                    break;
                case IMAP_LIST:
                    ap = op->args.head;
                    ap = ap->next;
                    ap = ap->next;
                    sfprintf(sfstdout, "@%s\n", ap->value.string);
                    break;
                case IMAP_OK:
                    n = 0;
                status:
                    /*
                     * check for status
                     */
                    if (ap = op->args.head)
                    {
                        if (ap->type == IMAP_list && (sp = ap->value.list.head) && sp->type == IMAP_name && (xp = (Imaplex_t*)strsearch(imapstatus, elementsof(imapstatus), sizeof(Imaplex_t), stracmp, sp->value.name, NiL)))
                        {
                            /*UNDENT...*/

    ap = ap->next;
    sp = sp->next;
    switch (xp->code)
    {
    case IMAP_STATUS_ALERT:
    case IMAP_STATUS_NEWNAME:
    case IMAP_STATUS_PARSE:
        n = 1;
        break;
    case IMAP_STATUS_PERMANENTFLAGS:
        if (sp && sp->type == IMAP_list)
            imapset(imap, sp->value.list.head, IMAP_FLAG_PERMANENT);
        break;
    case IMAP_STATUS_READ_ONLY:
        imap->mailbox.read_only = 1;
        break;
    case IMAP_STATUS_READ_WRITE:
        imap->mailbox.read_only = 0;
        break;
    case IMAP_STATUS_TRYCREATE:
        imap->mailbox.trycreate = 1;
        break;
    case IMAP_STATUS_UIDNEXT:
        imap->mailbox.uidnext = sp && sp->type == IMAP_number ? sp->value.number : 0;
        break;
    case IMAP_STATUS_UIDVALIDITY:
        imap->mailbox.uidvalidity = sp && sp->type == IMAP_number ? sp->value.number : 0;
        break;
    case IMAP_STATUS_UNSEEN:
        imap->mailbox.unseen = sp && sp->type == IMAP_number ? sp->value.number : 0;
        break;
    }

                            /*...INDENT*/
                            }
                        if (n && ap && ap->type == IMAP_string)
                            note(ERROR, "imap: %s", ap->value.string);
                    }
                    break;
                case IMAP_PREAUTH:
                    imap->authenticated = 1;
                    break;
                case IMAP_RECENT:
                    imap->mailbox.recent = op->count;
                    break;
                case IMAP_SEARCH:
                    for (ap = op->args.head; ap; ap = ap->next)
                        if (ap->type == IMAP_number)
                        {
                            imap->index->m_index = ap->value.number;
                            imap->index++;
                        }
                    break;
                }
                if (!op->retain)
                    imapfree(imap, op);
                if (wp == op || wp == imap->op)
                    return op;
            }
            continue;
        default:
            note(ERROR, "imap: lost server connection");
            break;
        }
        break;
    }
    return 0;
}

/*
 * va_list version of imapsend
 */

static Imapop_t*
imapvsend(register Imap_t* imap, int retain, const char* fmt, va_list ap)
{
    register int    i;
    register int    c;
    register int    q;
    register char*  s;
    va_list     oap;

    va_copy(oap, ap);

    /*
     * autologout may have dropped the connection
     * the autoreconnect is here
     */

    if (!imap->connected && imapconnect(imap))
        return 0;

    /*
     * grab a free tag
     * this might mean waiting for a previous one to finish
     */

    if (!(i = imap->tag))
        i = 1;
    c = i;
    while (imap->op[i].state)
    {
        if (++i >= elementsof(imap->op))
            i = 1;
        if (i == c)
            imaprecv(imap, imap->op);
    }
    imap->tag = i;

    /*
     * write the op
     */

    sfprintf(imap->np, "%d ", i);
    sfvprintf(imap->np, fmt, ap);
    s = struse(imap->np);
    q = 0;
    for (;;)
    {
        switch (c = *s++)
        {
        case 0:
            break;
        case '"':
        case '\'':
            sfputc(imap->tp, c);
            if (!q)
                q = c;
            continue;
        case ' ':
        case '\n':
        case '\r':
        case '\t':
            if (!q)
            {
                for (; (c = *s) && (c == ' ' || c == '\n' || c == '\r' || c == '\t'); s++);
                if (c && c != ')')
                    sfputc(imap->tp, ' ');
            }
            else
                sfputc(imap->tp, c);
            continue;
        case '(':
            sfputc(imap->tp, c);
            if (!q)
                for (; (c = *s) && (c == ' ' || c == '\n' || c == '\r' || c == '\t'); s++);
            continue;
        case ')':
            sfputc(imap->tp, c);
            if (!q)
            {
                for (; (c = *s) && (c == ' ' || c == '\n' || c == '\r' || c == '\t'); s++);
                if (c && c != ']')
                    sfputc(imap->tp, ' ');
            }
            continue;
        default:
            sfputc(imap->tp, c);
            continue;
        }
        break;
    }
    s = struse(imap->tp);
    if (TRACING('s'))
        note(ERROR, "imap: send %s", s);
    if (sfprintf(imap->sp, "%s\r\n", s) < 0 || sfsync(imap->sp) < 0)
    {
        note(ERROR|SYSTEM, "imap: server send error");
        i = 0;
    }
    if (!i)
        return 0;
    imap->op[i].state = IMAP_STATE_sent;
    imap->op[i].retain = retain;
    sfvsprintf(imap->op[i].msg, sizeof(imap->op[i].msg) - 1, fmt, oap);
    return imap->op + i;
}

/*
 * send a tagged imap op
 */

static Imapop_t*
imapsend(Imap_t* imap, int retain, const char* fmt, ...)
{
    Imapop_t*   op;
    va_list     ap;

    va_start(ap, fmt);
    op = imapvsend(imap, retain, fmt, ap);
    va_end(ap);
    return op;
}

/*
 * send and recv a tagged imap op
 */

static int
imapexec(Imap_t* imap, const char* fmt, ...)
{
    register Imapop_t*  op;
    va_list         ap;

    va_start(ap, fmt);
    op = imapvsend(imap, 1, fmt, ap);
    va_end(ap);
    if (!op || !imaprecv(imap, op))
        return 0;
    imapfree(imap, op);
    return op->code == IMAP_OK ? 0 : -1;
}

/*
 * connect and authenticate to the IMAP service
 */

static int
imapconnect(register Imap_t* imap)
{
    register char*  svc;
    int     fd;

    /*
     * imap->connected<0 means we got here from one of
     * the imapexec()'s in this function -- not good
     */

    if (imap->connected < 0)
    {
        note(FATAL, "imap: connection/authentication error");
        return -1;
    }

    /*
     * the old connection if any is useless now
     */

    if (imap->sp)
    {
        sfclose(imap->sp);
        imap->sp = 0;
    }
    if (imap->rp)
    {
        sfclose(imap->rp);
        imap->rp = 0;
    }
    if (!imap->host || !imap->user || !imap->meth)
    {
        register char*  host;
        register char*  user;
        register char*  meth;
        Sfio_t*     fp;

        /*
         * get the host and authentication info from the imap file
         *
         *  <host> [ <user> [ <meth> [ <arg> ... ] ] ]
         */

        if (fp = fileopen(state.var.imap, "IRXr"))
        {
            while (host = sfgetr(fp, '\n', 1))
            {
                for (; isspace(*host); host++);
                if (!*host || *host == '#')
                    continue;
                for (user = host; *user && !isspace(*user); user++);
                if (*user)
                    *user++ = 0;
                if (!imap->host || streq(imap->host, host))
                {
                    for (; isspace(*user); user++);
                    for (meth = user; *meth && !isspace(*meth); meth++);
                    if (*meth)
                        *meth++ = 0;
                    if (!imap->user || streq(imap->user, user))
                    {
                        for (; isspace(*meth); meth++);
                        goto match;
                    }
                }
            }
            host = 0;
            user = 0;
            meth = 0;
        }
        else
        {
            host = imap->host;
            user = imap->user;
            meth = imap->meth;
        }
    match:
        if (host && (!*host || streq(host, "*")))
            host = 0;
        if (!imap->host || host && !streq(host, imap->host))
            imap->host = host ? vmstrdup(imap->gm, host) : "local";
        if (user && (!*user || streq(user, "*")))
            user = 0;
        if (!imap->user || user && !streq(user, imap->user))
            imap->user = user ? vmstrdup(imap->gm, user) : state.var.user;
        if (meth && (!*meth || streq(meth, "*")))
            meth = 0;
        if (!imap->meth || meth && !streq(meth, imap->meth))
        {
            if (!meth)
            {
                if (streq(imap->user, "anonymous"))
                {
                    sfprintf(imap->tp, "LOGIN ANONYMOUS %s", state.var.user);
                    if (state.var.domain)
                        sfprintf(imap->tp, "@%s", state.var.domain);
                    meth = struse(imap->tp);
                }
                else
                    meth = "AUTHENTICATE XFILE";
            }
            imap->meth = vmstrdup(imap->gm, meth);
        }
        if (fp)
            sfclose(fp);
    }

    /*
     * connect to the service
     */

    sfprintf(imap->tp, "/dev/tcp/%s/inet.imap", imap->host);
    svc = struse(imap->tp);
    if ((fd = csopen(&cs, svc, 0)) < 0)
    {
        note(ERROR|SYSTEM, "imap: %s: cannot connect to service", svc);
        return -1;
    }
    if (!(imap->sp = sfnew(NiL, NiL, SF_UNBOUND, fd, SF_WRITE)) ||
        !(imap->rp = sfnew(NiL, NiL, SF_UNBOUND, fd, SF_READ)))
    {
        if (imap->sp)
        {
            sfclose(imap->sp);
            imap->sp = 0;
        }
        else
            close(fd);
        note(ERROR|SYSTEM, "imap: %s: cannot buffer service", svc);
        return -1;
    }
    imap->connected = -1;
    if (imapexec(imap, "CAPABILITY") || imap->version < IMAP_VERSION || imap->version == IMAP_VERSION && imap->revision < IMAP_REVISION)
    {
        if (imap->version)
            note(ERROR|SYSTEM, "imap: %s: service version %d.%d must be at least %d.%d", svc, imap->version, imap->revision, IMAP_VERSION, IMAP_REVISION);
        else
            note(ERROR|SYSTEM, "imap: %s: service connect error", svc);
        goto drop;
    }
    if (!imap->authenticated)
    {
        /*
         * do the authentication
         * imap->authenticated<0 is a hint to the
         * IMAP_MORE response to consult imap->meth
         */

        imap->authenticated = -1;
        if (imapexec(imap, "%s", imap->meth))
        {
            note(ERROR|SYSTEM, "imap: %s: service authentication error", svc);
            goto drop;
        }
        imap->authenticated = 1;
    }
    imap->connected = 1;
    return 0;
 drop:
    if (imap->sp)
    {
        sfclose(imap->sp);
        imap->sp = 0;
    }
    if (imap->rp)
    {
        sfclose(imap->rp);
        imap->rp = 0;
    }
    imap->connected = 0;
    return -1;
}

/*
 * print message and fail on VM_BADADDR,VM_NOMEM
 */

static int
vmexcept(Vmalloc_t* region, int type, void* obj, Vmdisc_t* disc)
{
    Vmstat_t    st;

    switch (type)
    {
    case VM_BADADDR:
        note(ERROR, "imap: invalid pointer %p passed to free or realloc", obj);
        imap_exit(1);
        return -1;
    case VM_NOMEM:
        vmstat(region, &st);
        note(ERROR, "imap: storage allocator out of space on %lu byte request ( region %lu segments %lu busy %lu:%lu:%lu free %lu:%lu:%lu )", (size_t)obj, st.extent, st.n_seg, st.n_busy, st.s_busy, st.m_busy, st.n_free, st.s_free, st.m_free);
        imap_exit(1);
        return -1;
    }
    return 0;
}

/*
 * initialize the IMAP service state
 */

static Imap_t*
imapinit(void)
{
    register Imap_t*    imap;

    if (!(imap = newof(0, Imap_t, 1, 0)))
    {
        note(ERROR|SYSTEM, "Out of space [imap]");
        return 0;
    }
    imap->vmdisc = *Vmdcheap;
    imap->vmdisc.exceptf = vmexcept;
    if (!(imap->gm = vmopen(&imap->vmdisc, Vmlast, 0)) || !(imap->vm = vmopen(&imap->vmdisc, Vmlast, 0)))
    {
        note(ERROR|SYSTEM, "Out of space [imap state vm]");
        if (imap->gm)
            vmclose(imap->gm);
        free(imap);
        return 0;
    }
    if (!(imap->mp = sfstropen()) || !(imap->tp = sfstropen()) || !(imap->np = sfstropen()))
    {
        note(ERROR|SYSTEM, "Out of space [imap tmp string stream]");
        vmclose(imap->gm);
        vmclose(imap->vm);
        free(imap);
        return 0;
    }
    imap->copy.fp = sfstdout;
    return state.msg.imap.state = (void*)imap;
}

/*
 * flush IMAP_STATE_sent requests and CLOSE
 */

static int
imapclose(register Imap_t* imap)
{
    register Msg_t* mp;
    register int    n;

    while (imaprecv(imap, imap->op));
    imap->selected = 0;
    if (state.folder == FIMAP)
    {
        n = 0;
        for (mp = state.msg.list; mp < state.msg.list + state.msg.count; mp++)
            if (!(mp->m_flag & MDELETE))
                n++;
        if (n)
            note(ERROR, "Held %d message%s in %s", n, n == 1 ? "" : "s", state.path.mail);
        else
            note(ERROR, "No more messages in %s", state.path.mail);
    }
    return imapexec(imap, "CLOSE");
}

/*
 * IMAP state.msg.list initialization
 */

int
imap_setptr(char* name, int isedit)
{
    register Imap_t*    imap;
    register char*      s;
    register char*      t;

    if (!(imap = IMAP) && (!name || !(imap = imapinit())))
        return -1;
    if (imap->selected && imapclose(imap))
        return -1;
    if (!name)
        return 0;
    vmclear(imap->vm);
    state.folder = FIMAP;
    memset(&imap->mailbox, sizeof(imap->mailbox), 0);
    imap->mailbox.exists = -1;

    /*
     * determine the service info
     * info from previous folders is cached
     * to preserve authentication
     * ${IMAP} provides defaults
     */

    if (streq(name, "@"))
        name = "@inbox";
    strncopy(state.path.prev, state.path.mail, sizeof(state.path.prev));
    if (name != state.path.mail)
        strncopy(state.path.mail, name, sizeof(state.path.mail));
    if (*name == '@')
        name++;
    else if (strneq(name, "imap://", 7))
    {
        sfprintf(imap->tp, "%s", name + 7);
        s = struse(imap->tp);
        if (!(t = strchr(s, '/')))
        {
            note(ERROR, "imap: %s: user name expected", name);
            return -1;
        }
        *t++ = 0;
        if (!imap->host || !streq(imap->host, s))
        {
            imap->host = vmstrdup(imap->gm, s);
            imap->connected = 0;
            imap->meth = 0;
        }
        if (s = strchr(t, '/'))
            *s++ = 0;
        if (!imap->user || !streq(imap->user, t))
        {
            imap->user = vmstrdup(imap->gm, t);
            imap->connected = 0;
            imap->meth = 0;
        }
        if (!s || !*s)
            name = "inbox";
        else
            name += (s - sfstrbase(imap->tp)) + 7;
    }
    if (!imap->connected && imapconnect(imap))
        return -1;
    if (imapexec(imap, "%s %s", state.readonly ? "EXAMINE" : "SELECT", name))
        return -1;
    imap->selected = 1;
    state.msg.count = 0;
    imapsync(imap);
    state.msg.dot = state.msg.list + imap->mailbox.unseen - 1;
    return 0;
}

/*
 * return message pointer given number
 */

static Msg_t*
imap_msg(int m)
{
    register Imap_t*    imap;
    register Msg_t*     mp;

    mp = state.msg.list + m - 1;
    if (!mp->m_info)
    {
        imap = IMAP;
        if (!(mp->m_info = (void*)vmnewof(imap->vm, 0, Imapmsg_t, 1, 0)))
            note(FATAL, "out of space [imap msg info]");
        if (imapexec(imap, "FETCH %d (RFC822.SIZE FLAGS ENVELOPE BODYSTRUCTURE INTERNALDATE)", m))
            note(FATAL, "imap: %d: cannot fetch message info", m);
        if (state.var.spam && !(mp->m_flag & (MSCAN|MSPAM)))
            setinput(mp);
        if (TRACING('b'))
        {
            register Imapmsg_t* ip;
            register Imappart_t*    pp;

            ip = (Imapmsg_t*)mp->m_info;
            for (pp = ip->parts; pp; pp = pp->next)
                note(ERROR, "imap: message %d id=%s content=%s type=%s encoding=%s name=%s size=%d/%d", m, pp->id, imapname(imapcontent, elementsof(imapcontent), pp->content), pp->type, pp->encoding, pp->name, pp->lines, pp->size);
        }
    }
    return mp;
}

/*
 * IMAP setinput()
 */

Sfio_t*
imap_setinput(register Msg_t* mp)
{
    register Imap_t*    imap = IMAP;
    int         m = mp - state.msg.list + 1;

    imap->copy.fp = imap->mp;
    sfstrseek(imap->mp, 0, SEEK_SET);
    if (imapexec(imap, "FETCH %d (BODY.PEEK[HEADER])", m))
        note(FATAL, "imap: %d: cannot fetch message header", m);
    imap->copy.fp = sfstdout;
    imap->mp->_endb = imap->mp->_next;
    sfseek(imap->mp, (Sfoff_t)0, SEEK_SET);
    return imap->mp;
}

/*
/*
 * IMAP command()
 */

int
imap_command(char* s)
{
    register Imap_t*    imap = IMAP;
    register int        n;
    int         items;
    char*           e;
    Imaplex_t*      xp;
    unsigned long       trace;

    if (strneq(s, "dump", 4) && (!(n = *(s + 4)) || isspace(n)))
    {
        for (s += 4; isspace(*s); s++);
        if (!*s)
        {
        list:
            sfprintf(sfstdout, "dump items are:");
            for (n = 0; n < elementsof(imapdump); n++)
                sfprintf(sfstdout, " %s", imapdump[n].name);
            sfprintf(sfstdout, "\n");
        }
        else for (items = 0;;)
        {
            for (; isspace(*s); s++);
            if (!*s)
                break;
            if (items++)
                sfprintf(sfstdout, "\n");
            if (!(xp = (Imaplex_t*)strpsearch(imapdump, elementsof(imapdump), sizeof(imapdump[0]), s, &e)))
            {
                note(ERROR, "%s: unknown dump item", s);
                goto list;
            }
            for (s = e; isspace(*s); s++);
            if (isdigit(*s))
            {
                n = strtol(s, &e, 0);
                s = e;
            }
            else if (*s == '*')
            {
                s++;
                n = -1;
            }
            else
                n = 0;
            switch (xp->code)
            {
            case IMAP_DUMP_FLAGS:
    for (n = 0; n < elementsof(imapflags); n++)
    sfprintf(sfstdout, "%15s%s%s\n", imapflags[n].name, (imapflags[n].code & IMAP_FLAG_APPLICABLE) ? " APPLICABLE" : "", (imapflags[n].code & IMAP_FLAG_PERMANENT) ? " PERMANENT" : "");
                break;
            case IMAP_DUMP_FOLDER:
    sfprintf(sfstdout, "           name %s\n", state.path.mail);
    sfprintf(sfstdout, "      delimiter %s\n", imap->mailbox.delimiter);
    sfprintf(sfstdout, "         exists %d\n", imap->mailbox.exists);
    sfprintf(sfstdout, "         recent %d\n", imap->mailbox.recent);
    sfprintf(sfstdout, "      read_only %d\n", imap->mailbox.recent);
    sfprintf(sfstdout, "      trycreate %d\n", imap->mailbox.trycreate);
    sfprintf(sfstdout, "        uidnext %d\n", imap->mailbox.uidnext);
    sfprintf(sfstdout, "    uidvalidity %d\n", imap->mailbox.uidvalidity);
    sfprintf(sfstdout, "         unseen %d\n", imap->mailbox.unseen);
                break;
            case IMAP_DUMP_MESSAGE:
            {
                register Msg_t*     mp;
                register Msg_t*     ep;
                register Imapmsg_t* ip;
                register Imappart_t*    pp;

                if (n > state.msg.count)
                {
                    sfprintf(sfstdout, "%d: invalid message", n);
                    break;
                }
                if (n < 0)
                {
                    mp = state.msg.list;
                    ep = state.msg.list + state.msg.count;
                }
                else if (n > 0)
                {
                    ep = state.msg.list + n;
                    mp = ep - 1;
                }
                else
                {
                    mp = state.msg.dot;
                    ep = mp + 1;
                }
                for (; mp < ep; mp++)
                {
                    sfprintf(sfstdout, "message %4d %s\n", mp - state.msg.list + 1, imapflagnames(imap->tp, imapmflags, elementsof(imapmflags), mp->m_flag));
                    if (ip = (Imapmsg_t*)mp->m_info)
                        for (pp = ip->parts; pp; pp = pp->next)
                            sfprintf(sfstdout, "%12s content=%s type=%s encoding=%s name=%s size=%d/%d\n", pp->id, imapname(imapcontent, elementsof(imapcontent), pp->content), pp->type, pp->encoding, pp->name, pp->lines, pp->size);
                }
                break;
            }
            case IMAP_DUMP_QUEUE:
            {
                register Imapop_t*  op;

                for (op = imap->op + 1; op < &imap->op[elementsof(imap->op)]; op++)
                    sfprintf(sfstdout, "        [%d] %s %s %d %s%s\n", op - imap->op, imapname(imapstate, elementsof(imapstate), op->state), imapname(imapresponse, elementsof(imapresponse), op->code), op->count, op->msg, op->retain ? " retain" : "");
                break;
            }
            case IMAP_DUMP_STATE:
    sfprintf(sfstdout, "           host %s\n", imap->host);
    sfprintf(sfstdout, "           user %s\n", imap->user);
    sfprintf(sfstdout, "           auth %s\n", imapflagnames(imap->tp, imapauth, elementsof(imapauth), imap->auth));
    sfprintf(sfstdout, "  authenticated %d\n", imap->authenticated);
    sfprintf(sfstdout, "      connected %d\n", imap->connected);
    sfprintf(sfstdout, "        exiting %d\n", imap->exiting);
    sfprintf(sfstdout, "       selected %d\n", imap->selected);
    sfprintf(sfstdout, "            tag %d\n", imap->tag);
    sfprintf(sfstdout, "        version %d.%d\n", imap->version, imap->revision);
                break;
            }
        }
        n = 0;
    }
    else
    {
        trace = state.trace;
        TRACE('r');
        n = imapexec(imap, "%s", s);
        state.trace = trace;
    }
    return n;
}

/*
 * IMAP copy()
 */

int
imap_copy(register struct msg* mp, Sfio_t* op, Dt_t** ignore, char* prefix, unsigned long flags)
{
    register Imap_t*    imap = IMAP;
    register Imapmsg_t* ip;
    register Imappart_t*    pp;
    register char*      s;
    register int        i;
    struct name*        np;

    /*
     * Compute the prefix string, without trailing whitespace
     */

    i = mp - state.msg.list + 1;
    mp = imap_msg(i);
    ip = (Imapmsg_t*)mp->m_info;
    imap->copy.fp = op;
    if (imap->copy.prefix = prefix)
    {
        imap->copy.prefixlen = strlen(prefix);
        s = prefix + imap->copy.prefixlen;
        while (--s >= prefix && isspace(*s));
        imap->copy.emptylen = (s + 1) - prefix;
        sfputr(op, imap->copy.prefix, -1);
    }
    sfprintf(op, "From %s %s\n", ip->from, ip->date);
    sfprintf(imap->tp, "FETCH %d (BODY[HEADER", i);
    if (ignore && *ignore)
    {
        if (ignore == &state.ignoreall)
            sfprintf(imap->tp, ".FIELDS NIL");
        else
        {
            if (dictflags(ignore) & RETAIN)
            {
                i = RETAIN;
                sfprintf(imap->tp, ".FIELDS (");
                s = "";
            }
            else
            {
                i = IGNORE;
                sfprintf(imap->tp, ".FIELDS.NOT (From");
                s = " ";
            }
            for (np = (struct name*)dtfirst(*ignore); np; np = (struct name*)dtnext(*ignore, np))
                if (np->flags & i)
                {
                    sfprintf(imap->tp, "%s%s", s, np->name);
                    s = " ";
                }
            sfprintf(imap->tp, ")");
        }
        sfprintf(imap->tp, "]");
        for (pp = ip->parts; pp; pp = pp->next)
            if (pp->content == IMAP_CONTENT_text)
                sfprintf(imap->tp, " BODY[%s]", pp->id);
    }
    else
        sfprintf(imap->tp, "] BODY[TEXT]");
    sfprintf(imap->tp, ")");
    if (imapexec(IMAP, struse(imap->tp)))
        note(FATAL, "imap: %d: cannot fetch message info", i);
    imap->copy.fp = sfstdout;
    imap->copy.prefix = 0;
    if (ignore && *ignore)
        for (pp = ip->parts; pp; pp = pp->next)
            if (pp->content == IMAP_CONTENT_attachment)
                sfprintf(op, "\n(attachment %3d %s %18s \"%s\")\n", pp->attachment, counts(1, pp->lines, pp->size), pp->type, pp->name);
    sfprintf(op, "\n");
    return 0;
}

/*
 * IMAP mkdir()
 */

int
imap_mkdir(char* s)
{
    if (*s == '@')
        s++;
    return imapexec(IMAP, "CREATE %s", s);
}

/*
 * IMAP rename()
 */

int
imap_rename(char* f, char* t)
{
    if (*f == '@')
        f++;
    if (*t == '@')
        t++;
    return imapexec(IMAP, "RENAME %s %s", f, t);
}

/*
 * IMAP rmdir()
 */

int
imap_rmdir(char* s)
{
    if (*s == '@')
        s++;
    return imapexec(IMAP, "DELETE %s", s);
}

/*
 * IMAP exit()
 */

void
imap_exit(int code)
{
    register Imap_t*    imap = IMAP;
    register Msg_t*     mp;

    if (state.folder == FIMAP)
        for (mp = state.msg.list; mp < state.msg.list + state.msg.count; mp++)
            if ((mp->m_flag & (MDELETE|MZOMBIE)) == MDELETE)
                imap_msgflags(mp, 0, MDELETE);
    imap->selected = 0;
    if (imap->connected)
        imap_quit();
    exit(code);
}

/*
 * IMAP folders()
 */

int
imap_folders(void)
{
    return imapexec(IMAP, "LIST \"\" *");
}

/*
 * IMAP getatt()
 */

static int
imap_getatt(Msg_t* mp, register Imappart_t* pp, register char* name, unsigned long flags, off_t* lines, off_t* chars)
{
    register Imap_t*    imap = IMAP;
    register char*      s;
    register int        n;
    char*           cmd;

    if (!(cmd = iscmd(name)))
    {
        if (state.var.attachments && name == pp->name)
        {
            sfprintf(state.path.temp, "%s/%s", state.var.attachments, name);
            name = struse(state.path.temp);
        }
        if (!(name = expand(name, 1)))
            return 1;
    }
    if (pp->encoding && mime(1) && mimeview(state.part.mime, "encoding", name, pp->type, pp->options))
        pp->encoding = pp->type;
    if (pp->encoding && !isdigit(pp->encoding[0]))
    {
        sfprintf(state.path.temp, "uudecode -h -x %s", pp->encoding);
        if (!mimecmp("text", pp->type, NiL))
            sfprintf(state.path.temp, " -t");
        if (cmd)
            sfprintf(state.path.temp, " -o - | %s", cmd);
        else if (filestd(name, "w"))
            sfprintf(state.path.temp, " | %s", state.var.pager);
        else
        {
            sfprintf(state.path.temp, " -o ", name);
            shquote(state.path.temp, name);
        }
        s = struse(state.path.temp);
        n = 1;
    }
    else if (cmd)
    {
        s = cmd;
        n = -1;
    }
    else if (filestd(name, "w"))
    {
        s = state.var.pager;
        n = -1;
    }
    else
    {
        s = name;
        n = 0;
    }
    if (state.var.debug)
    {
        note(DEBUG, "%s `%s'", n ? "pipe" : "file", s);
        if ((flags & GMIME) &&
            mime(1) &&
            (s = mimeview(state.part.mime, NiL, name, pp->type, pp->options)))
            note(DEBUG, "mimeview `%s'", s);
        return 0;
    }
    if (!(imap->copy.fp = n ? pipeopen(s, "w") : fileopen(s, "ERw"))) {
        imap->copy.fp = sfstdout;
        return 1;
    }
    if (lines)
        *lines = pp->lines;
    if (chars)
        *chars = pp->size;
    n = mp - state.msg.list + 1;
    if (imapexec(imap, "FETCH %d (BODY[%s])", n, pp->id))
        note(FATAL, "imap: %d: cannot fetch message info", n);
    imap->copy.fp = sfstdout;
    fileclose(imap->copy.fp);
    if (flags & GDISPLAY)
        note(ERROR, "\"%s\" %s", name, counts(1, pp->lines, pp->size));
    if ((flags & GMIME) &&
        mime(1) &&
        (s = mimeview(state.part.mime, NiL, name, pp->type, pp->options)) &&
        (n = start_command(state.var.shell, SIG_REG_EXEC, -1, -1, "-c", s, NiL)) >= 0)
        wait_command(n);
    return 0;
}

/*
 * IMAP get1()
 */

int
imap_get1(char** argv, unsigned long flags)
{
    register Imappart_t*    pp;
    register int        i;
    register char*      s;
    Msg_t*          mp;
    Imapmsg_t*      ip;
    char*           name;
    char*           a;
    char*           e;
    int         n;
    int         r;

    if (state.msg.dot < state.msg.list || state.msg.dot >= state.msg.list + state.msg.count)
    {
        note(ERROR, "No current message");
        return 1;
    }
    mp = imap_msg(state.msg.dot - state.msg.list + 1);
    ip = (Imapmsg_t*)mp->m_info;
    if (!ip->attachments || !(pp = ip->parts))
    {
        note(ERROR, "No attachments in current message");
        return 1;
    }
    if (!*argv)
    {
        do {
            if (pp->content == IMAP_CONTENT_attachment)
                sfprintf(sfstdout, "(attachment %3d %s %18s \"%s\")\n", pp->attachment, counts(1, pp->lines, pp->size), pp->type, pp->name);
        } while (pp = pp->next);
        return 0;
    }
    if (!(a = newof(0, char, ip->attachments, 1)))
        note(PANIC, "Out of space [imap attachments]");
    s = *argv++;
    r = 0;
    for (;;)
    {
        while (isspace(*s))
            s++;
        if (!*s)
            break;
        else if (*s == ',')
        {
            s++;
            r = 0;
        }
        else if (*s == '*')
        {
            if (!r)
                r = 1;
            for (i = r; i <= ip->attachments; i++)
                a[i] = 1;
            r = 0;
        }
        else if (*s == '-')
        {
            s++;
            r = 1;
        }
        else
        {
            n = strtol(s, &e, 0);
            if (n > 0 && n <= ip->attachments)
            {
                if (r)
                {
                    for (i = r; i <= n; i++)
                        a[i] = 1;
                    r = 0;
                }
                else
                    a[n] = 1;
            }
            else
            {
                note(ERROR, "%s: invalid attachment number", s);
                while (*e && !isspace(*e))
                    e++;
            }
            s = e;
            if (*s == '-')
            {
                s++;
                r = n;
            }
        }
    }
    r = 0;
    for (i = 1; i <= ip->attachments; i++)
        if (a[i])
        {
            while (pp->attachment != i)
                if (!(pp = pp->next))
                {
                    note(ERROR, "%d: attachment number out of range", i);
                    r = 1;
                    goto done;
                }
            if (pp->content != IMAP_CONTENT_attachment)
            {
                note(ERROR, "%d: not an attachment", i);
                continue;
            }
            if (name = *argv)
                argv++;
            else
                name = pp->name;
            if (imap_getatt(mp, pp, name, flags, NiL, NiL))
                r = 1;
        }
 done:
    free(a);
    return r;
}

/*
 * IMAP printhead()
 */

void
imap_printhead(int m, int who)
{
    register Msg_t*     mp;
    register Imapmsg_t* ip;
    char*           sizes;
    int         subjlen;
    int         current;
    int         disposition;

    mp = imap_msg(m);
    if (mp->m_flag & (MDELETE|MNONE))
        return;
    ip = (Imapmsg_t*)mp->m_info;
    current = state.msg.dot == mp && !state.var.justheaders ? '>' : ' ';
    if (mp->m_flag & MBOX)
        disposition = 'M';
    else if (mp->m_flag & MPRESERVE)
        disposition = 'P';
    else if (mp->m_flag & MSAVE)
        disposition = '*';
    else if (mp->m_flag & MSPAM)
        disposition = 'X';
    else if (!(mp->m_flag & (MREAD|MNEW)))
        disposition = 'U';
    else if ((mp->m_flag & (MREAD|MNEW)) == MNEW)
        disposition = 'N';
    else
        disposition = who ? 'R' : ' ';
    if (who)
    {
        if (!state.var.domain || strchr(ip->from, '@'))
            printf("%c %s\n", disposition, ip->from);
        else
            printf("%c %s@%s\n", disposition, ip->from, state.var.domain);
    }
    else
    {
        sizes = counts(!!state.var.news, mp->m_lines, mp->m_size);
        subjlen = state.screenwidth - 50 - strlen(sizes);
        if (ip->subject && subjlen >= 0)
            printf("%c%c%3d %-20.20s  %16.16s %s %.*s\n",
                current, disposition, m, ip->from, ip->date, sizes,
                subjlen, ip->subject);
        else
            printf("%c%c%3d %-20.20s  %16.16s %s\n",
                current, disposition, m, ip->from, ip->date, sizes);
    }
}

/*
 * imap_msgflags() support
 */

static void
imap_flags(register Imap_t* imap, Msg_t* mp, register int flags, char* op)
{
    register int    i;
    register int    c;

    if (TRACING('z'))
        note(ERROR, "IMAP: smap_flags msg=%d flags=0x%04x op=%s", mp - state.msg.list + 1, flags, op);
    sfprintf(imap->tp, "STORE %d %sFLAGS.SILENT ", mp - state.msg.list + 1, op);
    c = '(';
    for (i = 0; i < elementsof(imapflags); i++)
        if ((imapflags[i].flag & flags) && (imapflags[i].code & IMAP_FLAG_PERMANENT))
        {
            sfprintf(imap->tp, "%c%s", c, imapflags[i].name);
            c = ' ';
        }
    if (c == ' ')
    {
        sfprintf(imap->tp, ")");
        if (!imapsend(imap, 0, "%s", struse(imap->tp)))
            note(ERROR, "%d: message flags not updated", mp - state.msg.list + 1);
    }
    else
        sfstrseek(imap->tp, 0, SEEK_SET);
}

/*
 * IMAP message flag update
 */

void
imap_msgflags(register Msg_t* mp, int set, int clr)
{
    register Imap_t*    imap = IMAP;
    register int        flags;

    if (mp->m_flag & ~clr & MDELETE)
        return;
    if (flags = mp->m_flag & clr)
    {
        mp->m_flag &= ~clr;
        if (flags & (MDELETE|MREAD|MSCAN|MSPAM))
            imap_flags(imap, mp, flags, "-");
    }
    if (flags = ~mp->m_flag & set)
    {
        mp->m_flag |= set;
        if (flags & (MDELETE|MREAD|MSCAN|MSPAM))
            imap_flags(imap, mp, flags, "+");
    }
}

/*
 * IMAP message search/list
 * '(' IMAP SEARCH expression ')'
 */

int
imap_msglist(register char* s)
{
    register Imap_t*    imap = IMAP;
    register char*      t;

    for (; isspace(*s); s++);
    if (*s != '(')
    {
        note(ERROR, "imap: %s: invalid SEARCH expression", s);
        return 0;
    }
    s++;
    t = s + strlen(s);
    for (; t > s && isspace(*--t) && *t != ')';);
    imap->index = state.msg.list;
    if (imapexec(imap, "SEARCH %*.*s", t - s, t - s, s))
        return 0;
    imap->index->m_index = 0;
    return imap->index - state.msg.list;
}

/*
 * IMAP quit()
 */

void
imap_quit(void)
{
    register Imap_t*    imap = IMAP;
    register int        i;

    state.msg.imap.state = 0;
    if (imap->selected)
        imapclose(imap);
    imap->exiting = 1;
    imapexec(imap, "LOGOUT");
    for (i = 0; i < elementsof(imap->op); i++)
        if (imap->op[i].vm)
            vmclose(imap->op[i].vm);
    if (imap->gm)
        vmclose(imap->gm);
    if (imap->vm)
        vmclose(imap->vm);
    if (imap->np)
        sfclose(imap->np);
    if (imap->sp)
        sfclose(imap->sp);
    if (imap->rp)
        sfclose(imap->rp);
    if (imap->mp)
        sfclose(imap->mp);
    if (imap->tp)
        sfclose(imap->tp);
}

/*
 * IMAP save()
 */

int
imap_save(register Msg_t* mp, char* folder)
{
    return imapexec(IMAP, "COPY %d %s", mp - state.msg.list + 1, folder + 1);
}

#else

/*
 * stubs when IMAP can't fly
 */

int
imap_setptr(char* name, int isedit)
{
    note(ERROR, "imap: support not enabled");
    return -1;
}

#endif