int
main (int argc, char **argv)
{
int index;
mu_msgset_t msgset;
mu_mailbox_t mbox;
mu_url_t url;
struct mark_closure clos;
MU_APP_INIT_NLS ();
mh_argp_init ();
mh_argp_parse (&argc, &argv, 0, options, mh_option, args_doc, doc,
opt_handler, NULL, &index);
mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
mu_mailbox_get_url (mbox, &url);
mbox_dir = mu_url_to_string (url);
if (memcmp (mbox_dir, "mh:", 3) == 0)
mbox_dir += 3;
argc -= index;
argv += index;
mh_msgset_parse (&msgset, mbox, argc, argv, "cur");
clos.mbox = mbox;
clos.msgset = msgset;
//FIXME: msgset operates on UIDs but there's no way to inform it about that.
switch (action)
{
case ARG_ADD:
if (!seq_list)
{
mu_error (_("--add requires at least one --sequence argument"));
return 1;
}
mu_list_foreach (seq_list, action_add, (void *) &clos);
mh_global_save_state ();
break;
case ARG_DELETE:
if (!seq_list)
{
mu_error (_("--delete requires at least one --sequence argument"));
return 1;
}
mu_list_foreach (seq_list, action_delete, (void *) &clos);
mh_global_save_state ();
break;
case ARG_LIST:
if (!seq_list)
list_all (mbox);
else
mu_list_foreach (seq_list, action_list, &clos);
break;
}
mu_mailbox_close (mbox);
mu_mailbox_destroy (&mbox);
return 0;
}
static void
_free_reglist (void *data)
{
mu_list_t list = data;
mu_list_foreach (list, _free_regex, NULL);
mu_list_destroy (&list);
}
int
main (int argc, char **argv)
{
int status;
int index;
mu_mailbox_t mbox;
mu_msgset_t msgset;
int interactive = mh_interactive_mode_p ();
MU_APP_INIT_NLS ();
for (index = 1; index < argc; index++)
{
int colon = 0, cpos;
if (argv[index][0] == '-' && argv[index][1] == '-' &&
!strchr (argv[index], '=') &&
(!interactive ||
(colon = argv[index][cpos = strlen (argv[index]) - 1] == ':') ||
*mu_str_skip_class_comp (argv[index], MU_CTYPE_UPPER)) &&
index + 1 < argc)
{
if (colon)
{
cpos -= 2;
mu_asprintf (&argv[index], "--component=%*.*s", cpos, cpos,
argv[index] + 2);
}
else
mu_asprintf (&argv[index], "--component=%s", argv[index] + 2);
mu_asprintf (&argv[index + 1], "--pattern=%s", argv[index + 1]);
index++;
}
}
mh_help_hook = pick_help_hook;
mh_argp_init ();
mh_argp_parse (&argc, &argv, 0, options, mh_option,
args_doc, doc, opt_handler, NULL, &index);
if (pick_parse (lexlist))
return 1;
mbox = mh_open_folder (mh_current_folder (),
seq_list ? MU_STREAM_RDWR : MU_STREAM_READ);
argc -= index;
argv += index;
if (seq_list)
mu_msgset_create (&picked_message_uids, NULL, MU_MSGSET_UID);
mh_msgset_parse (&msgset, mbox, argc, argv, "all");
status = mu_msgset_foreach_message (msgset, pick_message, NULL);
if (picked_message_uids)
mu_list_foreach (seq_list, action_add, mbox);
mh_global_save_state ();
mu_mailbox_close (mbox);
mu_mailbox_destroy (&mbox);
return status;
}
static void
list_untagged_handler (mu_imap_t imap, mu_list_t resp, void *data)
{
struct list_closure *clos = data;
struct imap_list_element *elt;
size_t count;
if (clos->error_code)
return;
mu_list_count (resp, &count);
if (count == 4 &&
_mu_imap_list_nth_element_is_string (resp, 0, clos->command))
{
struct mu_list_response *rp;
rp = calloc (1, sizeof (*rp));
if (!rp)
{
clos->error_code = ENOMEM;
return;
}
elt = _mu_imap_list_at (resp, 1);
if (!(elt && elt->type == imap_eltype_list))
return;
rp->type = 0;
mu_list_foreach (elt->v.list, list_attr_conv, rp);
elt = _mu_imap_list_at (resp, 3);
if (!(elt && elt->type == imap_eltype_string))
return;
rp->name = strdup (elt->v.string);
if (!rp->name)
{
free (rp);
clos->error_code = ENOMEM;
return;
}
elt = _mu_imap_list_at (resp, 2);
if (!elt)
return;
if (_mu_imap_list_element_is_nil (elt))
{
rp->separator = 0;
rp->level = 0;
}
else if (elt->type != imap_eltype_string)
return;
else
{
rp->separator = elt->v.string[0];
rp->level = count_level (rp->name, rp->separator);
}
if ((clos->error_code = mu_list_append (clos->retlist, rp)))
mu_list_response_free (rp);
}
}
static int
sieve_init_load_path ()
{
static int inited = 0;
if (!inited)
{
if (lt_dlinit ())
return 1;
mu_list_foreach (mu_sieve_library_path_prefix, _add_load_dir, NULL);
#ifdef MU_SIEVE_MODDIR
_add_load_dir (MU_SIEVE_MODDIR, NULL);
#endif
mu_list_foreach (mu_sieve_library_path, _add_load_dir, NULL);
inited = 1;
}
return 0;
}
mu_sieve_comparator_t
mu_sieve_get_comparator (mu_sieve_machine_t mach, mu_list_t tags)
{
mu_sieve_comparator_t comp = NULL;
mu_list_foreach (tags, _find_comparator, &comp);
return comp ? comp : mu_sieve_comparator_lookup (mach,
"i;ascii-casemap",
MU_SIEVE_MATCH_IS);
}
int
pop3d_capa (char *arg, struct pop3d_session *sess)
{
if (strlen (arg) != 0)
return ERR_BAD_ARGS;
pop3d_outf ("+OK Capability list follows\n");
mu_list_foreach (sess->capa, print_capa, sess);
pop3d_outf (".\n");
return OK;
}
static int
list_filters ()
{
mu_list_t list;
int rc = mu_filter_get_list (&list);
if (rc)
{
mu_diag_funcall (MU_DIAG_ERROR, "mu_filter_get_list", NULL, rc);
return 1;
}
return mu_list_foreach (list, filter_printer, NULL);
}
int
imap4d_authenticate (struct imap4d_session *session,
struct imap4d_command *command, imap4d_tokbuf_t tok)
{
char *auth_type;
struct imap4d_auth adata;
enum imap4d_auth_result res;
if (imap4d_tokbuf_argc (tok) != 3)
return io_completion_response (command, RESP_BAD, "Invalid arguments");
auth_type = imap4d_tokbuf_getarg (tok, IMAP4_ARG_1);
if (tls_required)
return io_completion_response (command, RESP_NO,
"Command disabled: Use STARTTLS first");
adata.command = command;
adata.auth_type = auth_type;
adata.username = NULL;
res = mu_list_foreach (imap_auth_list, _auth_try, &adata);
switch (res)
{
case imap4d_auth_nosup:
return io_completion_response (command, RESP_NO,
"Authentication mechanism not supported");
case imap4d_auth_ok:
return 0;
case imap4d_auth_resp:
if (adata.response == RESP_OK && adata.username)
{
if (imap4d_session_setup (adata.username))
return io_completion_response (command, RESP_NO,
"User name or passwd rejected");
else
return io_completion_response (command, RESP_OK,
"%s authentication successful",
auth_type);
}
/* fall through */
case imap4d_auth_fail:
adata.response = RESP_NO;
break;
}
return io_completion_response (command, adata.response,
"%s authentication failed", auth_type);
}
static void
com_lsub (mu_folder_t folder, char **argv)
{
int rc;
mu_list_t list;
mu_printf ("listing subscriptions for '%s' '%s'\n", argv[0], argv[1]);
rc = mu_folder_lsub (folder, argv[0], argv[1], &list);
if (rc)
mu_diag_funcall (MU_DIAG_ERROR, "mu_folder_lsub", argv[0], rc);
else
{
mu_list_foreach (list, _print_list_entry, NULL);
mu_list_destroy (&list);
}
}
/* Negate the message set: on return PNSET consists of the messages
_not contained_ in the input message set. */
int
mu_msgset_negate (mu_msgset_t msgset, mu_msgset_t *pnset)
{
int rc;
struct invert_closure clos;
size_t total;
if (!msgset)
return EINVAL;
if (!msgset->mbox)
return MU_ERR_NOT_OPEN;
rc = mu_msgset_aggregate (msgset);
if (rc)
return rc;
rc = mu_mailbox_messages_count (msgset->mbox, &total);
if (rc)
return rc;
if (msgset->flags == MU_MSGSET_UID)
{
rc = mu_mailbox_translate (msgset->mbox,
MU_MAILBOX_MSGNO_TO_UID,
total, &total);
if (rc)
return rc;
}
rc = mu_msgset_create (&clos.nset, msgset->mbox, msgset->flags);
if (rc)
return rc;
clos.next_num = 1;
rc = mu_list_foreach (msgset->list, _invert_range, &clos);
if (rc == 0)
{
if (clos.next_num < total)
rc = mu_msgset_add_range (clos.nset, clos.next_num, total,
clos.nset->flags);
}
if (rc)
mu_msgset_free (clos.nset);
else
*pnset = clos.nset;
return rc;
}
int
main (int argc, char **argv)
{
int i;
char *host = NULL;
char *infile = NULL;
char *port = NULL;
int tls = 0;
int raw = 1;
int flags = 0;
mu_stream_t stream;
mu_smtp_t smtp;
mu_stream_t instr;
char *from = NULL;
mu_list_t rcpt_list = NULL;
mu_list_t meth_list = NULL;
mu_list_t skiphdr_list = NULL;
struct mu_sockaddr *sa;
struct mu_sockaddr_hints hints;
mu_set_program_name (argv[0]);
mu_stdstream_setup (MU_STDSTREAM_RESET_NONE);
if (argc < 2)
usage ();
memset (&hints, 0, sizeof (hints));
hints.flags = MU_AH_DETECT_FAMILY;
hints.port = 25;
hints.protocol = IPPROTO_TCP;
hints.socktype = SOCK_STREAM;
MU_ASSERT (mu_smtp_create (&smtp));
for (i = 1; i < argc; i++)
{
if (strncmp (argv[i], "port=", 5) == 0)
port = argv[i] + 5;
else if (strncmp (argv[i], "family=", 7) == 0)
{
hints.flags &= ~MU_AH_DETECT_FAMILY;
switch (argv[i][7])
{
case '4':
hints.family = AF_INET;
break;
case '6':
hints.family = AF_INET6;
break;
default:
mu_error ("invalid family name: %s", argv[i]+7);
exit (1);
}
}
else if (strncmp (argv[i], "trace=", 6) == 0)
{
char *arg = argv[i] + 6;
if (mu_isdigit (arg[0]))
mu_smtp_trace (smtp, atoi (argv[i] + 6) ?
MU_SMTP_TRACE_SET : MU_SMTP_TRACE_CLR);
else
{
mu_smtp_trace (smtp, MU_SMTP_TRACE_SET);
if (strcmp (arg, "secure") == 0)
mu_smtp_trace_mask (smtp, MU_SMTP_TRACE_SET,
MU_XSCRIPT_SECURE);
else if (strcmp (arg, "payload") == 0)
mu_smtp_trace_mask (smtp, MU_SMTP_TRACE_SET,
MU_XSCRIPT_PAYLOAD);
}
}
else if (strncmp (argv[i], "tls=", 4) == 0)
tls = atoi (argv[i] + 4);
else if (strncmp (argv[i], "domain=", 7) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_DOMAIN,
argv[i] + 7));
else if (strncmp (argv[i], "user="******"pass="******"service=", 8) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_SERVICE,
argv[i] + 8));
else if (strncmp (argv[i], "realm=", 6) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_REALM,
argv[i] + 6));
else if (strncmp (argv[i], "host=", 5) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_HOST,
argv[i] + 5));
else if (strncmp (argv[i], "url=", 4) == 0)
MU_ASSERT (mu_smtp_set_param (smtp, MU_SMTP_PARAM_URL,
argv[i] + 4));
else if (strncmp (argv[i], "input=", 6) == 0)
infile = argv[i] + 6;
else if (strncmp (argv[i], "raw=", 4) == 0)
raw = atoi (argv[i] + 4);
else if (strncmp (argv[i], "rcpt=", 5) == 0)
{
if (!rcpt_list)
MU_ASSERT (mu_list_create (&rcpt_list));
MU_ASSERT (mu_list_append (rcpt_list, argv[i] + 5));
}
else if (strncmp (argv[i], "from=", 5) == 0)
from = argv[i] + 5;
else if (strncmp (argv[i], "auth=", 5) == 0)
update_list (&meth_list, argv[i] + 5);
else if (strncmp (argv[i], "skiphdr=", 8) == 0)
{
update_list (&skiphdr_list, argv[i] + 8);
raw = 0;
}
else if (host)
{
mu_error ("server name already given: %s, new name %s?",
host, argv[i]);
exit (1);
}
else
host = argv[i];
}
if (!host)
usage ();
if (!raw)
flags = MU_STREAM_SEEK;
if (infile)
MU_ASSERT (mu_file_stream_create (&instr, infile, MU_STREAM_READ|flags));
else
MU_ASSERT (mu_stdio_stream_create (&instr, MU_STDIN_FD, flags));
host = argv[1];
MU_ASSERT (mu_sockaddr_from_node (&sa, host, port, &hints));
MU_ASSERT (mu_tcp_stream_create_from_sa (&stream, sa, NULL, MU_STREAM_RDWR));
mu_smtp_set_carrier (smtp, stream);
mu_stream_unref (stream);
if (!from)
{
from = getenv ("USER");
if (!from)
{
mu_error ("cannot determine sender name");
exit (1);
}
}
if (raw && !rcpt_list)
{
mu_error ("no recipients");
exit (1);
}
MU_ASSERT (mu_smtp_open (smtp));
MU_ASSERT (mu_smtp_ehlo (smtp));
if (tls && mu_smtp_capa_test (smtp, "STARTTLS", NULL) == 0)
{
MU_ASSERT (mu_smtp_starttls (smtp));
MU_ASSERT (mu_smtp_ehlo (smtp));
}
if (meth_list)
{
int status;
MU_ASSERT (mu_smtp_add_auth_mech_list (smtp, meth_list));
status = mu_smtp_auth (smtp);
switch (status)
{
case 0:
MU_ASSERT (mu_smtp_ehlo (smtp));
break;
case ENOSYS:
case MU_ERR_NOENT:
/* Ok, skip it */
break;
default:
mu_error ("authentication failed: %s", mu_strerror (status));
exit (1);
}
}
MU_ASSERT (mu_smtp_mail_basic (smtp, from, NULL));
mu_list_foreach (rcpt_list, send_rcpt_command, smtp);
if (raw)
{
/* Raw sending mode: send from the stream directly */
MU_ASSERT (mu_smtp_send_stream (smtp, instr));
}
else
{
/* Message (standard) sending mode: send a MU message. */
mu_message_t msg;
mu_stream_t ostr, bstr;
mu_header_t hdr;
mu_iterator_t itr;
mu_body_t body;
if (skiphdr_list)
mu_list_set_comparator (skiphdr_list, headercmp);
MU_ASSERT (mu_stream_to_message (instr, &msg));
mu_stream_unref (instr);
MU_ASSERT (mu_smtp_data (smtp, &ostr));
MU_ASSERT (mu_message_get_header (msg, &hdr));
MU_ASSERT (mu_header_get_iterator (hdr, &itr));
for (mu_iterator_first (itr); !mu_iterator_is_done (itr);
mu_iterator_next (itr))
{
const char *name;
void *value;
mu_iterator_current_kv (itr, (void*) &name, &value);
if (mu_list_locate (skiphdr_list, (void*) name, NULL) == 0)
continue;
mu_stream_printf (ostr, "%s: %s\n", name, (char*)value);
}
mu_iterator_destroy (&itr);
MU_ASSERT (mu_stream_write (ostr, "\n", 1, NULL));
MU_ASSERT (mu_message_get_body (msg, &body));
MU_ASSERT (mu_body_get_streamref (body, &bstr));
MU_ASSERT (mu_stream_copy (ostr, bstr, 0, NULL));
mu_stream_destroy (&bstr);
mu_stream_close (ostr);
mu_stream_destroy (&ostr);
}
MU_ASSERT (mu_smtp_dot (smtp));
MU_ASSERT (mu_smtp_quit (smtp));
mu_smtp_destroy (&smtp);
mu_stream_close (instr);
mu_stream_destroy (&instr);
return 0;
}
void
imap4d_auth_capability ()
{
mu_list_foreach (imap_auth_list, _auth_capa, NULL);
}