int mu_folder_enumerate (mu_folder_t folder, const char *name, void *pattern, int flags, size_t max_level, mu_list_t *pflist, mu_folder_enumerate_fp enumfun, void *enumdata) { int status; if (folder == NULL) return EINVAL; else if (folder->_list == NULL) return ENOSYS; else { mu_list_t list = NULL; if (pflist) { status = mu_list_create (&list); if (status) return status; *pflist = list; mu_list_set_destroy_item (list, mu_list_response_free); } else if (!enumfun) return EINVAL; status = folder->_list (folder, name, pattern, flags, max_level, list, enumfun, enumdata); if (status) mu_list_destroy (pflist); } return status; }
static int sieve_register (mu_list_t *pool, mu_list_t *list, const char *name, mu_sieve_handler_t handler, mu_sieve_data_type *req_arg_types, mu_sieve_data_type *opt_arg_types, mu_sieve_tag_group_t *tags, int required) { mu_sieve_register_t *reg = mu_sieve_palloc (pool, sizeof (*reg)); if (!reg) return ENOMEM; reg->name = name; reg->handler = handler; reg->req_args = req_arg_types; reg->opt_args = opt_arg_types; reg->tags = tags; reg->required = required; if (!*list) { int rc = mu_list_create (list); if (rc) { free (reg); return rc; } } return mu_list_append (*list, reg); }
void pop3d_session_init (struct pop3d_session *session) { if (mu_list_create (&session->capa)) mu_alloc_die (); mu_list_set_destroy_item (session->capa, capa_free); /* Initialize the capability list */ pop3d_append_capa_string (session, "TOP", NULL); pop3d_append_capa_string (session, "UIDL", NULL); pop3d_append_capa_string (session, "RESP-CODES", NULL); pop3d_append_capa_string (session, "PIPELINING", NULL); pop3d_append_capa_string (session, "AUTH-RESP-CODE", NULL); if (pop3d_xlines) pop3d_append_capa_string (session, "XLINES", NULL); pop3d_append_capa_func (session, "LOGIN-DELAY", login_delay_capa); /* This can be implemented by setting an header field on the message. */ pop3d_append_capa_string (session, "EXPIRE", (expire == EXPIRE_NEVER) ? "NEVER" : mu_umaxtostr (0, expire)); pop3d_append_capa_func (session, NULL, capa_user); pop3d_append_capa_func (session, "STLS", capa_stls); pop3d_append_capa_func (session, "IMPLEMENTATION", capa_implementation); }
int mu_sieve_register_comparator (mu_sieve_machine_t mach, const char *name, int required, mu_sieve_comparator_t is, mu_sieve_comparator_t contains, mu_sieve_comparator_t matches, mu_sieve_comparator_t regex, mu_sieve_comparator_t eq) { sieve_comparator_record_t *rp; if (!mach->comp_list) { int rc = mu_list_create (&mach->comp_list); if (rc) return rc; } rp = mu_sieve_malloc (mach, sizeof (*rp)); rp->required = required; rp->name = name; rp->comp[MU_SIEVE_MATCH_IS] = is; rp->comp[MU_SIEVE_MATCH_CONTAINS] = contains; rp->comp[MU_SIEVE_MATCH_MATCHES] = matches; rp->comp[MU_SIEVE_MATCH_REGEX] = regex; rp->comp[MU_SIEVE_MATCH_EQ] = eq; return mu_list_append (mach->comp_list, rp); }
static void add_sequence (char *name) { if (!seq_list && mu_list_create (&seq_list)) { mu_error (_("cannot create sequence list")); exit (1); } mu_list_append (seq_list, name); }
void imap4d_capability_add (const char *str) { if (!capa_list) { mu_list_create (&capa_list); mu_list_set_comparator (capa_list, comp); } mu_list_append (capa_list, (void*)str); }
static int _registrar_get_list (mu_list_t *plist) { int status = 0; if (plist == NULL) return MU_ERR_OUT_PTR_NULL; mu_monitor_wrlock (®istrar_monitor); if (registrar_list == NULL) status = mu_list_create (®istrar_list); *plist = registrar_list; mu_monitor_unlock (®istrar_monitor); return status; }
char * alias_expand (const char *name) { alias_t al; mu_list_t list; if (mailvar_get (NULL, "recursivealiases", mailvar_type_boolean, 0) == 0) { char *s; mu_list_t origlist; int status = mu_list_create (&list); if (status) { mu_diag_funcall (MU_DIAG_ERROR, "mu_list_create", NULL, status); return NULL; } status = mu_list_create (&origlist); if (status) { mu_list_destroy (&origlist); mu_diag_funcall (MU_DIAG_ERROR, "mu_list_create", NULL, status); return NULL; } mu_list_set_comparator (list, string_comp); mu_list_set_comparator (origlist, string_comp); recursive_alias_expand (name, list, origlist); s = util_slist_to_string (list, ","); mu_list_destroy (&origlist); mu_list_destroy (&list); return s; } if ((al = alias_lookup (name)) == NULL) return NULL; return util_slist_to_string (al->list, ","); }
/* Computes an intersection of two lists and returns it in PDEST. The resulting list contains elements from A that are also encountered in B (as per comparison function of the latter). If DUP_ITEM is not NULL, it is used to create copies of items to be stored in PDEST. In this case, the destroy_item function of B is also attached to PDEST. Otherwise, if DUP_ITEM is NULL, pointers to elements are stored and no destroy_item function is assigned. */ int mu_list_intersect_dup (mu_list_t *pdest, mu_list_t a, mu_list_t b, int (*dup_item) (void **, void *, void *), void *dup_closure) { mu_list_t dest; int rc; mu_iterator_t itr; rc = mu_list_create (&dest); if (rc) return rc; mu_list_set_comparator (dest, b->comp); if (dup_item) mu_list_set_destroy_item (dest, b->destroy_item); rc = mu_list_get_iterator (a, &itr); if (rc) { mu_list_destroy (&dest); return rc; } rc = 0; for (mu_iterator_first (itr); !mu_iterator_is_done (itr); mu_iterator_next (itr)) { void *data; mu_iterator_current (itr, &data); if (mu_list_locate (b, data, NULL) == 0) { void *new_data; if (dup_item && data) { rc = dup_item (&new_data, data, dup_closure); if (rc) break; } else new_data = data; mu_list_append (dest, new_data); /* FIXME: Check return, and? */ } } mu_iterator_destroy (&itr); *pdest = dest; return rc; }
void auth_add (char *name, imap4d_auth_handler_fp handler) { struct imap_auth *p = mu_alloc (sizeof (*p)); p->name = name; p->handler = handler; if (!imap_auth_list) { mu_list_create (&imap_auth_list); mu_list_set_comparator (imap_auth_list, comp); mu_list_set_destroy_item (imap_auth_list, mu_list_free_item); } mu_list_append (imap_auth_list, (void*)p); }
void _mu_sv_instr_push (mu_sieve_machine_t mach) { if (INSTR_DEBUG (mach)) { mu_sieve_debug (mach, "%4lu: PUSH\n", (unsigned long)(mach->pc - 1)); if (INSTR_DISASS (mach)) return; } if (!mach->stack && mu_list_create (&mach->stack)) { mu_sieve_error (mach, _("cannot create stack")); mu_sieve_abort (mach); } mu_list_prepend (mach->stack, (void*) mach->reg); }
int mu_registrar_get_iterator (mu_iterator_t *pitr) { int status = 0; if (pitr == NULL) return MU_ERR_OUT_PTR_NULL; mu_monitor_wrlock (®istrar_monitor); if (registrar_list == NULL) { status = mu_list_create (®istrar_list); if (status) return status; } status = mu_list_get_iterator (registrar_list, pitr); mu_monitor_unlock (®istrar_monitor); return status; }
static int alias_create (const char *name, alias_t *al) { int rc; if (!aliases) { mu_assoc_create (&aliases, sizeof (struct _alias), 0); mu_assoc_set_free (aliases, alias_free); } rc = mu_assoc_ref_install (aliases, name, (void**) al); if (rc == MU_ERR_EXISTS) return 0; if (rc == 0) return mu_list_create (&(*al)->list); return 1; }
static void addop (char *field, compfun comp) { struct comp_op *op = xmalloc (sizeof (*op)); if (!oplist) { if (mu_list_create (&oplist)) { mu_error (_("can't create operation list")); exit (1); } mu_list_set_destroy_item (oplist, mu_list_free_item); } op->field = field; op->comp = comp; mu_list_append (oplist, op); }
int mu_onexit (mu_onexit_t func, void *data) { struct onexit_closure *clos = malloc (sizeof (*clos)); if (!clos) return ENOMEM; clos->function = func; clos->data = data; if (!onexit_list) { int rc = mu_list_create (&onexit_list); mu_list_set_destroy_item (onexit_list, mu_list_free_item); if (rc) return rc; atexit (_mu_onexit_run); } return mu_list_append (onexit_list, clos); }
int mu_imap_genlist_new (mu_imap_t imap, int lsub, const char *refname, const char *mboxname, mu_list_t *plist) { mu_list_t list; int rc = mu_list_create (&list); if (rc == 0) { mu_list_set_destroy_item (list, mu_list_response_free); rc = mu_imap_genlist (imap, lsub, refname, mboxname, list); if (rc) mu_list_destroy (&list); else *plist = list; } return rc; }
int mu_folder_lsub (mu_folder_t folder, const char *dirname, const char *basename, mu_list_t *pflist) { int status; if (folder == NULL) return EINVAL; else if (folder->_lsub == NULL) return ENOSYS; else { status = mu_list_create (pflist); if (status) return status; mu_list_set_destroy_item (*pflist, mu_list_response_free); status = folder->_lsub (folder, dirname, basename, *pflist); } return status; }
static void update_list (mu_list_t *plist, const char *arg) { size_t j; struct mu_wordsplit ws; mu_list_t list = *plist; if (!list) { MU_ASSERT (mu_list_create (&list)); *plist = list; } ws.ws_delim = ","; if (mu_wordsplit (arg, &ws, MU_WRDSF_DEFFLAGS | MU_WRDSF_DELIM)) { mu_error ("mu_wordsplit: %s", mu_wordsplit_strerror (&ws)); exit (1); } for (j = 0; j < ws.ws_wordc; j++) MU_ASSERT (mu_list_append (list, ws.ws_wordv[j])); ws.ws_wordc = 0; mu_wordsplit_free (&ws); }
/* A folder could be remote (IMAP), or local(a spool directory) like $HOME/Mail etc .. We maintain a list of known folders to avoid creating multiple folders for the same URL. So, when mu_folder_create is called we check if we already have a folder for that URL and return it, otherwise we create a new one. Downsides: the scheme to detect the same URL is very weak, and there could be cases where you'll want a different folder for the same URL, there is not easy way to do this. */ int mu_folder_create_from_record (mu_folder_t *pfolder, mu_url_t url, mu_record_t record) { if (!pfolder) return MU_ERR_OUT_PTR_NULL; if (record || /* Look in the registrar list(iterator), for a possible concrete mailbox implementation that could match the URL. */ mu_registrar_lookup_url (url, MU_FOLDER_ATTRIBUTE_DIRECTORY, &record, NULL) == 0) { int (*f_init) (mu_folder_t) = NULL; mu_record_get_folder (record, &f_init); if (f_init) { int status, mask; mu_folder_t folder; int (*u_init) (mu_url_t) = NULL; status = mu_record_check_url (record, url, &mask); if (status) /* FIXME: mask would provide more info */ return status; mu_record_get_url (record, &u_init); if (u_init) { status = u_init (url); if (status) return status; } mu_monitor_wrlock (&folder_lock); /* Check if we already have the same URL folder. */ if (is_known_folder (url, &folder)) { folder->ref++; *pfolder = folder; mu_url_destroy (&url); /* FIXME: Hmm */ mu_monitor_unlock (&folder_lock); return 0; } else mu_monitor_unlock (&folder_lock); /* Create a new folder. */ /* Allocate memory for the folder. */ folder = calloc (1, sizeof (*folder)); if (folder != NULL) { folder->url = url; /* Initialize the internal foilder lock, now so the concrete folder could use it. */ status = mu_monitor_create (&folder->monitor, 0, folder); if (status == 0) { /* Create the concrete folder type. */ status = f_init (folder); if (status == 0) { if (!folder->_match) folder->_match = mu_folder_imap_match; *pfolder = folder; folder->ref++; /* Put on the internal list of known folders. */ if (known_folder_list == NULL) mu_list_create (&known_folder_list); mu_list_append (known_folder_list, folder); } } /* Something went wrong, destroy the object. */ if (status) { if (folder->monitor) mu_monitor_destroy (&folder->monitor, folder); free (folder); } } return status; } } return MU_ERR_NOENT; }
int mu_sieve_match_part_checker (const char *name, mu_list_t tags, mu_list_t args) { mu_iterator_t itr; mu_sieve_runtime_tag_t *match = NULL; mu_sieve_runtime_tag_t *comp = NULL; mu_sieve_runtime_tag_t *tmp; mu_sieve_comparator_t compfun = NULL; char *compname = "false"; int matchtype; int err = 0; if (!tags || mu_list_get_iterator (tags, &itr)) return 0; for (mu_iterator_first (itr); !err && !mu_iterator_is_done (itr); mu_iterator_next (itr)) { mu_sieve_runtime_tag_t *t; mu_iterator_current (itr, (void **)&t); if (strcmp (t->tag, "is") == 0 || strcmp (t->tag, "contains") == 0 || strcmp (t->tag, "matches") == 0 || strcmp (t->tag, "regex") == 0 || strcmp (t->tag, "count") == 0 || strcmp (t->tag, "value") == 0) { if (match) { mu_sv_compile_error (&mu_sieve_locus, _("match type specified twice in call to `%s'"), name); err = 1; } else match = t; } else if (strcmp (t->tag, "comparator") == 0) comp = t; } mu_iterator_destroy (&itr); if (err) return 1; if (!match || strcmp (match->tag, "is") == 0) matchtype = MU_SIEVE_MATCH_IS; else if (strcmp (match->tag, "contains") == 0) matchtype = MU_SIEVE_MATCH_CONTAINS; else if (strcmp (match->tag, "matches") == 0) matchtype = MU_SIEVE_MATCH_MATCHES; else if (strcmp (match->tag, "regex") == 0) matchtype = MU_SIEVE_MATCH_REGEX; else { char *str = match->arg->v.string; if (strcmp (match->tag, "count") == 0) { mu_sieve_value_t *val; char *str; size_t count; if (comp && strcmp (comp->arg->v.string, "i;ascii-numeric")) { mu_sv_compile_error (&mu_sieve_locus, /* TRANSLATORS: Do not translate ':count'. It is the name of a Sieve tag */ _("comparator %s is incompatible with " ":count in call to `%s'"), comp->arg->v.string, name); return 1; } matchtype = MU_SIEVE_MATCH_LAST; /* to not leave it undefined */ compfun = comp_false; val = mu_sieve_value_get (args, 1); if (!val) return 1; /* shouldn't happen */ /* NOTE: Type of v is always SVT_STRING_LIST */ mu_list_count (val->v.list, &count); if (count > 1) { mu_sv_compile_error (&mu_sieve_locus, _("second argument must be a list of one element")); return 1; } mu_list_get (val->v.list, 0, (void **) &str); count = strtoul (str, &str, 10); if (*str) { mu_sv_compile_error (&mu_sieve_locus, _("second argument cannot be converted to number")); return 1; } } else matchtype = MU_SIEVE_MATCH_EQ; if (mu_sieve_str_to_relcmp (str, NULL, NULL)) { mu_sv_compile_error (&mu_sieve_locus, _("invalid relational match `%s' in call to `%s'"), str, name); return 1; } } if (!compfun) { compname = comp ? comp->arg->v.string : "i;ascii-casemap"; compfun = mu_sieve_comparator_lookup (mu_sieve_machine, compname, matchtype); if (!compfun) { mu_sv_compile_error (&mu_sieve_locus, _("comparator `%s' is incompatible with match type `%s' in call to `%s'"), compname, match ? match->tag : "is", name); return 1; } } tmp = mu_sieve_malloc (mu_sieve_machine, sizeof (*tmp)); tmp->tag = TAG_COMPFUN; tmp->arg = mu_sieve_value_create (SVT_POINTER, compfun); mu_list_append (tags, tmp); if (matchtype == MU_SIEVE_MATCH_REGEX) { /* To speed up things, compile all patterns at once. Notice that it is supposed that patterns are in arg 2 */ mu_sieve_value_t *val, *newval; struct regex_data rd; int rc; if (mu_list_get (args, 1, (void**)&val)) return 0; rd.flags = REG_EXTENDED; if (strcmp (compname, "i;ascii-casemap") == 0) rd.flags |= REG_ICASE; mu_list_create (&rd.list); rc = mu_sieve_vlist_do (val, _regex_compile, &rd); mu_sieve_machine_add_destructor (mu_sieve_machine, _free_reglist, rd.list); if (rc) return rc; newval = mu_sieve_value_create (SVT_STRING_LIST, rd.list); mu_list_replace (args, val, newval); } #ifndef FNM_CASEFOLD else if (matchtype == MU_SIEVE_MATCH_MATCHES && strcmp (compname, "i;ascii-casemap") == 0) { int rc; mu_sieve_value_t *val; if (mu_list_get (args, 1, (void**)&val)) return 0; rc = mu_sieve_vlist_do (val, _pattern_upcase, NULL); if (rc) return rc; } #endif return 0; }
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; }