static void
_free_reglist (void *data)
{
mu_list_t list = data;
mu_list_foreach (list, _free_regex, NULL);
mu_list_destroy (&list);
}
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;
}
/* The folder is destroy if it is the last reference. */
void
mu_folder_destroy (mu_folder_t *pfolder)
{
if (pfolder && *pfolder)
{
mu_folder_t folder = *pfolder;
int destroy_lock = 0;
mu_monitor_t monitor = folder->monitor;
mu_monitor_wrlock (monitor);
/* Check if this the last reference for this folder. If yes removed
it from the list. */
mu_monitor_wrlock (&folder_lock);
folder->ref--;
/* Remove the folder from the list of known folder. */
if (folder->ref <= 0)
mu_list_remove (known_folder_list, folder);
/* If the list is empty we can safely remove it. */
if (mu_list_is_empty (known_folder_list))
mu_list_destroy (&known_folder_list);
mu_monitor_unlock (&folder_lock);
if (folder->ref <= 0)
{
mu_monitor_unlock (monitor);
destroy_lock = 1;
/* Notify the observers. */
if (folder->observable)
{
mu_observable_notify (folder->observable, MU_EVT_FOLDER_DESTROY,
folder);
mu_observable_destroy (&folder->observable, folder);
}
if (folder->_destroy)
folder->_destroy (folder);
mu_monitor_wrlock (monitor);
if (folder->authority)
mu_authority_destroy (&folder->authority, folder);
if (folder->url)
mu_url_destroy (&folder->url);
if (folder->property)
mu_property_destroy (&folder->property);
free (folder);
}
mu_monitor_unlock (monitor);
if (destroy_lock)
mu_monitor_destroy (&monitor, folder);
*pfolder = NULL;
}
}
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;
}
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);
}
}
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
ls_folders (char *fname, char *ref, char *pattern, int level)
{
int status;
mu_folder_t folder;
mu_list_t flist;
size_t count;
status = mu_folder_create (&folder, fname);
if (status)
{
mu_error ("mu_folder_create failed: %s", mu_strerror (status));
return 1;
}
status = mu_folder_open (folder, MU_STREAM_READ);
if (status)
{
mu_error ("mu_folder_create failed: %s", mu_strerror (status));
return 1;
}
status = mu_folder_enumerate (folder, ref, pattern, 0, level, &flist,
enumfun, NULL);
switch (status)
{
case 0:
mu_list_count (flist, &count);
printf ("Number of folders: %lu\n", (unsigned long) count);
mu_list_destroy (&flist);
break;
case MU_ERR_NOENT:
printf ("No folders matching %s %s in %s\n", ref, pattern, fname);
return 0;
default:
mu_error ("mu_folder_list failed: %s", mu_strerror (status));
}
return 0;
}
void
_mu_onexit_run (void)
{
mu_iterator_t itr;
int rc, status = 0;
if (!onexit_list)
return;
rc = mu_list_get_iterator (onexit_list, &itr);
if (rc)
{
mu_error (_("cannot create iterator, onexit aborted: %s"),
mu_strerror (rc));
mu_stream_destroy (&mu_strerr);
_exit (127);
}
for (mu_iterator_first (itr); !mu_iterator_is_done (itr);
mu_iterator_next (itr))
{
struct onexit_closure *cp;
int rc = mu_iterator_current (itr, (void**)&cp);
if (rc)
{
status = 127;
mu_error (_("cannot obtain current item while traversing the"
" onexit action list: %s"), mu_strerror (rc));
}
else
cp->function (cp->data);
mu_iterator_ctl (itr, mu_itrctl_delete, NULL);
}
mu_iterator_destroy (&itr);
mu_list_destroy (&onexit_list);
if (status)
_exit (status);
}
void
pop3d_session_free (struct pop3d_session *session)
{
mu_list_destroy (&session->capa);
}
