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_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; }
/* 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); }
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; }
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_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; }