+2000-12-24 Not Zed <NotZed@HelixCode.com>
+
+ * providers/imap/camel-imap-search.c (imap_body_contains): Lock
+ the command channel while searching.
+ (imap_body_contains): If performing a whole uid search, then add
+ references to our own summary items, dont look it up in the
+ folder. This way they can't vanish unexpectedly.
+
+ * providers/imap/camel-imap-folder.h (CamelImapFolder): Added a
+ private field.
+
+ * providers/imap/camel-imap-private.h: Added lock for imap
+ searches.
+
+ * Merge from camel-mt-branch.
+
+ * providers/imap/camel-imap-folder.c (imap_update_summary): Merge
+ fix, use the folder->summary.
+ (imap_get_message_flags, imap_set_message_flags,
+ imap_get_message_user_flag, imap_set_message_user_flag): Removed
+ again.
+ (camel_imap_folder_init): Setup private data/lock.
+ (imap_finalize): Free private data/search lock.
+ (imap_search_free): Lock the search_lock.
+ (imap_search_by_expression): Lock the search lock when using the
+ search object. Also copy/ref hte summary, rather than getting it
+ directly.
+ (imap_refresh_info): Free any info lookups. Use folder->summary
+ not imap_folder->summary. And lock around commands.
+
2000-12-22 Dan Winship <danw@helixcode.com>
* providers/imap/camel-imap-store.c (get_folder_info): When
* providers/imap/camel-imap-folder.c: Use %S instead of "%s" where
appropriate.
+2000-12-22 Not Zed <NotZed@HelixCode.com>
+
+ * camel-folder-summary.c (GLOBAL_INFO_UNLOCK): Doh, cut and paste
+ victim again, call unlock instead of lock!
+ (summary_assign_uid): Unlock around trying to get a new uid, if we
+ have a clash.
+
+2000-12-21 Not Zed <NotZed@HelixCode.com>
+
+ * tests/folder/Makefile.am (TESTS): reenabled the tests here.
+
+ * providers/nntp/camel-nntp-newsrc.c (CamelNNTPNewsrc): Add a
+ lock. Made completely mt-safe. Sigh, this is all so i can
+ support snooping of the set_flags stuff inside camel-nntp-folder,
+ since i've removed the global folder lock from all of the other
+ folder summary operations.
+ (camel_nntp_newsrc_read_for_server): Setup lock.
+ (camel_nntp_newsrc_get_highest_article_read): Lock internal access.
+ (camel_nntp_newsrc_get_num_articles_read):
+ (camel_nntp_newsrc_mark_article_read):
+ (camel_nntp_newsrc_mark_range_read):
+ (camel_nntp_newsrc_article_is_read):
+ (camel_nntp_newsrc_group_is_subscribed):
+ (camel_nntp_newsrc_unsubscribe_group):
+ (camel_nntp_newsrc_subscribe_group):
+ (camel_nntp_newsrc_get_subscribed_group_names):
+ (camel_nntp_newsrc_get_all_group_names): "
+ (camel_nntp_newsrc_write_to_file): Lock internal accesses.
+ (camel_nntp_newsrc_write): Lock around diry stuff.
+
+ * providers/local/camel-maildir-summary.c (maildir_summary_check):
+ Lock around our internal poking of the summary hashtable/array.
+ (maildir_summary_sync): And the same here too.
+
+ * camel-folder-summary.c: Moved the summaryprivate data into
+ camel-private.h. Only needed for the locks really.
+ (camel_folder_summary_init): Setup locks.
+ (camel_folder_summary_set_filename): Lock.
+ (camel_folder_summary_index): lock
+ (camel_folder_summary_uid): Lock
+ (camel_folder_summary_next_uid): "
+ (camel_folder_summary_set_uid): "
+ (camel_folder_summary_load): Lock around whole load. Hrm,
+ probably not required.
+ (camel_folder_summary_save): Lock around whole save, this is
+ reqwuired, unless we ref/copy the whole list first, and i couldn't
+ be bothreed.
+ (camel_folder_summary_add): lock
+ (summary_assign_uid): Lock around internal accesses.
+ (camel_folder_summary_info_new_from_parser): Lock around filtr stuff.
+ (camel_folder_summary_info_ref): Add locking. Could probably use
+ its own lock?
+ (camel_folder_summary_touch): Add locking, likewise.
+ (camel_folder_summary_clear): Lock. If the preiovus two are
+ changed, then so this will need mroe locking.
+ (camel_folder_summary_info_free): Lock around refcounting.
+ (camel_folder_summary_remove): Locking.
+ (camel_folder_summary_remove_uid): Lock ref, unlock, unref. Also
+ fixed a bug that would have made this never work, freeing the key,
+ which isn't allocated.
+ (camel_folder_summary_remove_index): lock, ref, unlock unref also.
+ (camel_message_info_ref): Lock using a separate global lock, since
+ we have no context here.
+ (camel_message_info_free): Here too.
+ (content_info_alloc): Use an alocation lock here. avoids races
+ with setting up content_info_chunks, etc.
+ (camel_folder_summary_info_new): And here too.
+ (camel_folder_summary_load): Changed to use a differnet lock for
+ loading/saving.
+ (camel_folder_summary_init): Doh, i do need a reflock afterall,
+ set one up.
+ (camel_folder_summary_finalize): Free it.
+ (camel_folder_summary_index): Add a reflock.
+ (camel_folder_summary_uid): And here too.
+ (camel_folder_summary_info_free): Use reflock instead of
+ summary_lock.
+ (camel_folder_summary_info_ref): Likewise.
+ (camel_folder_summary_remove_uid): Add reflocking.
+ (camel_folder_summary_remove_index): And here too.
+
+ * providers/vee/camel-vee-folder.c (camel_vee_folder_new): Setup a
+ summary object.
+ (vee_folder_build): Build each item into the real summary object.
+ (vee_folder_add, vee_folder_add_uid, vee_folder_add_change): New
+ functions to add a single record to the vfolder summary.
+ (vee_folder_build_folder): Use a real summary.
+ (vee_get_uids): Removed, use default impl.
+ (vee_free_message_info): "
+ (vee_get_message_info): "
+ (vee_get_summary): "
+ (vee_get_unread_message_count): "
+ (vee_get_message_count): "
+ (vee_sync): Make vee-folder-sync sync all subordinate folders.
+ Well i dont think this is right, but enough peopl ehave aksed for
+ it.
+ (vee_expunge): Same for expunge.
+ (vee_set_message_flags): Call parent class, then mirror flags to
+ subfolder.
+ (vee_get_message_user_flag): Removed, we just use the default
+ impl, and our flags should always match.
+ (vee_set_message_user_flag): Snoop the set and set on subfolder.
+ (vee_get_message_flags): Removed, jsut use parent impl, assume our
+ copy matches the real ones.
+ (get_real_message): Removed. We sort ofneed to keep the
+ summaryitem refed while we use it, so this doesn't make as much
+ sense as it did once.
+ (camel_vee_folder_finalise): Unhook listening events as we unref
+ folders.
+ (camel_vee_folder_new): Set the summary messageinfo data size
+ properly.
+ (vfolder_remove_match): Fixed for summary change.
+ (folder_changed): ditto. Also stopped changed items from being
+ re-searched and possibly removed. Might have to resort to the old
+ whole-search idea again.
+ (message_changed): Similarly. Might be easier just not to bother
+ with a whole search.
+
+ * providers/vee/camel-vee-folder.h: Removes summary
+ hashtable/array, and use a real summary object. Sigh, more work.
+
+ * providers/nntp/camel-nntp-folder.c (nntp_folder_sync): Move
+ summary to folder object.
+ (nntp_folder_get_message_count): Removed, use default impl.
+ (nntp_folder_set_message_flags): Call parent impl to do the work,
+ but snoop for newsrc.
+ (nntp_folder_get_uids): Removed, use default impl.
+ (nntp_folder_get_summary): "
+ (nntp_folder_get_message_info): "
+ (nntp_folder_free_message_info): "
+ (camel_nntp_folder_new): moved summary to folder class
+
+ * providers/imap/camel-imap-folder.c (camel_imap_folder_init):
+ Move summary to folder object.
+ (camel_imap_folder_new): "
+ (imap_finalize): No longer unref the summary (or infact, do
+ anything else either).
+ (imap_refresh_info): move summary to folder object.
+ (imap_sync): "
+ (imap_get_message_count): Removed, use default impl.
+ (imap_get_unread_message_count): "
+ (imap_get_uids): "
+ (imap_get_summary): "
+ (imap_free_summary): "
+ (imap_get_message_info): "
+ (imap_free_message_info): "
+ (imap_get_message_flags): "
+ (imap_set_message_flags): "
+ (imap_get_message_user_flag): ", this changes functionality, but
+ only by providing non-permanent flags.
+ (imap_set_message_user_flag): "
+ (imap_update_summary): move summary to folder object, and use
+ camel_folder_summary_info_new_from_header, instead of calling the
+ virtual function directly.
+
+ * providers/local/camel-maildir-folder.c (maildir_append_message):
+ move summary to folder object, again.
+ (maildir_get_message): "
+
+ * providers/local/camel-mh-folder.c (mh_append_message): move
+ summary to folder object.
+ (mh_get_message): "
+
+ * providers/local/camel-mbox-folder.c (mbox_append_message): Move
+ summary to folder object
+ (mbox_get_message): "
+ (mbox_set_message_user_flag): We need our own copy of this, sigh,
+ so we can track if the xev needs a rewrite (probably, its only a
+ guide anyway).
+ (mbox_set_message_user_tag): Same same with this one.
+ (camel_mbox_folder_class_init): Link in these new virtual functions.
+
+ * providers/local/camel-local-folder.h (CamelLocalFolder): removed
+ summary.
+
+ * providers/local/camel-local-folder.c (local_get_message_count):
+ (local_get_unread_message_count):
+ (local_get_uids):
+ (local_get_summary):
+ (local_free_summary):
+ (local_get_message_info):
+ (local_free_message_info):
+ (local_get_message_flags):
+ (local_set_message_flags):
+ (local_get_message_user_flag):
+ (local_set_message_user_flag):
+ (local_get_message_user_tag):
+ (local_set_message_user_tag): Removed, all now use default
+ implementation.
+ (camel_local_folder_class_init): Removed overrides.
+ (local_init): Clear folder->summary.
+ (local_finalize): move summary to folder.
+ (camel_local_folder_construct): "
+ (local_sync): "
+
+ * camel-folder.c (free_summary): Provide a real impl.
+ (get_summary): "
+ (free_uids): "
+ (get_uids): "
+ (free_message_info): "
+ (get_message_info): "
+ (set_message_user_tag): "
+ (get_message_user_tag): "
+ (set_message_user_flag): "
+ (get_message_user_flag): " Sigh, the last so far.
+ (get_message_flags): Sigh, 1 more afterall.
+ (get_unread_message_count): And and this.
+ (get_message_count): and this!
+ (set_message_flags): Sigh, and this.
+ (camel_folder_finalize): Unref the summary if we have it.
+ (camel_folder_free_uids): Remove locking.
+ (camel_folder_get_message_flags): Remove locks, since the summary
+ is now mt-safe.
+ (camel_folder_set_message_flags): "
+ (camel_folder_get_message_user_flag): "
+ (camel_folder_set_message_user_flag): "
+ (camel_folder_get_message_user_tag): "
+ (camel_folder_set_message_user_tag): "
+ (camel_folder_get_message_info): "
+ (camel_folder_free_message_info): "
+ (camel_folder_get_uids): "
+ (camel_folder_free_summary): "
+ (camel_folder_get_unread_message_count): "
+ (get_unread_message_count): Check we got info, no big deal, but
+ the summary might change while we're counting, and upset the count
+ slightly.
+ (camel_folder_get_message_count): Remove locks.
+
+ * camel-folder.h (struct _CamelFolder): Added CamelFolderSummary
+ to the base folder object. Sigh, this is going to be a lot of
+ work ...
+
+ * camel-service.c (camel_service_init, finalise): changed
+ connect_lock to be recursive e_mutex.
+
+ * camel-remote-store.c (camel_remote_store_init, finalise): Changed
+ stream_lock to recursive e_mutex.
+
+ * camel-private.h (RemoteStorePrivate, ServicePrivate): Use
+ recursive mutexes for connect_lock & stream_lock. Ick. Because
+ of the imap code.
+
+ * providers/imap/camel-imap-private.h: Change the command_lock to
+ be an EMutex.
+
+ * providers/imap/camel-imap-store.c (connect_to_server): Removed
+ the command_lock stuff. If we are just connected again, it should
+ be safe to assume we have exclusive access at this point without
+ it (and yes, removes a deadlock).
+ (imap_create): Remove a lock that wasn't even supposed to be
+ there.
+ (camel_imap_store_finalize, init): g_mutex->e_mutex(E_MUTEX_REC).
+ Use a recursive mutex since the imap code is multiply recursivly
+ calling some functions (sigh, it would be nice to fix this).
+
+2000-12-20 Not Zed <NotZed@HelixCode.com>
+
+ * camel-folder.c (folder_changed): Change the locks to inside the
+ if. Stops a deadloc,k and we dont need a lock to read a value.
+ (message_changed): Likewise.
+
+ * camel.c (camel_init): Blah, comment out g_thread_init, leave it
+ to the caller, since it can only ever be done once.
+
+ * camel-folder-thread.c (camel_folder_thread_messages_new): Ref
+ and save the folder in the thread return. Also get the summary
+ once, and access that for the messageinfo's. Added bonus that now
+ threads should come out in a similar order. We need to do this so
+ that the messageinfo's dont get unref'd under us, and using the
+ summary directly simplifies memory management.
+ (camel_folder_thread_messages_destroy): Free the summary/unref the
+ folder.
+
+ * camel-folder-thread.h: Add a folder to CamelFolderThread struct.
+
+2000-12-19 Not Zed <NotZed@HelixCode.com>
+
+ * providers/imap/camel-imap-utils.c (imap_translate_sexp): Unref
+ using e_sexp_unref, since it is no longer an object.
+
+ * tests/lib/camel-test.c: Added a global lock, and made it
+ thread-aware.
+
+ * camel-exception.c: Add a global lock. Not sure its really
+ needed here, but it doesn't really hurt.
+ (camel_exception_clear): Lock around access.
+ (camel_exception_set): Same.
+ (camel_exception_setv): "
+ (camel_exception_xfer): "
+
+ * providers/local/Makefile.am (noinst_HEADERS): Added, for
+ camel-local-private.h
+
+ * camel-folder.c (camel_folder_search_by_expression): Removed
+ locking here, now upto the implementing class to lock.
+ (camel_folder_search_free): Removed the folder lock here too, for
+ consistency really, and the locking probably wasn't needed.
+
+ * providers/local/camel-local-folder.c (local_get_summary):
+ Changed to copy/ref the summary items.
+ (local_free_summary): Unref the summary items/free the array.
+ (local_get_unread_message_count): Free info lookups.
+ (local_search_by_expression): Perform more fine-grained locking,
+ and dont lock the whole folder while searching, just the search
+ object. Dum de dum, it *would* be possible to not even have to
+ lock the search, by using our own copy of the search object each
+ time. Could be investigated.
+ (local_init): Init priaate data/lock.
+ (local_finalize): Free private data/lock.
+ (local_search_free): Also lock around the search object, because
+ it accesses global data inside.
+
+ * README.mt: Some info about the mt code development.
+
+ * camel-folder-search.c (match_message): Put in a warning, this
+ plain deadlocks so far, but i'm going to bed now.
+ (camel_folder_search_finalize): Use e_sexp_unref() since its no
+ longer an object.
+
+ * camel-session.c (camel_session_init): Init private data/lock.
+ (camel_session_finalise): Free private data/lock.
+ (camel_session_register_provider): Lock hash insert.
+ (service_cache_remove): Lock.
+ (camel_session_list_providers): "
+ (camel_session_get_service): Lock the whole function.
+
+ * camel-session.h (struct _CamelSession): Added private data.
+
+ * providers/imap/camel-imap-store.c (camel_imap_store_init): Setup
+ private data.
+ (camel_imap_store_finalize): Free private data.
+ (connect_to_server): Lock around command calls. I dont think its
+ needed, but it shouldn't hurt either.
+ (imap_connect): Lock around command calls. Again, I don think it
+ is needed, but wont hurt.
+ (imap_disconnect): ditto for this one.
+ (imap_create): Lock around command.
+ (get_folder): "
+ (get_folder_info): "
+ (subscribe_folder): "
+ (unsubscribe_folder): "
+ (imap_keepalive): "
+
+ * providers/imap/camel-imap-folder.c (camel_imap_folder_new): Lock
+ around calling a command.
+ (imap_refresh_info): Likewise.
+ (imap_sync): "
+ (imap_append_message): "
+ (imap_copy_message_to): "
+ (imap_move_message_to): "
+ (imap_get_message): "
+ (imap_update_summary): "
+ (imap_search_by_expression): ", also minor logic cleanup.
+ (imap_get_summary): Copy/ref the summary items.
+ (imap_free_summary): And free it now too.
+
+ * providers/imap/camel-imap-auth.c (imap_try_kerberos_v4_auth):
+ Lock the command stream for the command session.
+
+ * providers/imap/camel-imap-private.h: Private (locking info)
+ stuff for imap provider.
+ (CAMEL_IMAP_STORE_UNLOCK): Fix to call unlock, rather than lock!
+
+ * camel-service.c (camel_service_query_auth_types): Lock also for
+ the connection here, incase the service needs to connect.
+
+ * camel-remote-store.c (camel_remote_store_init): Init private
+ data/lock.
+ (camel_remote_store_finalise): Readded, free private data/lock.
+ (remote_send_stream): Changed to return the number of bytes
+ written, like a good little stream function should.
+ (camel_remote_store_send_string): Lock for stream access.
+ (camel_remote_store_send_stream): Same here.
+ (camel_remote_store_recv_line): And here.
+ (camel_remote_store_refresh_folders): Lock the store for cache
+ access.
+ (timeout_cb): Lock for stream access.
+
+2000-12-18 Not Zed <NotZed@HelixCode.com>
+
+ * camel-service.c (camel_service_init): Init private data.
+ (camel_service_finalise): Free private data.
+ (camel_service_connect): Lock around connection access.
+ (camel_service_disconnect): "
+
+ * camel-service.h (struct _CamelService): Added private field.
+
+ * camel-store.c (camel_store_init): Init private data/lock.
+ (camel_store_finalize): Free private data/lock.
+ (camel_store_get_folder): Lock internal calls.
+ (camel_store_delete_folder): "
+ (camel_store_rename_folder): "
+ (camel_store_get_root_folder): "
+ (camel_store_get_default_folder): "
+ (camel_store_get_folder_info): "
+ (camel_store_folder_subscribed): "
+ (camel_store_subscribe_folder): "
+ (camel_store_unsubscribe_folder): "
+ (lookup_folder): Lock accesses to the folder cache.
+ (cache_folder): "
+ (uncache_folder): And here too.
+
+ * camel-store.h (struct _CamelStore): Added a private field.
+
+ * Makefile.am (noinst_HEADERS): Add camel-private.h. There is a
+ comment in that header as to why it ins't installed.
+
+ * camel-private.h: New header for private data, that subclasses
+ can get to.
+
+ * tests/lib/camel-test.c (camel_test_init): If we do have threads
+ enabled already, dont call g_thread_init().
+
+ * tests/lib/folders.c (test_folder_counts): Add free of info.
+ (test_folder_message): And here too.
+
+ * providers/local/camel-maildir-summary.c (remove_summary): Free
+ info.
+ (maildir_summary_check): Free info lookups.
+
+ * providers/local/camel-mh-summary.c (message_info_new): Removed,
+ didn't add value.
+ (remove_summary): free info after being used.
+ (mh_summary_check): Free info lookups.
+ (mh_summary_sync): and here too.
+
+ * providers/local/camel-mbox-summary.c (summary_update): Free info
+ lookups.
+ (mbox_summary_sync_full): Likewise.
+ (mbox_summary_sync_quick): And here.
+ (mbox_summary_sync): ... and here.
+
+ * providers/local/camel-maildir-folder.c (maildir_get_message):
+ Free messageinfo lookups.
+
+ * providers/local/camel-mh-folder.c (mh_get_message): Free
+ messageinfo lookups.
+
+ * providers/local/camel-mbox-folder.c (mbox_get_message): Free
+ messageinfo lookups.
+
+ * providers/local/camel-local-summary.c
+ (message_info_new_from_message): Removed, since it wasn't doing
+ anything useful.
+ (message_info_new_from_parser): Same. And some other dead code.
+
+ * providers/local/camel-local-folder.c (local_get_message_info):
+ deconstify.
+ (local_free_message_info):new func to free info.
+ (local_get_uids):
+ (local_get_message_flags):
+ (local_set_message_flags):
+ (local_get_message_user_flag):
+ (local_set_message_user_flag):
+ (local_get_message_user_tag):
+ (local_set_message_user_tag): Free all info lookups.
+ (local_expunge): Dont call camel_folder_* functions, to avoid a deadlock.
+
+ * providers/nntp/camel-nntp-folder.c
+ (nntp_folder_get_message_info): deconstify.
+ (nntp_folder_free_message_info): Free summary item.
+ (nntp_folder_get_message_flags): Free summary lookup.
+ (nntp_folder_set_message_flags): and here.
+ (nntp_folder_get_uids): And here.
+
+ * providers/imap/camel-imap-auth.c: Make base64_*_simple optional
+ with the HAVE_KRB4 flag.
+
+ * providers/imap/camel-imap-folder.c (imap_free_message_info):
+ Added a free of the message info.
+ (imap_refresh_info):
+ (imap_sync):
+ (imap_refresh_info):
+ (imap_get_unread_message_count):
+ (imap_get_uids):
+ (imap_get_message_flags):
+ (imap_set_message_flags): Free any summary lookups.
+ (imap_get_message_flags): Get the message info directly from the
+ summary, not via the folder interface.
+ (imap_move_message_to): Dont call folder functions directly
+ (delete_message), as it will deadlock since we already have the
+ lock.
+
+ * providers/vee/camel-vee-folder.c (vee_free_message_info): Free/unref
+ the messageinfo.
+ (vee_get_message_info): First ref the internal copy, then return it.
+ (folder_changed): Free all got message info's.
+ (message_changed): And here.
+ (get_real_message): And here.
+ (vee_folder_build): and here.
+ (vee_folder_build_folder): ... and here.
+
+ * camel-folder-summary.c (camel_folder_summary_info_new):
+ Initialise the messageinfo refcount to 1.
+ (camel_folder_summary_info_free): Down the refcount till we need
+ to free.
+ (camel_folder_summary_info_ref): New function to up the refcount.
+ (camel_message_info_dup_to): Sewt the refcount of the dest to 1.
+ (camel_message_info_new): Set refcount to 1.
+ (camel_message_info_new_from_header): Dont allocate the mi
+ ourselves.
+ (camel_message_info_free): Handle refcounting.
+ (camel_message_info_ref): New function.
+ (camel_folder_summary_index): Ref the messageinfo before returning
+ it.
+ (camel_folder_summary_uid): Likewise.
+ (camel_folder_summary_save): Access the messageinfo array
+ directly, rather than through accessors (saves ref/unref).
+ (camel_folder_summary_clear): Likewise.
+ (camel_folder_summary_remove_index): Likewise.
+ (main): Free lookups.
+
+ * camel-folder-summary.h (CamelMessageInfo): Added a refcount
+ value.
+
+ * camel-folder.c (camel_folder_free_message_info): New function to
+ 'free' a message info.
+ (camel_folder_get_message_info): Deconstify return.
+ (camel_folder_lock): New (internal) function to thread-lock the
+ folder.
+ (camel_folder_unlock): Likewise for unlocking.
+ (freeze):
+ (thaw): Lock around access to folder->frozen/changed_frozen.
+ (folder_changed): Likewise.
+ (message_changed): Likewise.
+ (camel_folder_init): Init private data, locks and moved frozen
+ info.
+ (camel_folder_finalize): Free new private data, locks and moved
+ frozen info.
+ (copy_message_to): Free the messageinfo after we've used it.
+ (move_message_to): And here too.
+ (camel_folder_sync): Lock around virtual method invocation. Just
+ locking around any virtual method that is known to need it. This
+ is the first cut at locking.
+ (camel_folder_refresh_info): "
+ (camel_folder_expunge): "
+ (camel_folder_get_message_count): "
+ (camel_folder_get_unread_message_count): "
+ (camel_folder_append_message): "
+ (camel_folder_set_message_flags): "
+ (camel_folder_get_message_flags): "
+ (camel_folder_get_message_user_flag): "
+ (camel_folder_set_message_user_flag): "
+ (camel_folder_get_message_user_tag): "
+ (camel_folder_set_message_user_tag): "
+ (camel_folder_get_message): "
+ (camel_folder_get_uids): "
+ (camel_folder_free_uids): "
+ (camel_folder_get_summary): "
+ (camel_folder_search_by_expression): "
+ (camel_folder_free_summary): "
+ (camel_folder_search_free): "
+ (camel_folder_move_message_to): "
+ (camel_folder_copy_message_to): "
+ (copy_message_to): Dont call any of our own folder functions
+ directly, otherwise we will deadlock.
+ (move_message_to): Likewise.
+
+ * camel-folder.h (CamelFolder): Added free_message_info() function
+ & deconstify get_message_info()'s return.
+ (CamelFolder): Add a private field (for locks).
+ (struct _CamelFolder): Moved changed_changed/frozen into private
+ data, since it really is private and now needs locked access.
+
+>>>>>>> 1.641.2.8
2000-12-15 Jeffrey Stedfast <fejj@helixcode.com>
* camel-mime-utils.c (header_fold): When checking to see if we
noinst_HEADERS = \
- camel-charset-map-private.h
+ camel-charset-map-private.h \
+ camel-private.h
EXTRA_DIST = \
README
--- /dev/null
+
+This version of camel is working towards being multi-thread safe
+(MT-SAFE). At least, for the important api's.
+
+This code has now been merged into the main head, but this file
+will remain here as a log of how it was done, incase any issues
+arise. The ChangeLog of course has a much more detailed list
+of changes.
+
+Intended method
+===============
+
+I intend working on it in several stages:
+
+1. Making the api multi-threadable. Basically removing some const-returns,
+and copying some data where it wasn't before. The api should
+still continue to work if not being used in a multithreaded
+application. There is not a significant amount of work here since
+this was more or less the intention all along.
+
+Some functions where references to objects are returned may have to be
+changed slightly, so that refcounts are incremented before return.
+This doesn't affect much though.
+
+camel_folder::get_message_info done
+camel_folder_summary::uid done
+camel_folder_summary::index done
+camel_folder::get_summary
+ Needs to ref each summary item it points to. done
+camel_folder::free_summary
+ Needs to unref each summary item it points to. done
+camel_folder_get_message_tag
+ needs to copy the tag return
+camel_maildir_summary filename string
+ should not be able to modify the string
+ array contents after it has been added to
+ the summary.
+camel_folder done
+ Make every camel-folder use a camel-folder-summary.
+ This just reduces some of the code duplication,
+ since everything but vee-folder does this already.
+
+2. Adding high level locks for proof of concept. The locks will
+be stored in private or global data, so the api should remain the same for
+non-threaded applications.
+
+A per-folder lock which governs access to the folder
+ summary, the folder file or
+ communications socket, etc. done
+Locking for exceptions. done
+Per store locks for internal stuff. done
+Per-service locks for various internal lists and
+ caches done
+
+3. Further fine-grained locking where it can be done/is worthwhile.
+
+A per-index lock for libibex done
+Locking for the search object half done
+Internal lock for the folder_summary itself
+ So that searching can be detatched from other
+ folder operations, etc. done
+Possibly a lock for access to parts of a mime-part
+ or message
+
+4. A method to cancel operations.
+
+Individual outstanding operations must be cancellable, and not just
+'all current operations'. This will probably not use pthread_cancel
+type of cancelling.
+
+This will however, probably use a method for starting a new thread,
+through camel, that can then be cancelled, and/or some method of
+registering that a thread can be cancelled. Blocking states within
+camel, within that thread, will then act as checkpoints for if the
+operation, and if it is cancelled, the operation will abort
+(i.e. fail, with an appropriate exception code).
+
+Operation cancelling should also function when the application is not
+multi-threaded. Not sure of the api for this yet, probably a callback
+system. Hopefully the api for both scenarios can be made the same.
+
+Other thoughts
+==============
+
+Basically much of the code in camel that does the actual work does NOT
+need to be thread safe to make it safely usable in an mt context.
+
+camel-folder, camel-summary, camel-imap-search, and the camel-service
+classes (at least) are the important ones to be made multithreaded.
+
+For other things, they are either resources that are created
+one-off (for example, camel-mime-message, and its associated
+parts, like camel-internet-address), or multithreadedness
+doesn't make a lot of sense - e.g. camel-stream, or camel-mime-parser.
+
+So basically the approach is a low-risk one. Adding the minimum
+number of locks to start with, and providing further fine-grained
+locks as required. The locks should not need to be particularly
+fine-grained in order to get reasonable results.
+
+Log of changes
+==============
+
+Changed CamelFolder:get_message_info() to return a ref'd copy, requiring
+all get_message_info()'s to have a matching free_message_info().
+
+Moved the CamelFolder frozen changelog data to a private structure.
+
+Added a mutex for CamelFolder frozen changelog stuff (it was just easy
+to do, although it isn't needed yet).
+
+Added a single mutex around all other CamelFolder functions that need
+it, this is just the first cut at mt'edness.
+
+Fixed all camel-folder implementations that call any other
+camel-folder functions to call via virtual methods, to bypass the locks.
+
+Added camel-store private data.
+
+Added a single mutex lock for camel-store's folder functions.
+
+Added camel-service private data.
+
+Added a single mutex lock for camel-service's connect stuff.
+
+Added a mutex for remote-store stream io stuff.
+
+Added a mutex for imap, so it can bracket a compound command
+exclusively. Pop doesn't need this since you can only have a single
+folder per store, and the folder interface is already forced
+single-threaded.
+
+Added mutex for camel-session, most operations.
+
+Running the tests finds at least 1 deadlock so far. Need to
+work on that.
+
+Fixed get_summary to ref/unref its items.
+
+Removed the global folder lock from the toplevel
+camel_folder_search(), each implementation must now handle locking.
+
+Fixed the local-folder implementation of searching. imap-folder
+searching should already be mt-safe through the command lock.
+
+Fixed imap summary to ref/unref too.
+
+Built some test cases, and expanded the test framework library to
+handle multiple threads. It works!
+
+Next, added a recursive mutex class, so that locking inside imap had
+any chance of working. Got imap working.
+
+Moved the camel folder summary into the base folder class, and fixed
+everything to use it that way.
+
+Made the vfolder use a real camel-folder-summary rather than a
+hashtable + array that it was using, and probably fixed some problems
+which caused evolution-mail not to always catch flag updates. Oh, and
+made it sync/expunge all its subfolders when sync/expungeing.
+
+Made the camel-folder summary completely mt-safe.
+
+Removed all of the locks on the folder functions dealing directly with
+the summary, so now for example all summary lookups will not be
+interupted by long operations.
+
+Made the nntp newsrc thing mt-safe, because of some unfortunate
+sideeffect of it being called from the summary interaction code in
+nntp-folder.
+
#include <config.h>
#include "camel-exception.h"
+/* i dont know why gthread_mutex stuff even exists, this is easier */
+/* also, i'm not convinced mutexes are needed here. But it
+ doesn't really hurt either */
+#ifdef ENABLE_THREADS
+#include <pthread.h>
+
+static pthread_mutex_t exception_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+#define CAMEL_EXCEPTION_LOCK(e) (pthread_mutex_lock(&exception_mutex))
+#define CAMEL_EXCEPTION_UNLOCK(e) (pthread_mutex_unlock(&exception_mutex))
+#else
+#define CAMEL_EXCEPTION_LOCK(e)
+#define CAMEL_EXCEPTION_UNLOCK(e)
+#endif
/**
* camel_exception_new: allocate a new exception object.
void
camel_exception_clear (CamelException *exception)
{
- if (!exception) return;
-
- /* free the description text */
+ if (!exception)
+ return;
+
+ CAMEL_EXCEPTION_LOCK(exception);
+
if (exception->desc)
g_free (exception->desc);
exception->desc = NULL;
-
- /* set the Exception Id to NULL */
exception->id = CAMEL_EXCEPTION_NONE;
-}
-
-
+ CAMEL_EXCEPTION_UNLOCK(exception);
+}
/**
* camel_exception_free: Free an exception
void
camel_exception_free (CamelException *exception)
{
- if (!exception) return;
+ if (!exception)
+ return;
- /* free the description text */
if (exception->desc)
g_free (exception->desc);
- /* free the exeption itself */
g_free (exception);
}
ExceptionId id,
const char *desc)
{
- /* if no exception is given, do nothing */
- if (!ex) return;
+ if (!ex)
+ return;
+
+ CAMEL_EXCEPTION_LOCK(exception);
ex->id = id;
- /* remove the previous exception description */
if (ex->desc)
- g_free (ex->desc);
- ex->desc = g_strdup (desc);
-}
+ g_free(ex->desc);
+ ex->desc = g_strdup(desc);
+ CAMEL_EXCEPTION_UNLOCK(exception);
+}
/**
* camel_exception_setv: set an exception
{
va_list args;
- /* if no exception is given, do nothing */
- if (!ex) return;
+ if (!ex)
+ return;
+
+ CAMEL_EXCEPTION_LOCK(exception);
if (ex->desc)
g_free (ex->desc);
- /* create the temporary exception string */
va_start(args, format);
ex->desc = g_strdup_vprintf (format, args);
va_end (args);
ex->id = id;
-}
-
-
-
-
-
+ CAMEL_EXCEPTION_UNLOCK(exception);
+}
/**
* camel_exception_xfer: transfer an exception
camel_exception_xfer (CamelException *ex_dst,
CamelException *ex_src)
{
+ CAMEL_EXCEPTION_LOCK(exception);
+
if (ex_dst->desc)
g_free (ex_dst->desc);
ex_src->desc = NULL;
ex_src->id = CAMEL_EXCEPTION_NONE;
-}
-
-
-
-
-
+ CAMEL_EXCEPTION_UNLOCK(exception);
+}
/**
* camel_exception_get_id: get the exception id
return CAMEL_EXCEPTION_NONE;
}
-
-
-
/**
* camel_exception_get_description: get the description of an exception.
* @ex: The exception object
const gchar *
camel_exception_get_description (CamelException *ex)
{
+ char *ret = NULL;
+
if (ex)
- return ex->desc;
- else
- return NULL;
+ ret = ex->desc;
+
+ return ret;
}
CamelFolderSearch *search = (CamelFolderSearch *)obj;
struct _CamelFolderSearchPrivate *p = _PRIVATE(obj);
- /* yeah, this is a gtk object */
if (search->sexp)
- gtk_object_unref((GtkObject *)search->sexp);
+ e_sexp_unref(search->sexp);
g_free(search->last_search);
g_hash_table_foreach(p->mempool_hash, free_mempool, obj);
g_ptr_array_free(result, TRUE);
}
+
+
+
/* dummy function, returns false always, or an empty match array */
static ESExpResult *
search_dummy(struct _ESExp *f, int argc, struct _ESExpResult **argv, CamelFolderSearch *search)
#include "e-util/md5-utils.h"
#include "e-util/e-memory.h"
+#include "camel-private.h"
+
+#ifdef ENABLE_THREADS
+#include <pthread.h>
+
+static pthread_mutex_t info_lock = PTHREAD_MUTEX_INITIALIZER;
+
+/* this lock is ONLY for the standalone messageinfo stuff */
+#define GLOBAL_INFO_LOCK(i) pthread_mutex_lock(&info_lock)
+#define GLOBAL_INFO_UNLOCK(i) pthread_mutex_unlock(&info_lock)
+#else
+#define GLOBAL_INFO_LOCK(i)
+#define GLOBAL_INFO_UNLOCK(i)
+#endif
+
/* this should probably be conditional on it existing */
#define USE_BSEARCH
#define CAMEL_FOLDER_SUMMARY_VERSION (11)
-struct _CamelFolderSummaryPrivate {
- GHashTable *filter_charset; /* CamelMimeFilterCharset's indexed by source charset */
-
- CamelMimeFilterIndex *filter_index;
- CamelMimeFilterBasic *filter_64;
- CamelMimeFilterBasic *filter_qp;
- CamelMimeFilterSave *filter_save;
-
- ibex *index;
-};
-
#define _PRIVATE(o) (((CamelFolderSummary *)(o))->priv)
/* trivial lists, just because ... */
s->messages = g_ptr_array_new();
s->messages_uid = g_hash_table_new(g_str_hash, g_str_equal);
+
+#ifdef ENABLE_THREADS
+ p->summary_lock = g_mutex_new();
+ p->io_lock = g_mutex_new();
+ p->filter_lock = g_mutex_new();
+ p->alloc_lock = g_mutex_new();
+ p->ref_lock = g_mutex_new();
+#endif
}
static void free_o_name(void *key, void *value, void *data)
if (p->filter_save)
camel_object_unref ((CamelObject *)p->filter_save);
+#ifdef ENABLE_THREADS
+ g_mutex_free(p->summary_lock);
+ g_mutex_free(p->io_lock);
+ g_mutex_free(p->filter_lock);
+ g_mutex_free(p->alloc_lock);
+ g_mutex_free(p->ref_lock);
+#endif
+
g_free(p);
}
CamelFolderSummary *
camel_folder_summary_new (void)
{
- CamelFolderSummary *new = CAMEL_FOLDER_SUMMARY ( camel_object_new (camel_folder_summary_get_type ()));
- return new;
+ CamelFolderSummary *new = CAMEL_FOLDER_SUMMARY ( camel_object_new (camel_folder_summary_get_type ())); return new;
}
**/
void camel_folder_summary_set_filename(CamelFolderSummary *s, const char *name)
{
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
+
g_free(s->summary_path);
s->summary_path = g_strdup(name);
+
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
/**
* @i:
*
* Retrieve a summary item by index number.
+ *
+ * A referenced to the summary item is returned, which may be
+ * ref'd or free'd as appropriate.
*
* Return value: The summary item, or NULL if the index @i is out
* of range.
+ * It must be freed using camel_folder_summary_info_free().
**/
CamelMessageInfo *
camel_folder_summary_index(CamelFolderSummary *s, int i)
{
+ CamelMessageInfo *info = NULL;
+
+ CAMEL_SUMMARY_LOCK(s, ref_lock);
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
+
if (i<s->messages->len)
- return g_ptr_array_index(s->messages, i);
- return NULL;
+ info = g_ptr_array_index(s->messages, i);
+
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
+
+ if (info)
+ info->refcount++;
+
+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);
+
+ return info;
}
/**
* @uid:
*
* Retrieve a summary item by uid.
+ *
+ * A referenced to the summary item is returned, which may be
+ * ref'd or free'd as appropriate.
*
* Return value: The summary item, or NULL if the uid @uid
* is not available.
+ * It must be freed using camel_folder_summary_info_free().
**/
CamelMessageInfo *
camel_folder_summary_uid(CamelFolderSummary *s, const char *uid)
{
- return g_hash_table_lookup(s->messages_uid, uid);
+ CamelMessageInfo *info;
+
+ CAMEL_SUMMARY_LOCK(s, ref_lock);
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
+
+ info = g_hash_table_lookup(s->messages_uid, uid);
+
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
+
+ if (info)
+ info->refcount++;
+
+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);
+
+ return info;
}
/**
**/
guint32 camel_folder_summary_next_uid(CamelFolderSummary *s)
{
- guint32 uid = s->nextuid++;
+ guint32 uid;
+
+
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
+
+ uid = s->nextuid++;
+
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
/* FIXME: sync this to disk */
/* summary_header_save(s);*/
void camel_folder_summary_set_uid(CamelFolderSummary *s, guint32 uid)
{
/* TODO: sync to disk? */
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
+
s->nextuid = MAX(s->nextuid, uid);
+
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
/**
return -1;
}
+ CAMEL_SUMMARY_LOCK(s, io_lock);
if ( ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->summary_header_load(s, in) == -1) {
fclose(in);
+ CAMEL_SUMMARY_UNLOCK(s, io_lock);
return -1;
}
camel_folder_summary_add(s, mi);
}
+
+ CAMEL_SUMMARY_UNLOCK(s, io_lock);
if (fclose(in) == -1)
return -1;
io(printf("saving header\n"));
+ CAMEL_SUMMARY_LOCK(s, io_lock);
+
if ( ((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->summary_header_save(s, out) == -1) {
fclose(out);
+ CAMEL_SUMMARY_UNLOCK(s, io_lock);
return -1;
}
/* now write out each message ... */
/* FIXME: check returns */
- count = camel_folder_summary_count(s);
+
+ count = s->messages->len;
for (i=0;i<count;i++) {
- mi = camel_folder_summary_index(s, i);
+ mi = s->messages->pdata[i];
((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_save(s, out, mi);
if (s->build_content) {
perform_content_info_save(s, out, mi->content);
}
}
+
+ CAMEL_SUMMARY_UNLOCK(s, io_lock);
+
if (fclose(out) == -1)
return -1;
uid = camel_message_info_uid(info);
}
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
+
while (g_hash_table_lookup(s->messages_uid, uid)) {
g_warning("Trying to insert message with clashing uid (%s). new uid re-assigned", camel_message_info_uid(info));
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
camel_message_info_set_uid(info, camel_folder_summary_next_uid_string(s));
uid = camel_message_info_uid(info);
info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED;
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
}
+
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
/**
summary_assign_uid(s, info);
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
+
#ifdef DOESTRV
/* this is vitally important, and also if this is ever modified, then
the hash table needs to be resynced */
g_ptr_array_add(s->messages, info);
g_hash_table_insert(s->messages_uid, (char *)camel_message_info_uid(info), info);
s->flags |= CAMEL_SUMMARY_DIRTY;
+
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
/**
* know if we are going to store this in the summary, but no matter */
summary_assign_uid(s, info);
+ CAMEL_SUMMARY_LOCK(s, filter_lock);
+
if (p->index) {
if (p->filter_index == NULL)
p->filter_index = camel_mime_filter_index_new_ibex(p->index);
/* always scan the content info, even if we dont save it */
info->content = summary_build_content_info(s, info, mp);
+
+ CAMEL_SUMMARY_UNLOCK(s, filter_lock);
+
info->size = camel_mime_parser_tell(mp) - start;
}
return info;
* @s:
* @mi:
*
- * Free the message info @mi, and all associated memory.
+ * Unref and potentially free the message info @mi, and all associated memory.
**/
void camel_folder_summary_info_free(CamelFolderSummary *s, CamelMessageInfo *mi)
{
g_assert(mi);
g_assert(s);
+ CAMEL_SUMMARY_LOCK(s, ref_lock);
+
+ g_assert(mi->refcount >= 1);
+
+ mi->refcount--;
+ if (mi->refcount > 0) {
+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);
+ return;
+ }
+
+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);
+
ci = mi->content;
((CamelFolderSummaryClass *)(CAMEL_OBJECT_GET_CLASS(s)))->message_info_free(s, mi);
}
/**
+ * camel_folder_summary_info_ref:
+ * @s:
+ * @mi:
+ *
+ * Add an extra reference to @mi.
+ **/
+void camel_folder_summary_info_ref(CamelFolderSummary *s, CamelMessageInfo *mi)
+{
+ g_assert(mi);
+ g_assert(s);
+
+ CAMEL_SUMMARY_LOCK(s, ref_lock);
+ g_assert(mi->refcount >= 1);
+ mi->refcount++;
+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);
+}
+
+/**
* camel_folder_summary_touch:
* @s:
*
void
camel_folder_summary_touch(CamelFolderSummary *s)
{
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
s->flags |= CAMEL_SUMMARY_DIRTY;
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
/**
{
int i;
- if (camel_folder_summary_count(s) == 0)
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
+ if (camel_folder_summary_count(s) == 0) {
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
return;
+ }
- for (i=0;i<camel_folder_summary_count(s);i++)
- camel_folder_summary_info_free(s, camel_folder_summary_index(s, i));
+ for (i=0;i<s->messages->len;i++)
+ camel_folder_summary_info_free(s, s->messages->pdata[i]);
g_ptr_array_set_size(s->messages, 0);
g_hash_table_destroy(s->messages_uid);
s->messages_uid = g_hash_table_new(g_str_hash, g_str_equal);
s->flags |= CAMEL_SUMMARY_DIRTY;
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
}
/**
**/
void camel_folder_summary_remove(CamelFolderSummary *s, CamelMessageInfo *info)
{
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
g_hash_table_remove(s->messages_uid, camel_message_info_uid(info));
g_ptr_array_remove(s->messages, info);
- camel_folder_summary_info_free(s, info);
s->flags |= CAMEL_SUMMARY_DIRTY;
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
+
+ camel_folder_summary_info_free(s, info);
}
/**
CamelMessageInfo *oldinfo;
char *olduid;
+ CAMEL_SUMMARY_LOCK(s, ref_lock);
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
if (g_hash_table_lookup_extended(s->messages_uid, uid, (void *)&olduid, (void *)&oldinfo)) {
+ /* make sure it doesn't vanish while we're removing it */
+ oldinfo->refcount++;
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);
camel_folder_summary_remove(s, oldinfo);
- g_free(olduid);
- }
+ camel_folder_summary_info_free(s, oldinfo);
+ } else {
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);
+ }
}
/**
**/
void camel_folder_summary_remove_index(CamelFolderSummary *s, int index)
{
- CamelMessageInfo *oldinfo;
-
- oldinfo = camel_folder_summary_index (s, index);
- if (oldinfo)
- camel_folder_summary_remove(s, oldinfo);
+ CAMEL_SUMMARY_LOCK(s, ref_lock);
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
+ if (index < s->messages->len) {
+ CamelMessageInfo *info = s->messages->pdata[index];
+ /* make sure it doesn't vanish while we're not looking */
+ info->refcount++;
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);
+ camel_folder_summary_remove(s, info);
+ camel_folder_summary_info_free(s, info);
+ } else {
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
+ CAMEL_SUMMARY_UNLOCK(s, ref_lock);
+ }
}
/**
{
CamelMessageInfo *mi;
+ CAMEL_SUMMARY_LOCK(s, alloc_lock);
if (s->message_info_chunks == NULL)
s->message_info_chunks = e_memchunk_new(32, s->message_info_size);
mi = e_memchunk_alloc(s->message_info_chunks);
+ CAMEL_SUMMARY_UNLOCK(s, alloc_lock);
+
memset(mi, 0, s->message_info_size);
#ifdef DOESTRV
mi->strings = e_strv_new(s->message_info_strings);
#endif
+ mi->refcount = 1;
return mi;
}
{
CamelMessageContentInfo *ci;
+ CAMEL_SUMMARY_LOCK(s, alloc_lock);
if (s->content_info_chunks == NULL)
s->content_info_chunks = e_memchunk_new(32, s->content_info_size);
ci = e_memchunk_alloc(s->content_info_chunks);
+ CAMEL_SUMMARY_UNLOCK(s, alloc_lock);
+
memset(ci, 0, s->content_info_size);
return ci;
}
and any indexing and what not is performed
*/
+/* must have filter_lock before calling this function */
static CamelMessageContentInfo *
summary_build_content_info(CamelFolderSummary *s, CamelMessageInfo *msginfo, CamelMimeParser *mp)
{
}
/* build the content-info, from a message */
+/* this needs no lock, as we copy all data, and ibex is threadsafe */
static CamelMessageContentInfo *
summary_build_content_info_message(CamelFolderSummary *s, CamelMessageInfo *msginfo, CamelMimePart *object)
{
{
CamelMessageInfo *info;
- info = g_new0 (CamelMessageInfo, 1);
+ info = g_malloc0(sizeof(*info));
#ifdef DOESTRV
info->strings = e_strv_new (CAMEL_MESSAGE_INFO_LAST);
#endif
-
+ info->refcount = 1;
+
return info;
}
+/**
+ * camel_message_info_ref:
+ * @info:
+ *
+ * Reference an info.
+ *
+ * NOTE: This interface is not MT-SAFE, like the others.
+ **/
+void camel_message_info_ref(CamelMessageInfo *info)
+{
+ GLOBAL_INFO_LOCK(info);
+ info->refcount++;
+ GLOBAL_INFO_UNLOCK(info);
+}
/**
* camel_message_info_new_from_header:
to = camel_folder_summary_format_address (header, "to");
cc = camel_folder_summary_format_address (header, "cc");
- info = g_new0 (CamelMessageInfo, 1);
-#ifdef DOESTRV
- info->strings = e_strv_new (CAMEL_MESSAGE_INFO_LAST);
+ info = camel_message_info_new();
+
camel_message_info_set_subject (info, subject);
camel_message_info_set_from (info, from);
camel_message_info_set_to (info, to);
camel_message_info_set_cc (info, cc);
-#else
- info->subject = subject;
- info->from = from;
- info->to = to;
- info->cc = cc;
-#endif
-
+
return info;
}
to->size = from->size;
to->date_sent = from->date_sent;
to->date_received = from->date_received;
+ to->refcount = 1;
/* Copy strings */
#ifdef DOESTRV
* camel_message_info_free:
* @mi: the message info
*
- * Frees a CamelMessageInfo and its contents.
+ * Unref's and potentially frees a CamelMessageInfo and its contents.
*
* Can only be used to free CamelMessageInfo's created with
* camel_message_info_dup_to.
*
+ * NOTE: This interface is not MT-SAFE, like the others.
+ *
**/
void
camel_message_info_free(CamelMessageInfo *mi)
{
+ g_return_if_fail(mi != NULL);
+
+ GLOBAL_INFO_LOCK(info);
+ mi->refcount--;
+ if (mi->refcount > 0) {
+ GLOBAL_INFO_UNLOCK(info);
+ return;
+ }
+ GLOBAL_INFO_UNLOCK(info);
+
#ifdef DOESTRV
e_strv_destroy(mi->strings);
#else
printf("Printing summary\n");
for (i=0;i<camel_folder_summary_count(s);i++) {
- message_info_dump(camel_folder_summary_index(s, i));
+ CamelMessageInfo *info = camel_folder_summary_index(s, i);
+ message_info_dump(info);
+ camel_folder_summary_info_free(info);
}
printf("Saivng summary\n");
printf("Printing summary\n");
for (i=0;i<camel_folder_summary_count(n);i++) {
- message_info_dump(camel_folder_summary_index(n, i));
+ CamelMessageInfo *info = camel_folder_summary_index(s, i);
+ message_info_dump(info);
+ camel_folder_summary_info_free(info);
}
camel_object_unref(n);
}
#endif
guint32 flags;
guint32 size;
+ guint32 refcount;
time_t date_sent;
time_t date_received;
CamelMessageInfo *camel_folder_summary_info_new_from_parser(CamelFolderSummary *, CamelMimeParser *);
CamelMessageInfo *camel_folder_summary_info_new_from_message(CamelFolderSummary *, CamelMimeMessage *);
+void camel_folder_summary_info_ref(CamelFolderSummary *, CamelMessageInfo *);
void camel_folder_summary_info_free(CamelFolderSummary *, CamelMessageInfo *);
/* removes a summary item, doesn't fix content offsets */
/* message info utils for working with pseudo-messageinfo structures
NOTE: These cannot be added to a real summary object, but suffice for all
other external interfaces that use message info's */
-CamelMessageInfo *camel_message_info_new (void);
-CamelMessageInfo *camel_message_info_new_from_header (struct _header_raw *header);
+CamelMessageInfo *camel_message_info_new(void);
+void camel_message_info_ref(CamelMessageInfo *info);
+CamelMessageInfo *camel_message_info_new_from_header(struct _header_raw *header);
void camel_message_info_dup_to(const CamelMessageInfo *from, CamelMessageInfo *to);
void camel_message_info_free(CamelMessageInfo *mi);
int i;
CamelFolderThreadNode *c, *child, *head;
CamelFolderThread *thread;
- GPtrArray *myuids;
+ GHashTable *wanted = NULL;
+ GPtrArray *summary;
#ifdef TIMEIT
struct timeval start, end;
thread = g_malloc(sizeof(*thread));
thread->tree = NULL;
thread->node_chunks = e_memchunk_new(32, sizeof(CamelFolderThreadNode));
+ thread->folder = folder;
+ camel_object_ref((CamelObject *)folder);
+
+ /* wanted is the list of what we want, we put it in a hash for quick lookup */
+ if (uids) {
+ wanted = g_hash_table_new(g_str_hash, g_str_equal);
+ for (i=0;i<uids->len;i++)
+ g_hash_table_insert(wanted, uids->pdata[i], uids->pdata[i]);
+ }
- if (uids == NULL)
- uids = myuids = camel_folder_get_uids(folder);
- else
- myuids = NULL;
-
+ thread->summary = summary = camel_folder_get_summary(folder);
+
id_table = g_hash_table_new((GHashFunc)id_hash, (GCompareFunc)id_equal);
no_id_table = g_hash_table_new(NULL, NULL);
- for (i=0;i<uids->len;i++) {
- const CamelMessageInfo *mi;
- mi = camel_folder_get_message_info(folder, uids->pdata[i]);
+ for (i=0;i<summary->len;i++) {
+ CamelMessageInfo *mi = summary->pdata[i];
+ const char *uid = camel_message_info_uid(mi);
- if (mi == NULL) {
- g_warning("Folder doesn't contain uid %s", (char *)uids->pdata[i]);
+ if (wanted && g_hash_table_lookup(wanted, uid) == 0)
continue;
- }
if (mi->message_id.id.id) {
c = g_hash_table_lookup(id_table, &mi->message_id);
uids->len, diff / 1000, diff % 1000);
#endif
- if (myuids)
- camel_folder_free_uids(folder, myuids);
-
return thread;
}
void
camel_folder_thread_messages_destroy(CamelFolderThread *thread)
{
+ camel_folder_free_summary(thread->folder, thread->summary);
+ camel_object_unref((CamelObject *)thread->folder);
e_memchunk_destroy(thread->node_chunks);
g_free(thread);
}
typedef struct CamelFolderThread {
struct _CamelFolderThreadNode *tree;
struct _EMemChunk *node_chunks;
+ CamelFolder *folder;
+ GPtrArray *summary;
} CamelFolderThread;
CamelFolderThread *camel_folder_thread_messages_new(CamelFolder *folder, GPtrArray *uids);
#include "string-utils.h"
#include "e-util/e-memory.h"
+#include "camel-private.h"
+
static CamelObjectClass *parent_class = NULL;
/* Returns the class for a CamelFolder */
const gchar *uid,
CamelException *ex);
-static const CamelMessageInfo *get_message_info (CamelFolder *folder,
- const char *uid);
+static CamelMessageInfo *get_message_info (CamelFolder *folder, const char *uid);
+static void free_message_info (CamelFolder *folder, CamelMessageInfo *info);
static GPtrArray *search_by_expression (CamelFolder *folder,
const char *exp,
camel_folder_class->search_by_expression = search_by_expression;
camel_folder_class->search_free = search_free;
camel_folder_class->get_message_info = get_message_info;
+ camel_folder_class->free_message_info = free_message_info;
camel_folder_class->copy_message_to = copy_message_to;
camel_folder_class->move_message_to = move_message_to;
camel_folder_class->freeze = freeze;
{
CamelFolder *folder = object;
- folder->frozen = 0;
- folder->changed_frozen = camel_folder_change_info_new();
+ folder->priv = g_malloc0(sizeof(*folder->priv));
+ folder->priv->frozen = 0;
+ folder->priv->changed_frozen = camel_folder_change_info_new();
+#ifdef ENABLE_THREADS
+ folder->priv->lock = g_mutex_new();
+ folder->priv->change_lock = g_mutex_new();
+#endif
}
static void
if (camel_folder->parent_store)
camel_object_unref (CAMEL_OBJECT (camel_folder->parent_store));
- camel_folder_change_info_free(camel_folder->changed_frozen);
+ if (camel_folder->summary)
+ camel_object_unref((CamelObject *)camel_folder->summary);
+
+ camel_folder_change_info_free(camel_folder->priv->changed_frozen);
+#ifdef ENABLE_THREADS
+ g_mutex_free(camel_folder->priv->lock);
+ g_mutex_free(camel_folder->priv->change_lock);
+#endif
+ g_free(camel_folder->priv);
}
CamelType
{
g_return_if_fail (CAMEL_IS_FOLDER (folder));
+ CAMEL_FOLDER_LOCK(folder, lock);
+
CF_CLASS (folder)->sync (folder, expunge, ex);
+
+ CAMEL_FOLDER_UNLOCK(folder, lock);
}
{
g_return_if_fail (CAMEL_IS_FOLDER (folder));
+ CAMEL_FOLDER_LOCK(folder, lock);
+
CF_CLASS (folder)->refresh_info (folder, ex);
+
+ CAMEL_FOLDER_UNLOCK(folder, lock);
}
{
g_return_if_fail (CAMEL_IS_FOLDER (folder));
+ CAMEL_FOLDER_LOCK(folder, lock);
+
CF_CLASS (folder)->expunge (folder, ex);
-}
+ CAMEL_FOLDER_UNLOCK(folder, lock);
+}
static int
get_message_count (CamelFolder *folder)
{
- g_warning ("CamelFolder::get_message_count not implemented "
- "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
- return -1;
+ g_return_val_if_fail(folder->summary != NULL, -1);
+
+ return camel_folder_summary_count(folder->summary);
}
/**
int
camel_folder_get_message_count (CamelFolder *folder)
{
+ int ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), -1);
- return CF_CLASS (folder)->get_message_count (folder);
-}
+ ret = CF_CLASS (folder)->get_message_count (folder);
+ return ret;
+}
static int
-get_unread_message_count (CamelFolder *folder)
+get_unread_message_count(CamelFolder *folder)
{
- g_warning ("CamelFolder::get_unread_message_count not implemented "
- "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
- return -1;
+ int i, count, unread=0;
+
+ g_return_val_if_fail(folder->summary != NULL, -1);
+
+ count = camel_folder_summary_count(folder->summary);
+ for (i=0; i<count; i++) {
+ CamelMessageInfo *info = camel_folder_summary_index(folder->summary, i);
+
+ if (info && !(info->flags & CAMEL_MESSAGE_SEEN))
+ unread++;
+
+ camel_folder_summary_info_free(folder->summary, info);
+ }
+
+ return unread;
}
/**
int
camel_folder_get_unread_message_count (CamelFolder *folder)
{
+ int ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), -1);
+
+ ret = CF_CLASS (folder)->get_unread_message_count (folder);
- return CF_CLASS (folder)->get_unread_message_count (folder);
+ return ret;
}
-
static void
append_message (CamelFolder *folder, CamelMimeMessage *message,
const CamelMessageInfo *info, CamelException *ex)
{
g_return_if_fail (CAMEL_IS_FOLDER (folder));
+ CAMEL_FOLDER_LOCK(folder, lock);
+
CF_CLASS (folder)->append_message (folder, message, info, ex);
+
+ CAMEL_FOLDER_UNLOCK(folder, lock);
}
return CF_CLASS (folder)->get_permanent_flags (folder);
}
-
static guint32
-get_message_flags (CamelFolder *folder, const char *uid)
+get_message_flags(CamelFolder *folder, const char *uid)
{
- g_warning ("CamelFolder::get_message_flags not implemented for `%s'",
- camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
- return 0;
+ CamelMessageInfo *info;
+ guint32 flags;
+
+ g_return_val_if_fail(folder->summary != NULL, 0);
+
+ info = camel_folder_summary_uid(folder->summary, uid);
+ g_return_val_if_fail(info != NULL, 0);
+
+ flags = info->flags;
+ camel_folder_summary_info_free(folder->summary, info);
+
+ return flags;
}
/**
guint32
camel_folder_get_message_flags (CamelFolder *folder, const char *uid)
{
+ guint32 ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), 0);
- return CF_CLASS (folder)->get_message_flags (folder, uid);
-}
+ ret = CF_CLASS (folder)->get_message_flags (folder, uid);
+ return ret;
+}
static void
-set_message_flags (CamelFolder *folder, const char *uid,
- guint32 flags, guint32 set)
+set_message_flags(CamelFolder *folder, const char *uid, guint32 flags, guint32 set)
{
- g_warning ("CamelFolder::set_message_flags not implemented for `%s'",
- camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
+ CamelMessageInfo *info;
+ guint32 new;
+
+ g_return_if_fail(folder->summary != NULL);
+
+ info = camel_folder_summary_uid(folder->summary, uid);
+ g_return_if_fail(info != NULL);
+
+ new = (info->flags & ~flags) | (set & flags);
+ if (new == info->flags) {
+ camel_folder_summary_info_free(folder->summary, info);
+ return;
+ }
+
+ info->flags = new | CAMEL_MESSAGE_FOLDER_FLAGGED;
+ camel_folder_summary_touch(folder->summary);
+ camel_folder_summary_info_free(folder->summary, info);
+
+ camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
}
/**
static gboolean
-get_message_user_flag (CamelFolder *folder, const char *uid,
- const char *name)
+get_message_user_flag(CamelFolder *folder, const char *uid, const char *name)
{
- g_warning ("CamelFolder::get_message_user_flag not implemented "
- "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
- return FALSE;
+ CamelMessageInfo *info;
+ gboolean ret;
+
+ g_return_val_if_fail(folder->summary != NULL, FALSE);
+
+ info = camel_folder_summary_uid(folder->summary, uid);
+ g_return_val_if_fail(info != NULL, FALSE);
+
+ ret = camel_flag_get(&info->user_flags, name);
+ camel_folder_summary_info_free(folder->summary, info);
+
+ return ret;
}
/**
camel_folder_get_message_user_flag (CamelFolder *folder, const char *uid,
const char *name)
{
+ gboolean ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), 0);
- return CF_CLASS (folder)->get_message_user_flag (folder, uid, name);
-}
+ ret = CF_CLASS (folder)->get_message_user_flag (folder, uid, name);
+ return ret;
+}
static void
-set_message_user_flag (CamelFolder *folder, const char *uid,
- const char *name, gboolean value)
+set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value)
{
- g_warning ("CamelFolder::set_message_user_flag not implemented "
- "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
+ CamelMessageInfo *info;
+
+ g_return_if_fail(folder->summary != NULL);
+
+ info = camel_folder_summary_uid(folder->summary, uid);
+ g_return_if_fail(info != NULL);
+
+ if (camel_flag_set(&info->user_flags, name, value)) {
+ info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED;
+ camel_folder_summary_touch(folder->summary);
+ camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
+ }
+ camel_folder_summary_info_free(folder->summary, info);
}
/**
CF_CLASS (folder)->set_message_user_flag (folder, uid, name, value);
}
-static const char *get_message_user_tag(CamelFolder *folder, const char *uid, const char *name)
+static const char *
+get_message_user_tag(CamelFolder *folder, const char *uid, const char *name)
{
- g_warning ("CamelFolder::get_message_user_tag not implemented "
- "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
- return NULL;
+ CamelMessageInfo *info;
+ const char *ret;
+
+ g_return_val_if_fail(folder->summary != NULL, NULL);
+
+ info = camel_folder_summary_uid(folder->summary, uid);
+ g_return_val_if_fail(info != NULL, FALSE);
+
+#warning "Need to duplicate tag string"
+
+ ret = camel_tag_get(&info->user_tags, name);
+ camel_folder_summary_info_free(folder->summary, info);
+
+ return ret;
}
/**
const char *
camel_folder_get_message_user_tag (CamelFolder *folder, const char *uid, const char *name)
{
+ const char *ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), 0);
- return CF_CLASS (folder)->get_message_user_tag (folder, uid, name);
-}
+#warning "get_message_user_tag() needs to copy the tag contents"
+ ret = CF_CLASS (folder)->get_message_user_tag (folder, uid, name);
+ return ret;
+}
static void
set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value)
{
- g_warning ("CamelFolder::set_message_user_tag not implemented "
- "for `%s'", camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
+ CamelMessageInfo *info;
+
+ g_return_if_fail(folder->summary != NULL);
+
+ info = camel_folder_summary_uid(folder->summary, uid);
+ g_return_if_fail(info != NULL);
+
+ if (camel_tag_set(&info->user_tags, name, value)) {
+ info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED;
+ camel_folder_summary_touch(folder->summary);
+ camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
+ }
+ camel_folder_summary_info_free(folder->summary, info);
}
/**
CF_CLASS (folder)->set_message_user_tag (folder, uid, name, value);
}
-
-static const CamelMessageInfo *
+static CamelMessageInfo *
get_message_info (CamelFolder *folder, const char *uid)
{
- g_warning ("CamelFolder::get_message_info not implemented for `%s'",
- camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
- return NULL;
+ g_return_val_if_fail(folder->summary != NULL, NULL);
+
+ return camel_folder_summary_uid(folder->summary, uid);
}
/**
* @folder: a CamelFolder
* @uid: the uid of a message
*
- * Return value: the summary information for the indicated message
+ * Retrieve the CamelMessageInfo for the specified @uid. This return
+ * must be freed using free_message_info().
+ *
+ * Return value: the summary information for the indicated message, or NULL
+ * if the uid does not exist.
**/
-const CamelMessageInfo *
+CamelMessageInfo *
camel_folder_get_message_info (CamelFolder *folder, const char *uid)
{
+ CamelMessageInfo *ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL);
g_return_val_if_fail (uid != NULL, NULL);
- return CF_CLASS (folder)->get_message_info (folder, uid);
+ ret = CF_CLASS (folder)->get_message_info (folder, uid);
+
+ return ret;
}
+static void
+free_message_info (CamelFolder *folder, CamelMessageInfo *info)
+{
+ g_return_if_fail(folder->summary != NULL);
+
+ camel_folder_summary_info_free(folder->summary, info);
+}
+
+/**
+ * camel_folder_free_message_info:
+ * @folder:
+ * @info:
+ *
+ * Free (unref) a CamelMessageInfo, previously obtained with get_message_info().
+ **/
+void
+camel_folder_free_message_info(CamelFolder *folder, CamelMessageInfo *info)
+{
+ g_return_if_fail(CAMEL_IS_FOLDER (folder));
+ g_return_if_fail(info != NULL);
+
+ CF_CLASS (folder)->free_message_info(folder, info);
+}
/* TODO: is this function required anyway? */
gboolean
* Return value: Message corresponding to the UID
**/
CamelMimeMessage *
-camel_folder_get_message (CamelFolder *folder, const gchar *uid,
- CamelException *ex)
+camel_folder_get_message (CamelFolder *folder, const gchar *uid, CamelException *ex)
{
+ CamelMimeMessage *ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL);
- return CF_CLASS (folder)->get_message (folder, uid, ex);
-}
+ CAMEL_FOLDER_LOCK(folder, lock);
+
+ ret = CF_CLASS (folder)->get_message (folder, uid, ex);
+ CAMEL_FOLDER_UNLOCK(folder, lock);
+
+ return ret;
+}
static GPtrArray *
-get_uids (CamelFolder *folder)
+get_uids(CamelFolder *folder)
{
- g_warning ("CamelFolder::get_uids not implemented for `%s'",
- camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
- return NULL;
+ GPtrArray *array;
+ int i, count;
+
+ array = g_ptr_array_new();
+
+ g_return_val_if_fail(folder->summary != NULL, array);
+
+ count = camel_folder_summary_count(folder->summary);
+ g_ptr_array_set_size(array, count);
+ for (i=0; i<count; i++) {
+ CamelMessageInfo *info = camel_folder_summary_index(folder->summary, i);
+
+ if (info) {
+ array->pdata[i] = g_strdup(camel_message_info_uid(info));
+ camel_folder_summary_info_free(folder->summary, info);
+ } else {
+ array->pdata[i] = g_strdup("xx unknown uid xx");
+ }
+ }
+
+ return array;
}
/**
GPtrArray *
camel_folder_get_uids (CamelFolder *folder)
{
+ GPtrArray *ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL);
- return CF_CLASS (folder)->get_uids (folder);
-}
+ ret = CF_CLASS (folder)->get_uids (folder);
+ return ret;
+}
static void
free_uids (CamelFolder *folder, GPtrArray *array)
{
- g_warning ("CamelFolder::free_uids not implemented for `%s'",
- camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
+ int i;
+
+ for (i=0; i<array->len; i++)
+ g_free(array->pdata[i]);
+ g_ptr_array_free(array, TRUE);
}
/**
CF_CLASS (folder)->free_uids (folder, array);
}
-
static GPtrArray *
-get_summary (CamelFolder *folder)
+get_summary(CamelFolder *folder)
{
- g_warning ("CamelFolder::get_summary not implemented for `%s'",
- camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
- return NULL;
+ GPtrArray *res = g_ptr_array_new();
+ int i, count;
+
+ g_return_val_if_fail(folder->summary != NULL, res);
+
+ count = camel_folder_summary_count(folder->summary);
+ g_ptr_array_set_size(res, count);
+ for (i=0;i<count;i++)
+ res->pdata[i] = camel_folder_summary_index(folder->summary, i);
+
+ return res;
}
/**
GPtrArray *
camel_folder_get_summary (CamelFolder *folder)
{
+ GPtrArray *ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL);
- return CF_CLASS (folder)->get_summary (folder);
-}
+ ret = CF_CLASS (folder)->get_summary (folder);
+ return ret;
+}
static void
-free_summary (CamelFolder *folder, GPtrArray *array)
+free_summary(CamelFolder *folder, GPtrArray *summary)
{
- g_warning ("CamelFolder::free_summary not implemented for `%s'",
- camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
+ int i;
+
+ g_return_if_fail(folder->summary != NULL);
+
+ for (i=0;i<summary->len;i++)
+ camel_folder_summary_info_free(folder->summary, summary->pdata[i]);
+
+ g_ptr_array_free(summary, TRUE);
}
/**
camel_folder_search_by_expression (CamelFolder *folder, const char *expression,
CamelException *ex)
{
+ GPtrArray *ret;
+
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), NULL);
g_return_val_if_fail (folder->has_search_capability, NULL);
- return CF_CLASS (folder)->search_by_expression (folder, expression, ex);
+ /* NOTE: that it is upto the callee to lock */
+
+ ret = CF_CLASS (folder)->search_by_expression (folder, expression, ex);
+
+ return ret;
}
static void
g_return_if_fail (CAMEL_IS_FOLDER (folder));
g_return_if_fail (folder->has_search_capability);
- return CF_CLASS (folder)->search_free (folder, result);
+ /* NOTE: upto the callee to lock */
+ CF_CLASS (folder)->search_free (folder, result);
}
static void
-copy_message_to (CamelFolder *source, const char *uid, CamelFolder *dest,
- CamelException *ex)
+copy_message_to (CamelFolder *source, const char *uid, CamelFolder *dest, CamelException *ex)
{
CamelMimeMessage *msg;
- const CamelMessageInfo *info;
+ CamelMessageInfo *info;
/* Default implementation. */
- msg = camel_folder_get_message (source, uid, ex);
+ /* we alredy have the lock, dont deadlock */
+ msg = CF_CLASS(source)->get_message(source, uid, ex);
if (!msg)
return;
- info = camel_folder_get_message_info (source, uid);
+ info = CF_CLASS(source)->get_message_info (source, uid);
camel_folder_append_message (dest, msg, info, ex);
camel_object_unref (CAMEL_OBJECT (msg));
+ if (info)
+ CF_CLASS(source)->free_message_info(source, info);
}
/**
g_warning("CamelFolder.copy_message_to() is a deprecated api");
- if (source->parent_store == dest->parent_store) {
- return CF_CLASS (source)->copy_message_to (source, uid,
- dest, ex);
- } else
- return copy_message_to (source, uid, dest, ex);
+ CAMEL_FOLDER_LOCK(source, lock);
+
+ if (source->parent_store == dest->parent_store)
+ return CF_CLASS (source)->copy_message_to (source, uid, dest, ex);
+ else
+ copy_message_to (source, uid, dest, ex);
+
+ CAMEL_FOLDER_UNLOCK(source, lock);
}
CamelFolder *dest, CamelException *ex)
{
CamelMimeMessage *msg;
- const CamelMessageInfo *info;
+ CamelMessageInfo *info;
/* Default implementation. */
- msg = camel_folder_get_message (source, uid, ex);
+ msg = CF_CLASS(source)->get_message (source, uid, ex);
if (!msg)
return;
- info = camel_folder_get_message_info (source, uid);
+ info = CF_CLASS(source)->get_message_info (source, uid);
camel_folder_append_message (dest, msg, info, ex);
camel_object_unref (CAMEL_OBJECT (msg));
- if (camel_exception_is_set(ex))
- return;
- camel_folder_delete_message (source, uid);
+ if (!camel_exception_is_set(ex))
+ CF_CLASS(source)->set_message_flags(source, uid, CAMEL_MESSAGE_DELETED, CAMEL_MESSAGE_DELETED);
+
+ if (info)
+ CF_CLASS(source)->free_message_info(source, info);
}
/**
* @dest folders have the same parent_store, this may be more efficient
* than a camel_folder_append_message() followed by
* camel_folder_delete_message().
- *
- * FIXME: This call should be depracated, since append_message() can
- * determine this from the message itself.
**/
void
camel_folder_move_message_to (CamelFolder *source, const char *uid,
g_warning("CamelFolder.move_message_to() is a deprecated api");
- if (source->parent_store == dest->parent_store) {
- return CF_CLASS (source)->move_message_to (source, uid,
- dest, ex);
- } else
- return move_message_to (source, uid, dest, ex);
+ CAMEL_FOLDER_LOCK(source, lock);
+
+ if (source->parent_store == dest->parent_store)
+ CF_CLASS (source)->move_message_to (source, uid, dest, ex);
+ else
+ move_message_to (source, uid, dest, ex);
+
+ CAMEL_FOLDER_UNLOCK(source, lock);
}
static void
freeze (CamelFolder *folder)
{
- folder->frozen++;
+ CAMEL_FOLDER_LOCK(folder, change_lock);
+
+ folder->priv->frozen++;
+
+ CAMEL_FOLDER_UNLOCK(folder, change_lock);
}
/**
int i;
CamelFolderChangeInfo *info;
- folder->frozen--;
- if (folder->frozen != 0)
- return;
-
- /* If we have more or less messages, do a folder changed, otherwise just
- do a message changed for each one.
- TODO: message_changed is now probably irrelevant and not required */
- info = folder->changed_frozen;
- if (info->uid_added->len > 0 || info->uid_removed->len > 0) {
- camel_object_trigger_event(CAMEL_OBJECT(folder), "folder_changed", info);
- } else if (info->uid_changed->len > 0) {
- for (i=0;i<info->uid_changed->len;i++) {
- camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", info->uid_changed->pdata[i]);
+ CAMEL_FOLDER_LOCK(folder, change_lock);
+
+ folder->priv->frozen--;
+ if (folder->priv->frozen == 0) {
+ /* If we have more or less messages, do a folder changed, otherwise just
+ do a message changed for each one.
+ TODO: message_changed is now probably irrelevant and not required */
+ info = folder->priv->changed_frozen;
+ if (info->uid_added->len > 0 || info->uid_removed->len > 0) {
+ camel_object_trigger_event(CAMEL_OBJECT(folder), "folder_changed", info);
+ } else if (info->uid_changed->len > 0) {
+ for (i=0;i<info->uid_changed->len;i++) {
+ camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", info->uid_changed->pdata[i]);
+ }
}
+ camel_folder_change_info_clear(info);
}
- camel_folder_change_info_clear(info);
+ CAMEL_FOLDER_UNLOCK(folder, change_lock);
}
/**
camel_folder_thaw (CamelFolder *folder)
{
g_return_if_fail (CAMEL_IS_FOLDER (folder));
- g_return_if_fail (folder->frozen != 0);
+ g_return_if_fail (folder->priv->frozen != 0);
CF_CLASS (folder)->thaw (folder);
}
{
CamelFolder *folder = CAMEL_FOLDER (obj);
CamelFolderChangeInfo *changed = event_data;
+ gboolean ret = TRUE;
+
+ if (folder->priv->frozen) {
+ CAMEL_FOLDER_LOCK(folder, change_lock);
- if (folder->frozen) {
if (changed != NULL)
- camel_folder_change_info_cat(folder->changed_frozen, changed);
+ camel_folder_change_info_cat(folder->priv->changed_frozen, changed);
else
g_warning("Class %s is passing NULL to folder_changed event",
camel_type_to_name (CAMEL_OBJECT_GET_TYPE (folder)));
- return FALSE;
+ ret = FALSE;
+
+ CAMEL_FOLDER_UNLOCK(folder, change_lock);
}
- return TRUE;
+
+ return ret;
}
static gboolean
message_changed (CamelObject *obj, /*const char *uid*/gpointer event_data)
{
CamelFolder *folder = CAMEL_FOLDER (obj);
+ gboolean ret = TRUE;
+
+ if (folder->priv->frozen) {
+ CAMEL_FOLDER_LOCK(folder, change_lock);
+
+ camel_folder_change_info_change_uid(folder->priv->changed_frozen, (char *)event_data);
+ ret = FALSE;
- if (folder->frozen) {
- camel_folder_change_info_change_uid(folder->changed_frozen, (char *)event_data);
- return FALSE;
+ CAMEL_FOLDER_UNLOCK(folder, change_lock);
}
- return TRUE;
+ return ret;
}
* @void:
*
* Create a new folder change info structure.
+ *
+ * Change info structures are not MT-SAFE and must be
+ * locked for exclusive access externally.
*
* Return value:
**/
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
-/* camel-folder.h: Abstract class for an email folder */
-
-/*
- * Author:
- * Bertrand Guiheneuf <bertrand@helixcode.com>
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ *
+ * camel-folder.h: Abstract class for an email folder
+ *
+ * Authors: Bertrand Guiheneuf <bertrand@helixcode.com>
+ * Michael Zucchi <notzed@helixcode.com>
*
* Copyright 1999, 2000 Helix Code, Inc. (http://www.helixcode.com)
*
* USA
*/
-
#ifndef CAMEL_FOLDER_H
#define CAMEL_FOLDER_H 1
GHashTable *uid_source; /* used to create unique lists */
struct _EMemPool *uid_pool; /* pool used to store copies of uid strings */
+ struct _CamelFolderChangeInfoPrivate *priv;
};
struct _CamelFolder
{
CamelObject parent_object;
- int frozen;
- CamelFolderChangeInfo *changed_frozen; /* queues changed events */
+ struct _CamelFolderPrivate *priv;
char *name;
char *full_name;
CamelStore *parent_store;
+ CamelFolderSummary *summary;
guint32 permanent_flags;
gboolean has_summary_capability:1;
gboolean has_search_capability:1;
+
};
typedef struct {
void (*search_free) (CamelFolder *folder, GPtrArray *result);
- const CamelMessageInfo * (*get_message_info) (CamelFolder *, const char *uid);
+ CamelMessageInfo * (*get_message_info) (CamelFolder *, const char *uid);
+ void (*free_message_info) (CamelFolder *, CamelMessageInfo *);
void (*copy_message_to) (CamelFolder *source,
const char *uid,
void camel_folder_search_free (CamelFolder *folder, GPtrArray *);
/* summary info */
-const CamelMessageInfo *camel_folder_get_message_info (CamelFolder *summary,
- const char *uid);
+CamelMessageInfo *camel_folder_get_message_info (CamelFolder *folder, const char *uid);
+void camel_folder_free_message_info (CamelFolder *folder, CamelMessageInfo *info);
+/* FIXME: copy-message-to is not required */
void camel_folder_copy_message_to (CamelFolder *source,
const char *uid,
CamelFolder *dest,
CamelFolder *dest,
CamelException *ex);
+/* stop/restart getting events */
void camel_folder_freeze (CamelFolder *folder);
void camel_folder_thaw (CamelFolder *folder);
+#if 0
+/* lock/unlock at the thread level, NOTE: only used internally */
+void camel_folder_lock (CamelFolder *folder);
+void camel_folder_unlock (CamelFolder *folder);
+#endif
/* For use by subclasses (for free_{uids,summary,subfolder_names}) */
void camel_folder_free_nop (CamelFolder *folder, GPtrArray *array);
--- /dev/null
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ * camel-private.h: Private info for class implementers.
+ *
+ * Authors: Michael Zucchi <notzed@helixcode.com>
+ *
+ * Copyright 1999, 2000 Helix Code, Inc. (http://www.helixcode.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+#ifndef CAMEL_PRIVATE_H
+#define CAMEL_PRIVATE_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus }*/
+
+/* need a way to configure and save this data, if this header is to
+ be installed. For now, dont install it */
+
+#include "config.h"
+
+#ifdef ENABLE_THREADS
+#include <pthread.h>
+#include "e-util/e-msgport.h"
+#endif
+
+struct _CamelFolderPrivate {
+#ifdef ENABLE_THREADS
+ GMutex *lock;
+ GMutex *change_lock;
+#endif
+
+ /* must require the 'change_lock' to access this */
+ int frozen;
+ struct _CamelFolderChangeInfo *changed_frozen; /* queues changed events */
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_FOLDER_LOCK(f, l) (g_mutex_lock(((CamelFolder *)f)->priv->l))
+#define CAMEL_FOLDER_UNLOCK(f, l) (g_mutex_unlock(((CamelFolder *)f)->priv->l))
+#else
+#define CAMEL_FOLDER_LOCK(f, l)
+#define CAMEL_FOLDER_UNLOCK(f, l)
+#endif
+
+struct _CamelStorePrivate {
+#ifdef ENABLE_THREADS
+ GMutex *folder_lock; /* for locking folder operations */
+ GMutex *cache_lock; /* for locking access to the cache */
+#endif
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_STORE_LOCK(f, l) (g_mutex_lock(((CamelStore *)f)->priv->l))
+#define CAMEL_STORE_UNLOCK(f, l) (g_mutex_unlock(((CamelStore *)f)->priv->l))
+#else
+#define CAMEL_STORE_LOCK(f, l)
+#define CAMEL_STORE_UNLOCK(f, l)
+#endif
+
+struct _CamelServicePrivate {
+#ifdef ENABLE_THREADS
+ EMutex *connect_lock; /* for locking connection operations */
+#endif
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_SERVICE_LOCK(f, l) (e_mutex_lock(((CamelService *)f)->priv->l))
+#define CAMEL_SERVICE_UNLOCK(f, l) (e_mutex_unlock(((CamelService *)f)->priv->l))
+#else
+#define CAMEL_SERVICE_LOCK(f, l)
+#define CAMEL_SERVICE_UNLOCK(f, l)
+#endif
+
+struct _CamelSessionPrivate {
+#ifdef ENABLE_THREADS
+ GMutex *lock; /* for locking everything basically */
+#endif
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_SESSION_LOCK(f, l) (g_mutex_lock(((CamelSession *)f)->priv->l))
+#define CAMEL_SESSION_UNLOCK(f, l) (g_mutex_unlock(((CamelSession *)f)->priv->l))
+#else
+#define CAMEL_SESSION_LOCK(f, l)
+#define CAMEL_SESSION_UNLOCK(f, l)
+#endif
+
+
+struct _CamelRemoteStorePrivate {
+#ifdef ENABLE_THREADS
+ EMutex *stream_lock; /* for locking stream operations */
+#endif
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_REMOTE_STORE_LOCK(f, l) (e_mutex_lock(((CamelRemoteStore *)f)->priv->l))
+#define CAMEL_REMOTE_STORE_UNLOCK(f, l) (e_mutex_unlock(((CamelRemoteStore *)f)->priv->l))
+#else
+#define CAMEL_REMOTE_STORE_LOCK(f, l)
+#define CAMEL_REMOTE_STORE_UNLOCK(f, l)
+#endif
+
+/* most of this stuff really is private, but the lock can be used by subordinate classes */
+struct _CamelFolderSummaryPrivate {
+ GHashTable *filter_charset; /* CamelMimeFilterCharset's indexed by source charset */
+
+ CamelMimeFilterIndex *filter_index;
+ CamelMimeFilterBasic *filter_64;
+ CamelMimeFilterBasic *filter_qp;
+ CamelMimeFilterSave *filter_save;
+
+ struct ibex *index;
+
+#ifdef ENABLE_THREADS
+ GMutex *summary_lock; /* for the summary hashtable/array */
+ GMutex *io_lock; /* load/save lock, for access to saved_count, etc */
+ GMutex *filter_lock; /* for accessing any of the filtering/indexing stuff, since we share them */
+ GMutex *alloc_lock; /* for setting up and using allocators */
+ GMutex *ref_lock; /* for reffing/unreffing messageinfo's ALWAYS obtain before summary_lock */
+#endif
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_SUMMARY_LOCK(f, l) (g_mutex_lock(((CamelFolderSummary *)f)->priv->l))
+#define CAMEL_SUMMARY_UNLOCK(f, l) (g_mutex_unlock(((CamelFolderSummary *)f)->priv->l))
+#else
+#define CAMEL_SUMMARY_LOCK(f, l)
+#define CAMEL_SUMMARY_UNLOCK(f, l)
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* CAMEL_H */
+
#include "camel-url.h"
#include "string-utils.h"
+#include "camel-private.h"
+
#define d(x) x
#if d(!)0
extern gboolean camel_verbose_debug;
remote_store->istream = NULL;
remote_store->ostream = NULL;
remote_store->timeout_id = 0;
+
+ remote_store->priv = g_malloc0(sizeof(*remote_store->priv));
+#ifdef ENABLE_THREADS
+ remote_store->priv->stream_lock = e_mutex_new(E_MUTEX_REC);
+#endif
+}
+
+static void
+camel_remote_store_finalise(CamelObject *object)
+{
+ CamelRemoteStore *remote_store = CAMEL_REMOTE_STORE (object);
+
+#ifdef ENABLE_THREADS
+ e_mutex_destroy(remote_store->priv->stream_lock);
+#endif
+ g_free(remote_store->priv);
}
-/*
- *static void
- *camel_remote_store_finalize (CamelObject *object)
- *{
- * CamelRemoteStore *remote_store = CAMEL_REMOTE_STORE (object);
- *
- * g_free (remote_store->nice_name);
- *}
- */
CamelType
camel_remote_store_get_type (void)
(CamelObjectClassInitFunc) camel_remote_store_class_init,
NULL,
(CamelObjectInitFunc) camel_remote_store_init,
- (CamelObjectFinalizeFunc) NULL);
+ (CamelObjectFinalizeFunc) camel_remote_store_finalise);
}
return camel_remote_store_type;
static gboolean
timeout_cb (gpointer data)
{
- CRSC (data)->keepalive (CAMEL_REMOTE_STORE (data));
+ CamelRemoteStore *store = CAMEL_REMOTE_STORE(data);
+
+ CAMEL_REMOTE_STORE_LOCK(store, stream_lock);
+
+ CRSC (data)->keepalive(store);
+
+ CAMEL_REMOTE_STORE_UNLOCK(store, stream_lock);
+
return TRUE;
}
return 0;
}
+/* FIXME: All of these functions need an api overhaul, they're not like
+ any other functions, anywhere in the world ... */
+
/**
* camel_remote_store_send_string: Writes a string to the server
* @store: a CamelRemoteStore
g_return_val_if_fail (fmt, -1);
va_start (ap, fmt);
+ CAMEL_REMOTE_STORE_LOCK(store, stream_lock);
ret = CRSC (store)->send_string (store, ex, fmt, ap);
+ CAMEL_REMOTE_STORE_UNLOCK(store, stream_lock);
va_end (ap);
return ret;
static gint
remote_send_stream (CamelRemoteStore *store, CamelStream *stream, CamelException *ex)
{
+ int ret;
+
/* Check for connectedness. Failed (or cancelled) operations will
* close the connection. */
-
+
if (store->ostream == NULL) {
d(g_message ("remote: (sendstream) disconnected, reconnecting."));
d(fprintf (stderr, "(sending stream)\n"));
- if (camel_stream_write_to_stream (stream, store->ostream) < 0) {
+ ret = camel_stream_write_to_stream (stream, store->ostream);
+ if (ret < 0) {
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE,
g_strerror (errno));
camel_service_disconnect (CAMEL_SERVICE (store), FALSE, NULL);
- return -1;
}
-
- return 0;
+
+ return ret;
}
/**
gint
camel_remote_store_send_stream (CamelRemoteStore *store, CamelStream *stream, CamelException *ex)
{
+ int ret;
+
g_return_val_if_fail (CAMEL_IS_REMOTE_STORE (store), -1);
g_return_val_if_fail (CAMEL_IS_STREAM (stream), -1);
+
+ CAMEL_REMOTE_STORE_LOCK(store, stream_lock);
- return CRSC (store)->send_stream (store, stream, ex);
+ ret = CRSC (store)->send_stream (store, stream, ex);
+
+ CAMEL_REMOTE_STORE_UNLOCK(store, stream_lock);
+
+ return ret;
}
static int
* @dest: a pointer that will be set to the location of a buffer
* holding the server's response
* @ex: a CamelException
- * Return value: 0 on success, -1 on error
+ * Return value: -1 on error, otherwise the length read.
*
* Reads a line from the server (terminated by \n or \r\n).
**/
camel_remote_store_recv_line (CamelRemoteStore *store, char **dest,
CamelException *ex)
{
+ int ret;
+
g_return_val_if_fail (CAMEL_IS_REMOTE_STORE (store), -1);
g_return_val_if_fail (dest, -1);
+
+ CAMEL_REMOTE_STORE_LOCK(store, stream_lock);
- return CRSC (store)->recv_line (store, dest, ex);
+ ret = CRSC (store)->recv_line (store, dest, ex);
+
+ CAMEL_REMOTE_STORE_UNLOCK(store, stream_lock);
+
+ return ret;
}
static void
*
* Refreshes the folders listed in the folders hashtable.
**/
-
void
camel_remote_store_refresh_folders (CamelRemoteStore *store, CamelException *ex)
{
+ CAMEL_STORE_LOCK(store, cache_lock);
+
g_hash_table_foreach (CAMEL_STORE (store)->folders, refresh_folder_info, ex);
+
+ CAMEL_STORE_UNLOCK(store, cache_lock);
}
typedef struct {
CamelStore parent_object;
-
+ struct _CamelRemoteStorePrivate *priv;
+
CamelStream *istream, *ostream;
guint timeout_id, default_port;
} CamelRemoteStore;
/* Standard Camel function */
CamelType camel_remote_store_get_type (void);
+/* FIXME: All of these i/o functions need an api overhaul, they're not like
+ any other functions, anywhere in the world ... */
+
/* Extra public functions */
gint camel_remote_store_send_string (CamelRemoteStore *store, CamelException *ex,
char *fmt, ...);
#include <ctype.h>
#include <stdlib.h>
+#include "camel-private.h"
+
static CamelObjectClass *parent_class = NULL;
/* Returns the class for a CamelService */
}
static void
+camel_service_init (void *o, void *k)
+{
+ CamelService *service = o;
+
+ service->priv = g_malloc0(sizeof(*service->priv));
+#ifdef ENABLE_THREADS
+ service->priv->connect_lock = e_mutex_new(E_MUTEX_REC);
+#endif
+}
+
+static void
camel_service_finalize (CamelObject *object)
{
CamelService *camel_service = CAMEL_SERVICE (object);
camel_url_free (camel_service->url);
if (camel_service->session)
camel_object_unref (CAMEL_OBJECT (camel_service->session));
+
+#ifdef ENABLE_THREADS
+ e_mutex_destroy(camel_service->priv->connect_lock);
+#endif
+ g_free(camel_service->priv);
}
sizeof (CamelServiceClass),
(CamelObjectClassInitFunc) camel_service_class_init,
NULL,
- NULL,
+ (CamelObjectInitFunc) camel_service_init,
camel_service_finalize );
}
gboolean
camel_service_connect (CamelService *service, CamelException *ex)
{
+ gboolean ret = FALSE;
+
g_return_val_if_fail (CAMEL_IS_SERVICE (service), FALSE);
g_return_val_if_fail (service->session != NULL, FALSE);
g_return_val_if_fail (service->url != NULL, FALSE);
+ CAMEL_SERVICE_LOCK(service, connect_lock);
+
if (service->connected) {
/* But we're still connected, so no exception
* and return true.
*/
g_warning ("camel_service_connect: trying to connect to an already connected service");
- return TRUE;
- }
-
- if (CSERV_CLASS (service)->connect (service, ex)) {
+ ret = TRUE;
+ } else if (CSERV_CLASS (service)->connect (service, ex)) {
service->connected = TRUE;
- return TRUE;
+ ret = TRUE;
}
- return FALSE;
+ CAMEL_SERVICE_UNLOCK(service, connect_lock);
+
+ return ret;
}
static gboolean
camel_service_disconnect (CamelService *service, gboolean clean,
CamelException *ex)
{
- gboolean res;
+ gboolean res = TRUE;
- if (!service->connected)
- return TRUE;
+ CAMEL_SERVICE_LOCK(service, connect_lock);
+
+ if (service->connected) {
+ res = CSERV_CLASS (service)->disconnect (service, clean, ex);
+ service->connected = FALSE;
+ }
+
+ CAMEL_SERVICE_UNLOCK(service, connect_lock);
- res = CSERV_CLASS (service)->disconnect (service, clean, ex);
- service->connected = FALSE;
return res;
}
GList *
camel_service_query_auth_types (CamelService *service, CamelException *ex)
{
+ GList *ret;
+
+ /* note that we get the connect lock here, which means the callee
+ must not call the connect functions itself */
+ CAMEL_SERVICE_LOCK(service, connect_lock);
+
if (service->url->empty)
- return CSERV_CLASS (service)->query_auth_types_generic (service, ex);
+ ret = CSERV_CLASS (service)->query_auth_types_generic (service, ex);
else
- return CSERV_CLASS (service)->query_auth_types_connected (service, ex);
+ ret = CSERV_CLASS (service)->query_auth_types_connected (service, ex);
+
+ CAMEL_SERVICE_UNLOCK(service, connect_lock);
+
+ return ret;
}
static void
struct hostent *h;
char *hostname;
+#warning "This needs to use gethostbyname_r()"
+
if (service->url->host)
hostname = service->url->host;
else
struct _CamelService {
CamelObject parent_object;
+ struct _CamelServicePrivate *priv;
CamelSession *session;
CamelProvider *provider;
#include "camel-url.h"
#include "hash-table-utils.h"
+#include "camel-private.h"
+
static CamelObjectClass *parent_class;
static void
{
session->modules = camel_provider_init ();
session->providers = g_hash_table_new (g_strcase_hash, g_strcase_equal);
+ session->priv = g_malloc0(sizeof(*session->priv));
+#ifdef ENABLE_THREADS
+ session->priv->lock = g_mutex_new();
+#endif
}
static gboolean
g_hash_table_foreach_remove (session->providers,
camel_session_destroy_provider, NULL);
g_hash_table_destroy (session->providers);
+
+#ifdef ENABLE_THREADS
+ g_mutex_free(session->priv->lock);
+#endif
+
+ g_free(session->priv);
}
static void
* @provider: provider object
*
* Registers a protocol to provider mapping for the session.
+ *
+ * Assumes the session lock has already been obtained,
+ * which is the case for automatically loaded provider modules.
**/
void
camel_session_register_provider (CamelSession *session,
g_return_val_if_fail (CAMEL_IS_SESSION (session), NULL);
- if (load) {
+ CAMEL_SESSION_LOCK(session, lock);
+
+ if (load)
g_hash_table_foreach (session->modules, ensure_loaded, session);
- }
list = NULL;
g_hash_table_foreach (session->providers, add_to_list, &list);
+
+ CAMEL_SESSION_UNLOCK(session, lock);
+
return list;
}
g_return_if_fail (service != NULL);
g_return_if_fail (service->url != NULL);
+ CAMEL_SESSION_LOCK(session, lock);
+
provider = g_hash_table_lookup (session->providers, service->url->protocol);
g_hash_table_remove (provider->service_cache, service->url);
+
+ CAMEL_SESSION_UNLOCK(session, lock);
}
/**
/* We need to look up the provider so we can then lookup
the service in the provider's cache */
+ CAMEL_SESSION_LOCK(session, lock);
provider = g_hash_table_lookup (session->providers, url->protocol);
if (!provider) {
/* See if there's one we can load. */
if (camel_exception_get_id (ex) !=
CAMEL_EXCEPTION_NONE) {
camel_url_free (url);
+ CAMEL_SESSION_UNLOCK(session, lock);
return NULL;
}
}
_("No provider available for protocol `%s'"),
url->protocol);
camel_url_free (url);
+ CAMEL_SESSION_UNLOCK(session, lock);
return NULL;
}
if (service != NULL) {
camel_url_free (url);
camel_object_ref (CAMEL_OBJECT (service));
+ CAMEL_SESSION_UNLOCK(session, lock);
return service;
}
g_hash_table_insert (provider->service_cache, url, service);
camel_object_hook_event (CAMEL_OBJECT (service), "finalize", (CamelObjectEventHookFunc) service_cache_remove, session);
}
+ CAMEL_SESSION_UNLOCK(session, lock);
return service;
}
struct _CamelSession
{
CamelObject parent_object;
+ struct _CamelSessionPrivate *priv;
char *storage_path;
CamelAuthCallback authenticator;
#include "camel-folder.h"
#include "camel-exception.h"
+#include "camel-private.h"
+
static CamelServiceClass *parent_class = NULL;
/* Returns the class for a CamelStore */
if (store->folders == NULL)
store->folders = g_hash_table_new (g_str_hash, g_str_equal);
store->flags = 0;
+
+ store->priv = g_malloc0(sizeof(*store->priv));
+#ifdef ENABLE_THREADS
+ store->priv->folder_lock = g_mutex_new();
+ store->priv->cache_lock = g_mutex_new();
+#endif
}
static void
}
g_hash_table_destroy (store->folders);
}
+
+#ifdef ENABLE_THREADS
+ g_mutex_free(store->priv->folder_lock);
+ g_mutex_free(store->priv->cache_lock);
+#endif
+ g_free(store->priv);
}
static CamelFolder *
lookup_folder (CamelStore *store, const char *folder_name)
{
+ CamelFolder *folder = NULL;
+
+ CAMEL_STORE_LOCK(store, cache_lock);
+
if (store->folders) {
- CamelFolder *folder = g_hash_table_lookup (store->folders, folder_name);
+ folder = g_hash_table_lookup (store->folders, folder_name);
if (folder)
camel_object_ref(CAMEL_OBJECT(folder));
- return folder;
}
- return NULL;
+
+ CAMEL_STORE_UNLOCK(store, cache_lock);
+
+ return folder;
}
static void folder_finalize (CamelObject *folder, gpointer event_data, gpointer user_data)
static void
cache_folder (CamelStore *store, const char *folder_name, CamelFolder *folder)
{
- if (!store->folders)
- return;
+ CAMEL_STORE_LOCK(store, cache_lock);
- if (g_hash_table_lookup (store->folders, folder_name)) {
- g_warning ("Caching folder %s that already exists.",
- folder_name);
+ if (store->folders) {
+ if (g_hash_table_lookup (store->folders, folder_name)) {
+ g_warning ("Caching folder %s that already exists.", folder_name);
+ }
+ g_hash_table_insert (store->folders, g_strdup (folder_name), folder);
+
+ camel_object_hook_event (CAMEL_OBJECT (folder), "finalize", folder_finalize, store);
}
- g_hash_table_insert (store->folders, g_strdup (folder_name), folder);
- camel_object_hook_event (CAMEL_OBJECT (folder), "finalize", folder_finalize, store);
+ CAMEL_STORE_UNLOCK(store, cache_lock);
/*
* gt_k so as not to get caught by my little gt_k cleanliness detector.
static void
uncache_folder (CamelStore *store, CamelFolder *folder)
{
+ CAMEL_STORE_LOCK(store, cache_lock);
+
g_hash_table_foreach_remove (store->folders, folder_matches, folder);
+
+ CAMEL_STORE_UNLOCK(store, cache_lock);
}
{
CamelFolder *folder = NULL;
+ /* NB: we already have folder_lock */
+
/* Try cache first. */
folder = CS_CLASS(store)->lookup_folder(store, folder_name);
char *name;
CamelFolder *folder = NULL;
+ CAMEL_STORE_LOCK(store, folder_lock);
+
name = CS_CLASS(store)->get_folder_name(store, folder_name, ex);
if (name) {
folder = get_folder_internal(store, name, flags, ex);
g_free (name);
}
+
+ CAMEL_STORE_UNLOCK(store, folder_lock);
+
return folder;
}
{
char *name;
+ CAMEL_STORE_LOCK(store, folder_lock);
+
name = CS_CLASS (store)->get_folder_name (store, folder_name, ex);
if (name) {
CS_CLASS (store)->delete_folder (store, name, ex);
g_free (name);
}
+
+ CAMEL_STORE_UNLOCK(store, folder_lock);
}
/**
{
char *old, *new;
+ CAMEL_STORE_LOCK(store, folder_lock);
+
old = CS_CLASS (store)->get_folder_name(store, old_name, ex);
if (old) {
new = CS_CLASS (store)->get_folder_name(store, new_name, ex);
}
g_free(old);
}
+
+ CAMEL_STORE_UNLOCK(store, folder_lock);
}
char *name;
CamelFolder *folder = NULL;
+ CAMEL_STORE_LOCK(store, folder_lock);
+
name = CS_CLASS (store)->get_root_folder_name (store, ex);
if (name) {
folder = get_folder_internal (store, name, CAMEL_STORE_FOLDER_CREATE, ex);
g_free (name);
}
+
+ CAMEL_STORE_UNLOCK(store, folder_lock);
+
return folder;
}
char *name;
CamelFolder *folder = NULL;
+ CAMEL_STORE_LOCK(store, folder_lock);
+
name = CS_CLASS (store)->get_default_folder_name (store, ex);
if (name) {
folder = get_folder_internal (store, name, CAMEL_STORE_FOLDER_CREATE, ex);
g_free (name);
}
+
+ CAMEL_STORE_UNLOCK(store, folder_lock);
+
return folder;
}
gboolean subscribed_only,
CamelException *ex)
{
+ CamelFolderInfo *ret;
+
g_return_val_if_fail (CAMEL_IS_STORE (store), NULL);
- return CS_CLASS (store)->get_folder_info (store, top, fast,
- recursive, subscribed_only,
- ex);
+ CAMEL_STORE_LOCK(store, folder_lock);
+
+ ret = CS_CLASS (store)->get_folder_info (store, top, fast, recursive, subscribed_only, ex);
+
+ CAMEL_STORE_UNLOCK(store, folder_lock);
+
+ return ret;
}
camel_store_folder_subscribed (CamelStore *store,
const char *folder_name)
{
+ gboolean ret;
+
g_return_val_if_fail (CAMEL_IS_STORE (store), FALSE);
g_return_val_if_fail (store->flags & CAMEL_STORE_SUBSCRIPTIONS, FALSE);
- return CS_CLASS (store)->folder_subscribed (store, folder_name);
+ CAMEL_STORE_LOCK(store, folder_lock);
+
+ ret = CS_CLASS (store)->folder_subscribed (store, folder_name);
+
+ CAMEL_STORE_UNLOCK(store, folder_lock);
+
+ return ret;
}
static void
g_return_if_fail (CAMEL_IS_STORE (store));
g_return_if_fail (store->flags & CAMEL_STORE_SUBSCRIPTIONS);
+ CAMEL_STORE_LOCK(store, folder_lock);
+
CS_CLASS (store)->subscribe_folder (store, folder_name, ex);
+
+ CAMEL_STORE_UNLOCK(store, folder_lock);
}
static void
g_return_if_fail (CAMEL_IS_STORE (store));
g_return_if_fail (store->flags & CAMEL_STORE_SUBSCRIPTIONS);
+ CAMEL_STORE_LOCK(store, folder_lock);
+
CS_CLASS (store)->unsubscribe_folder (store, folder_name, ex);
+
+ CAMEL_STORE_UNLOCK(store, folder_lock);
}
struct _CamelStore
{
CamelService parent_object;
+ struct _CamelStorePrivate *priv;
+ /* should have cache_lock when accessing this (priv->cache_lock) */
GHashTable *folders;
int flags;
void (*uncache_folder) (CamelStore *store,
CamelFolder *folder);
+ /* this should take flags instead, so its more futureproof */
CamelFolderInfo *(*get_folder_info) (CamelStore *store,
const char *top,
gboolean fast,
CamelMedium *message,
CamelException *ex);
+/* FIXME: This should use a camel-address */
gboolean camel_transport_send_to (CamelTransport *transport,
CamelMedium *message,
GList *recipients,
{
#ifdef ENABLE_THREADS
#ifdef G_THREADS_ENABLED
- g_thread_init (NULL);
+ /*g_thread_init (NULL);*/
#else /* G_THREADS_ENABLED */
printf ("Threads are not supported by your version of glib\n");
#endif /* G_THREADS_ENABLED */
libcamelimap_la_LDFLAGS = $(KRB4_LDFLAGS) -version-info 0:0:0
+noinst_HEADERS = \
+ camel-imap-private.h
+
EXTRA_DIST = libcamelimap.urls
#include "camel-imap-command.h"
#include "camel-imap-utils.h"
+#include "camel-imap-private.h"
+
+#ifdef HAVE_KRB4
+
static char *
base64_encode_simple (const char *data, int len)
{
(unsigned char *)data, &state, &save);
}
-#ifdef HAVE_KRB4
#define IMAP_KERBEROS_V4_PROTECTION_NONE 1
#define IMAP_KERBEROS_V4_PROTECTION_INTEGRITY 2
#define IMAP_KERBEROS_V4_PROTECTION_PRIVACY 4
des_cblock session;
des_key_schedule schedule;
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
+
/* The kickoff. */
response = camel_imap_command (store, NULL, ex,
"AUTHENTICATE KERBEROS_V4");
if (!response)
- return FALSE;
+ goto fail;
resp = camel_imap_response_extract_continuation (response, ex);
if (!resp)
- return FALSE;
+ goto fail;
+
data = imap_next_word (resp);
/* First server response is a base64-encoded 32-bit random number
if (!response)
goto lose;
camel_imap_response_free (response);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
return TRUE;
break_and_lose:
camel_exception_set (ex, CAMEL_EXCEPTION_SERVICE_CANT_AUTHENTICATE,
_("Bad authentication response from server."));
}
+fail:
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
return FALSE;
}
#endif /* HAVE_KRB4 */
* and quoted strings otherwise. (%S does not support strings that
* contain newlines.)
*
+ * This function assumes you have an exclusive lock on the command
+ * channel/stream.
+ *
* Return value: %NULL if an error occurred (in which case @ex will
* be set). Otherwise, a CamelImapResponse describing the server's
* response, which the caller must free with camel_imap_response_free().
* This method is for sending continuing responses to the IMAP server
* after camel_imap_command returns a CAMEL_IMAP_PLUS response.
*
+ * This function assumes you have an exclusive lock on the remote stream.
+ *
* Return value: as for camel_imap_command()
**/
CamelImapResponse *
#include "camel-mime-filter-crlf.h"
#include "camel-exception.h"
#include "camel-mime-utils.h"
+#include "camel-imap-private.h"
#define d(x) x
static const char *imap_get_full_name (CamelFolder *folder);
static void imap_expunge (CamelFolder *folder, CamelException *ex);
-/* message counts */
-static gint imap_get_message_count (CamelFolder *folder);
-static gint imap_get_unread_message_count (CamelFolder *folder);
-
/* message manipulation */
static CamelMimeMessage *imap_get_message (CamelFolder *folder, const gchar *uid,
CamelException *ex);
CamelFolder *destination, CamelException *ex);
/* summary info */
-static GPtrArray *imap_get_uids (CamelFolder *folder);
-static GPtrArray *imap_get_summary (CamelFolder *folder);
-static const CamelMessageInfo *imap_get_message_info (CamelFolder *folder, const char *uid);
-
static void imap_update_summary (CamelFolder *folder, int first, int last,
CamelFolderChangeInfo *changes,
CamelException *ex);
camel_folder_class->expunge = imap_expunge;
camel_folder_class->get_full_name = imap_get_full_name;
- camel_folder_class->get_uids = imap_get_uids;
- camel_folder_class->free_uids = camel_folder_free_nop;
-
- camel_folder_class->get_message_count = imap_get_message_count;
- camel_folder_class->get_unread_message_count = imap_get_unread_message_count;
camel_folder_class->get_message = imap_get_message;
camel_folder_class->append_message = imap_append_message;
camel_folder_class->copy_message_to = imap_copy_message_to;
camel_folder_class->move_message_to = imap_move_message_to;
- camel_folder_class->get_summary = imap_get_summary;
- camel_folder_class->get_message_info = imap_get_message_info;
- camel_folder_class->free_summary = camel_folder_free_nop;
-
camel_folder_class->search_by_expression = imap_search_by_expression;
camel_folder_class->search_free = imap_search_free;
-
- camel_folder_class->get_message_flags = imap_get_message_flags;
- camel_folder_class->set_message_flags = imap_set_message_flags;
- camel_folder_class->get_message_user_flag = imap_get_message_user_flag;
- camel_folder_class->set_message_user_flag = imap_set_message_user_flag;
}
static void
folder->has_summary_capability = TRUE;
folder->has_search_capability = TRUE;
- imap_folder->summary = NULL;
+ folder->summary = NULL;
+ imap_folder->priv = g_malloc0(sizeof(*imap_folder->priv));
+#ifdef ENABLE_THREADS
+ imap_folder->priv->search_lock = g_mutex_new();
+#endif
}
CamelType
camel_folder_construct (folder, parent, folder_name, short_name);
+ CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
response = camel_imap_command (imap_store, folder, ex, NULL);
+ CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
+
if (!response) {
camel_object_unref ((CamelObject *)folder);
return NULL;
}
camel_imap_response_free (response);
- imap_folder->summary = camel_imap_summary_new (summary_file, validity);
- if (!imap_folder->summary) {
+ folder->summary = camel_imap_summary_new (summary_file, validity);
+ if (!folder->summary) {
camel_object_unref (CAMEL_OBJECT (folder));
camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM,
_("Could not load summary for %s"),
{
CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (object);
- camel_object_unref ((CamelObject *)imap_folder->summary);
if (imap_folder->search)
camel_object_unref ((CamelObject *)imap_folder->search);
+
+#ifdef ENABLE_THREADS
+ g_mutex_free(imap_folder->priv->search_lock);
+#endif
+ g_free(imap_folder->priv);
}
static void
/* Get UIDs and flags of all messages. */
if (imap_folder->exists) {
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
response = camel_imap_command (store, folder, ex,
"FETCH 1:%d (UID FLAGS)",
imap_folder->exists);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
if (!response) {
camel_folder_change_info_free (changes);
return;
* the UID in the folder, that it means the message was
* deleted on the server, so we remove it from the summary.
*/
- summary_len = camel_folder_summary_count (imap_folder->summary);
+ summary_len = camel_folder_summary_count (folder->summary);
for (i = 0; i < summary_len && i < imap_folder->exists; i++) {
- info = camel_folder_summary_index (imap_folder->summary, i);
- iinfo = (CamelImapMessageInfo *)info;
-
/* Shouldn't happen, but... */
if (!new[i].uid)
continue;
+ info = camel_folder_summary_index (imap_folder->summary, i);
+ iinfo = (CamelImapMessageInfo *)info;
+
if (strcmp (camel_message_info_uid (info), new[i].uid) != 0) {
camel_folder_change_info_remove_uid (changes, camel_message_info_uid (info));
camel_folder_summary_remove (imap_folder->summary, info);
+ camel_folder_summary_info_free(folder->summary, info);
+ folder_changed = TRUE;
+ g_free (new[i].uid);
i--;
summary_len--;
continue;
camel_folder_change_info_change_uid (changes, new[i].uid);
}
+ camel_folder_summary_info_free(folder->summary, info);
+
g_free (new[i].uid);
}
/* Remove any leftover cached summary messages. */
while (summary_len > i + 1) {
- info = camel_folder_summary_index (imap_folder->summary, --summary_len);
+ info = camel_folder_summary_index (folder->summary, --summary_len);
camel_folder_change_info_remove_uid (changes, camel_message_info_uid (info));
- camel_folder_summary_remove (imap_folder->summary, info);
+ camel_folder_summary_remove (folder->summary, info);
+ camel_folder_summary_info_free(folder->summary, info);
}
/* Add any new folder messages. */
imap_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
{
CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
- CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
+ /*CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);*/
CamelImapResponse *response;
int i, max;
/* Set the flags on any messages that have changed this session */
- max = camel_folder_summary_count (imap_folder->summary);
+ max = camel_folder_summary_count (folder->summary);
for (i = 0; i < max; i++) {
CamelMessageInfo *info;
- info = camel_folder_summary_index (imap_folder->summary, i);
- if (info->flags & CAMEL_MESSAGE_FOLDER_FLAGGED) {
+ info = camel_folder_summary_index (folder->summary, i);
+ if (info && (info->flags & CAMEL_MESSAGE_FOLDER_FLAGGED)) {
char *flags;
flags = imap_create_flag_list (info->flags);
if (flags) {
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
response = camel_imap_command (
store, folder, ex,
"UID STORE %s FLAGS.SILENT %s",
camel_message_info_uid(info), flags);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
+
g_free (flags);
- if (!response)
+ if (!response) {
+ camel_folder_summary_info_free(folder->summary, info);
return;
+ }
camel_imap_response_free (response);
}
info->flags &= ~CAMEL_MESSAGE_FOLDER_FLAGGED;
}
+ camel_folder_summary_info_free(folder->summary, info);
}
if (expunge) {
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
response = camel_imap_command (store, folder, ex, "EXPUNGE");
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
camel_imap_response_free (response);
}
- camel_folder_summary_save (imap_folder->summary);
+ camel_folder_summary_save (folder->summary);
}
static void
return folder->full_name;
}
-static gint
-imap_get_message_count (CamelFolder *folder)
-{
- CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
-
- return camel_folder_summary_count (imap_folder->summary);
-}
-
-static gint
-imap_get_unread_message_count (CamelFolder *folder)
-{
- CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
- CamelMessageInfo *info;
- int i, max, count = 0;
-
- max = camel_folder_summary_count (imap_folder->summary);
- for (i = 0; i < max; i++) {
- info = camel_folder_summary_index (imap_folder->summary, i);
- if (!(info->flags & CAMEL_MESSAGE_SEEN))
- count++;
- }
-
- return count;
-}
-
static void
imap_append_message (CamelFolder *folder, CamelMimeMessage *message,
const CamelMessageInfo *info, CamelException *ex)
camel_object_unref (CAMEL_OBJECT (crlf_filter));
camel_object_unref (CAMEL_OBJECT (memstream));
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
response = camel_imap_command (store, NULL, ex, "APPEND %S%s%s {%d}",
folder->full_name, flagstr ? " " : "",
flagstr ? flagstr : "", ba->len);
if (!response) {
g_byte_array_free (ba, TRUE);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
return;
}
result = camel_imap_response_extract_continuation (response, ex);
if (!result) {
g_byte_array_free (ba, TRUE);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
return;
}
g_free (result);
g_byte_array_append (ba, "\0", 3);
response = camel_imap_command_continuation (store, ex, ba->data);
g_byte_array_free (ba, TRUE);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
if (!response)
return;
camel_imap_response_free (response);
CamelImapStore *store = CAMEL_IMAP_STORE (source->parent_store);
CamelImapResponse *response;
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
response = camel_imap_command (store, source, ex, "UID COPY %s %S",
uid, destination->full_name);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
+
camel_imap_response_free (response);
}
CamelImapStore *store = CAMEL_IMAP_STORE (source->parent_store);
CamelImapResponse *response;
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
response = camel_imap_command (store, source, ex, "UID COPY %s %S",
uid, destination->full_name);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
camel_imap_response_free (response);
if (camel_exception_is_set (ex))
camel_folder_delete_message (source, uid);
}
-static GPtrArray *
-imap_get_uids (CamelFolder *folder)
-{
- CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
- const CamelMessageInfo *info;
- GPtrArray *array;
- int i, count;
-
- count = camel_folder_summary_count (imap_folder->summary);
-
- array = g_ptr_array_new ();
- g_ptr_array_set_size (array, count);
-
- for (i = 0; i < count; i++) {
- info = camel_folder_summary_index (imap_folder->summary, i);
- array->pdata[i] = g_strdup (camel_message_info_uid(info));
- }
-
- return array;
-}
-
static CamelMimeMessage *
imap_get_message (CamelFolder *folder, const gchar *uid, CamelException *ex)
{
char *result, *mesg, *p;
int len;
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
response = camel_imap_command (store, folder, ex,
"UID FETCH %s BODY.PEEK[]", uid);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
+
if (!response)
return NULL;
result = camel_imap_response_extract (response, "FETCH", ex);
CamelFolderChangeInfo *changes, CamelException *ex)
{
CamelImapStore *store = CAMEL_IMAP_STORE (folder->parent_store);
- CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
+ /*CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);*/
CamelImapResponse *response;
GPtrArray *headers = NULL;
char *q, *summary_specifier;
int i;
summary_specifier = imap_protocol_get_summary_specifier (store);
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
if (first == last) {
response = camel_imap_command (store, folder, ex,
"FETCH %d (%s)", first,
"FETCH %d:%d (%s)", first,
last, summary_specifier);
}
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
g_free (summary_specifier);
if (!response)
/* We can't just call camel_folder_summary_add_from_parser
* because it will assign the wrong UID, and thus get the
* uid hash table wrong and all that. FIXME some day.
+ * Well you can actually now, because you can override next_uid_string(), but
+ * it hasn't been done yet.
*/
- info = camel_folder_summary_info_new_from_header (
- imap_folder->summary, h);
+ info = camel_folder_summary_info_new_from_header(folder->summary, h);
iinfo = (CamelImapMessageInfo *)info;
header_raw_clear (&h);
uid = g_strndup (uid, q - uid);
} else
info->size = strtoul (size + 12, NULL, 10);
- camel_folder_summary_add (imap_folder->summary, info);
+ camel_folder_summary_add (folder->summary, info);
}
camel_imap_response_free (response);
}
static GPtrArray *
-imap_get_summary (CamelFolder *folder)
-{
- CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
-
- return imap_folder->summary->messages;
-}
-
-/* get a single message info, by uid */
-static const CamelMessageInfo *
-imap_get_message_info (CamelFolder *folder, const char *uid)
-{
- CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
-
- return camel_folder_summary_uid (imap_folder->summary, uid);
-}
-
-static GPtrArray *
imap_search_by_expression (CamelFolder *folder, const char *expression, CamelException *ex)
{
CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
+ GPtrArray *matches, *summary;
+
+ /* we could get around this by creating a new search object each time,
+ but i doubt its worth it since any long operation would lock the
+ command channel too */
+ CAMEL_IMAP_FOLDER_LOCK(folder, search_lock);
if (!imap_folder->search)
imap_folder->search = camel_imap_search_new ();
camel_folder_search_set_folder (imap_folder->search, folder);
- camel_folder_search_set_summary (
- imap_folder->search, imap_folder->summary->messages);
+ summary = camel_folder_get_summary(folder);
+ camel_folder_search_set_summary(imap_folder->search, summary);
+ uids = camel_folder_search_execute_expression (imap_folder->search, expression, ex);
+
+ CAMEL_IMAP_FOLDER_UNLOCK(folder, search_lock);
- return camel_folder_search_execute_expression (imap_folder->search,
- expression, ex);
+ camel_folder_free_summary(folder, summary);
}
static void
g_return_if_fail (imap_folder->search);
- camel_folder_search_free_result (imap_folder->search, uids);
-}
+ CAMEL_IMAP_FOLDER_LOCK(folder, search_lock);
-static guint32
-imap_get_message_flags (CamelFolder *folder, const char *uid)
-{
- const CamelMessageInfo *info;
-
- info = imap_get_message_info (folder, uid);
- g_return_val_if_fail (info != NULL, 0);
-
- return info->flags;
-}
-
-static void
-imap_set_message_flags (CamelFolder *folder, const char *uid, guint32 flags, guint32 set)
-{
- CamelImapFolder *imap_folder = (CamelImapFolder *)folder;
- CamelMessageInfo *info;
- guint32 new;
-
- info = camel_folder_summary_uid (imap_folder->summary, uid);
- g_return_if_fail (info != NULL);
-
- new = (info->flags & ~flags) | (set & flags);
- if (new == info->flags)
- return;
-
- info->flags = new | CAMEL_MESSAGE_FOLDER_FLAGGED;
- camel_folder_summary_touch (imap_folder->summary);
-
- camel_object_trigger_event (CAMEL_OBJECT (folder), "message_changed",
- (gpointer)uid);
-}
-
-static gboolean
-imap_get_message_user_flag (CamelFolder *folder, const char *uid, const char *name)
-{
- /* FIXME */
- return FALSE;
-}
+ camel_folder_search_free_result (imap_folder->search, uids);
-static void
-imap_set_message_user_flag (CamelFolder *folder, const char *uid, const char *name, gboolean value)
-{
- /* FIXME */
- camel_object_trigger_event (CAMEL_OBJECT (folder), "message_changed",
- (gpointer)uid);
+ CAMEL_IMAP_FOLDER_UNLOCK(folder, search_lock);
}
void
typedef struct {
CamelFolder parent_object;
+ struct _CamelImapFolderPrivate *priv;
+
CamelFolderSearch *search;
CamelFolderSummary *summary;
int exists;
--- /dev/null
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ * camel-imap-private.h: Private info for imap.
+ *
+ * Authors: Michael Zucchi <notzed@helixcode.com>
+ *
+ * Copyright 1999, 2000 Helix Code, Inc. (http://www.helixcode.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+#ifndef CAMEL_PRIVATE_H
+#define CAMEL_PRIVATE_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus }*/
+
+/* need a way to configure and save this data, if this header is to
+ be installed. For now, dont install it */
+
+#include "config.h"
+
+#ifdef ENABLE_THREADS
+#include "e-util/e-msgport.h"
+#endif
+
+struct _CamelImapStorePrivate {
+#ifdef ENABLE_THREADS
+ EMutex *command_lock; /* for locking the command stream for a complete operation */
+#endif
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_IMAP_STORE_LOCK(f, l) (e_mutex_lock(((CamelImapStore *)f)->priv->l))
+#define CAMEL_IMAP_STORE_UNLOCK(f, l) (e_mutex_unlock(((CamelImapStore *)f)->priv->l))
+#else
+#define CAMEL_IMAP_STORE_LOCK(f, l)
+#define CAMEL_IMAP_STORE_UNLOCK(f, l)
+#endif
+
+struct _CamelImapFolderPrivate {
+#ifdef ENABLE_THREADS
+ GMutex *search_lock; /* for locking the search object */
+#endif
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_IMAP_FOLDER_LOCK(f, l) (g_mutex_lock(((CamelImapFolder *)f)->priv->l))
+#define CAMEL_IMAP_FOLDER_UNLOCK(f, l) (g_mutex_unlock(((CamelImapFolder *)f)->priv->l))
+#else
+#define CAMEL_IMAP_FOLDER_LOCK(f, l)
+#define CAMEL_IMAP_FOLDER_UNLOCK(f, l)
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* CAMEL_H */
+
#include "camel-imap-command.h"
#include "camel-imap-folder.h"
#include "camel-imap-search.h"
+#include "camel-imap-private.h"
static ESExpResult *
imap_body_contains (struct _ESExp *f, int argc, struct _ESExpResult **argv,
CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (s->folder);
char *value = argv[0]->value.string;
CamelImapResponse *response;
- char *result, *p, *lasts = NULL;
+ char *result, *p, *lasts = NULL, *real_uid;
const char *uid;
ESExpResult *r;
CamelMessageInfo *info;
+ GHashTable *uid_hash = NULL;
+
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
if (s->current) {
uid = camel_message_info_uid (s->current);
"UID SEARCH BODY \"%s\"",
value);
}
+
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
+
if (!response)
return r;
result = camel_imap_response_extract (response, "SEARCH", NULL);
break;
}
} else {
- /* FIXME: The strings added to the array must be
- * static...
- */
- info = camel_folder_summary_uid (imap_folder->summary, p);
- g_ptr_array_add (r->value.ptrarray, (char *)camel_message_info_uid (info));
+ /* if we need to setup a hash of summary items, this way we get
+ access to the summary memory which is locked for the duration of
+ the search, and wont vanish on us */
+ if (uid_hash == NULL) {
+ int i;
+
+ uid_hash = g_hash_table_new(g_str_hash, g_str_equal);
+ for (i=0;i<s->summary->len;i++) {
+ info = s->summary->pdata[i];
+ g_hash_table_insert(uid_hash, camel_message_info_uid(info), info);
+ }
+ }
+ if (g_hash_table_lookup_extended(uid_hash, p, &real_uid, &info))
+ g_ptr_array_add (r->value.ptrarray, real_uid);
}
}
+ /* we could probably cache this globally, but its probably not worth it */
+ if (uid_hash)
+ g_hash_table_destroy(uid_hash);
+
return r;
}
#include "camel-url.h"
#include "string-utils.h"
+#include "camel-imap-private.h"
+
#define d(x) x
/* Specified in RFC 2060 */
g_hash_table_foreach_remove (imap_store->subscribed_folders,
free_sub, NULL);
g_hash_table_destroy (imap_store->subscribed_folders);
+#ifdef ENABLE_THREADS
+ e_mutex_destroy(imap_store->priv->command_lock);
+#endif
+ g_free(imap_store->priv);
}
static void
imap_store->connected = FALSE;
imap_store->subscribed_folders = g_hash_table_new (g_str_hash, g_str_equal);
+
+ imap_store->priv = g_malloc0(sizeof(*imap_store->priv));
+#ifdef ENABLE_THREADS
+ imap_store->priv->command_lock = e_mutex_new(E_MUTEX_REC);
+#endif
}
CamelType
{ NULL, 0 }
};
+/* we have remote-store:connect_lock by now */
static gboolean
connect_to_server (CamelService *service, CamelException *ex)
{
}
}
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
response = camel_imap_command (store, NULL, ex,
"LOGIN %S %S",
service->url->user,
service->url->passwd);
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
if (!response) {
errbuf = g_strdup_printf (_("Unable to authenticate "
"to IMAP server.\n%s\n\n"),
namespace++;
else
namespace = "";
+
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
if (store->server_level >= IMAP_LEVEL_IMAP4REV1) {
/* This idiom means "tell me the hierarchy separator
* for the given path, even if that path doesn't exist.
"LIST \"\" %S",
namespace);
}
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
+
if (!response)
return FALSE;
if (store->connected && clean) {
/* send the logout command */
+
+ /* NB: this lock probably isn't required */
+ CAMEL_IMAP_STORE_LOCK(store, command_lock);
response = camel_imap_command (store, NULL, ex, "LOGOUT");
+ CAMEL_IMAP_STORE_UNLOCK(store, command_lock);
camel_imap_response_free (response);
}
return CAMEL_SERVICE_CLASS (remote_store_class)->disconnect (service, clean, ex);
}
+/* NOTE: Must have imap_store::command_lock before calling this */
static gboolean
imap_folder_exists (CamelImapStore *store, const char *folder_name,
gboolean *selectable, char **short_name,
return TRUE;
}
+/* NOTE: Must have imap_store::command_lock before calling this */
static gboolean
imap_create (CamelImapStore *store, const char *folder_name,
CamelException *ex)
char *short_name, *summary_file, *p;
gboolean selectable;
+ /* lock around the whole lot to check/create atomically */
+ CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
if (!imap_folder_exists (imap_store, folder_name,
&selectable, &short_name, ex)) {
- if ((flags & CAMEL_STORE_FOLDER_CREATE) == 0)
- return NULL;
-
- if (!imap_create (imap_store, folder_name, ex))
- return NULL;
-
- if (!imap_folder_exists (imap_store, folder_name,
- &selectable, &short_name, ex))
+ if ((flags & CAMEL_STORE_FOLDER_CREATE) == 0
+ || (!imap_create (imap_store, folder_name, ex))
+ || (!imap_folder_exists (imap_store, folder_name,
+ &selectable, &short_name, ex))) {
+ CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
return NULL;
+ }
}
+ CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
if (!selectable) {
camel_exception_setv (ex, CAMEL_EXCEPTION_STORE_NO_FOLDER,
else
name = "";
}
+ CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
response = camel_imap_command (imap_store, NULL, ex,
"LIST \"\" %S", name);
+ CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
if (!response)
return FALSE;
list = camel_imap_response_extract (response, "LIST", ex);
else
pattern = g_strdup_printf ("%s%c", name,
recursive ? '*' : '%');
+ CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
response = camel_imap_command (imap_store, NULL, ex,
"%s \"\" %S",
subscribed_only ? "LSUB" : "LIST",
pattern);
+ CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
+
g_free (pattern);
if (!response)
return NULL;
if (!fi->url)
continue;
+ CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
response = camel_imap_command (
imap_store, NULL, NULL,
"STATUS %S (MESSAGES UNSEEN)",
fi->full_name);
+ CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
if (!response)
continue;
status = camel_imap_response_extract (
CamelImapStore *imap_store = CAMEL_IMAP_STORE (store);
CamelImapResponse *response;
+ CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
response = camel_imap_command (imap_store, NULL, ex,
"SUBSCRIBE %S", folder_name);
if (response) {
CamelImapStore *imap_store = CAMEL_IMAP_STORE (store);
CamelImapResponse *response;
gpointer key, value;
-
+
+ CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
response = camel_imap_command (imap_store, NULL, ex,
"UNSUBSCRIBE %S", folder_name);
+ CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
if (response) {
g_hash_table_lookup_extended (imap_store->subscribed_folders,
folder_name, &key, &value);
CamelImapStore *imap_store = CAMEL_IMAP_STORE (store);
CamelImapResponse *response;
+ CAMEL_IMAP_STORE_LOCK(imap_store, command_lock);
response = camel_imap_command (imap_store, NULL, NULL, "NOOP");
+ CAMEL_IMAP_STORE_UNLOCK(imap_store, command_lock);
camel_imap_response_free (response);
}
typedef struct {
CamelRemoteStore parent_object;
-
+ struct _CamelImapStorePrivate *priv;
+
CamelFolder *current_folder;
guint32 command;
camel-maildir-store.h \
camel-maildir-summary.h
+noinst_HEADERS = \
+ camel-local-private.h
+
libcamellocal_la_LDFLAGS = -version-info 0:0:0
libcamellocal_la_LIBADD = $(top_builddir)/e-util/libeutil.la $(top_builddir)/libibex/libibex.la $(UNICODE_LIBS)
#include "camel-mime-filter-from.h"
#include "camel-exception.h"
+#include "camel-local-private.h"
+
#define d(x) /*(printf("%s(%d): ", __FILE__, __LINE__),(x))*/
static CamelFolderClass *parent_class = NULL;
static void local_unlock(CamelLocalFolder *lf);
static void local_sync(CamelFolder *folder, gboolean expunge, CamelException *ex);
-static gint local_get_message_count(CamelFolder *folder);
-static gint local_get_unread_message_count(CamelFolder *folder);
-
-static GPtrArray *local_get_uids(CamelFolder *folder);
-static GPtrArray *local_get_summary(CamelFolder *folder);
-#if 0
-static void local_append_message(CamelFolder *folder, CamelMimeMessage * message, const CamelMessageInfo * info, CamelException *ex);
-static CamelMimeMessage *local_get_message(CamelFolder *folder, const gchar * uid, CamelException *ex);
-#endif
static void local_expunge(CamelFolder *folder, CamelException *ex);
-static const CamelMessageInfo *local_get_message_info(CamelFolder *folder, const char *uid);
-
static GPtrArray *local_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex);
static void local_search_free(CamelFolder *folder, GPtrArray * result);
-static guint32 local_get_message_flags(CamelFolder *folder, const char *uid);
-static void local_set_message_flags(CamelFolder *folder, const char *uid, guint32 flags, guint32 set);
-static gboolean local_get_message_user_flag(CamelFolder *folder, const char *uid, const char *name);
-static void local_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value);
-static const char *local_get_message_user_tag(CamelFolder *folder, const char *uid, const char *name);
-static void local_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value);
-
-
static void local_finalize(CamelObject * object);
static void
/* virtual method overload */
camel_folder_class->sync = local_sync;
- camel_folder_class->get_message_count = local_get_message_count;
- camel_folder_class->get_unread_message_count = local_get_unread_message_count;
- camel_folder_class->get_uids = local_get_uids;
- camel_folder_class->free_uids = camel_folder_free_deep;
- camel_folder_class->get_summary = local_get_summary;
- camel_folder_class->free_summary = camel_folder_free_nop;
camel_folder_class->expunge = local_expunge;
camel_folder_class->search_by_expression = local_search_by_expression;
camel_folder_class->search_free = local_search_free;
- camel_folder_class->get_message_info = local_get_message_info;
-
- camel_folder_class->get_message_flags = local_get_message_flags;
- camel_folder_class->set_message_flags = local_set_message_flags;
- camel_folder_class->get_message_user_flag = local_get_message_user_flag;
- camel_folder_class->set_message_user_flag = local_set_message_user_flag;
- camel_folder_class->get_message_user_tag = local_get_message_user_tag;
- camel_folder_class->set_message_user_tag = local_set_message_user_tag;
-
camel_local_folder_class->lock = local_lock;
camel_local_folder_class->unlock = local_unlock;
}
CAMEL_MESSAGE_DELETED | CAMEL_MESSAGE_DRAFT |
CAMEL_MESSAGE_FLAGGED | CAMEL_MESSAGE_SEEN | CAMEL_MESSAGE_USER;
- local_folder->summary = NULL;
+ folder->summary = NULL;
local_folder->search = NULL;
+
+ local_folder->priv = g_malloc0(sizeof(*local_folder->priv));
+#ifdef ENABLE_THREADS
+ local_folder->priv->search_lock = g_mutex_new();
+#endif
}
static void
local_finalize(CamelObject * object)
{
CamelLocalFolder *local_folder = CAMEL_LOCAL_FOLDER(object);
+ CamelFolder *folder = (CamelFolder *)object;
- if (local_folder->summary) {
- camel_local_summary_sync(local_folder->summary, FALSE, local_folder->changes, NULL);
- camel_object_unref((CamelObject *)local_folder->summary);
+ if (folder->summary) {
+ camel_local_summary_sync((CamelLocalSummary *)folder->summary, FALSE, local_folder->changes, NULL);
+ camel_object_unref((CamelObject *)folder->summary);
+ folder->summary = NULL;
}
if (local_folder->search) {
g_free(local_folder->index_path);
camel_folder_change_info_free(local_folder->changes);
+
+#ifdef ENABLE_THREADS
+ g_mutex_free(local_folder->priv->search_lock);
+#endif
+ g_free(local_folder->priv);
}
CamelType camel_local_folder_get_type(void)
lf->flags = flags;
- lf->summary = CLOCALF_CLASS(lf)->create_summary(lf->summary_path, lf->folder_path, lf->index);
- if (camel_local_summary_load(lf->summary, forceindex, ex) == -1) {
+ folder->summary = (CamelFolderSummary *)CLOCALF_CLASS(lf)->create_summary(lf->summary_path, lf->folder_path, lf->index);
+ if (camel_local_summary_load((CamelLocalSummary *)folder->summary, forceindex, ex) == -1) {
camel_object_unref (CAMEL_OBJECT (folder));
return NULL;
}
return;
/* if sync fails, we'll pass it up on exit through ex */
- camel_local_summary_sync(lf->summary, expunge, lf->changes, ex);
+ camel_local_summary_sync((CamelLocalSummary *)folder->summary, expunge, lf->changes, ex);
camel_local_folder_unlock(lf);
if (camel_folder_change_info_changed(lf->changes)) {
/* force save of metadata */
if (lf->index)
ibex_save(lf->index);
- if (lf->summary)
- camel_folder_summary_save(CAMEL_FOLDER_SUMMARY(lf->summary));
+ if (folder->summary)
+ camel_folder_summary_save(folder->summary);
}
static void
d(printf("expunge\n"));
/* Just do a sync with expunge, serves the same purpose */
- camel_folder_sync(folder, TRUE, ex);
-}
-
-/*
- The following functions all work off the summary, so the default operations provided
- in camel-local-folder will suffice for all subclasses. They may want to
- snoop various operations to ensure the status remains synced, or just wait
- for the sync operation
-*/
-static gint
-local_get_message_count(CamelFolder *folder)
-{
- CamelLocalFolder *local_folder = CAMEL_LOCAL_FOLDER(folder);
-
- g_return_val_if_fail(local_folder->summary != NULL, -1);
-
- return camel_folder_summary_count(CAMEL_FOLDER_SUMMARY(local_folder->summary));
-}
-
-static gint
-local_get_unread_message_count(CamelFolder *folder)
-{
- CamelLocalFolder *local_folder = CAMEL_LOCAL_FOLDER(folder);
- CamelMessageInfo *info;
- GPtrArray *infolist;
- gint i, max, count = 0;
-
- g_return_val_if_fail(local_folder->summary != NULL, -1);
-
- max = camel_folder_summary_count(CAMEL_FOLDER_SUMMARY(local_folder->summary));
- if (max == -1)
- return -1;
-
- infolist = local_get_summary(folder);
-
- for (i = 0; i < infolist->len; i++) {
- info = (CamelMessageInfo *) g_ptr_array_index(infolist, i);
- if (!(info->flags & CAMEL_MESSAGE_SEEN))
- count++;
- }
-
- return count;
+ /* call the callback directly, to avoid locking problems */
+ CAMEL_FOLDER_CLASS (CAMEL_OBJECT_GET_CLASS(folder))->sync(folder, TRUE, ex);
}
static GPtrArray *
-local_get_uids(CamelFolder *folder)
-{
- GPtrArray *array;
- CamelLocalFolder *local_folder = CAMEL_LOCAL_FOLDER(folder);
- int i, count;
-
- count = camel_folder_summary_count(CAMEL_FOLDER_SUMMARY(local_folder->summary));
- array = g_ptr_array_new();
- g_ptr_array_set_size(array, count);
- for (i = 0; i < count; i++) {
- CamelMessageInfo *info = camel_folder_summary_index(CAMEL_FOLDER_SUMMARY(local_folder->summary), i);
-
- array->pdata[i] = g_strdup(camel_message_info_uid(info));
- }
-
- return array;
-}
-
-GPtrArray *
-local_get_summary(CamelFolder *folder)
+local_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex)
{
CamelLocalFolder *local_folder = CAMEL_LOCAL_FOLDER(folder);
+ GPtrArray *summary, *matches;
- return CAMEL_FOLDER_SUMMARY(local_folder->summary)->messages;
-}
-
-/* get a single message info, by uid */
-static const CamelMessageInfo *
-local_get_message_info(CamelFolder *folder, const char *uid)
-{
- CamelLocalFolder *local_folder = CAMEL_LOCAL_FOLDER(folder);
+ /* NOTE: could get away without the search lock by creating a new
+ search object each time */
- return camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(local_folder->summary), uid);
-}
-
-static GPtrArray *
-local_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex)
-{
- CamelLocalFolder *local_folder = CAMEL_LOCAL_FOLDER(folder);
+ CAMEL_LOCAL_FOLDER_LOCK(folder, search_lock);
- if (local_folder->search == NULL) {
+ if (local_folder->search == NULL)
local_folder->search = camel_folder_search_new();
- }
camel_folder_search_set_folder(local_folder->search, folder);
- if (local_folder->summary) {
- /* FIXME: dont access summary array directly? */
- camel_folder_search_set_summary(local_folder->search,
- CAMEL_FOLDER_SUMMARY(local_folder->summary)->messages);
- }
-
camel_folder_search_set_body_index(local_folder->search, local_folder->index);
+ summary = camel_folder_get_summary(folder);
+ camel_folder_search_set_summary(local_folder->search, summary);
- return camel_folder_search_execute_expression(local_folder->search, expression, ex);
-}
-
-static void
-local_search_free(CamelFolder *folder, GPtrArray * result)
-{
- CamelLocalFolder *local_folder = CAMEL_LOCAL_FOLDER(folder);
-
- camel_folder_search_free_result(local_folder->search, result);
-}
-
-static guint32
-local_get_message_flags(CamelFolder *folder, const char *uid)
-{
- CamelMessageInfo *info;
- CamelLocalFolder *mf = CAMEL_LOCAL_FOLDER(folder);
-
- info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid);
- g_return_val_if_fail(info != NULL, 0);
-
- return info->flags;
-}
-
-static void
-local_set_message_flags(CamelFolder *folder, const char *uid, guint32 flags, guint32 set)
-{
- CamelMessageInfo *info;
- CamelLocalFolder *mf = CAMEL_LOCAL_FOLDER(folder);
- guint32 new;
-
- info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid);
- g_return_if_fail(info != NULL);
-
- new = (info->flags & ~flags) | (set & flags);
- if (new == info->flags)
- return;
-
- info->flags = new | CAMEL_MESSAGE_FOLDER_FLAGGED;
- camel_folder_summary_touch(CAMEL_FOLDER_SUMMARY(mf->summary));
-
- camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
-}
+ matches = camel_folder_search_execute_expression(local_folder->search, expression, ex);
-static gboolean
-local_get_message_user_flag(CamelFolder *folder, const char *uid, const char *name)
-{
- CamelMessageInfo *info;
- CamelLocalFolder *mf = CAMEL_LOCAL_FOLDER(folder);
+ CAMEL_LOCAL_FOLDER_UNLOCK(folder, search_lock);
- info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid);
- g_return_val_if_fail(info != NULL, FALSE);
+ camel_folder_free_summary(folder, summary);
- return camel_flag_get(&info->user_flags, name);
+ return matches;
}
static void
-local_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value)
-{
- CamelMessageInfo *info;
- CamelLocalFolder *mf = CAMEL_LOCAL_FOLDER(folder);
-
- info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid);
- g_return_if_fail(info != NULL);
-
- if (!camel_flag_set(&info->user_flags, name, value))
- return;
-
- info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED|CAMEL_MESSAGE_FOLDER_XEVCHANGE;
- camel_folder_summary_touch(CAMEL_FOLDER_SUMMARY(mf->summary));
- camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
-}
-
-static const char *
-local_get_message_user_tag(CamelFolder *folder, const char *uid, const char *name)
-{
- CamelMessageInfo *info;
- CamelLocalFolder *mf = CAMEL_LOCAL_FOLDER(folder);
-
- info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid);
- g_return_val_if_fail(info != NULL, FALSE);
-
- return camel_tag_get(&info->user_tags, name);
-}
-
-static void
-local_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value)
+local_search_free(CamelFolder *folder, GPtrArray * result)
{
- CamelMessageInfo *info;
- CamelLocalFolder *mf = CAMEL_LOCAL_FOLDER(folder);
+ CamelLocalFolder *local_folder = CAMEL_LOCAL_FOLDER(folder);
- info = camel_folder_summary_uid(CAMEL_FOLDER_SUMMARY(mf->summary), uid);
- g_return_if_fail(info != NULL);
+ /* we need to lock this free because of the way search_free_result works */
+ /* FIXME: put the lock inside search_free_result */
+ CAMEL_LOCAL_FOLDER_LOCK(folder, search_lock);
- if (!camel_tag_set(&info->user_tags, name, value))
- return;
+ camel_folder_search_free_result(local_folder->search, result);
- info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED|CAMEL_MESSAGE_FOLDER_XEVCHANGE;
- camel_folder_summary_touch(CAMEL_FOLDER_SUMMARY(mf->summary));
- camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
+ CAMEL_LOCAL_FOLDER_UNLOCK(folder, search_lock);
}
-
-
typedef struct {
CamelFolder parent_object;
+ struct _CamelLocalFolderPrivate *priv;
guint32 flags; /* open mode flags */
char *index_path; /* where the index file lives */
ibex *index; /* index for this folder */
- CamelLocalSummary *summary;
CamelFolderSearch *search; /* used to run searches, we just use the real thing (tm) */
CamelFolderChangeInfo *changes; /* used to store changes to the folder during processing */
} CamelLocalFolder;
--- /dev/null
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ * camel-local-private.h: Private info for local provider.
+ *
+ * Authors: Michael Zucchi <notzed@helixcode.com>
+ *
+ * Copyright 1999, 2000 Helix Code, Inc. (http://www.helixcode.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+ * USA
+ */
+
+#ifndef CAMEL_PRIVATE_H
+#define CAMEL_PRIVATE_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus }*/
+
+/* need a way to configure and save this data, if this header is to
+ be installed. For now, dont install it */
+
+#include "config.h"
+
+#ifdef ENABLE_THREADS
+#include <pthread.h>
+#endif
+
+struct _CamelLocalFolderPrivate {
+#ifdef ENABLE_THREADS
+ GMutex *search_lock; /* for locking the search object */
+#endif
+};
+
+#ifdef ENABLE_THREADS
+#define CAMEL_LOCAL_FOLDER_LOCK(f, l) (g_mutex_lock(((CamelLocalFolder *)f)->priv->l))
+#define CAMEL_LOCAL_FOLDER_UNLOCK(f, l) (g_mutex_unlock(((CamelLocalFolder *)f)->priv->l))
+#else
+#define CAMEL_LOCAL_FOLDER_LOCK(f, l)
+#define CAMEL_LOCAL_FOLDER_UNLOCK(f, l)
+#endif
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* CAMEL_H */
+
#define _PRIVATE(o) (((CamelLocalSummary *)(o))->priv)
-#if 0
-static int summary_header_load (CamelFolderSummary *, FILE *);
-static int summary_header_save (CamelFolderSummary *, FILE *);
-#endif
-
static CamelMessageInfo * message_info_new (CamelFolderSummary *, struct _header_raw *);
-static CamelMessageInfo * message_info_new_from_parser (CamelFolderSummary *, CamelMimeParser *);
-static CamelMessageInfo * message_info_new_from_message(CamelFolderSummary *s, CamelMimeMessage *msg);
-#if 0
-static CamelMessageInfo * message_info_load (CamelFolderSummary *, FILE *);
-static int message_info_save (CamelFolderSummary *, FILE *, CamelMessageInfo *);
-#endif
-/*static void message_info_free (CamelFolderSummary *, CamelMessageInfo *);*/
static int local_summary_decode_x_evolution(CamelLocalSummary *cls, const char *xev, CamelMessageInfo *mi);
static char *local_summary_encode_x_evolution(CamelLocalSummary *cls, const CamelMessageInfo *mi);
static void camel_local_summary_class_init (CamelLocalSummaryClass *klass);
static void camel_local_summary_init (CamelLocalSummary *obj);
static void camel_local_summary_finalise (CamelObject *obj);
-
static CamelFolderSummaryClass *camel_local_summary_parent;
CamelType
camel_local_summary_parent = CAMEL_FOLDER_SUMMARY_CLASS(camel_type_get_global_classfuncs(camel_folder_summary_get_type()));
- /*sklass->summary_header_load = summary_header_load;
- sklass->summary_header_save = summary_header_save;*/
-
sklass->message_info_new = message_info_new;
- sklass->message_info_new_from_parser = message_info_new_from_parser;
- sklass->message_info_new_from_message = message_info_new_from_message;
-
- /*sklass->message_info_load = message_info_load;
- sklass->message_info_save = message_info_save;*/
- /*sklass->message_info_free = message_info_free;*/
klass->load = local_summary_load;
klass->check = local_summary_check;
for (i=0;i<camel_folder_summary_count(s);i++) {
CamelMessageInfo *info = camel_folder_summary_index(s, i);
do_stat_mi(cls, &stats, info);
+ camel_folder_summary_info_free(s, info);
}
printf("\nMemory used by summary:\n\n");
return outlen;
}
-#if 0
-static int
-summary_header_load(CamelFolderSummary *s, FILE *in)
-{
- CamelLocalSummary *mbs = CAMEL_LOCAL_SUMMARY(s);
-
- if (((CamelFolderSummaryClass *)camel_local_summary_parent)->summary_header_load(s, in) == -1)
- return -1;
-
- return camel_folder_summary_decode_uint32(in, &mbs->folder_size);
-}
-
-static int
-summary_header_save(CamelFolderSummary *s, FILE *out)
-{
- CamelLocalSummary *mbs = CAMEL_LOCAL_SUMMARY(s);
-
- if (((CamelFolderSummaryClass *)camel_local_summary_parent)->summary_header_save(s, out) == -1)
- return -1;
-
- return camel_folder_summary_encode_uint32(out, mbs->folder_size);
-}
-
-static int
-header_evolution_decode(const char *in, guint32 *uid, guint32 *flags)
-{
- char *header;
-
- if (in && (header = header_token_decode(in))) {
- if (strlen (header) == strlen ("00000000-0000")
- && sscanf (header, "%08x-%04x", uid, flags) == 2) {
- g_free(header);
- return *uid;
- }
- g_free(header);
- }
-
- return -1;
-}
-
-static char *
-header_evolution_encode(guint32 uid, guint32 flags)
-{
- return g_strdup_printf("%08x-%04x", uid, flags & 0xffff);
-}
-#endif
-
static int
local_summary_check(CamelLocalSummary *cls, CamelFolderChangeInfo *changeinfo, CamelException *ex)
{
- /* FIXME: sync index here */
+ /* FIXME: sync index here ? */
return 0;
}
return mi;
}
-
-static CamelMessageInfo * message_info_new_from_message(CamelFolderSummary *s, CamelMimeMessage *msg)
-{
- CamelMessageInfo *mi;
- /*CamelLocalSummary *cls = (CamelLocalSummary *)s;*/
-
- mi = ((CamelFolderSummaryClass *)camel_local_summary_parent)->message_info_new_from_message(s, msg);
-#if 0
- if (mi) {
-
- if (mi->uid == NULL) {
- d(printf("no uid assigned yet, assigning one\n"));
- mi->uid = camel_folder_summary_next_uid_string(s);
- mi->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED | CAMEL_MESSAGE_FOLDER_NOXEV;
- }
-
- if (cls->index
- && (cls->index_force
- || !ibex_contains_name(cls->index, mi->uid))) {
- d(printf("Am indexing message %s\n", mi->uid));
- camel_folder_summary_set_index(s, cls->index);
- } else {
- d(printf("Not indexing message %s\n", mi->uid));
- camel_folder_summary_set_index(s, NULL);
- }
- }
-#endif
- return mi;
-}
-
-static CamelMessageInfo *
-message_info_new_from_parser(CamelFolderSummary *s, CamelMimeParser *mp)
-{
- CamelMessageInfo *mi;
- /*CamelLocalSummary *mbs = CAMEL_LOCAL_SUMMARY(s);*/
-
- mi = ((CamelFolderSummaryClass *)camel_local_summary_parent)->message_info_new_from_parser(s, mp);
- if (mi) {
-#if 0
- /* do we want to index this message as we add it, as well? */
- if (mbs->index
- && (mbs->index_force
- || !ibex_contains_name(mbs->index, mi->uid))) {
- d(printf("Am indexing message %s\n", mi->uid));
- camel_folder_summary_set_index(s, mbs->index);
- } else {
- d(printf("Not indexing message %s\n", mi->uid));
- camel_folder_summary_set_index(s, NULL);
- }
-#endif
- }
-
- return mi;
-}
-
-#if 0
-static CamelMessageInfo *
-message_info_load(CamelFolderSummary *s, FILE *in)
-{
- CamelMessageInfo *mi;
-
- io(printf("loading local message info\n"));
-
- mi = ((CamelFolderSummaryClass *)camel_local_summary_parent)->message_info_load(s, in);
- if (mi) {
- guint32 position;
- CamelLocalMessageInfo *mbi = (CamelLocalMessageInfo *)mi;
-
- camel_folder_summary_decode_uint32(in, &position);
- mbi->frompos = position;
- }
-
- return mi;
-}
-
-static int
-message_info_save(CamelFolderSummary *s, FILE *out, CamelMessageInfo *mi)
-{
- CamelLocalMessageInfo *mbi = (CamelLocalMessageInfo *)mi;
-
- io(printf("saving local message info\n"));
-
- ((CamelFolderSummaryClass *)camel_local_summary_parent)->message_info_save(s, out, mi);
-
- return camel_folder_summary_encode_uint32(out, mbi->frompos);
-}
-#endif
d(printf("Appending message\n"));
/* add it to the summary/assign the uid, etc */
- mi = camel_local_summary_add(lf->summary, message, info, lf->changes, ex);
+ mi = camel_local_summary_add((CamelLocalSummary *)folder->summary, message, info, lf->changes, ex);
if (camel_exception_is_set(ex)) {
return;
}
d(printf("getting message: %s\n", uid));
/* get the message summary info */
- if ((info = camel_folder_summary_uid((CamelFolderSummary *)lf->summary, uid)) == NULL) {
+ if ((info = camel_folder_summary_uid(folder->summary, uid)) == NULL) {
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, _("Cannot get message: %s\n %s"), uid, _("No such message"));
return NULL;
}
/* what do we do if the message flags (and :info data) changes? filename mismatch - need to recheck I guess */
name = g_strdup_printf("%s/cur/%s", lf->folder_path, camel_maildir_info_filename(mdi));
+
+ camel_folder_summary_info_free(folder->summary, info);
+
if ((message_stream = camel_stream_fs_new_with_name(name, O_RDONLY, 0)) == NULL) {
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, _("Cannot get message: %s\n %s"),
name, g_strerror(errno));
#include <ctype.h>
+#include "camel-private.h"
#include "e-util/e-memory.h"
#define d(x) /*(printf("%s(%d): ", __FILE__, __LINE__),(x))*/
if (cls->index)
ibex_unindex(cls->index, (char *)camel_message_info_uid(info));
camel_folder_summary_remove((CamelFolderSummary *)cls, info);
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, info);
}
static int
if (info == NULL || (cls->index && (!ibex_contains_name(cls->index, uid)))) {
/* need to add this file to the summary */
if (info != NULL) {
- g_hash_table_remove(left, uid);
+ CamelMessageInfo *old = g_hash_table_lookup(left, camel_message_info_uid(info));
+ if (old) {
+ g_hash_table_remove(left, uid);
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, old);
+ }
camel_folder_summary_remove((CamelFolderSummary *)cls, info);
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, info);
}
camel_maildir_summary_add(cls, d->d_name, forceindex);
} else {
const char *filename;
+ CamelMessageInfo *old;
- g_hash_table_remove(left, camel_message_info_uid(info));
+ old = g_hash_table_lookup(left, camel_message_info_uid(info));
+ if (old) {
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, old);
+ g_hash_table_remove(left, camel_message_info_uid(info));
+ }
mdi = (CamelMaildirMessageInfo *)info;
filename = camel_maildir_info_filename(mdi);
/* TODO: only store the extension in the mdi->filename struct, not the whole lot */
if (filename == NULL || strcmp(filename, d->d_name) != 0) {
#ifdef DOESTRV
+#warning "cannot modify the estrv after its been setup, for mt-safe code"
d(printf("filename changed: %s to %s\n", filename, d->d_name));
/* need to update the summary hash string reference since it might (will) change */
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
g_hash_table_remove(s->messages_uid, uid);
info->strings = e_strv_set_ref(info->strings, CAMEL_MAILDIR_INFO_FILENAME, d->d_name);
/* we need to re-pack as well */
info->strings = e_strv_pack(info->strings);
g_hash_table_insert(s->messages_uid, (char *)camel_message_info_uid(info), info);
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
#else
g_free(mdi->filename);
mdi->filename = g_strdup(d->d_name);
#endif
}
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, info);
}
g_free(uid);
}
continue;
/* already in summary? shouldn't happen, but just incase ... */
- if (camel_folder_summary_uid((CamelFolderSummary *)cls, name))
+ if ((info = camel_folder_summary_uid((CamelFolderSummary *)cls, name))) {
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, info);
newname = destname = camel_folder_summary_next_uid_string(s);
- else {
+ } else {
newname = NULL;
destname = name;
}
g_free(cur);
/* sort the summary based on receive time, since the directory order is not useful */
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
qsort(s->messages->pdata, s->messages->len, sizeof(CamelMessageInfo *), sort_receive_cmp);
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
/* FIXME: move this up a class? */
/* we'll assume it didn't work, but dont change anything else */
g_free(newname);
} else {
+ /* TODO: If this is made mt-safe, then this code could be a problem, since
+ the estrv is being modified.
+ Sigh, this may mean the maildir name has to be cached another way */
#ifdef DOESTRV
+#warning "cannot modify the estrv after its been setup, for mt-safe code"
+ CAMEL_SUMMARY_LOCK(s, summary_lock);
/* need to update the summary hash ref */
g_hash_table_remove(s->messages_uid, camel_message_info_uid(info));
info->strings = e_strv_set_ref_free(info->strings, CAMEL_MAILDIR_INFO_FILENAME, newname);
info->strings = e_strv_pack(info->strings);
g_hash_table_insert(s->messages_uid, (char *)camel_message_info_uid(info), info);
+ CAMEL_SUMMARY_UNLOCK(s, summary_lock);
#else
g_free(mdi->filename);
mdi->filename = newname;
/* strip FOLDER_MESSAGE_FLAGED, etc */
info->flags &= 0xffff;
}
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, info);
}
return 0;
}
static int mbox_lock(CamelLocalFolder *lf, CamelLockType type, CamelException *ex);
static void mbox_unlock(CamelLocalFolder *lf);
+static void mbox_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value);
+static void mbox_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value);
+
static void mbox_append_message(CamelFolder *folder, CamelMimeMessage * message, const CamelMessageInfo * info, CamelException *ex);
static CamelMimeMessage *mbox_get_message(CamelFolder *folder, const gchar * uid, CamelException *ex);
static CamelLocalSummary *mbox_create_summary(const char *path, const char *folder, ibex *index);
camel_folder_class->append_message = mbox_append_message;
camel_folder_class->get_message = mbox_get_message;
+ camel_folder_class->set_message_user_flag = mbox_set_message_user_flag;
+ camel_folder_class->set_message_user_tag = mbox_set_message_user_tag;
+
lclass->create_summary = mbox_create_summary;
lclass->lock = mbox_lock;
lclass->unlock = mbox_unlock;
CamelLocalFolder *lf = (CamelLocalFolder *)folder;
CamelStream *output_stream = NULL, *filter_stream = NULL;
CamelMimeFilter *filter_from = NULL;
- CamelMboxSummary *mbs = (CamelMboxSummary *)lf->summary;
+ CamelMboxSummary *mbs = (CamelMboxSummary *)folder->summary;
CamelMessageInfo *mi;
char *fromline = NULL;
int fd;
d(printf("Appending message\n"));
/* first, check the summary is correct (updates folder_size too) */
- camel_local_summary_check(lf->summary, lf->changes, ex);
+ camel_local_summary_check((CamelLocalSummary *)folder->summary, lf->changes, ex);
if (camel_exception_is_set(ex))
goto fail;
/* add it to the summary/assign the uid, etc */
- mi = camel_local_summary_add(lf->summary, message, info, lf->changes, ex);
+ mi = camel_local_summary_add((CamelLocalSummary *)folder->summary, message, info, lf->changes, ex);
if (camel_exception_is_set(ex))
goto fail;
/* and we need to set the frompos/XEV explicitly */
((CamelMboxMessageInfo *)mi)->frompos = mbs->folder_size?mbs->folder_size+1:0;
#if 0
- xev = camel_local_summary_encode_x_evolution(lf->summary, mi);
+ xev = camel_local_summary_encode_x_evolution((CamelLocalSummary *)folder->summary, mi);
if (xev) {
/* the x-ev header should match the 'current' flags, no problem, so store as much */
camel_medium_set_header((CamelMedium *)message, "X-Evolution", xev);
retry:
/* get the message summary info */
- info = (CamelMboxMessageInfo *) camel_folder_summary_uid((CamelFolderSummary *)lf->summary, uid);
+ info = (CamelMboxMessageInfo *) camel_folder_summary_uid(folder->summary, uid);
if (info == NULL) {
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
_("Cannot get message: %s from folder %s\n %s"), uid, lf->folder_path,
strerror(errno));
camel_local_folder_unlock(lf);
+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)info);
return NULL;
}
camel_mime_parser_state(parser));
camel_object_unref((CamelObject *)parser);
+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)info);
if (!retried) {
retried = TRUE;
- camel_local_summary_check(lf->summary, lf->changes, ex);
+ camel_local_summary_check((CamelLocalSummary *)folder->summary, lf->changes, ex);
if (!camel_exception_is_set(ex))
goto retry;
}
camel_local_folder_unlock(lf);
return NULL;
}
+
+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)info);
message = camel_mime_message_new();
if (camel_mime_part_construct_from_parser((CamelMimePart *)message, parser) == -1) {
return message;
}
+
+static void
+mbox_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value)
+{
+ CamelMessageInfo *info;
+
+ g_return_if_fail(folder->summary != NULL);
+
+ info = camel_folder_summary_uid(folder->summary, uid);
+ g_return_if_fail(info != NULL);
+
+ if (camel_flag_set(&info->user_flags, name, value)) {
+ info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED|CAMEL_MESSAGE_FOLDER_XEVCHANGE;
+ camel_folder_summary_touch(folder->summary);
+ camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
+ }
+ camel_folder_summary_info_free(folder->summary, info);
+}
+
+static void
+mbox_set_message_user_tag(CamelFolder *folder, const char *uid, const char *name, const char *value)
+{
+ CamelMessageInfo *info;
+
+ g_return_if_fail(folder->summary != NULL);
+
+ info = camel_folder_summary_uid(folder->summary, uid);
+ g_return_if_fail(info != NULL);
+
+ if (camel_tag_set(&info->user_tags, name, value)) {
+ info->flags |= CAMEL_MESSAGE_FOLDER_FLAGGED|CAMEL_MESSAGE_FOLDER_XEVCHANGE;
+ camel_folder_summary_touch(folder->summary);
+ camel_object_trigger_event(CAMEL_OBJECT(folder), "message_changed", (char *) uid);
+ }
+ camel_folder_summary_info_free(folder->summary, info);
+}
CamelMessageInfo *mi = camel_folder_summary_index(s, i);
camel_folder_change_info_add_source(changeinfo, camel_message_info_uid(mi));
+ camel_folder_summary_info_free(s, mi);
}
}
for (i = 0; i < count; i++) {
CamelMessageInfo *mi = camel_folder_summary_index(s, i);
camel_folder_change_info_add_update(changeinfo, camel_message_info_uid(mi));
+ camel_folder_summary_info_free(s, mi);
}
camel_folder_change_info_build_diff(changeinfo);
}
CamelFolderSummary *s = (CamelFolderSummary *)mbs;
CamelMimeParser *mp = NULL;
int i, count;
- CamelMboxMessageInfo *info;
+ CamelMboxMessageInfo *info = NULL;
int fd = -1, fdout = -1;
char *tmpname = NULL;
char *buffer, *xevnew = NULL;
/* remove it from the change list */
camel_folder_change_info_remove_uid(changeinfo, uid);
camel_folder_summary_remove(s, (CamelMessageInfo *)info);
+ camel_folder_summary_info_free(s, (CamelMessageInfo *)info);
count--;
i--;
info = NULL;
d(printf("we are now at %d, from = %d\n", (int)camel_mime_parser_tell(mp),
(int)camel_mime_parser_tell_start_from(mp)));
camel_mime_parser_unstep(mp);
+ camel_folder_summary_info_free(s, (CamelMessageInfo *)info);
+ info = NULL;
}
}
unlink(tmpname);
if (mp)
camel_object_unref((CamelObject *)mp);
+ if (info)
+ camel_folder_summary_info_free(s, (CamelMessageInfo *)info);
return -1;
}
CamelFolderSummary *s = (CamelFolderSummary *)mbs;
CamelMimeParser *mp = NULL;
int i, count;
- CamelMboxMessageInfo *info;
+ CamelMboxMessageInfo *info = NULL;
int fd = -1;
char *xevnew, *xevtmp;
const char *xev;
d(printf("Checking message %s %08x\n", info->info.uid, info->info.flags));
- if ((info->info.flags & CAMEL_MESSAGE_FOLDER_FLAGGED) == 0)
+ if ((info->info.flags & CAMEL_MESSAGE_FOLDER_FLAGGED) == 0) {
+ camel_folder_summary_info_free(s, (CamelMessageInfo *)info);
+ info = NULL;
continue;
+ }
d(printf("Updating message %s\n", info->info.uid));
camel_mime_parser_drop_step(mp);
info->info.flags &= 0xffff;
+ camel_folder_summary_info_free(s, (CamelMessageInfo *)info);
}
d(printf("Closing folders\n"));
error:
if (fd != -1)
close(fd);
-
if (mp)
camel_object_unref((CamelObject *)mp);
+ if (info)
+ camel_folder_summary_info_free(s, (CamelMessageInfo *)info);
return -1;
}
quick = FALSE;
else
work |= (info->flags & CAMEL_MESSAGE_FOLDER_FLAGGED) != 0;
+ camel_folder_summary_info_free(s, info);
}
/* yuck i hate this logic, but its to simplify the 'all ok, update summary' and failover cases */
d(printf("Appending message\n"));
/* add it to the summary/assign the uid, etc */
- mi = camel_local_summary_add(lf->summary, message, info, lf->changes, ex);
+ mi = camel_local_summary_add((CamelLocalSummary *)folder->summary, message, info, lf->changes, ex);
if (camel_exception_is_set(ex)) {
return;
}
d(printf("getting message: %s\n", uid));
/* get the message summary info */
- if ((info = camel_folder_summary_uid((CamelFolderSummary *)lf->summary, uid)) == NULL) {
+ if ((info = camel_folder_summary_uid(folder->summary, uid)) == NULL) {
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, _("Cannot get message: %s\n %s"), uid, _("No such message"));
return NULL;
}
+ /* we only need it to check the message exists */
+ camel_folder_summary_info_free(folder->summary, info);
+
name = g_strdup_printf("%s/%s", lf->folder_path, uid);
if ((message_stream = camel_stream_fs_new_with_name(name, O_RDONLY, 0)) == NULL) {
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID, _("Cannot get message: %s\n %s"),
#define CAMEL_MH_SUMMARY_VERSION (0x2000)
-static CamelMessageInfo *message_info_new(CamelFolderSummary *, struct _header_raw *);
-
static int mh_summary_check(CamelLocalSummary *cls, CamelFolderChangeInfo *changeinfo, CamelException *ex);
static int mh_summary_sync(CamelLocalSummary *cls, gboolean expunge, CamelFolderChangeInfo *changeinfo, CamelException *ex);
/*static int mh_summary_add(CamelLocalSummary *cls, CamelMimeMessage *msg, CamelMessageInfo *info, CamelFolderChangeInfo *, CamelException *ex);*/
parent_class = (CamelLocalSummaryClass *)camel_type_get_global_classfuncs(camel_local_summary_get_type ());
/* override methods */
- sklass->message_info_new = message_info_new;
sklass->next_uid_string = mh_summary_next_uid_string;
lklass->check = mh_summary_check;
return o;
}
-static CamelMessageInfo *message_info_new(CamelFolderSummary * s, struct _header_raw *h)
-{
- CamelMessageInfo *mi;
- /*CamelMhSummary *mhs = (CamelMhSummary *)s;*/
-
- mi = ((CamelFolderSummaryClass *) parent_class)->message_info_new(s, h);
- /* hmm, this isn't quite right */
- if (mi) {
- /*mi->uid = mh_summary_next_uid_string(s);*/
- }
-
- return mi;
-}
-
static char *mh_summary_next_uid_string(CamelFolderSummary *s)
{
CamelMhSummary *mhs = (CamelMhSummary *)s;
if (cls->index)
ibex_unindex(cls->index, (char *)camel_message_info_uid(info));
camel_folder_summary_remove((CamelFolderSummary *)cls, info);
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, info);
}
static int
if (info != NULL) {
g_hash_table_remove(left, camel_message_info_uid(info));
camel_folder_summary_remove((CamelFolderSummary *)cls, info);
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, info);
}
camel_mh_summary_add(cls, d->d_name, forceindex);
} else {
- g_hash_table_remove(left, camel_message_info_uid(info));
- }
+ const char *uid = camel_message_info_uid(info);
+ CamelMessageInfo *old = g_hash_table_lookup(left, uid);
+
+ if (old) {
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, old);
+ g_hash_table_remove(left, uid);
+ }
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, info);
+ }
}
}
closedir(dir);
g_warning("Problem occured when trying to expunge, ignored");
}
}
+ camel_folder_summary_info_free((CamelFolderSummary *)cls, info);
}
return 0;
{
CamelNNTPStore *store;
- camel_folder_summary_save (CAMEL_NNTP_FOLDER(folder)->summary);
+ camel_folder_summary_save (folder->summary);
store = CAMEL_NNTP_STORE (camel_folder_get_parent_store (folder));
camel_nntp_newsrc_write (store->newsrc);
}
-static gint
-nntp_folder_get_message_count (CamelFolder *folder)
-{
- CamelNNTPFolder *nntp_folder = CAMEL_NNTP_FOLDER(folder);
-
- g_assert (folder);
- g_assert (nntp_folder->summary);
-
- return camel_folder_summary_count(nntp_folder->summary);
-}
-
-static guint32
-nntp_folder_get_message_flags (CamelFolder *folder, const char *uid)
-{
- CamelNNTPFolder *nntp_folder = CAMEL_NNTP_FOLDER (folder);
- CamelMessageInfo *info = camel_folder_summary_uid (nntp_folder->summary, uid);
-
- return info->flags;
-}
-
static void
nntp_folder_set_message_flags (CamelFolder *folder, const char *uid,
guint32 flags, guint32 set)
{
- CamelNNTPFolder *nntp_folder = CAMEL_NNTP_FOLDER (folder);
- CamelMessageInfo *info = camel_folder_summary_uid (nntp_folder->summary, uid);
- guint32 new;
-
- new = (info->flags & ~flags) | (set & flags);
- if (new == info->flags)
- return;
+ ((CamelFolderClass *)parent_class)->set_message_flags(folder, uid, flags, set);
- info->flags = new;
if (flags & set & CAMEL_MESSAGE_SEEN) {
int article_num;
CamelNNTPStore *nntp_store = CAMEL_NNTP_STORE (camel_folder_get_parent_store (folder));
folder->name,
article_num);
}
-
- camel_folder_summary_touch (nntp_folder->summary);
}
static CamelMimeMessage *
return NULL;
}
+ /* this could probably done fairly easily with an nntp stream that
+ returns eof after '.' */
+
/* XXX ick ick ick. read the entire message into a buffer and
then create a stream_mem for it. */
buf_alloc = 2048;
return message;
}
-static GPtrArray *
-nntp_folder_get_uids (CamelFolder *folder)
-{
- CamelNNTPFolder *nntp_folder = CAMEL_NNTP_FOLDER (folder);
- GPtrArray *out;
- CamelMessageInfo *message_info;
- int i;
- int count = camel_folder_summary_count (nntp_folder->summary);
-
- out = g_ptr_array_new ();
- g_ptr_array_set_size (out, count);
-
- for (i = 0; i < count; i++) {
- message_info = camel_folder_summary_index (nntp_folder->summary, i);
- out->pdata[i] = g_strdup (camel_message_info_uid(message_info));
- }
-
- return out;
-}
-
-static GPtrArray *
-nntp_folder_get_summary (CamelFolder *folder)
-{
- CamelNNTPFolder *nntp_folder = CAMEL_NNTP_FOLDER (folder);
-
- return nntp_folder->summary->messages;
-}
-
static GPtrArray*
nntp_folder_search_by_expression (CamelFolder *folder, const char *expression, CamelException *ex)
{
return NULL;
}
-static const CamelMessageInfo*
-nntp_folder_get_message_info (CamelFolder *folder, const char *uid)
-{
- CamelNNTPFolder *nntp_folder = CAMEL_NNTP_FOLDER (folder);
-
- return camel_folder_summary_uid (nntp_folder->summary, uid);
-}
-
static void
nntp_folder_finalize (CamelObject *object)
{
/* virtual method overload */
camel_folder_class->sync = nntp_folder_sync;
- camel_folder_class->get_message_count = nntp_folder_get_message_count;
camel_folder_class->set_message_flags = nntp_folder_set_message_flags;
- camel_folder_class->get_message_flags = nntp_folder_get_message_flags;
camel_folder_class->get_message = nntp_folder_get_message;
- camel_folder_class->get_uids = nntp_folder_get_uids;
- camel_folder_class->free_uids = camel_folder_free_deep;
- camel_folder_class->get_summary = nntp_folder_get_summary;
- camel_folder_class->free_summary = camel_folder_free_nop;
camel_folder_class->search_by_expression = nntp_folder_search_by_expression;
- camel_folder_class->get_message_info = nntp_folder_get_message_info;
}
CamelType
root_dir_path,
folder->name);
- nntp_folder->summary = camel_folder_summary_new ();
- camel_folder_summary_set_filename (nntp_folder->summary,
+ folder->summary = camel_folder_summary_new ();
+ camel_folder_summary_set_filename (folder->summary,
nntp_folder->summary_file_path);
- if (-1 == camel_folder_summary_load (nntp_folder->summary)) {
+ if (-1 == camel_folder_summary_load (folder->summary)) {
/* Bad or nonexistant summary file */
camel_nntp_get_headers (CAMEL_FOLDER( folder )->parent_store,
nntp_folder, ex);
}
/* XXX check return value */
- camel_folder_summary_save (nntp_folder->summary);
+ camel_folder_summary_save (folder->summary);
}
return folder;
#include "camel-nntp-newsrc.h"
#include <camel/camel-folder-summary.h>
+#ifdef ENABLE_THREADS
+#include <pthread.h>
+
+#define NEWSRC_LOCK(f, l) (g_mutex_lock(((CamelNNTPNewsrc *)f)->l))
+#define NEWSRC_UNLOCK(f, l) (g_mutex_unlock(((CamelNNTPNewsrc *)f)->l))
+#else
+#define NEWSRC_LOCK(f, l)
+#define NEWSRC_UNLOCK(f, l)
+#endif
+
typedef struct {
guint low;
guint high;
gchar *filename;
GHashTable *groups;
gboolean dirty;
+#ifdef ENABLE_THREADS
+ GMutex *lock;
+#endif
} ;
+
static NewsrcGroup *
camel_nntp_newsrc_group_add (CamelNNTPNewsrc *newsrc, const char *group_name, gboolean subscribed)
{
camel_nntp_newsrc_get_highest_article_read (CamelNNTPNewsrc *newsrc, const char *group_name)
{
NewsrcGroup *group;
+ int ret;
+
+ NEWSRC_LOCK(newsrc, lock);
group = g_hash_table_lookup (newsrc->groups, group_name);
+ ret = camel_nntp_newsrc_group_get_highest_article_read (newsrc, group);
+
+ NEWSRC_UNLOCK(newsrc, lock);
- return camel_nntp_newsrc_group_get_highest_article_read (newsrc, group);
+ return ret;
}
int
camel_nntp_newsrc_get_num_articles_read (CamelNNTPNewsrc *newsrc, const char *group_name)
{
NewsrcGroup *group;
+ int ret;
+
+ NEWSRC_LOCK(newsrc, lock);
group = g_hash_table_lookup (newsrc->groups, group_name);
+ ret = camel_nntp_newsrc_group_get_num_articles_read (newsrc, group);
+
+ NEWSRC_UNLOCK(newsrc, lock);
- return camel_nntp_newsrc_group_get_num_articles_read (newsrc, group);
+ return ret;
}
void
camel_nntp_newsrc_mark_article_read (CamelNNTPNewsrc *newsrc, const char *group_name, int num)
{
+ NEWSRC_LOCK(newsrc, lock);
camel_nntp_newsrc_mark_range_read (newsrc, group_name, num, num);
+ NEWSRC_UNLOCK(newsrc, lock);
}
void
low = tmp;
}
+ NEWSRC_LOCK(newsrc, lock);
group = g_hash_table_lookup (newsrc->groups, group_name);
camel_nntp_newsrc_group_mark_range_read (newsrc, group, low, high);
+ NEWSRC_UNLOCK(newsrc, lock);
}
gboolean
{
int i;
NewsrcGroup *group;
+ int ret = FALSE;
+ NEWSRC_LOCK(newsrc, lock);
group = g_hash_table_lookup (newsrc->groups, group_name);
for (i = 0; i < group->ranges->len; i++) {
if (num >= g_array_index (group->ranges, ArticleRange, i).low &&
num <= g_array_index (group->ranges, ArticleRange, i).high) {
- return TRUE;
+ ret = TRUE;
+ break;
}
}
+ NEWSRC_UNLOCK(newsrc, lock);
+
return FALSE;
}
gboolean
camel_nntp_newsrc_group_is_subscribed (CamelNNTPNewsrc *newsrc, const char *group_name)
{
- NewsrcGroup *group = g_hash_table_lookup (newsrc->groups, group_name);
+ NewsrcGroup *group;
+ int ret = FALSE;
+
+ NEWSRC_LOCK(newsrc, lock);
+
+ group = g_hash_table_lookup (newsrc->groups, group_name);
if (group) {
- return group->subscribed;
- }
- else {
- return FALSE;
+ ret = group->subscribed;
}
+
+ NEWSRC_UNLOCK(newsrc, lock);
+
+ return ret;
}
void
camel_nntp_newsrc_subscribe_group (CamelNNTPNewsrc *newsrc, const char *group_name)
{
- NewsrcGroup *group = g_hash_table_lookup (newsrc->groups, group_name);
+ NewsrcGroup *group;
+
+ NEWSRC_LOCK(newsrc, lock);
+
+ group = g_hash_table_lookup (newsrc->groups, group_name);
if (group) {
if (!group->subscribed)
else {
camel_nntp_newsrc_group_add (newsrc, group_name, TRUE);
}
+
+ NEWSRC_UNLOCK(newsrc, lock);
}
void
camel_nntp_newsrc_unsubscribe_group (CamelNNTPNewsrc *newsrc, const char *group_name)
{
- NewsrcGroup *group = g_hash_table_lookup (newsrc->groups, group_name);
+ NewsrcGroup *group;
+
+ NEWSRC_LOCK(newsrc, lock);
+ group = g_hash_table_lookup (newsrc->groups, group_name);
if (group) {
if (group->subscribed)
newsrc->dirty = TRUE;
else {
camel_nntp_newsrc_group_add (newsrc, group_name, FALSE);
}
+
+ NEWSRC_UNLOCK(newsrc, lock);
}
struct newsrc_ptr_array {
gboolean subscribed_only;
};
+/* this needs to strdup the grup_name, if the group array is likely to change */
static void
get_group_foreach (char *group_name, NewsrcGroup *group, struct newsrc_ptr_array *npa)
{
g_return_val_if_fail (newsrc, NULL);
+ NEWSRC_LOCK(newsrc, lock);
+
npa.ptr_array = g_ptr_array_new();
npa.subscribed_only = TRUE;
g_hash_table_foreach (newsrc->groups,
(GHFunc)get_group_foreach, &npa);
+ NEWSRC_UNLOCK(newsrc, lock);
+
return npa.ptr_array;
}
g_return_val_if_fail (newsrc, NULL);
+ NEWSRC_LOCK(newsrc, lock);
+
npa.ptr_array = g_ptr_array_new();
npa.subscribed_only = FALSE;
g_hash_table_foreach (newsrc->groups,
(GHFunc)get_group_foreach, &npa);
+ NEWSRC_UNLOCK(newsrc, lock);
+
return npa.ptr_array;
}
newsrc_fp.newsrc = newsrc;
newsrc_fp.fp = fp;
+ NEWSRC_LOCK(newsrc, lock);
+
g_hash_table_foreach (newsrc->groups,
(GHFunc)camel_nntp_newsrc_write_group_line,
&newsrc_fp);
+
+ NEWSRC_UNLOCK(newsrc, lock);
}
void
g_return_if_fail (newsrc);
+ NEWSRC_LOCK(newsrc, lock);
+
if (!newsrc->dirty)
return;
if ((fp = fopen(newsrc->filename, "w")) == NULL) {
g_warning ("Couldn't open newsrc file '%s'.\n", newsrc->filename);
+ NEWSRC_UNLOCK(newsrc, lock);
return;
}
- camel_nntp_newsrc_write_to_file(newsrc, fp);
-
newsrc->dirty = FALSE;
+ NEWSRC_UNLOCK(newsrc, lock);
+
+ camel_nntp_newsrc_write_to_file(newsrc, fp);
fclose(fp);
}
newsrc = g_new0(CamelNNTPNewsrc, 1);
newsrc->filename = filename;
newsrc->groups = g_hash_table_new (g_str_hash, g_str_equal);
+#ifdef ENABLE_THREADS
+ newsrc->lock = g_mutex_new();
+#endif
if ((fd = open(filename, O_RDONLY)) == -1) {
g_warning ("~/.newsrc-%s not present.\n", server);
folder = CAMEL_FOLDER (camel_object_new (CAMEL_POP3_FOLDER_TYPE));
camel_folder_construct (folder, parent, "inbox", "inbox");
- camel_folder_refresh_info (folder, ex);
+ /* mt-ok, since we dont have the folder-lock for new() */
+ camel_folder_refresh_info (folder, ex);/* mt-ok */
if (camel_exception_is_set (ex)) {
camel_object_unref (CAMEL_OBJECT (folder));
folder = NULL;
#include <string.h>
+#define d(x)
+
/* our message info includes the parent folder */
typedef struct _CamelVeeMessageInfo {
CamelMessageInfo info;
#define _PRIVATE(o) (((CamelVeeFolder *)(o))->priv)
static void vee_sync (CamelFolder *folder, gboolean expunge, CamelException *ex);
+static void vee_expunge (CamelFolder *folder, CamelException *ex);
-static GPtrArray *vee_get_uids (CamelFolder *folder);
-GPtrArray *vee_get_summary (CamelFolder *folder);
-
-static gint vee_get_message_count (CamelFolder *folder);
-static gint vee_get_unread_message_count (CamelFolder *folder);
static CamelMimeMessage *vee_get_message (CamelFolder *folder, const gchar *uid, CamelException *ex);
-static const CamelMessageInfo *vee_get_message_info (CamelFolder *folder, const char *uid);
static GPtrArray *vee_search_by_expression(CamelFolder *folder, const char *expression, CamelException *ex);
-static guint32 vee_get_message_flags (CamelFolder *folder, const char *uid);
static void vee_set_message_flags (CamelFolder *folder, const char *uid, guint32 flags, guint32 set);
-static gboolean vee_get_message_user_flag (CamelFolder *folder, const char *uid, const char *name);
static void vee_set_message_user_flag (CamelFolder *folder, const char *uid, const char *name, gboolean value);
-
static void camel_vee_folder_class_init (CamelVeeFolderClass *klass);
static void camel_vee_folder_init (CamelVeeFolder *obj);
static void camel_vee_folder_finalise (CamelObject *obj);
+static void folder_changed(CamelFolder *sub, gpointer type, CamelVeeFolder *vf);
+static void message_changed(CamelFolder *f, const char *uid, CamelVeeFolder *mf);
+
static void vee_folder_build(CamelVeeFolder *vf, CamelException *ex);
static void vee_folder_build_folder(CamelVeeFolder *vf, CamelFolder *source, CamelException *ex);
camel_vee_folder_parent = CAMEL_FOLDER_CLASS(camel_type_get_global_classfuncs (camel_folder_get_type ()));
folder_class->sync = vee_sync;
+ folder_class->expunge = vee_expunge;
- folder_class->get_uids = vee_get_uids;
- folder_class->free_uids = camel_folder_free_deep;
- folder_class->get_summary = vee_get_summary;
- folder_class->free_summary = camel_folder_free_nop;
folder_class->get_message = vee_get_message;
- folder_class->get_message_info = vee_get_message_info;
-
- folder_class->get_message_count = vee_get_message_count;
- folder_class->get_unread_message_count = vee_get_unread_message_count;
folder_class->search_by_expression = vee_search_by_expression;
- folder_class->get_message_flags = vee_get_message_flags;
folder_class->set_message_flags = vee_set_message_flags;
- folder_class->get_message_user_flag = vee_get_message_user_flag;
folder_class->set_message_user_flag = vee_set_message_user_flag;
}
node = p->folders;
while (node) {
CamelFolder *f = node->data;
+ camel_object_unhook_event ((CamelObject *)f, "folder_changed", (CamelObjectEventHookFunc) folder_changed, vf);
+ camel_object_unhook_event ((CamelObject *)f, "message_changed", (CamelObjectEventHookFunc) message_changed, vf);
camel_object_unref((CamelObject *)f);
node = g_list_next(node);
}
+ g_free(vf->expression);
+ g_free(vf->vname);
+
camel_folder_change_info_free(vf->changes);
#ifdef DYNAMIC
camel_object_unref((CamelObject *)vf->search);
*searchpart++ = 0;
}
- vf->messages = g_ptr_array_new();
- vf->messages_uid = g_hash_table_new(g_str_hash, g_str_equal);
+ folder->summary = camel_folder_summary_new();
+ folder->summary->message_info_size = sizeof(CamelVeeMessageInfo);
vf->expression = g_strdup(searchpart);
vf->vname = namepart;
return folder;
}
+static CamelVeeMessageInfo *
+vee_folder_add(CamelVeeFolder *vf, CamelFolder *f, CamelMessageInfo *info)
+{
+ CamelVeeMessageInfo *mi;
+ char *uid;
+ CamelFolder *folder = (CamelFolder *)vf;
+
+ mi = (CamelVeeMessageInfo *)camel_folder_summary_info_new(folder->summary);
+ camel_message_info_dup_to(info, (CamelMessageInfo *)mi);
+ uid = g_strdup_printf("%p:%s", f, camel_message_info_uid(info));
+#ifdef DOESTRV
+ mi->info.strings = e_strv_set_ref_free(mi->info.strings, CAMEL_MESSAGE_INFO_UID, uid);
+ mi->info.strings = e_strv_pack(mi->info.strings);
+#else
+ g_free(mi->info.uid);
+ mi->info.uid = uid;
+#endif
+ mi->folder = f;
+ camel_folder_summary_add(folder->summary, (CamelMessageInfo *)mi);
+
+ return mi;
+}
+
+static CamelVeeMessageInfo *
+vee_folder_add_uid(CamelVeeFolder *vf, CamelFolder *f, const char *inuid)
+{
+ CamelMessageInfo *info;
+ CamelVeeMessageInfo *mi = NULL;
+
+ info = camel_folder_get_message_info(f, inuid);
+ if (info) {
+ mi = vee_folder_add(vf, f, info);
+ camel_folder_free_message_info(f, info);
+ }
+ return mi;
+}
+
#ifdef DYNAMIC
static void
vfolder_remove_match(CamelVeeFolder *vf, CamelVeeMessageInfo *vinfo)
printf("removing match %s\n", uid);
- g_hash_table_remove(vf->messages_uid, uid);
- g_ptr_array_remove_fast(vf->messages, vinfo);
+ camel_folder_summary_remove(((CamelFolder *)vf)->summary, (CamelMessageInfo *)vinfo);
camel_folder_change_info_remove_uid(vf->changes, uid);
- camel_message_info_free((CamelMessageInfo *)vinfo);
}
static CamelVeeMessageInfo *
-vfolder_add_match(CamelVeeFolder *vf, CamelFolder *f, const CamelMessageInfo *info)
+vee_folder_add_change(CamelVeeFolder *vf, CamelFolder *f, CamelMessageInfo *info)
{
- CamelVeeMessageInfo *mi;
- char *uid;
+ CamelVeeMessageInfo *mi = NULL;
- mi = g_malloc0(sizeof(*mi));
- camel_message_info_dup_to(info, (CamelMessageInfo*)mi);
- uid = g_strdup_printf("%p:%s", f, camel_message_info_uid(info));
-#ifdef DOESTRV
- mi->info.strings = e_strv_set_ref_free(mi->info.strings, CAMEL_MESSAGE_INFO_UID, uid);
- mi->info.strings = e_strv_pack(mi->info.strings);
-#else
- g_free (mi->info.uid);
- mi->info.uid = uid;
-#endif
- mi->folder = f;
- g_ptr_array_add(vf->messages, mi);
- uid = (char *)camel_message_info_uid(mi);
- g_hash_table_insert(vf->messages_uid, uid, mi);
-
- printf("adding match %s\n", uid);
-
- camel_folder_change_info_add_uid(vf->changes, uid);
+ mi = vee_folder_add(vf, f, info);
+ camel_folder_change_info_add_uid(vf->changes, camel_message_info_uid(mi));
+
return mi;
}
+
#endif
static void
CamelFlag *flag;
CamelTag *tag;
- printf("changing match %s\n", camel_message_info_uid(vinfo));
+ d(printf("changing match %s\n", camel_message_info_uid(vinfo)));
vinfo->info.flags = info->flags;
camel_flag_list_free(&vinfo->info.user_flags);
camel_folder_change_info_change_uid(vf->changes, camel_message_info_uid(vinfo));
}
+/* FIXME: This code is a big race, as it is never called locked ... */
+
static void
folder_changed(CamelFolder *sub, gpointer type, CamelVeeFolder *vf)
{
#ifdef DYNAMIC
CamelFolderChangeInfo *changes = type;
+ CamelFolder *folder = (CamelFolder *)vf;
/* assume its faster to search a long list in whole, than by part */
if (changes && (changes->uid_added->len + changes->uid_changed->len) < 500) {
char *vuid;
CamelVeeMessageInfo *vinfo;
gboolean match;
- const CamelMessageInfo *info;
+ CamelMessageInfo *info;
ex = camel_exception_new();
+ /* FIXME: We dont search body contents with this search, so, it isn't as
+ useful as it might be.
+ We shold probably just perform a whole search if we need to, i.e. there
+ are added items. Changed items we are unlikely to want to remove immediately
+ anyway, although I guess it might be useful.
+ Removed items can always just be removed.
+ */
+
/* see if added ones now match us */
for (i=0;i<changes->uid_added->len;i++) {
info = camel_folder_get_message_info(sub, changes->uid_added->pdata[i]);
camel_folder_search_set_folder(vf->search, sub);
match = camel_folder_search_match_expression(vf->search, vf->expression, info, ex);
if (match)
- vinfo = vfolder_add_match(vf, sub, info);
+ vinfo = vee_folder_add_change(vf, sub, info);
+ camel_folder_free_message_info(sub, info);
}
}
for (i=0;i<changes->uid_changed->len;i++) {
info = camel_folder_get_message_info(sub, changes->uid_changed->pdata[i]);
vuid = g_strdup_printf("%p:%s", sub, (char *)changes->uid_changed->pdata[i]);
- vinfo = (CamelVeeMessageInfo *)vee_get_message_info((CamelFolder *)vf, vuid);
+ vinfo = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, vuid);
if (info) {
camel_folder_search_set_folder(vf->search, sub);
+#if 0
match = camel_folder_search_match_expression(vf->search, vf->expression, info, ex);
+#endif
if (vinfo) {
- if (match)
- vfolder_change_match(vf, vinfo, info);
- else
+#if 0
+ if (!match)
vfolder_remove_match(vf, vinfo);
- } else if (match)
- vfolder_add_match(vf, sub, info);
+ else
+#endif
+ vfolder_change_match(vf, vinfo, info);
+ }
+#if 0
+ else if (match)
+ vee_folder_add_change(vf, sub, info);
+#endif
+ camel_folder_free_message_info(sub, info);
} else if (vinfo)
vfolder_remove_match(vf, vinfo);
+ if (vinfo)
+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);
+
g_free(vuid);
}
/* mirror removes directly, if they used to match */
for (i=0;i<changes->uid_removed->len;i++) {
vuid = g_strdup_printf("%p:%s", sub, (char *)changes->uid_removed->pdata[i]);
- vinfo = (CamelVeeMessageInfo *)vee_get_message_info((CamelFolder *)vf, vuid);
- if (vinfo)
+ vinfo = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, vuid);
+ if (vinfo) {
vfolder_remove_match(vf, vinfo);
+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);
+ }
g_free(vuid);
}
} else {
}
}
+/* FIXME: This code is a race, as it is never called locked */
+
/* track flag changes in the summary */
static void
message_changed(CamelFolder *f, const char *uid, CamelVeeFolder *mf)
{
- const CamelMessageInfo *info;
+ CamelMessageInfo *info;
CamelVeeMessageInfo *vinfo;
char *vuid;
+ CamelFolder *folder = (CamelFolder *)mf;
#ifdef DYNAMIC
- gboolean match;
+ /*gboolean match;*/
CamelException *ex;
#endif
info = camel_folder_get_message_info(f, uid);
vuid = g_strdup_printf("%p:%s", f, uid);
- vinfo = (CamelVeeMessageInfo *)vee_get_message_info((CamelFolder *)mf, vuid);
+ vinfo = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, vuid);
/* see if this message now matches/doesn't match anymore */
#ifdef DYNAMIC
camel_folder_search_set_folder(mf->search, f);
ex = camel_exception_new();
+#if 0
match = camel_folder_search_match_expression(mf->search, mf->expression, info, ex);
+#endif
camel_exception_free(ex);
if (info) {
if (vinfo) {
- if (match)
- vfolder_change_match(mf, vinfo, info);
- else
+#if 0
+ if (!match)
vfolder_remove_match(mf, vinfo);
- } else if (match)
- vfolder_add_match(mf, f, info);
+ else
+#endif
+ vfolder_change_match(mf, vinfo, info);
+ }
+#if 0
+ else if (match)
+ vee_folder_add_change(mf, f, info);
+#endif
} else if (vinfo)
vfolder_remove_match(mf, vinfo);
#else
vfolder_change_match(mf, vinfo, info);
#endif
+ if (info)
+ camel_folder_free_message_info(f, info);
+ if (vinfo)
+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)vinfo);
+
/* cascade up, if required. This could probably be delayed,
but doesn't matter really, that is what freeze is for. */
if (camel_folder_change_info_changed(mf->changes)) {
}
-
static void
vee_sync (CamelFolder *folder, gboolean expunge, CamelException *ex)
{
- ;
-}
-
-static gint vee_get_message_count (CamelFolder *folder)
-{
CamelVeeFolder *vf = (CamelVeeFolder *)folder;
+ struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
+ GList *node;
- return vf->messages->len;
-}
-
-static gint
-vee_get_unread_message_count (CamelFolder *folder)
-{
- CamelVeeFolder *vee_folder = CAMEL_VEE_FOLDER (folder);
- CamelMessageInfo *info;
- GPtrArray *infolist;
- gint i, count = 0;
-
- g_return_val_if_fail (folder != NULL, -1);
+ node = p->folders;
+ while (node) {
+ CamelFolder *f = node->data;
- infolist = vee_folder->messages;
-
- for (i = 0; i < infolist->len; i++) {
- info = (CamelMessageInfo *) g_ptr_array_index (infolist, i);
- if (!(info->flags & CAMEL_MESSAGE_SEEN))
- count++;
+ camel_folder_sync(f, expunge, ex);
+ node = node->next;
}
-
- return count;
}
-static gboolean
-get_real_message(CamelFolder *folder, const char *uid, CamelFolder **out_folder, const char **out_uid)
+static void
+vee_expunge (CamelFolder *folder, CamelException *ex)
{
- CamelVeeMessageInfo *mi;
+ CamelVeeFolder *vf = (CamelVeeFolder *)folder;
+ struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
+ GList *node;
- mi = (CamelVeeMessageInfo *)vee_get_message_info(folder, uid);
- g_return_val_if_fail(mi != NULL, FALSE);
+ node = p->folders;
+ while (node) {
+ CamelFolder *f = node->data;
- *out_folder = mi->folder;
- *out_uid = strchr(camel_message_info_uid(mi), ':')+1;
- return TRUE;
+ camel_folder_expunge(f, ex);
+ node = node->next;
+ }
}
static CamelMimeMessage *vee_get_message(CamelFolder *folder, const gchar *uid, CamelException *ex)
{
- const char *real_uid;
- CamelFolder *real_folder;
+ CamelVeeMessageInfo *mi;
+ CamelMimeMessage *msg = NULL;
- if (!get_real_message(folder, uid, &real_folder, &real_uid)) {
+ mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
+ if (mi == NULL)
camel_exception_setv(ex, CAMEL_EXCEPTION_FOLDER_INVALID_UID,
"No such message %s in %s", uid,
folder->name);
- return NULL;
- }
-
- return camel_folder_get_message (real_folder, real_uid, ex);
-}
-
-GPtrArray *vee_get_summary(CamelFolder *folder)
-{
- CamelVeeFolder *vf = (CamelVeeFolder *)folder;
+ else
+ msg = camel_folder_get_message(mi->folder, strchr(camel_message_info_uid(mi), ':') + 1, ex);
+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
- return vf->messages;
-}
-
-static const CamelMessageInfo *vee_get_message_info(CamelFolder *f, const char *uid)
-{
- CamelVeeFolder *vf = (CamelVeeFolder *)f;
-
- return g_hash_table_lookup(vf->messages_uid, uid);
-}
-
-static GPtrArray *vee_get_uids (CamelFolder *folder)
-{
- GPtrArray *result;
- int i;
- CamelVeeFolder *vf = (CamelVeeFolder *)folder;
-
- result = g_ptr_array_new ();
- g_ptr_array_set_size (result, vf->messages->len);
- for (i=0;i<vf->messages->len;i++) {
- CamelMessageInfo *mi = g_ptr_array_index(vf->messages, i);
- result->pdata[i] = g_strdup(camel_message_info_uid(mi));
- }
-
- return result;
+ return msg;
}
static GPtrArray *
return result;
}
-static guint32
-vee_get_message_flags(CamelFolder *folder, const char *uid)
-{
- const char *real_uid;
- CamelFolder *real_folder;
-
- if (!get_real_message (folder, uid, &real_folder, &real_uid))
- return 0;
-
- return camel_folder_get_message_flags(real_folder, real_uid);
-}
-
static void
vee_set_message_flags(CamelFolder *folder, const char *uid, guint32 flags, guint32 set)
{
- const char *real_uid;
- CamelFolder *real_folder;
-
- if (!get_real_message(folder, uid, &real_folder, &real_uid))
- return;
-
- camel_folder_set_message_flags(real_folder, real_uid, flags, set);
-}
-
-static gboolean
-vee_get_message_user_flag(CamelFolder *folder, const char *uid, const char *name)
-{
- const char *real_uid;
- CamelFolder *real_folder;
-
- if (!get_real_message(folder, uid, &real_folder, &real_uid))
- return FALSE;
+ CamelVeeMessageInfo *mi;
- return camel_folder_get_message_user_flag(real_folder, real_uid, name);
+ mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
+ if (mi) {
+ ((CamelFolderClass *)camel_vee_folder_parent)->set_message_flags(folder, uid, flags, set);
+ camel_folder_set_message_flags(mi->folder, strchr(camel_message_info_uid(mi), ':') + 1, flags, set);
+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
+ }
}
static void
vee_set_message_user_flag(CamelFolder *folder, const char *uid, const char *name, gboolean value)
{
- const char *real_uid;
- CamelFolder *real_folder;
-
- if (!get_real_message(folder, uid, &real_folder, &real_uid))
- return;
+ CamelVeeMessageInfo *mi;
- return camel_folder_set_message_user_flag(real_folder, real_uid, name, value);
+ mi = (CamelVeeMessageInfo *)camel_folder_summary_uid(folder->summary, uid);
+ if (mi) {
+ ((CamelFolderClass *)camel_vee_folder_parent)->set_message_user_flag(folder, uid, name, value);
+ camel_folder_set_message_user_flag(mi->folder, strchr(camel_message_info_uid(mi), ':') + 1, name, value);
+ camel_folder_summary_info_free(folder->summary, (CamelMessageInfo *)mi);
+ }
}
-
/*
need incremental update, based on folder.
Need to watch folders for changes and update accordingly.
static void
vee_folder_build(CamelVeeFolder *vf, CamelException *ex)
{
+ CamelFolder *folder = (CamelFolder *)vf;
struct _CamelVeeFolderPrivate *p = _PRIVATE(vf);
GList *node;
- int i;
- GPtrArray *messages;
- GHashTable *messages_uid;
- for (i=0;i<vf->messages->len;i++) {
- CamelMessageInfo *mi = g_ptr_array_index(vf->messages, i);
- camel_message_info_free(mi);
- }
-
- messages = g_ptr_array_new();
- messages_uid = g_hash_table_new(g_str_hash, g_str_equal);
-
- g_ptr_array_free(vf->messages, TRUE);
- vf->messages = messages;
- g_hash_table_destroy(vf->messages_uid);
- vf->messages_uid = messages_uid;
+ camel_folder_summary_clear(folder->summary);
node = p->folders;
while (node) {
GPtrArray *matches;
CamelFolder *f = node->data;
- CamelVeeMessageInfo *mi;
- const CamelMessageInfo *info;
int i;
matches = camel_folder_search_by_expression(f, vf->expression, ex);
- for (i = 0; i < matches->len; i++) {
- info = camel_folder_get_message_info(f, matches->pdata[i]);
- if (info) {
- char *uid;
+ for (i = 0; i < matches->len; i++)
+ vee_folder_add_uid(vf, f, matches->pdata[i]);
- mi = g_malloc0(sizeof(*mi));
- camel_message_info_dup_to(info, (CamelMessageInfo *)mi);
- uid = g_strdup_printf("%p:%s", f, camel_message_info_uid(info));
-#ifdef DOESTRV
- mi->info.strings = e_strv_set_ref_free(mi->info.strings, CAMEL_MESSAGE_INFO_UID, uid);
- mi->info.strings = e_strv_pack(mi->info.strings);
-#else
- g_free(mi->info.uid);
- mi->info.uid = uid;
-#endif
- mi->folder = f;
- g_ptr_array_add(messages, mi);
- g_hash_table_insert(messages_uid, (char *)camel_message_info_uid(mi), mi);
- }
- }
camel_folder_search_free(f, matches);
node = g_list_next(node);
}
GPtrArray *matches;
CamelFolder *f = source;
CamelVeeMessageInfo *mi;
- const CamelMessageInfo *info;
-
- GPtrArray *messages;
- GHashTable *messages_uid;
+ CamelFolder *folder = (CamelFolder *)vf;
int i;
+ int count;
- for (i=0;i<vf->messages->len;i++) {
- CamelVeeMessageInfo *mi = g_ptr_array_index(vf->messages, i);
- if (mi->folder == source) {
+ count = camel_folder_summary_count(folder->summary);
+ for (i=0;i<count;i++) {
+ CamelVeeMessageInfo *mi = (CamelVeeMessageInfo *)camel_folder_summary_index(folder->summary, i);
+ if (mi && mi->folder == source) {
const char *uid = camel_message_info_uid(mi);
camel_folder_change_info_add_source(vf->changes, uid);
- g_hash_table_remove(vf->messages_uid, uid);
- g_ptr_array_remove_index_fast(vf->messages, i);
-
- camel_message_info_free((CamelMessageInfo *)mi);
+ camel_folder_summary_remove(folder->summary, (CamelMessageInfo *)mi);
i--;
}
+ camel_message_info_free((CamelMessageInfo *)mi);
}
- messages = vf->messages;
- messages_uid = vf->messages_uid;
-
matches = camel_folder_search_by_expression(f, vf->expression, ex);
for (i = 0; i < matches->len; i++) {
- info = camel_folder_get_message_info(f, matches->pdata[i]);
- if (info) {
- char *uid;
-
- mi = g_malloc0(sizeof(*mi));
- camel_message_info_dup_to(info, (CamelMessageInfo*)mi);
- uid = g_strdup_printf("%p:%s", f, camel_message_info_uid(info));
-#ifdef DOESTRV
- mi->info.strings = e_strv_set_ref_free(mi->info.strings, CAMEL_MESSAGE_INFO_UID, uid);
- mi->info.strings = e_strv_pack(mi->info.strings);
-#else
- g_free (mi->info.uid);
- mi->info.uid = uid;
-#endif
- mi->folder = f;
- g_ptr_array_add(messages, mi);
- uid = (char *)camel_message_info_uid(mi);
- g_hash_table_insert(messages_uid, uid, mi);
- camel_folder_change_info_add_update(vf->changes, uid);
- }
+ mi = vee_folder_add_uid(vf, f, matches->pdata[i]);
+ if (mi)
+ camel_folder_change_info_add_update(vf->changes, camel_message_info_uid(mi));
}
camel_folder_search_free(f, matches);
char *vname; /* local name */
CamelFolder *local; /* local storage for folder */
- /* FIXME: Move this to a summary object??? */
- GPtrArray *messages; /* message info's */
- GHashTable *messages_uid;
CamelFolderChangeInfo *changes;
#ifdef DYNAMIC
CamelFolderSearch *search;
check_PROGRAMS = \
test1 test4 test5 \
test2 test6 test7 \
- test3
+ test3 \
+ test8
TESTS = test1 test4 test5 \
test2 test6 test7 \
- test3
+ test3 \
+ test8
test6 basic folder operations, IMAP
test7 basic folder operations, NNTP
+test8 multithreaded folder torture test, local
+
--- /dev/null
+/* threaded folder testing */
+
+#include "camel-test.h"
+#include "folders.h"
+#include "messages.h"
+
+#include <camel/camel-exception.h>
+#include <camel/camel-service.h>
+#include <camel/camel-session.h>
+#include <camel/camel-store.h>
+
+#define MAX_MESSAGES (100)
+#define MAX_THREADS (10)
+
+#define d(x)
+
+#ifndef ENABLE_THREADS
+int main(int argc, char **argv)
+{
+ printf("Test %s is only compiled with threads enabled\n", argv[0]);
+ return 77;
+}
+#else
+
+#include <pthread.h>
+
+/* god, who designed this horrid interface */
+static char *auth_callback(CamelAuthCallbackMode mode,
+ char *data, gboolean secret,
+ CamelService *service, char *item,
+ CamelException *ex)
+{
+ return NULL;
+}
+
+#define ARRAY_LEN(x) (sizeof(x)/sizeof(x[0]))
+
+static char *local_providers[] = {
+ "mbox",
+ "mh",
+ "maildir"
+};
+
+static void
+test_add_message(CamelFolder *folder, int j)
+{
+ CamelMimeMessage *msg;
+ char *content;
+ char *subject;
+ CamelException ex;
+
+ camel_exception_init(&ex);
+
+ push("creating message %d\n", j);
+ msg = test_message_create_simple();
+ content = g_strdup_printf("Test message %d contents\n\n", j);
+ test_message_set_content_simple((CamelMimePart *)msg, 0, "text/plain",
+ content, strlen(content));
+ test_free(content);
+ subject = g_strdup_printf("Test message %d subject", j);
+ camel_mime_message_set_subject(msg, subject);
+ pull();
+
+ push("appending simple message %d", j);
+ camel_folder_append_message(folder, msg, NULL, &ex);
+ check_msg(!camel_exception_is_set(&ex), "%s", camel_exception_get_description(&ex));
+ pull();
+
+ check_unref(msg, 1);
+}
+
+struct _threadinfo {
+ int id;
+ CamelFolder *folder;
+};
+
+static void *
+worker(void *d)
+{
+ struct _threadinfo *info = d;
+ int i, j, id = info->id;
+ char *sub, *content;
+ GPtrArray *res;
+ CamelException *ex = camel_exception_new();
+ CamelMimeMessage *msg;
+
+ /* we add a message, search for it, twiddle some flags, delete it */
+ /* and flat out */
+ for (i=0;i<MAX_MESSAGES;i++) {
+ d(printf("Thread %ld message %i\n", pthread_self(), i));
+ test_add_message(info->folder, id+i);
+
+ sub = g_strdup_printf("(match-all (header-contains \"subject\" \"message %d subject\"))", id+i);
+
+ push("searching for message %d\n\tusing: %s", id+i, sub);
+ res = camel_folder_search_by_expression(info->folder, sub, ex);
+ check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
+ check_msg(res->len == 1, "res->len = %d", res->len);
+ pull();
+
+ push("getting message '%s'", res->pdata[0]);
+ msg = camel_folder_get_message(info->folder, (char *)res->pdata[0], ex);
+ check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
+ pull();
+
+ push("comparing content");
+ content = g_strdup_printf("Test message %d contents\n\n", id+i);
+ test_message_compare_content(camel_medium_get_content_object((CamelMedium *)msg), content, strlen(content));
+ test_free(content);
+
+ push("deleting message, cleanup");
+ j=(100.0*rand()/(RAND_MAX+1.0));
+ if (j<=70) {
+ camel_folder_delete_message(info->folder, res->pdata[0]);
+ }
+
+ camel_folder_search_free(info->folder, res);
+ res = NULL;
+ test_free(sub);
+
+ check_unref(msg, 1);
+ pull();
+
+ /* about 1-in 100 calls will expunge */
+ j=(200.0*rand()/(RAND_MAX+1.0));
+ if (j<=2) {
+ d(printf("Forcing an expuge\n"));
+ push("expunging folder");
+ camel_folder_expunge(info->folder, ex);
+ check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
+ pull();
+ }
+ }
+
+ camel_exception_free(ex);
+
+ return info;
+}
+
+int main(int argc, char **argv)
+{
+ CamelSession *session;
+ CamelException *ex;
+ int i, j, index;
+ char *path;
+ CamelStore *store;
+ pthread_t threads[MAX_THREADS];
+ struct _threadinfo *info;
+ CamelFolder *folder;
+ GPtrArray *uids;
+
+ camel_test_init(argc, argv);
+
+ ex = camel_exception_new();
+
+ /* clear out any camel-test data */
+ system("/bin/rm -rf /tmp/camel-test");
+
+ session = camel_session_new("/tmp/camel-test", auth_callback, NULL, NULL);
+
+ for (j=0;j<ARRAY_LEN(local_providers);j++) {
+ for (index=0;index<2;index++) {
+ path = g_strdup_printf("method %s %s", local_providers[j], index?"indexed":"nonindexed");
+ camel_test_start(path);
+ test_free(path);
+
+ push("trying %s index %d", local_providers[j], index);
+ path = g_strdup_printf("%s:///tmp/camel-test/%s", local_providers[j], local_providers[j]);
+ store = camel_session_get_store(session, path, ex);
+ check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
+ test_free(path);
+
+ if (index == 0)
+ folder = camel_store_get_folder(store, "testbox", CAMEL_STORE_FOLDER_CREATE, ex);
+ else
+ folder = camel_store_get_folder(store, "testbox",
+ CAMEL_STORE_FOLDER_CREATE|CAMEL_STORE_FOLDER_BODY_INDEX, ex);
+ check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
+
+ for (i=0;i<MAX_THREADS;i++) {
+ info = g_malloc(sizeof(*info));
+ info->id = i*MAX_MESSAGES;
+ info->folder = folder;
+ pthread_create(&threads[i], 0, worker, info);
+ }
+
+ for (i=0;i<MAX_THREADS;i++) {
+ pthread_join(threads[i], (void **)&info);
+ g_free(info);
+ }
+ pull();
+
+ push("deleting remaining messages");
+ uids = camel_folder_get_uids(folder);
+ for (i=0;i<uids->len;i++) {
+ camel_folder_delete_message(folder, uids->pdata[i]);
+ }
+ camel_folder_free_uids(folder, uids);
+
+ camel_folder_expunge(folder, ex);
+ check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
+
+ check_unref(folder, 1);
+
+ camel_store_delete_folder(store, "testbox", ex);
+ check_msg(!camel_exception_is_set(ex), "%s", camel_exception_get_description(ex));
+
+ check_unref(store, 1);
+
+ pull();
+
+ camel_test_end();
+ }
+ }
+
+ camel_object_unref((CamelObject *)session);
+ camel_exception_free(ex);
+
+ return 0;
+}
+
+#endif /* ENABLE_THREADS */
#include <stdio.h>
#include <signal.h>
+#ifdef ENABLE_THREADS
+#include <pthread.h>
+#endif
+
+#ifdef ENABLE_THREADS
+/* well i dunno, doesn't seem to be in the headers but hte manpage mentions it */
+/* a nonportable checking mutex for glibc, not really needed, just validates
+ the test harness really */
+# ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
+static pthread_mutex_t lock = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
+# else
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+# endif
+#define CAMEL_TEST_LOCK pthread_mutex_lock(&lock)
+#define CAMEL_TEST_UNLOCK pthread_mutex_unlock(&lock)
+#define CAMEL_TEST_ID (pthread_self())
+#else
+#define CAMEL_TEST_LOCK
+#define CAMEL_TEST_UNLOCK
+#define CAMEL_TEST_ID (0)
+#endif
+
+static int setup;
+static int ok;
+
struct _stack {
struct _stack *next;
+ int fatal;
char *what;
};
-static int setup;
-static struct _stack *state;
-static struct _stack *nonfatal;
-static int ok;
+/* per-thread state */
+struct _state {
+ char *test;
+ int nonfatal;
+ struct _stack *state;
+};
+
+static GHashTable *info_table;
int camel_test_verbose;
+static void
+dump_action(int id, struct _state *s, void *d)
+{
+ struct _stack *node;
+
+#ifdef ENABLE_THREADS
+ printf("\nThread %d:\n", id);
+#endif
+ node = s->state;
+ if (node) {
+ printf("Current action:\n");
+ while (node) {
+ printf("\t%s%s\n", node->fatal?"":"[nonfatal]", node->what);
+ node = node->next;
+ }
+ }
+ printf("\tTest: %s\n", s->test);
+}
+
static void die(int sig)
{
static int indie = 0;
- struct _stack *node;
if (!indie) {
indie = 1;
printf("\n\nReceived fatal signal %d\n", sig);
- node = state;
- if (node) {
- printf("Current action:\n");
- while (node) {
- printf("\t%s\n", node->what);
- node = node->next;
- }
- }
+ g_hash_table_foreach(info_table, (GHFunc)dump_action, 0);
}
_exit(1);
}
+static struct _state *
+current_state(void)
+{
+ struct _state *info;
+
+ if (info_table == NULL)
+ info_table = g_hash_table_new(0, 0);
+
+ info = g_hash_table_lookup(info_table, (void *)CAMEL_TEST_ID);
+ if (info == NULL) {
+ info = g_malloc0(sizeof(*info));
+ g_hash_table_insert(info_table, (void *)CAMEL_TEST_ID, info);
+ }
+ return info;
+}
+
+
void camel_test_init(int argc, char **argv)
{
void camel_init(void);
setup = 1;
+#ifndef ENABLE_THREADS
camel_init();
+#endif
+
+ info_table = g_hash_table_new(0, 0);
/* yeah, we do need ot thread init, even though camel isn't compiled with enable threads */
g_thread_init(NULL);
void camel_test_start(const char *what)
{
+ struct _state *s;
+
+ CAMEL_TEST_LOCK;
+
+ s = current_state();
+
if (!setup)
camel_test_init(0, 0);
ok = 1;
+ s->test = g_strdup(what);
+
if (camel_test_verbose > 0) {
printf("Test: %s ... ", what);
fflush(stdout);
}
+
+ CAMEL_TEST_UNLOCK;
}
void camel_test_push(const char *what, ...)
struct _stack *node;
va_list ap;
char *text;
+ struct _state *s;
+
+ CAMEL_TEST_LOCK;
+
+ s = current_state();
va_start(ap, what);
text = g_strdup_vprintf(what, ap);
node = g_malloc(sizeof(*node));
node->what = text;
- node->next = state;
- state = node;
+ node->next = s->state;
+ node->fatal = 1;
+ s->state = node;
+
+ CAMEL_TEST_UNLOCK;
}
void camel_test_pull(void)
{
struct _stack *node;
+ struct _state *s;
- g_assert(state);
+ CAMEL_TEST_LOCK;
+
+ s = current_state();
+
+ g_assert(s->state);
if (camel_test_verbose > 3)
- printf("Finish step: %s\n", state->what);
+ printf("Finish step: %s\n", s->state->what);
- node = state;
- state = node->next;
+ node = s->state;
+ s->state = node->next;
+ if (!node->fatal)
+ s->nonfatal--;
g_free(node->what);
g_free(node);
+
+ CAMEL_TEST_UNLOCK;
}
/* where to set breakpoints */
+void camel_test_break(void);
+
void camel_test_break(void)
{
}
va_end(ap);
}
+
void camel_test_failv(const char *why, va_list ap)
{
- struct _stack *node;
char *text;
+ struct _state *s;
+
+ CAMEL_TEST_LOCK;
+
+ s = current_state();
text = g_strdup_vprintf(why, ap);
- if ((nonfatal == NULL && camel_test_verbose > 0)
- || (nonfatal && camel_test_verbose > 1)) {
+ if ((s->nonfatal == 0 && camel_test_verbose > 0)
+ || (s->nonfatal && camel_test_verbose > 1)) {
printf("Failed.\n%s\n", text);
camel_test_break();
}
g_free(text);
- if ((nonfatal == NULL && camel_test_verbose > 0)
- || (nonfatal && camel_test_verbose > 2)) {
- node = state;
- if (node) {
- printf("Current action:\n");
- while (node) {
- printf("\t%s\n", node->what);
- node = node->next;
- }
- }
+ if ((s->nonfatal == 0 && camel_test_verbose > 0)
+ || (s->nonfatal && camel_test_verbose > 2)) {
+ g_hash_table_foreach(info_table, (GHFunc)dump_action, 0);
}
- if (nonfatal == NULL) {
+ if (s->nonfatal == 0) {
exit(1);
} else {
ok=0;
if (camel_test_verbose > 1) {
- printf("Known problem (ignored): %s\n", nonfatal->what);
+ printf("Known problem (ignored):\n");
+ dump_action(CAMEL_TEST_ID, s, 0);
}
}
+
+ CAMEL_TEST_UNLOCK;
}
-void camel_test_nonfatal(const char *why, ...)
+void camel_test_nonfatal(const char *what, ...)
{
struct _stack *node;
va_list ap;
char *text;
+ struct _state *s;
- va_start(ap, why);
- text = g_strdup_vprintf(why, ap);
+ CAMEL_TEST_LOCK;
+
+ s = current_state();
+
+ va_start(ap, what);
+ text = g_strdup_vprintf(what, ap);
va_end(ap);
- if (camel_test_verbose>3)
+ if (camel_test_verbose > 3)
printf("Start nonfatal: %s\n", text);
node = g_malloc(sizeof(*node));
node->what = text;
- node->next = nonfatal;
- nonfatal = node;
+ node->next = s->state;
+ node->fatal = 0;
+ s->nonfatal++;
+ s->state = node;
+
+ CAMEL_TEST_UNLOCK;
}
void camel_test_fatal(void)
{
- struct _stack *node;
-
- g_assert(nonfatal);
-
- if (camel_test_verbose>3)
- printf("Finish nonfatal: %s\n", nonfatal->what);
-
- node = nonfatal;
- nonfatal = node->next;
- g_free(node->what);
- g_free(node);
+ camel_test_pull();
}
void camel_test_end(void)
{
GPtrArray *s;
int i, myunread;
- const CamelMessageInfo *info;
+ CamelMessageInfo *info;
push("test folder counts %d total %d unread", total, unread);
info = camel_folder_get_message_info(folder, s->pdata[i]);
if (info->flags & CAMEL_MESSAGE_SEEN)
myunread--;
+ camel_folder_free_message_info(folder, info);
}
check(unread == myunread);
camel_folder_free_uids(folder, s);
test_folder_message(CamelFolder *folder, const char *uid)
{
CamelMimeMessage *msg;
- const CamelMessageInfo *info;
+ CamelMessageInfo *info;
GPtrArray *s;
int i;
CamelException *ex = camel_exception_new();
info = camel_folder_get_message_info(folder, uid);
check(info != NULL);
check(strcmp(camel_message_info_uid(info), uid) == 0);
+ camel_folder_free_message_info(folder, info);
/* then, getting message */
msg = camel_folder_get_message(folder, uid, ex);
test_folder_not_message(CamelFolder *folder, const char *uid)
{
CamelMimeMessage *msg;
- const CamelMessageInfo *info;
+ CamelMessageInfo *info;
GPtrArray *s;
int i;
CamelException *ex = camel_exception_new();
int j;
int indexed, max;
GPtrArray *uids;
- const CamelMessageInfo *info;
+ CamelMessageInfo *info;
max=local?2:1;
check_msg(strcmp(camel_message_info_subject(info), subject)==0,
"info->subject %s", camel_message_info_subject(info));
camel_folder_free_uids(folder, uids);
+ camel_folder_free_message_info(folder, info);
pull();
test_free(subject);
check_msg(strcmp(camel_message_info_subject(info), subject)==0,
"info->subject %s", camel_message_info_subject(info));
test_free(subject);
+ camel_folder_free_message_info(folder, info);
pull();
}
check_msg(strcmp(camel_message_info_subject(info), subject)==0,
"info->subject %s", camel_message_info_subject(info));
test_free(subject);
+ camel_folder_free_message_info(folder, info);
pull();
}
pull();
check_msg(strcmp(camel_message_info_subject(info), subject)==0,
"info->subject %s", camel_message_info_subject(info));
test_free(subject);
+ camel_folder_free_message_info(folder, info);
pull();
}
pull();
projects / platform / upstream / evolution-data-server.git / commitdiff