int
imap4d_uid (struct imap4d_command *command, imap4d_tokbuf_t tok)
{
char *cmd;
int rc = RESP_NO;
char *err_text = "Completed";
if (imap4d_tokbuf_argc (tok) < 3)
return util_finish (command, RESP_BAD, "Invalid arguments");
cmd = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
if (mu_c_strcasecmp (cmd, "FETCH") == 0)
rc = imap4d_fetch0 (tok, 1, &err_text);
else if (mu_c_strcasecmp (cmd, "COPY") == 0)
rc = imap4d_copy0 (tok, 1, &err_text);
else if (mu_c_strcasecmp (cmd, "STORE") == 0)
rc = imap4d_store0 (tok, 1, &err_text);
else if (mu_c_strcasecmp (cmd, "SEARCH") == 0)
rc = imap4d_search0 (tok, 1, &err_text);
else
{
err_text = "Uknown uid command";
rc = RESP_BAD;
}
return util_finish (command, rc, "%s %s", cmd, err_text);
}
/* Return T if letter precedence is 'bulk' or 'junk' */
static int
bulk_precedence_p (mu_header_t hdr)
{
int rc = 0;
const char *str;
if (mu_header_sget_value (hdr, MU_HEADER_PRECEDENCE, &str) == 0)
{
rc = mu_c_strcasecmp (str, "bulk") == 0
|| mu_c_strcasecmp (str, "junk") == 0;
}
return rc;
}
static int
list_attr_conv (void *item, void *data)
{
struct imap_list_element *elt = item;
struct mu_list_response *rp = data;
if (elt->type != imap_eltype_string)
return 0;
if (mu_c_strcasecmp (elt->v.string, "\\Noinferiors"))
rp->type |= MU_FOLDER_ATTRIBUTE_DIRECTORY;
if (mu_c_strcasecmp (elt->v.string, "\\Noselect"))
rp->type |= MU_FOLDER_ATTRIBUTE_FILE;
/* FIXME: \Marked nad \Unmarked have no correspondence in flags. */
return 0;
}
static int
folder_pop_get_authority (mu_folder_t folder, mu_authority_t *pauth)
{
int status = 0;
if (folder->authority == NULL)
{
/* assert (folder->url); */
if (folder->url == NULL)
return EINVAL;
if (folder->url->auth == NULL
|| strcmp (folder->url->auth, "*") == 0)
{
status = mu_authority_create (&folder->authority, NULL, folder);
mu_authority_set_authenticate (folder->authority, _pop_user, folder);
}
/*
"+apop" could be supported.
Anything else starting with "+" is an extension mechanism.
Without a "+" it's a SASL mechanism.
*/
else if (mu_c_strcasecmp (folder->url->auth, "+APOP") == 0)
{
status = mu_authority_create (&folder->authority, NULL, folder);
mu_authority_set_authenticate (folder->authority, _pop_apop, folder);
}
else
{
status = MU_ERR_BAD_AUTH_SCHEME;
}
}
if (pauth)
*pauth = folder->authority;
return status;
}
static int
compare_action (void *item, void *data)
{
struct comp_op *op = item;
struct comp_data *dp = data;
char *a, *ap, *b, *bp;
mu_header_t h;
if (mu_message_get_header (dp->m[0], &h)
|| mu_header_aget_value (h, op->field, &a))
return 0;
if (mu_message_get_header (dp->m[1], &h)
|| mu_header_aget_value (h, op->field, &b))
{
free (a);
return 0;
}
ap = a;
bp = b;
if (mu_c_strcasecmp (op->field, MU_HEADER_SUBJECT) == 0)
{
if (mu_c_strncasecmp (ap, "re:", 3) == 0)
ap += 3;
if (mu_c_strncasecmp (b, "re:", 3) == 0)
bp += 3;
}
dp->r = op->comp (ap, bp);
free (a);
free (b);
return dp->r; /* go on until the difference is found */
}
static int
eat_args (imap4d_tokbuf_t tok)
{
int n = IMAP4_ARG_1;
char *p;
p = imap4d_tokbuf_getarg (tok, n++);
if (!p)
return RESP_BAD;
if (mu_c_strcasecmp (p, "NIL") == 0)
{
if (imap4d_tokbuf_getarg (tok, n))
return RESP_BAD;
return RESP_OK;
}
else if (p[0] != '(')
return RESP_BAD;
/* Collect arguments */
while ((p = imap4d_tokbuf_getarg (tok, n++)))
{
if (p[0] == ')')
{
if (imap4d_tokbuf_getarg (tok, n))
return RESP_BAD;
return RESP_OK;
}
}
return RESP_BAD;
}
int
mu_url_is_scheme (mu_url_t url, const char *scheme)
{
if (url && scheme && url->scheme
&& mu_c_strcasecmp (url->scheme, scheme) == 0)
return 1;
return 0;
}
int
smtp_kw (const char *name)
{
static struct kw {
char *name;
int code;
} kw[] = {
{ "ehlo", KW_EHLO },
{ "helo", KW_HELO },
{ "mail", KW_MAIL },
{ "rcpt", KW_RCPT },
{ "data", KW_DATA },
{ "help", KW_HELP },
{ "quit", KW_QUIT },
{ NULL },
};
int i;
for (i = 0; kw[i].name != NULL; i++)
if (mu_c_strcasecmp (name, kw[i].name) == 0)
return kw[i].code;
return -1;
}
int
imap4d_list (struct imap4d_session *session,
struct imap4d_command *command, imap4d_tokbuf_t tok)
{
char *ref;
char *wcard;
if (imap4d_tokbuf_argc (tok) != 4)
return io_completion_response (command, RESP_BAD, "Invalid arguments");
ref = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
wcard = imap4d_tokbuf_getarg (tok, IMAP4_ARG_2);
/* If wildcard is empty, it is a special case: we have to
return the hierarchy. */
if (*wcard == '\0')
{
if (*ref)
io_untagged_response (RESP_NONE,
"LIST (\\NoSelect) \"%c\" \"%c\"",
MU_HIERARCHY_DELIMITER,
MU_HIERARCHY_DELIMITER);
else
io_untagged_response (RESP_NONE,
"LIST (\\NoSelect) \"%c\" \"\"",
MU_HIERARCHY_DELIMITER);
}
/* There is only one mailbox in the "INBOX" hierarchy ... INBOX. */
else if (mu_c_strcasecmp (ref, "INBOX") == 0
|| (ref[0] == 0 && mu_c_strcasecmp (wcard, "INBOX") == 0))
{
io_untagged_response (RESP_NONE, "LIST (\\NoInferiors) NIL INBOX");
}
else
{
int status;
mu_folder_t folder;
char *cwd;
char *p, *q;
struct refinfo refinfo;
switch (*wcard)
{
/* Absolute Path in wcard, dump the old ref. */
case '/':
{
ref = calloc (2, 1);
ref[0] = *wcard;
wcard++;
}
break;
/* Absolute Path, but take care of things like ~guest/Mail,
ref becomes ref = ~guest. */
case '~':
{
char *s = strchr (wcard, '/');
if (s)
{
ref = calloc (s - wcard + 1, 1);
memcpy (ref, wcard, s - wcard);
ref [s - wcard] = '\0';
wcard = s + 1;
}
else
{
ref = mu_strdup (wcard);
wcard += strlen (wcard);
}
}
break;
default:
ref = mu_strdup (ref);
}
/* Move any directory not containing a wildcard into the reference
So (ref = ~guest, wcard = Mail/folder1/%.vf) -->
(ref = ~guest/Mail/folder1, wcard = %.vf). */
for (p = wcard; (q = strpbrk (p, "/%*")) && *q == '/'; p = q + 1)
;
if (p > wcard)
{
size_t seglen = p - wcard;
size_t reflen = strlen (ref);
int addslash = (reflen > 0 && ref[reflen-1] != '/');
size_t len = seglen + reflen + addslash + 1;
ref = realloc (ref, len);
if (addslash)
ref[reflen++] = '/';
memcpy (ref + reflen, wcard, seglen);
ref[reflen + seglen] = 0;
wcard += seglen;
}
/* Allocates. */
cwd = namespace_checkfullpath (ref, wcard, NULL);
if (!cwd)
{
free (ref);
return io_completion_response (command, RESP_NO,
"The requested item could not be found.");
}
status = mu_folder_create (&folder, cwd);
if (status)
{
free (ref);
free (cwd);
return io_completion_response (command, RESP_NO,
"The requested item could not be found.");
}
/* Force the right matcher */
mu_folder_set_match (folder, mu_folder_imap_match);
memset (&refinfo, 0, sizeof refinfo);
refinfo.refptr = ref;
refinfo.reflen = strlen (ref);
refinfo.pfxlen = strlen (cwd);
refinfo.homelen = strlen (imap4d_homedir);
/* The special name INBOX is included in the output from LIST, if
INBOX is supported by this server for this user and if the
uppercase string "INBOX" matches the interpreted reference and
mailbox name arguments with wildcards as described above. The
criteria for omitting INBOX is whether SELECT INBOX will return
failure; it is not relevant whether the user's real INBOX resides
on this or some other server. */
if (!*ref &&
(mu_imap_wildmatch (wcard, "INBOX", MU_HIERARCHY_DELIMITER) == 0
|| mu_imap_wildmatch (wcard, "inbox", MU_HIERARCHY_DELIMITER) == 0))
io_untagged_response (RESP_NONE, "LIST (\\NoInferiors) NIL INBOX");
mu_folder_enumerate (folder, NULL, wcard, 0, 0, NULL,
list_fun, &refinfo);
mu_folder_destroy (&folder);
free (refinfo.buf);
free (cwd);
free (ref);
}
return io_completion_response (command, RESP_OK, "Completed");
}
static int
headercmp (const void *item, const void *data)
{
return mu_c_strcasecmp (item, data);
}
static int
store_thunk (imap4d_parsebuf_t p)
{
struct store_parse_closure *pclos = imap4d_parsebuf_data (p);
char *mstr;
char *data;
int status;
char *end;
mstr = imap4d_parsebuf_next (p, 1);
data = imap4d_parsebuf_next (p, 1);
if (*data == '+')
{
pclos->how = STORE_ADD;
data++;
}
else if (*data == '-')
{
pclos->how = STORE_UNSET;
data++;
}
else
pclos->how = STORE_SET;
if (mu_c_strcasecmp (data, "FLAGS"))
imap4d_parsebuf_exit (p, "Bogus data item");
data = imap4d_parsebuf_next (p, 1);
if (*data == '.')
{
data = imap4d_parsebuf_next (p, 1);
if (mu_c_strcasecmp (data, "SILENT") == 0)
{
pclos->ack = 0;
imap4d_parsebuf_next (p, 1);
}
else
imap4d_parsebuf_exit (p, "Bogus data suffix");
}
status = mu_msgset_create (&pclos->msgset, mbox, MU_MSGSET_NUM);
if (status)
imap4d_parsebuf_exit (p, "Software error");
/* Get the message numbers in set[]. */
status = mu_msgset_parse_imap (pclos->msgset,
pclos->isuid ? MU_MSGSET_UID : MU_MSGSET_NUM,
mstr, &end);
if (status)
imap4d_parsebuf_exit (p, "Failed to parse message set");
if (strcmp (p->token, "NIL"))
{
if (p->token[0] != '(')
imap4d_parsebuf_exit (p, "Syntax error");
while (imap4d_parsebuf_next (p, 1) && p->token[0] != ')')
if (mu_imap_flag_to_attribute (p->token, &pclos->type))
imap4d_parsebuf_exit (p, "Unrecognized flag");
}
return RESP_OK;
}
static int
comp_text (void *a, void *b)
{
return mu_c_strcasecmp (a, b);
}
void
smtp (int fd)
{
int state, c;
char *buf = NULL;
size_t size = 0;
mu_mailbox_t mbox;
mu_message_t msg;
char *tempfile;
char *rcpt_addr;
in = fdopen (fd, "r");
out = fdopen (fd, "w");
SETVBUF (in, NULL, _IOLBF, 0);
SETVBUF (out, NULL, _IOLBF, 0);
smtp_reply (220, "Ready");
for (state = STATE_INIT; state != STATE_QUIT; )
{
int argc;
char **argv;
int kw, len;
if (getline (&buf, &size, in) == -1)
exit (1);
len = strlen (buf);
while (len > 0 && (buf[len-1] == '\n' || buf[len-1] == '\r'))
len --;
buf[len] = 0;
if (mu_argcv_get (buf, "", NULL, &argc, &argv))
exit (1);
kw = smtp_kw (argv[0]);
if (kw == KW_QUIT)
{
smtp_reply (221, "Done");
state = STATE_QUIT;
mu_argcv_free (argc, argv);
continue;
}
switch (state)
{
case STATE_INIT:
switch (kw)
{
case KW_EHLO:
case KW_HELO:
if (argc == 2)
{
smtp_reply (250, "pleased to meet you");
state = STATE_EHLO;
}
else
smtp_reply (501, "%s requires domain address", argv[0]);
break;
default:
smtp_reply (503, "Polite people say HELO first");
break;
}
break;
case STATE_EHLO:
switch (kw)
{
case KW_MAIL:
if (argc == 2)
from_person = check_prefix (argv[1], "from:");
else if (argc == 3 && mu_c_strcasecmp (argv[1], "from:") == 0)
from_person = argv[2];
else
from_person = NULL;
if (from_person)
{
from_person = strdup (from_person);
smtp_reply (250, "Sender OK");
state = STATE_MAIL;
}
else
smtp_reply (501, "Syntax error");
break;
default:
smtp_reply (503, "Need MAIL command");
}
break;
case STATE_MAIL:
switch (kw)
{
case KW_RCPT:
if (argc == 2)
rcpt_addr = check_prefix (argv[1], "to:");
else if (argc == 3 && mu_c_strcasecmp (argv[1], "to:") == 0)
rcpt_addr = argv[2];
else
rcpt_addr = NULL;
if (rcpt_addr)
{
if (add_recipient (rcpt_addr))
smtp_reply (451, "Recipient not accepted");
else
{
smtp_reply (250, "Recipient OK");
state = STATE_RCPT;
}
}
else
smtp_reply (501, "Syntax error");
break;
default:
smtp_reply (503, "Need RCPT command");
}
break;
case STATE_RCPT:
switch (kw)
{
case KW_RCPT:
if (argc == 2)
rcpt_addr = check_prefix (argv[1], "to:");
else if (argc == 3 && mu_c_strcasecmp (argv[1], "to:") == 0)
rcpt_addr = argv[2];
else
rcpt_addr = NULL;
if (rcpt_addr)
{
if (add_recipient (rcpt_addr))
smtp_reply (451, "Recipient not accepted");
else
{
smtp_reply (250, "Recipient OK");
state = STATE_RCPT;
}
}
else
smtp_reply (501, "Syntax error");
break;
case KW_DATA:
smtp_reply (354,
"Enter mail, end with \".\" on a line by itself");
make_tmp (in, from_person, &tempfile);
if ((c = mu_mailbox_create_default (&mbox, tempfile)) != 0)
{
mu_error ("%s: can't create mailbox %s: %s",
progname,
tempfile, mu_strerror (c));
unlink (tempfile);
exit (1);
}
if ((c = mu_mailbox_open (mbox, MU_STREAM_RDWR)) != 0)
{
mu_error ("%s: can't open mailbox %s: %s",
progname,
tempfile, mu_strerror (c));
unlink (tempfile);
exit (1);
}
mu_mailbox_get_message (mbox, 1, &msg);
if (message_finalize (msg, 0) == 0)
mta_send (msg);
else
smtp_reply (501, "can't send message"); /*FIXME: code?*/
unlink (tempfile);
mu_address_destroy (&recipients);
from_person = NULL;
smtp_reply (250, "Message accepted for delivery");
state = STATE_EHLO;
break;
default:
smtp_reply (503, "Invalid command");
break;
}
break;
}
mu_argcv_free (argc, argv);
}
close (fd);
}
/* FIXME: How do we do this ??????:
IF a new mailbox is created with the same name as a mailbox which was
deleted, its unique identifiers MUST be greater than any unique identifiers
used in the previous incarnation of the mailbox. */
int
imap4d_create (struct imap4d_session *session,
struct imap4d_command *command, imap4d_tokbuf_t tok)
{
char *name;
int isdir = 0;
int ns;
int rc = RESP_OK;
const char *msg = "Completed";
if (imap4d_tokbuf_argc (tok) != 3)
return io_completion_response (command, RESP_BAD, "Invalid arguments");
name = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
if (*name == '\0')
return io_completion_response (command, RESP_BAD, "Too few arguments");
/* Creating, "Inbox" should always fail. */
if (mu_c_strcasecmp (name, "INBOX") == 0)
return io_completion_response (command, RESP_BAD, "Already exist");
/* RFC 3501:
If the mailbox name is suffixed with the server's hierarchy
separator character, this is a declaration that the client intends
to create mailbox names under this name in the hierarchy.
The trailing delimiter will be removed by namespace normalizer, so
test for it now.
*/
if (name[strlen (name) - 1] == MU_HIERARCHY_DELIMITER)
isdir = 1;
/* Allocates memory. */
name = namespace_getfullpath (name, &ns);
if (!name)
return io_completion_response (command, RESP_NO, "Cannot create mailbox");
/* It will fail if the mailbox already exists. */
if (access (name, F_OK) != 0)
{
if (make_interdir (name, MU_HIERARCHY_DELIMITER, MKDIR_PERMISSIONS))
{
rc = RESP_NO;
msg = "Cannot create mailbox";
}
if (rc == RESP_OK && !isdir)
{
mu_mailbox_t mbox;
rc = mu_mailbox_create_default (&mbox, name);
if (rc)
{
mu_diag_output (MU_DIAG_ERR,
_("Cannot create mailbox %s: %s"), name,
mu_strerror (rc));
rc = RESP_NO;
msg = "Cannot create mailbox";
}
else if ((rc = mu_mailbox_open (mbox,
MU_STREAM_RDWR | MU_STREAM_CREAT
| mailbox_mode[ns])))
{
mu_diag_output (MU_DIAG_ERR,
_("Cannot open mailbox %s: %s"),
name, mu_strerror (rc));
rc = RESP_NO;
msg = "Cannot create mailbox";
}
else
{
mu_mailbox_close (mbox);
mu_mailbox_destroy (&mbox);
rc = RESP_OK;
}
}
}
else
{
rc = RESP_NO;
msg = "already exists";
}
return io_completion_response (command, rc, "%s", msg);
}
/* :comparator i;ascii-casemap */
static int
i_ascii_casemap_is (const char *pattern, const char *text)
{
return mu_c_strcasecmp (pattern, text) == 0;
}
static int
i_ascii_casemap_eq (const char *pattern, const char *text)
{
return mu_c_strcasecmp (text, pattern);
}
void
message_display_parts (mu_message_t msg, int indent)
{
int ret, j;
size_t nparts;
mu_message_t part;
mu_header_t hdr;
mu_stream_t str;
mu_body_t body;
int ismulti;
size_t nbytes;
/* How many parts does the message has? */
if ((ret = mu_message_get_num_parts (msg, &nparts)) != 0)
{
fprintf (stderr, "mu_message_get_num_parts - %s\n", mu_strerror (ret));
exit (2);
}
/* Iterate through all the parts.
Treat type "message/rfc822" differently, since it is a message of
its own that can have other subparts(recursive). */
for (j = 1; j <= nparts; j++)
{
int status;
const char *hvalue;
char *type = NULL;
const char *encoding = "";
MU_ASSERT (mu_message_get_part (msg, j, &part));
MU_ASSERT (mu_message_get_header (part, &hdr));
status = mu_header_sget_value (hdr, MU_HEADER_CONTENT_TYPE,
&hvalue);
if (status == MU_ERR_NOENT)
/* nothing */;
else if (status != 0)
mu_error ("Cannot get header value: %s", mu_strerror (status));
else
{
status = mu_mimehdr_aget_disp (hvalue, &type);
if (status)
mu_error ("Cannot extract content type field: %s",
mu_strerror (status));
}
printf ("%*.*sType of part %d = %s\n", indent, indent, "",
j, type ? type : "");
print_message_part_sizes (part, indent);
if (mu_header_sget_value (hdr, MU_HEADER_CONTENT_TRANSFER_ENCODING,
&encoding))
encoding = "";
ismulti = 0;
if ((type
&& mu_c_strcasecmp (type, "message/rfc822") == 0)
|| (mu_message_is_multipart (part, &ismulti) == 0 && ismulti))
{
if (!ismulti)
MU_ASSERT (mu_message_unencapsulate (part, &part, NULL));
MU_ASSERT (mu_message_get_header (part, &hdr));
if (mu_header_sget_value (hdr, MU_HEADER_FROM, &from))
from = "";
if (mu_header_sget_value (hdr, MU_HEADER_SUBJECT, &subject))
subject = "";
printf ("%*.*sEncapsulated message : %s\t%s\n",
indent, indent, "", from, subject);
printf ("%*.*sBegin\n", indent, indent, "");
message_display_parts (part, indent + indent_level);
mu_message_destroy (&part, NULL);
}
else if (!type
|| (mu_c_strcasecmp (type, "text/plain") == 0)
|| (mu_c_strcasecmp (type, "text/html")) == 0)
{
printf ("%*.*sText Message\n", indent, indent, "");
printf ("%*.*sBegin\n", indent, indent, "");
mu_message_get_body (part, &body);
mu_body_get_streamref (body, &str);
/* Make sure the original body stream is not closed when
str gets destroyed */
mu_filter_create (&str, str, encoding, MU_FILTER_DECODE,
MU_STREAM_READ);
while (mu_stream_readline (str, buf, sizeof (buf), &nbytes) == 0
&& nbytes)
{
printf ("%*.*s%s", indent, indent, "", buf);
}
mu_stream_destroy (&str);
}
else
{
/* Save the attachements. */
char *fname = NULL;
mu_message_aget_decoded_attachment_name (part, charset,
&fname, NULL);
if (fname == NULL)
fname = mu_tempname (NULL);
printf ("%*.*sAttachment - saving [%s]\n", indent, indent, "",
fname);
printf ("%*.*sBegin\n", indent, indent, "");
if (charset)
{
mu_mime_io_buffer_t info;
mu_mime_io_buffer_create (&info);
mu_mime_io_buffer_set_charset (info, charset);
MU_ASSERT (mu_message_save_attachment (part, NULL, info));
mu_mime_io_buffer_destroy (&info);
}
else
MU_ASSERT (mu_message_save_attachment (part, fname, NULL));
if (print_attachments)
print_file (fname, indent);
free (fname);
}
printf ("\n%*.*sEnd\n", indent, indent, "");
free (type);
}
}
