/**
* em_cache_add:
* @emc:
* @n:
*
* Add a cache node to the cache, once added the memory is owned by
* the cache. If there are conflicts and the old node is still in
* use, then the new node is not added, otherwise it is added and any
* nodes older than the expire time are flushed.
**/
void
em_cache_add(EMCache *emc, EMCacheNode *n)
{
EMCacheNode *old, *prev;
EDList old_nodes;
e_dlist_init(&old_nodes);
g_mutex_lock(emc->lock);
old = g_hash_table_lookup(emc->key_table, n->key);
if (old != NULL) {
if (old->ref_count == 0) {
g_hash_table_remove(emc->key_table, old->key);
e_dlist_remove((EDListNode *)old);
e_dlist_addtail(&old_nodes, (EDListNode *)old);
goto insert;
} else {
e_dlist_addtail(&old_nodes, (EDListNode *)n);
}
} else {
time_t now;
insert:
now = time(0);
g_hash_table_insert(emc->key_table, n->key, n);
e_dlist_addhead(&emc->lru_list, (EDListNode *)n);
n->stamp = now;
emc->node_count++;
c(printf("inserting node %s\n", n->key));
old = (EMCacheNode *)emc->lru_list.tailpred;
prev = old->prev;
while (prev && old->stamp < now - emc->timeout) {
if (old->ref_count == 0) {
c(printf("expiring node %s\n", old->key));
g_hash_table_remove(emc->key_table, old->key);
e_dlist_remove((EDListNode *)old);
e_dlist_addtail(&old_nodes, (EDListNode *)old);
}
old = prev;
prev = prev->prev;
}
}
g_mutex_unlock(emc->lock);
while ((old = (EMCacheNode *)e_dlist_remhead(&old_nodes))) {
emc->node_free(old);
g_free(old->key);
g_free(old);
}
}
void
camel_groupwise_journal_transfer (CamelGroupwiseJournal *groupwise_journal, CamelGroupwiseFolder *source_folder,
CamelMimeMessage *message, const CamelMessageInfo *mi,
const char *original_uid, char **transferred_uid,
CamelException *ex)
{
CamelOfflineJournal *journal = (CamelOfflineJournal *) groupwise_journal;
CamelGroupwiseStore *gw_store= CAMEL_GROUPWISE_STORE(journal->folder->parent_store) ;
CamelGroupwiseJournalEntry *entry;
char *uid;
if (!update_cache (groupwise_journal, message, mi, &uid, ex))
return;
entry = g_new (CamelGroupwiseJournalEntry, 1);
entry->type = CAMEL_GROUPWISE_JOURNAL_ENTRY_APPEND;
entry->uid = uid;
entry->original_uid = g_strdup (original_uid);
entry->source_container = g_strdup (camel_groupwise_store_container_id_lookup (gw_store, ((CamelFolder *)source_folder)->name));
e_dlist_addtail (&journal->queue, (EDListNode *) entry);
if (transferred_uid)
*transferred_uid = g_strdup (uid);
}
/**
* e_import_class_add_importer:
* @ec: An initialised implementing instance of EImport.
* @importer: Importer to add.
* @freefunc: If supplied, called to free the importer node
* when it is no longer needed.
* @data: Data for the callback.
*
**/
void
e_import_class_add_importer(EImportClass *klass, EImportImporter *importer, EImportImporterFunc freefunc, void *data)
{
struct _EImportImporters *node, *ei, *en;
node = g_malloc(sizeof(*node));
node->importer = importer;
node->free = freefunc;
node->data = data;
ei = (struct _EImportImporters *)klass->importers.head;
en = ei->next;
while (en && ei->importer->pri < importer->pri) {
ei = en;
en = en->next;
}
if (en == NULL)
e_dlist_addtail(&klass->importers, (EDListNode *)node);
else {
node->next = ei->next;
node->next->prev = node;
node->prev = ei;
ei->next = node;
}
}
/**
* camel_offline_journal_construct:
* @journal: a #CamelOfflineJournal object
* @folder: a #CamelFolder object
* @filename: a filename to save/load the journal
*
* Constructs a journal object.
**/
void
camel_offline_journal_construct (CamelOfflineJournal *journal, CamelFolder *folder, const char *filename)
{
EDListNode *entry;
FILE *fp;
journal->filename = g_strdup (filename);
journal->folder = folder;
if ((fp = g_fopen (filename, "rb"))) {
while ((entry = CAMEL_OFFLINE_JOURNAL_GET_CLASS (journal)->entry_load (journal, fp)))
e_dlist_addtail (&journal->queue, entry);
fclose (fp);
}
}
/**
* em_cache_clear:
* @emc:
*
* clear the cache. just for api completeness.
**/
void
em_cache_clear(EMCache *emc)
{
EMCacheNode *node;
EDList old_nodes;
e_dlist_init(&old_nodes);
g_mutex_lock(emc->lock);
while ((node = (EMCacheNode *)e_dlist_remhead(&emc->lru_list)))
e_dlist_addtail(&old_nodes, (EDListNode *)node);
g_mutex_unlock(emc->lock);
while ((node = (EMCacheNode *)e_dlist_remhead(&old_nodes))) {
emc->node_free(node);
g_free(node->key);
g_free(node);
}
}
/**
* e_event_add_items:
* @emp: An initialised EEvent structure.
* @items: A list of EEventItems event listeners to register on this event manager.
* @freefunc: A function called when the @items list is no longer needed.
* @data: callback data for @freefunc and for item event handlers.
*
* Adds @items to the list of events listened to on the event manager @emp.
*
* Return value: An opaque key which can later be passed to remove_items.
**/
void *
e_event_add_items(EEvent *emp, GSList *items, EEventItemsFunc freefunc, void *data)
{
struct _event_node *node;
node = g_malloc(sizeof(*node));
node->events = items;
node->freefunc = freefunc;
node->data = data;
e_dlist_addtail(&emp->priv->events, (EDListNode *)node);
if (emp->priv->sorted) {
g_slist_foreach(emp->priv->sorted, (GFunc)g_free, NULL);
g_slist_free(emp->priv->sorted);
emp->priv->sorted = NULL;
}
return (void *)node;
}
void
camel_groupwise_journal_append (CamelGroupwiseJournal *groupwise_journal, CamelMimeMessage *message,
const CamelMessageInfo *mi, char **appended_uid, CamelException *ex)
{
CamelOfflineJournal *journal = (CamelOfflineJournal *) groupwise_journal;
CamelGroupwiseJournalEntry *entry;
char *uid;
if (!update_cache (groupwise_journal, message, mi, &uid, ex))
return;
entry = g_new (CamelGroupwiseJournalEntry, 1);
entry->type = CAMEL_GROUPWISE_JOURNAL_ENTRY_APPEND;
entry->uid = uid;
e_dlist_addtail (&journal->queue, (EDListNode *) entry);
if (appended_uid)
*appended_uid = g_strdup (uid);
}
/**
* camel_operation_new:
* @status: Callback for receiving status messages. This will always
* be called with an internal lock held.
* @status_data: User data.
*
* Create a new camel operation handle. Camel operation handles can
* be used in a multithreaded application (or a single operation
* handle can be used in a non threaded appliation) to cancel running
* operations and to obtain notification messages of the internal
* status of messages.
*
* Return value: A new operation handle.
**/
CamelOperation *
camel_operation_new (CamelOperationStatusFunc status, void *status_data)
{
CamelOperation *cc;
cc = g_malloc0(sizeof(*cc));
cc->flags = 0;
cc->blocked = 0;
cc->refcount = 1;
cc->status = status;
cc->status_data = status_data;
cc->cancel_port = e_msgport_new();
cc->cancel_fd = -1;
LOCK();
e_dlist_addtail(&operation_list, (EDListNode *)cc);
UNLOCK();
return cc;
}
void
e_iconv_close(iconv_t ip)
{
struct _iconv_cache_node *in;
if (ip == (iconv_t)-1)
return;
LOCK();
in = g_hash_table_lookup(iconv_cache_open, ip);
if (in) {
cd(printf("closing iconv converter '%s'\n", in->parent->conv));
e_dlist_remove((EDListNode *)in);
in->busy = FALSE;
e_dlist_addtail(&in->parent->open, (EDListNode *)in);
} else {
g_warning("trying to close iconv i dont know about: %p", ip);
iconv_close(ip);
}
UNLOCK();
}