camel/providers/imap/camel-imap-wrapper.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; -*- */
   2 /* camel-imap-wrapper.c: data wrapper for offline IMAP data */
   3
   4 /*
   5  * Author: Dan Winship <danw@ximian.com>
   6  *
   7  * Copyright 2000 Ximian, Inc. (www.ximian.com)
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of version 2 of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  21  * USA
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <errno.h>
  29 #include <string.h>
  30
  31 #include <libedataserver/e-msgport.h>
  32
  33 #include "camel-exception.h"
  34 #include "camel-mime-filter-basic.h"
  35 #include "camel-mime-filter-charset.h"
  36 #include "camel-mime-filter-crlf.h"
  37 #include "camel-mime-part.h"
  38 #include "camel-stream-filter.h"
  39
  40 #include "camel-imap-folder.h"
  41 #include "camel-imap-wrapper.h"
  42
  43 struct _CamelImapWrapperPrivate {
  44         GMutex *lock;
  45 };
  46
  47 #define CAMEL_IMAP_WRAPPER_LOCK(f, l) (g_mutex_lock(((CamelImapWrapper *)f)->priv->l))
  48 #define CAMEL_IMAP_WRAPPER_UNLOCK(f, l) (g_mutex_unlock(((CamelImapWrapper *)f)->priv->l))
  49
  50
  51 static CamelDataWrapperClass *parent_class = NULL;
  52
  53 /* Returns the class for a CamelDataWrapper */
  54 #define CDW_CLASS(so) CAMEL_DATA_WRAPPER_CLASS (CAMEL_OBJECT_GET_CLASS(so))
  55
  56 static ssize_t write_to_stream (CamelDataWrapper *imap_wrapper, CamelStream *stream);
  57
  58 static void
  59 camel_imap_wrapper_class_init (CamelImapWrapperClass *camel_imap_wrapper_class)
  60 {
  61         CamelDataWrapperClass *camel_data_wrapper_class =
  62                 CAMEL_DATA_WRAPPER_CLASS (camel_imap_wrapper_class);
  63
  64         parent_class = CAMEL_DATA_WRAPPER_CLASS (camel_type_get_global_classfuncs (camel_data_wrapper_get_type ()));
  65
  66         /* virtual method override */
  67         camel_data_wrapper_class->write_to_stream = write_to_stream;
  68 }
  69
  70 static void
  71 camel_imap_wrapper_finalize (CamelObject *object)
  72 {
  73         CamelImapWrapper *imap_wrapper = CAMEL_IMAP_WRAPPER (object);
  74
  75         if (imap_wrapper->folder)
  76                 camel_object_unref (CAMEL_OBJECT (imap_wrapper->folder));
  77         if (imap_wrapper->uid)
  78                 g_free (imap_wrapper->uid);
  79         if (imap_wrapper->part)
  80                 g_free (imap_wrapper->part_spec);
  81
  82         g_mutex_free (imap_wrapper->priv->lock);
  83
  84         g_free (imap_wrapper->priv);
  85 }
  86
  87 static void
  88 camel_imap_wrapper_init (gpointer object, gpointer klass)
  89 {
  90         CamelImapWrapper *imap_wrapper = CAMEL_IMAP_WRAPPER (object);
  91
  92         imap_wrapper->priv = g_new0 (struct _CamelImapWrapperPrivate, 1);
  93         imap_wrapper->priv->lock = g_mutex_new ();
  94 }
  95
  96 CamelType
  97 camel_imap_wrapper_get_type (void)
  98 {
  99         static CamelType type = CAMEL_INVALID_TYPE;
 100
 101         if (type == CAMEL_INVALID_TYPE) {
 102                 type = camel_type_register (
 103                         CAMEL_DATA_WRAPPER_TYPE,
 104                         "CamelImapWrapper",
 105                         sizeof (CamelImapWrapper),
 106                         sizeof (CamelImapWrapperClass),
 107                         (CamelObjectClassInitFunc) camel_imap_wrapper_class_init,
 108                         NULL,
 109                         (CamelObjectInitFunc) camel_imap_wrapper_init,
 110                         (CamelObjectFinalizeFunc) camel_imap_wrapper_finalize);
 111         }
 112
 113         return type;
 114 }
 115
 116
 117 static void
 118 imap_wrapper_hydrate (CamelImapWrapper *imap_wrapper, CamelStream *stream)
 119 {
 120         CamelDataWrapper *data_wrapper = (CamelDataWrapper *) imap_wrapper;
 121
 122         camel_object_ref (stream);
 123         data_wrapper->stream = stream;
 124         data_wrapper->offline = FALSE;
 125
 126         camel_object_unref (imap_wrapper->folder);
 127         imap_wrapper->folder = NULL;
 128         g_free (imap_wrapper->uid);
 129         imap_wrapper->uid = NULL;
 130         g_free (imap_wrapper->part_spec);
 131         imap_wrapper->part = NULL;
 132 }
 133
 134
 135 static ssize_t
 136 write_to_stream (CamelDataWrapper *data_wrapper, CamelStream *stream)
 137 {
 138         CamelImapWrapper *imap_wrapper = CAMEL_IMAP_WRAPPER (data_wrapper);
 139
 140         CAMEL_IMAP_WRAPPER_LOCK (imap_wrapper, lock);
 141         if (data_wrapper->offline) {
 142                 CamelStream *datastream;
 143
 144                 datastream = camel_imap_folder_fetch_data (
 145                         imap_wrapper->folder, imap_wrapper->uid,
 146                         imap_wrapper->part_spec, FALSE, NULL);
 147                 if (!datastream) {
 148                         CAMEL_IMAP_WRAPPER_UNLOCK (imap_wrapper, lock);
 149 #ifdef ENETUNREACH
 150                         errno = ENETUNREACH;
 151 #else
 152 #warning FIXME: what errno to use if no ENETUNREACH
 153                         errno = EINVAL;
 154 #endif
 155                         return -1;
 156                 }
 157
 158                 imap_wrapper_hydrate (imap_wrapper, datastream);
 159                 camel_object_unref (datastream);
 160         }
 161         CAMEL_IMAP_WRAPPER_UNLOCK (imap_wrapper, lock);
 162
 163         return parent_class->write_to_stream (data_wrapper, stream);
 164 }
 165
 166
 167 CamelDataWrapper *
 168 camel_imap_wrapper_new (CamelImapFolder *imap_folder,
 169                         CamelContentType *type, CamelTransferEncoding encoding,
 170                         const char *uid, const char *part_spec,
 171                         CamelMimePart *part)
 172 {
 173         CamelImapWrapper *imap_wrapper;
 174         CamelStream *stream;
 175
 176         imap_wrapper = (CamelImapWrapper *)camel_object_new(camel_imap_wrapper_get_type());
 177
 178         camel_data_wrapper_set_mime_type_field (CAMEL_DATA_WRAPPER (imap_wrapper), type);
 179         ((CamelDataWrapper *)imap_wrapper)->offline = TRUE;
 180         ((CamelDataWrapper *)imap_wrapper)->encoding = encoding;
 181
 182         imap_wrapper->folder = imap_folder;
 183         camel_object_ref (imap_folder);
 184         imap_wrapper->uid = g_strdup (uid);
 185         imap_wrapper->part_spec = g_strdup (part_spec);
 186
 187         /* Don't ref this, it's our parent. */
 188         imap_wrapper->part = part;
 189
 190         /* Try the cache. */
 191         stream = camel_imap_folder_fetch_data (imap_folder, uid, part_spec,
 192                                                TRUE, NULL);
 193         if (stream) {
 194                 imap_wrapper_hydrate (imap_wrapper, stream);
 195                 camel_object_unref (stream);
 196         }
 197
 198         return (CamelDataWrapper *)imap_wrapper;
 199 }