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 int
test_and_update_prop (mu_property_t prop, const char *from,
time_t now, unsigned int days,
mu_sieve_machine_t mach)
{
const char *result;
char *timebuf;
time_t last;
int rc = mu_property_sget_value (prop, from, &result);
switch (rc)
{
case MU_ERR_NOENT:
break;
case 0:
if (days == 0)
return 1;
last = (time_t) strtoul (result, NULL, 0);
if (last + (24 * 60 * 60 * days) > now)
return 1;
break;
default:
mu_sieve_error (mach, "%lu: mu_property_sget_value: %s",
(unsigned long) mu_sieve_get_message_num (mach),
mu_strerror (rc));
return -1;
}
rc = mu_asprintf (&timebuf, "%lu", (unsigned long) now);
if (rc)
{
mu_sieve_error (mach, "%lu: mu_asprintf: %s",
(unsigned long) mu_sieve_get_message_num (mach),
mu_strerror (rc));
return -1;
}
rc = mu_property_set_value (prop, from, timebuf, 1);
free (timebuf);
if (rc)
{
mu_sieve_error (mach, "%lu: mu_property_set_value: %s",
(unsigned long) mu_sieve_get_message_num (mach),
mu_strerror (rc));
return -1;
}
rc = mu_property_save (prop);
if (rc)
{
mu_sieve_error (mach, "%lu: mu_property_save: %s",
(unsigned long) mu_sieve_get_message_num (mach),
mu_strerror (rc));
return -1;
}
return 0;
}
static int
mbox_append_message (mu_mailbox_t mailbox, mu_message_t msg)
{
int status = 0;
mbox_data_t mud = mailbox->data;
mu_off_t qid;
if (msg == NULL || mud == NULL)
return EINVAL;
MU_DEBUG1 (mailbox->debug, MU_DEBUG_TRACE1, "mbox_append_message (%s)\n",
mud->name);
switch (mud->state)
{
case MBOX_NO_STATE:
if ((status = mu_locker_lock (mailbox->locker)) != 0)
{
MU_DEBUG1 (mailbox->debug, MU_DEBUG_TRACE1,
"mbox_append_message: %s\n",
mu_strerror(status));
return status;
}
default:
{
mu_off_t size;
/* Move to the end of the file, not necesary if _APPEND mode. */
if ((status = mu_stream_size (mailbox->stream, &size)) != 0
|| (qid = size,
status = mbox_append_message0 (mailbox, msg,
&size, 0, 0)) != 0)
{
if (status != EAGAIN)
mu_locker_unlock (mailbox->locker);
return status;
}
}
}
mu_locker_unlock (mailbox->locker);
if (mailbox->observable)
{
char *buf = NULL;
mu_asprintf (&buf, "%lu", (unsigned long) qid);
mu_observable_notify (mailbox->observable, MU_EVT_MESSAGE_APPEND, buf);
free (buf);
}
return 0;
}
int
mu_sockaddr_format (char **pbuf, const struct sockaddr *sa, socklen_t salen)
{
int rc = MU_ERR_FAILURE;
switch (sa->sa_family)
{
#ifdef MAILUTILS_IPV6
case AF_INET:
case AF_INET6:
{
char host[NI_MAXHOST];
char srv[NI_MAXSERV];
if (getnameinfo (sa, salen,
host, sizeof (host), srv, sizeof (srv),
NI_NUMERICHOST|NI_NUMERICSERV) == 0)
{
if (sa->sa_family == AF_INET6)
rc = mu_asprintf (pbuf, "inet6://[%s]:%s", host, srv);
else
rc = mu_asprintf (pbuf, "inet://%s:%s", host, srv);
}
else
rc = mu_asprintf (pbuf, "%s://[getnameinfo failed]",
sa->sa_family == AF_INET ?
"inet" : "inet6");
break;
}
#else
case AF_INET:
{
struct sockaddr_in *s_in = (struct sockaddr_in *)sa;
rc = mu_asprintf (pbuf, "inet://%s:%hu",
inet_ntoa (s_in->sin_addr), s_in->sin_port);
break;
}
#endif
case AF_UNIX:
{
struct sockaddr_un *s_un = (struct sockaddr_un *)sa;
if (S_UN_NAME (s_un, salen)[0] == 0)
rc = mu_asprintf (pbuf, "unix://[anonymous socket]");
else
rc = mu_asprintf (pbuf, "unix://%s", s_un->sun_path);
break;
}
default:
rc = mu_asprintf (pbuf, "family:%d", sa->sa_family);
}
return rc;
}
static int
_ndbm_file_safety (mu_dbm_file_t db, int mode, uid_t owner)
{
int rc;
char *name;
rc = mu_asprintf (&name, "%s.pag", db->db_name);
if (rc)
return rc;
rc = mu_file_safety_check (name, mode, owner, NULL);
if (rc)
{
free (name);
return rc;
}
strcpy (name + strlen (name) - 3, "dir");
rc = mu_file_safety_check (name, mode, owner, NULL);
free (name);
return rc;
}
static int
mu_port_print (SCM exp, SCM port, scm_print_state *pstate)
{
struct mu_port *mp = MU_PORT (exp);
mu_off_t size = 0;
scm_puts ("#<", port);
scm_print_port_mode (exp, port);
scm_puts ("mu-port", port);
if (mu_stream_size (mp->stream, &size) == 0)
{
char *buf;
if (mu_asprintf (&buf, " %5lu", (unsigned long) size) == 0)
{
scm_puts (buf, port);
scm_puts (" chars", port);
free (buf);
}
}
scm_putc ('>', port);
return 1;
}
static int
_mu_conn_setup (LDAP **pld)
{
int rc;
LDAPURLDesc *ludlist, **ludp;
char **urls = NULL;
int nurls = 0;
char *ldapuri = NULL;
LDAP *ld = NULL;
int protocol = LDAP_VERSION3; /* FIXME: must be configurable */
if (ldap_param.debug)
{
if (ber_set_option (NULL, LBER_OPT_DEBUG_LEVEL, &ldap_param.debug)
!= LBER_OPT_SUCCESS )
mu_error (_("cannot set LBER_OPT_DEBUG_LEVEL %d"), ldap_param.debug);
if (ldap_set_option (NULL, LDAP_OPT_DEBUG_LEVEL, &ldap_param.debug)
!= LDAP_OPT_SUCCESS )
mu_error (_("could not set LDAP_OPT_DEBUG_LEVEL %d"),
ldap_param.debug);
}
if (ldap_param.url)
{
rc = ldap_url_parse (ldap_param.url, &ludlist);
if (rc != LDAP_URL_SUCCESS)
{
mu_error (_("cannot parse LDAP URL(s)=%s (%d)"),
ldap_param.url, rc);
return 1;
}
for (ludp = &ludlist; *ludp; )
{
LDAPURLDesc *lud = *ludp;
char **tmp;
if (lud->lud_dn && lud->lud_dn[0]
&& (lud->lud_host == NULL || lud->lud_host[0] == '\0'))
{
/* if no host but a DN is provided, try DNS SRV to gather the
host list */
char *domain = NULL, *hostlist = NULL;
size_t i;
struct mu_wordsplit ws;
if (ldap_dn2domain (lud->lud_dn, &domain) || !domain)
{
mu_error (_("DNS SRV: cannot convert DN=\"%s\" into a domain"),
lud->lud_dn );
goto dnssrv_free;
}
rc = ldap_domain2hostlist (domain, &hostlist);
if (rc)
{
mu_error (_("DNS SRV: cannot convert domain=%s into a hostlist"),
domain);
goto dnssrv_free;
}
if (mu_wordsplit (hostlist, &ws, MU_WRDSF_DEFFLAGS))
{
mu_error (_("DNS SRV: could not parse hostlist=\"%s\": %s"),
hostlist, mu_wordsplit_strerror (&ws));
goto dnssrv_free;
}
tmp = realloc (urls, sizeof(char *) * (nurls + ws.ws_wordc + 1));
if (!tmp)
{
mu_error ("DNS SRV %s", mu_strerror (errno));
goto dnssrv_free;
}
urls = tmp;
urls[nurls] = NULL;
for (i = 0; i < ws.ws_wordc; i++)
{
urls[nurls + i + 1] = NULL;
rc = mu_asprintf (&urls[nurls + i],
"%s://%s",
lud->lud_scheme, ws.ws_wordv[i]);
if (rc)
{
mu_error ("DNS SRV %s", mu_strerror (rc));
goto dnssrv_free;
}
}
nurls += i;
dnssrv_free:
mu_wordsplit_free (&ws);
ber_memfree (hostlist);
ber_memfree (domain);
}
else
{
tmp = realloc (urls, sizeof(char *) * (nurls + 2));
if (!tmp)
{
mu_error ("DNS SRV %s", mu_strerror (errno));
break;
}
urls = tmp;
urls[nurls + 1] = NULL;
urls[nurls] = ldap_url_desc2str (lud);
if (!urls[nurls])
{
mu_error ("DNS SRV %s", mu_strerror (errno));
break;
}
nurls++;
}
*ludp = lud->lud_next;
lud->lud_next = NULL;
ldap_free_urldesc (lud);
}
if (ludlist)
{
ldap_free_urldesc (ludlist);
return 1;
}
else if (!urls)
return 1;
rc = mu_argcv_string (nurls, urls, &ldapuri);
if (rc)
{
mu_error ("%s", mu_strerror (rc));
return 1;
}
ber_memvfree ((void **)urls);
}
mu_diag_output (MU_DIAG_INFO,
"constructed LDAP URI: %s", ldapuri ? ldapuri : "<DEFAULT>");
rc = ldap_initialize (&ld, ldapuri);
if (rc != LDAP_SUCCESS)
{
mu_error (_("cannot create LDAP session handle for URI=%s (%d): %s"),
ldapuri, rc, ldap_err2string (rc));
free (ldapuri);
return 1;
}
free (ldapuri);
ldap_set_option (ld, LDAP_OPT_PROTOCOL_VERSION, &protocol);
if (ldap_param.tls)
{
rc = ldap_start_tls_s (ld, NULL, NULL);
if (rc != LDAP_SUCCESS)
{
char *msg = NULL;
ldap_get_option (ld,
LDAP_OPT_DIAGNOSTIC_MESSAGE,
(void*)&msg);
mu_error (_("ldap_start_tls failed: %s"), ldap_err2string (rc));
mu_error (_("TLS diagnostics: %s"), msg);
ldap_memfree (msg);
ldap_unbind_ext (ld, NULL, NULL);
return 1;
}
}
/* FIXME: Timeouts, SASL, etc. */
*pld = ld;
return 0;
}
int
mu_message_create_attachment (const char *content_type, const char *encoding,
const char *filename, mu_message_t *newmsg)
{
mu_header_t hdr;
mu_body_t body;
mu_stream_t fstream = NULL, tstream = NULL;
char *header = NULL, *name = NULL, *fname = NULL;
int ret;
if (newmsg == NULL)
return MU_ERR_OUT_PTR_NULL;
if (filename == NULL)
return EINVAL;
if ((ret = mu_message_create (newmsg, NULL)) == 0)
{
if (content_type == NULL)
content_type = "text/plain";
if (encoding == NULL)
encoding = "7bit";
if ((fname = strdup (filename)) != NULL)
{
name = strrchr (fname, '/');
if (name)
name++;
else
name = fname;
ret = mu_asprintf (&header,
"Content-Type: %s; name=%s\n"
"Content-Transfer-Encoding: %s\n"
"Content-Disposition: attachment; filename=%s\n\n",
content_type, name, encoding, name);
if (ret == 0)
{
if ((ret = mu_header_create (&hdr, header,
strlen (header))) == 0)
{
mu_stream_t bstr;
mu_message_get_body (*newmsg, &body);
mu_body_get_streamref (body, &bstr);
if ((ret = mu_file_stream_create (&fstream, filename,
MU_STREAM_READ)) == 0)
{
if ((ret = mu_filter_create (&tstream, fstream, encoding,
MU_FILTER_ENCODE,
MU_STREAM_READ)) == 0)
{
mu_stream_copy (bstr, tstream, 0, NULL);
mu_stream_unref (tstream);
mu_message_set_header (*newmsg, hdr, NULL);
}
}
mu_stream_unref (bstr);
free (header);
}
}
}
}
if (ret)
{
if (*newmsg)
mu_message_destroy (newmsg, NULL);
if (hdr)
mu_header_destroy (&hdr);
if (fstream)
mu_stream_destroy (&fstream);
if (fname)
free (fname);
}
return ret;
}
static int
mbox_message_qid (mu_message_t msg, mu_message_qid_t *pqid)
{
mbox_message_t mum = mu_message_get_owner (msg);
return mu_asprintf (pqid, "%lu", (unsigned long) mum->header_from);
}
