/*
* camel-imapx-job.c
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) version 3.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the program; if not, see
*
*/
#include "camel-imapx-job.h"
#include
typedef struct _CamelIMAPXRealJob CamelIMAPXRealJob;
/* CamelIMAPXJob + some private bits */
struct _CamelIMAPXRealJob {
CamelIMAPXJob public;
volatile gint ref_count;
/* Used for running some jobs synchronously. */
GCond *done_cond;
GMutex *done_mutex;
gboolean done_flag;
/* Extra job-specific data. */
gpointer data;
GDestroyNotify destroy_data;
};
static void
imapx_job_cancelled_cb (GCancellable *cancellable,
CamelIMAPXJob *job)
{
/* Unblock camel_imapx_run_job() immediately.
*
* If camel_imapx_job_done() is called sometime later,
* the GCond will broadcast but no one will be listening. */
camel_imapx_job_done (job);
}
CamelIMAPXJob *
camel_imapx_job_new (GCancellable *cancellable)
{
CamelIMAPXRealJob *real_job;
if (cancellable != NULL)
g_object_ref (cancellable);
real_job = g_slice_new0 (CamelIMAPXRealJob);
/* Initialize private bits. */
real_job->ref_count = 1;
real_job->done_cond = g_cond_new ();
real_job->done_mutex = g_mutex_new ();
/* Initialize public bits. */
real_job->public.cancellable = cancellable;
return (CamelIMAPXJob *) real_job;
}
CamelIMAPXJob *
camel_imapx_job_ref (CamelIMAPXJob *job)
{
CamelIMAPXRealJob *real_job;
g_return_val_if_fail (CAMEL_IS_IMAPX_JOB (job), NULL);
real_job = (CamelIMAPXRealJob *) job;
g_atomic_int_inc (&real_job->ref_count);
return job;
}
void
camel_imapx_job_unref (CamelIMAPXJob *job)
{
CamelIMAPXRealJob *real_job;
g_return_if_fail (CAMEL_IS_IMAPX_JOB (job));
real_job = (CamelIMAPXRealJob *) job;
if (g_atomic_int_dec_and_test (&real_job->ref_count)) {
/* Free the public stuff. */
g_clear_error (&real_job->public.error);
if (real_job->public.pop_operation_msg)
camel_operation_pop_message (
real_job->public.cancellable);
if (real_job->public.cancellable != NULL)
g_object_unref (real_job->public.cancellable);
/* Free the private stuff. */
g_cond_free (real_job->done_cond);
g_mutex_free (real_job->done_mutex);
if (real_job->destroy_data != NULL)
real_job->destroy_data (real_job->data);
/* Fill the memory with a bit pattern before releasing
* it back to the slab allocator, so we can more easily
* identify dangling CamelIMAPXJob pointers. */
memset (real_job, 0xaa, sizeof (CamelIMAPXRealJob));
/* But leave the reference count set to zero, so
* CAMEL_IS_IMAPX_JOB can identify it as bad. */
real_job->ref_count = 0;
g_slice_free (CamelIMAPXRealJob, real_job);
}
}
gboolean
camel_imapx_job_check (CamelIMAPXJob *job)
{
CamelIMAPXRealJob *real_job;
real_job = (CamelIMAPXRealJob *) job;
return (real_job != NULL && real_job->ref_count > 0);
}
void
camel_imapx_job_wait (CamelIMAPXJob *job)
{
CamelIMAPXRealJob *real_job;
g_return_if_fail (CAMEL_IS_IMAPX_JOB (job));
real_job = (CamelIMAPXRealJob *) job;
g_mutex_lock (real_job->done_mutex);
while (!real_job->done_flag)
g_cond_wait (
real_job->done_cond,
real_job->done_mutex);
g_mutex_unlock (real_job->done_mutex);
}
void
camel_imapx_job_done (CamelIMAPXJob *job)
{
CamelIMAPXRealJob *real_job;
g_return_if_fail (CAMEL_IS_IMAPX_JOB (job));
real_job = (CamelIMAPXRealJob *) job;
g_mutex_lock (real_job->done_mutex);
real_job->done_flag = TRUE;
g_cond_broadcast (real_job->done_cond);
g_mutex_unlock (real_job->done_mutex);
}
gboolean
camel_imapx_job_run (CamelIMAPXJob *job,
CamelIMAPXServer *is,
GError **error)
{
gulong cancel_id = 0;
g_return_val_if_fail (CAMEL_IS_IMAPX_JOB (job), FALSE);
g_return_val_if_fail (CAMEL_IS_IMAPX_SERVER (is), FALSE);
g_return_val_if_fail (job->start != NULL, FALSE);
if (g_cancellable_set_error_if_cancelled (job->cancellable, error))
return FALSE;
if (G_IS_CANCELLABLE (job->cancellable))
cancel_id = g_cancellable_connect (
job->cancellable,
G_CALLBACK (imapx_job_cancelled_cb),
camel_imapx_job_ref (job),
(GDestroyNotify) camel_imapx_job_unref);
job->start (job, is);
if (!job->noreply)
camel_imapx_job_wait (job);
if (cancel_id > 0)
g_cancellable_disconnect (job->cancellable, cancel_id);
if (g_cancellable_set_error_if_cancelled (job->cancellable, error))
return FALSE;
if (job->error != NULL) {
g_propagate_error (error, job->error);
job->error = NULL;
return FALSE;
}
return TRUE;
}
gboolean
camel_imapx_job_matches (CamelIMAPXJob *job,
CamelFolder *folder,
const gchar *uid)
{
/* XXX CamelFolder can be NULL. I'm less sure about the
* message UID but let's assume that can be NULL too. */
g_return_val_if_fail (CAMEL_IS_IMAPX_JOB (job), FALSE);
if (folder != NULL)
g_return_val_if_fail (CAMEL_IS_FOLDER (folder), FALSE);
if (job->matches == NULL)
return FALSE;
return job->matches (job, folder, uid);
}
gpointer
camel_imapx_job_get_data (CamelIMAPXJob *job)
{
CamelIMAPXRealJob *real_job;
g_return_val_if_fail (CAMEL_IS_IMAPX_JOB (job), NULL);
real_job = (CamelIMAPXRealJob *) job;
return real_job->data;
}
void
camel_imapx_job_set_data (CamelIMAPXJob *job,
gpointer data,
GDestroyNotify destroy_data)
{
CamelIMAPXRealJob *real_job;
g_return_if_fail (CAMEL_IS_IMAPX_JOB (job));
real_job = (CamelIMAPXRealJob *) job;
if (real_job->destroy_data != NULL)
real_job->destroy_data (real_job->data);
real_job->data = data;
real_job->destroy_data = destroy_data;
}