[evolution-kolab] CamelImapxAcl: API / stubs rework

[Christian Hilberg <chilberg src gnome org>]

commit 0c161e120282dc0ef762874e1fde75d91a370646
Author: Christian Hilberg <hilberg kernelconcepts de>
Date:   Mon Oct 1 18:43:07 2012 +0200

    CamelImapxAcl: API / stubs rework
    
    * instead of plain strings for ACL, use datastructures here
      similar to CamelImapxMetadata
    * this (a) eases data handling and (b) makes the API and
      internal functions look more like those implemented in
      CamelImapxMetadata

 src/libekolab/camel-imapx-acl.c |  269 +++++++++++++++++++++++++++++++++------
 src/libekolab/camel-imapx-acl.h |   70 ++++++++---
 2 files changed, 284 insertions(+), 55 deletions(-)
---
diff --git a/src/libekolab/camel-imapx-acl.c b/src/libekolab/camel-imapx-acl.c
index 589b8de..04c0fe5 100644
--- a/src/libekolab/camel-imapx-acl.c
+++ b/src/libekolab/camel-imapx-acl.c
@@ -37,26 +37,119 @@
 
 /*----------------------------------------------------------------------------*/
 
+static gboolean
+imapx_acl_entry_validate_access_id (const gchar *access_id,
+                                    GError **err)
+{
+	g_return_val_if_fail (access_id != NULL, FALSE);
+	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
+
+	/* FIXME implement me */
+	g_warning ("%s[%u] FIXME implement me", __func__, __LINE__);
+
+	return TRUE;
+}
+
+static gboolean
+imapx_acl_entry_validate_rights (const gchar *rights,
+                                 GError **err)
+{
+	g_return_val_if_fail (rights != NULL, FALSE);
+	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
+
+	/* FIXME implement me */
+	g_warning ("%s[%u] FIXME implement me", __func__, __LINE__);
+
+	return TRUE;
+}
+
+static void
+imapx_acl_entry_gdestroy (gpointer data)
+{
+	CamelImapxAclEntry *entry = NULL;
+
+	if (data == NULL)
+		return;
+
+	entry = (CamelImapxAclEntry *) data;
+	camel_imapx_acl_entry_free (entry);
+}
 
 /*----------------------------------------------------------------------------*/
 
+CamelImapxAclEntry*
+camel_imapx_acl_entry_new (const gchar *access_id,
+                           const gchar *rights,
+                           GError **err)
+{
+	CamelImapxAclEntry *entry = NULL;
+	GError *tmp_err = NULL;
+	gboolean ok = FALSE;
+
+	g_return_val_if_fail (access_id != NULL, NULL);
+	/* rights may be NULL */
+	g_return_val_if_fail (err == NULL || *err == NULL, NULL);
+
+	ok = imapx_acl_entry_validate_access_id (access_id,
+	                                         &tmp_err);
+	if (! ok)
+		goto exit;
+
+	if (rights != NULL) {
+		ok = imapx_acl_entry_validate_rights (rights,
+		                                      &tmp_err);
+		if (! ok)
+			goto exit;
+	}
+
+	entry = g_new0 (CamelImapxAclEntry, 1);
+	entry->access_id = g_strdup (access_id);
+	entry->rights = g_strdup (rights);
+
+ exit:
+	if (tmp_err != NULL) {
+		g_propagate_error (err, tmp_err);
+		return NULL;
+	}
+
+	return entry;
+}
+
+void
+camel_imapx_acl_entry_free (CamelImapxAclEntry *entry)
+{
+	if (entry == NULL)
+		return;
+
+	if (entry->access_id != NULL)
+		g_free (entry->access_id);
+
+	if (entry->rights != NULL)
+		g_free (entry->rights);
+
+	g_free (entry);
+}
+
 CamelImapxAcl*
 camel_imapx_acl_new (gboolean locked)
 {
 	CamelImapxAcl *acl = g_new0 (CamelImapxAcl, 1);
-	g_mutex_init (&(acl->acl_lock));
+	g_mutex_init (&(acl->lock));
 
 	if (locked)
-		g_mutex_lock (&(acl->acl_lock));
+		g_mutex_lock (&(acl->lock));
 
+	/* foldername:myrights */
 	acl->myrights = g_hash_table_new_full (g_str_hash,
 	                                       g_str_equal,
 	                                       g_free,
 	                                       g_free);
+
+	/* foldername:access_id:rights */
 	acl->mboxes = g_hash_table_new_full (g_str_hash,
 	                                     g_str_equal,
 	                                     g_free,
-	                                     g_free);
+	                                     (GDestroyNotify) g_hash_table_destroy);
 	return acl;
 }
 
@@ -66,14 +159,16 @@ camel_imapx_acl_free (CamelImapxAcl *acl)
 	if (acl == NULL)
 		return;
 
-	if (acl->myrights)
+	while (! g_mutex_trylock (&(acl->lock)));
+
+	if (acl->myrights != NULL)
 		g_hash_table_destroy (acl->myrights);
-	if (acl->mboxes)
+
+	if (acl->mboxes != NULL)
 		g_hash_table_destroy (acl->mboxes);
 
-	while (! g_mutex_trylock (&(acl->acl_lock)));
-	g_mutex_unlock (&(acl->acl_lock));
-	g_mutex_clear (&(acl->acl_lock));
+	g_mutex_unlock (&(acl->lock));
+	g_mutex_clear (&(acl->lock));
 
 	g_free (acl);
 }
@@ -89,7 +184,7 @@ camel_imapx_acl_resect (CamelImapxAcl *acl)
 		return NULL;
 
 	/* (acquire acl lock) */
-	g_mutex_lock (&(acl->acl_lock));
+	g_mutex_lock (&(acl->lock));
 
 	tmp_acl = camel_imapx_acl_new (FALSE);
 
@@ -103,82 +198,182 @@ camel_imapx_acl_resect (CamelImapxAcl *acl)
 	tmp_acl->mboxes = mboxes;
 
 	/* (release acl lock) */
-	g_mutex_unlock (&(acl->acl_lock));
+	g_mutex_unlock (&(acl->lock));
 
 	return tmp_acl;
 }
 
 gboolean
-camel_imapx_acl_add_acl_from_server_response (CamelImapxAcl *acl,
-                                              CamelIMAPXStream *is,
-                                              GCancellable *cancellable,
-                                              GError **err)
+camel_imapx_acl_validate (CamelImapxAcl *acl,
+                          GError **err)
 {
 	g_return_val_if_fail (acl != NULL, FALSE);
-	g_return_val_if_fail (CAMEL_IS_IMAPX_STREAM (is), FALSE);
-	(void)cancellable; /* FIXME */ /* cancellable may be NULL */
 	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
-	/* FIXME implement me */
+	/* (acquire acl lock) */
+	g_mutex_lock (&(acl->lock));
+
 	g_warning ("%s()[%u] FIXME implement me", __func__, __LINE__);
 
+	/* (release acl lock) */
+	g_mutex_unlock (&(acl->lock));
+
 	return TRUE;
 }
 
+GList*
+camel_imapx_acl_get_as_list (CamelImapxAcl *acl,
+                             const gchar *mbox_name)
+{
+	g_return_val_if_fail (acl != NULL, NULL);
+	g_return_val_if_fail (mbox_name != NULL, NULL);
+
+	/* (acquire acl lock) */
+	g_mutex_lock (&(acl->lock));
+
+	g_warning ("%s()[%u] FIXME implement me", __func__, __LINE__);
+
+	/* (release acl lock) */
+	g_mutex_unlock (&(acl->lock));
+
+	return NULL;
+}
+
+void
+camel_imapx_acl_free_list (GList *entries)
+{
+	if (entries == NULL)
+		return;
+
+	g_list_free_full (entries,
+	                  imapx_acl_entry_gdestroy);
+}
+
 gboolean
-camel_imapx_acl_add_myrights_from_server_response (CamelImapxAcl *acl,
-                                                   CamelIMAPXStream *is,
-                                                   GCancellable *cancellable,
-                                                   GError **err)
+camel_imapx_acl_update_acl (CamelImapxAcl *acl,
+                            const gchar *mbox_name,
+                            const GList *entries,
+                            GError **err)
 {
 	g_return_val_if_fail (acl != NULL, FALSE);
-	g_return_val_if_fail (CAMEL_IS_IMAPX_STREAM (is), FALSE);
-	(void)cancellable; /* FIXME */ /* cancellable may be NULL */
+	g_return_val_if_fail (mbox_name != NULL, FALSE);
+	/* entries may be NULL (used for deletion) */
 	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
-	/* FIXME implement me */
+	if (entries == NULL)
+		return TRUE;
+
+	/* (acquire acl lock) */
+	g_mutex_lock (&(acl->lock));
+
 	g_warning ("%s()[%u] FIXME implement me", __func__, __LINE__);
 
+	/* (release acl lock) */
+	g_mutex_unlock (&(acl->lock));
+
 	return TRUE;
 }
 
+gchar*
+camel_imapx_acl_get_myrights (CamelImapxAcl *acl,
+                              const gchar *mbox_name)
+{
+	g_return_val_if_fail (acl != NULL, FALSE);
+	g_return_val_if_fail (mbox_name != NULL, FALSE);
+
+	/* (acquire acl lock) */
+	g_mutex_lock (&(acl->lock));
+
+	g_warning ("%s()[%u] FIXME implement me", __func__, __LINE__);
+
+	/* (release acl lock) */
+	g_mutex_unlock (&(acl->lock));
+
+	return NULL;
+}
+
 gboolean
-camel_imapx_acl_remove_acl (CamelImapxAcl *acl,
-                            const gchar *mailbox_name)
+camel_imapx_acl_update_myrights (CamelImapxAcl *acl,
+                                 const gchar *mbox_name,
+                                 const gchar *rights,
+                                 GError **err)
 {
 	g_return_val_if_fail (acl != NULL, FALSE);
-	g_return_val_if_fail (mailbox_name != NULL, FALSE);
+	g_return_val_if_fail (mbox_name != NULL, FALSE);
+	/* rights may be NULL (used for deletion) */
+	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
+
+	/* (acquire acl lock) */
+	g_mutex_lock (&(acl->lock));
 
-	/* FIXME implement me */
 	g_warning ("%s()[%u] FIXME implement me", __func__, __LINE__);
 
+	/* (release acl lock) */
+	g_mutex_unlock (&(acl->lock));
+
 	return TRUE;
 }
 
 gboolean
-camel_imapx_acl_remove_myrights (CamelImapxAcl *acl,
-                                 const gchar *mailbox_name)
+camel_imapx_acl_update_acl_from_server_response (CamelImapxAcl *acl,
+                                                 CamelIMAPXStream *is,
+                                                 GCancellable *cancellable,
+                                                 GError **err)
 {
 	g_return_val_if_fail (acl != NULL, FALSE);
-	g_return_val_if_fail (mailbox_name != NULL, FALSE);
+	g_return_val_if_fail (CAMEL_IS_IMAPX_STREAM (is), FALSE);
+	/* cancellable may be NULL */
+	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
+
+	/* (acquire acl lock) */
+	g_mutex_lock (&(acl->lock));
 
-	/* FIXME implement me */
 	g_warning ("%s()[%u] FIXME implement me", __func__, __LINE__);
 
+	/* (release acl lock) */
+	g_mutex_unlock (&(acl->lock));
+
 	return TRUE;
 }
 
 gboolean
-camel_imapx_acl_validate_imapacl (const gchar *imapacl,
-                                  GError **err)
+camel_imapx_acl_update_myrights_from_server_response (CamelImapxAcl *acl,
+                                                      CamelIMAPXStream *is,
+                                                      GCancellable *cancellable,
+                                                      GError **err)
 {
-	/* imapacl may be NULL */
+	g_return_val_if_fail (acl != NULL, FALSE);
+	g_return_val_if_fail (CAMEL_IS_IMAPX_STREAM (is), FALSE);
+	/* cancellable may be NULL */
 	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
-	if (imapacl == NULL)
-		return TRUE;
+	/* (acquire acl lock) */
+	g_mutex_lock (&(acl->lock));
+
+	g_warning ("%s()[%u] FIXME implement me", __func__, __LINE__);
+
+	/* (release acl lock) */
+	g_mutex_unlock (&(acl->lock));
 
 	return TRUE;
 }
 
+GSList*
+camel_imapx_acl_new_commandlist (CamelImapxAcl *acl,
+                                 GError **err)
+{
+	g_return_val_if_fail (acl != NULL, NULL);
+	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
+
+	/* (acquire acl lock) */
+	g_mutex_lock (&(acl->lock));
+
+	g_warning ("%s()[%u] FIXME implement me", __func__, __LINE__);
+
+	/* (release acl lock) */
+	g_mutex_unlock (&(acl->lock));
+
+	return NULL;
+}
+
 /*----------------------------------------------------------------------------*/
diff --git a/src/libekolab/camel-imapx-acl.h b/src/libekolab/camel-imapx-acl.h
index 4dc4391..f43368c 100644
--- a/src/libekolab/camel-imapx-acl.h
+++ b/src/libekolab/camel-imapx-acl.h
@@ -41,14 +41,29 @@
 
 /*----------------------------------------------------------------------------*/
 
-typedef struct _CamelImapxAcl {
+typedef struct _CamelImapxAclEntry CamelImapxAclEntry;
+struct _CamelImapxAclEntry {
+	gchar *access_id;
+	gchar *rights;
+};
+
+typedef struct _CamelImapxAcl CamelImapxAcl;
+struct _CamelImapxAcl {
 	GHashTable *myrights; /* MYRIGHTS per folder */
 	GHashTable *mboxes;   /* ACL per folder      */
-	GMutex acl_lock;
-} CamelImapxAcl;
+	GMutex lock;
+};
 
 /*----------------------------------------------------------------------------*/
 
+CamelImapxAclEntry*
+camel_imapx_acl_entry_new (const gchar *access_id,
+                           const gchar *rights,
+                           GError **err);
+
+void
+camel_imapx_acl_entry_free (CamelImapxAclEntry *entry);
+
 CamelImapxAcl*
 camel_imapx_acl_new (gboolean locked);
 
@@ -59,27 +74,46 @@ CamelImapxAcl*
 camel_imapx_acl_resect (CamelImapxAcl *acl);
 
 gboolean
-camel_imapx_acl_add_acl_from_server_response (CamelImapxAcl *acl,
-                                              CamelIMAPXStream *is,
-                                              GCancellable *cancellable,
-                                              GError **err);
-gboolean
-camel_imapx_acl_add_myrights_from_server_response (CamelImapxAcl *acl,
-                                                   CamelIMAPXStream *is,
-                                                   GCancellable *cancellable,
-                                                   GError **err);
+camel_imapx_acl_validate (CamelImapxAcl *acl,
+                          GError **err);
+
+GList*
+camel_imapx_acl_get_as_list (CamelImapxAcl *acl,
+                             const gchar *mbox_name);
+
+void
+camel_imapx_acl_free_list (GList *entries);
 
 gboolean
-camel_imapx_acl_remove_acl (CamelImapxAcl *acl,
-                            const gchar *mailbox_name);
+camel_imapx_acl_update_acl (CamelImapxAcl *acl,
+                            const gchar *mbox_name,
+                            const GList *entries,
+                            GError **err);
+
+gchar*
+camel_imapx_acl_get_myrights (CamelImapxAcl *acl,
+                              const gchar *mbox_name);
 
 gboolean
-camel_imapx_acl_remove_myrights (CamelImapxAcl *acl,
-                                 const gchar *mailbox_name);
+camel_imapx_acl_update_myrights (CamelImapxAcl *acl,
+                                 const gchar *mbox_name,
+                                 const gchar *rights,
+                                 GError **err);
 
 gboolean
-camel_imapx_acl_validate_imapacl (const gchar *imapacl,
-                                  GError **err);
+camel_imapx_acl_update_acl_from_server_response (CamelImapxAcl *acl,
+                                                 CamelIMAPXStream *is,
+                                                 GCancellable *cancellable,
+                                                 GError **err);
+gboolean
+camel_imapx_acl_update_myrights_from_server_response (CamelImapxAcl *acl,
+                                                      CamelIMAPXStream *is,
+                                                      GCancellable *cancellable,
+                                                      GError **err);
+
+GSList*
+camel_imapx_acl_new_commandlist (CamelImapxAcl *acl,
+                                 GError **err);
 
 /*----------------------------------------------------------------------------*/