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;
}
