← Back to branch summary

~ubuntu-branches/ubuntu/precise/evolution-data-server/precise-proposed

« back to all changes in this revision

Viewing changes to .pc/999git_EDS_3_1_3_1_to_f94a069.patch/camel/providers/imap/camel-imap-wrapper.c

  • Committer: Bazaar Package Importer
  • Author(s): Mathieu Trudel-Lapierre
  • Date: 2011-07-27 11:45:30 UTC
  • mfrom: (1.1.90 upstream)
  • Revision ID: james.westby@ubuntu.com-20110727114530-v4ntbu728os68b0b
Tags: 3.1.4-0ubuntu1
* New upstream version.
* debian/patches/999git_EDS_3_1_3_1_to_f94a069.patch: drop, included in
  the upstream 3.1.4 tarball.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/999git_EDS_3_1_3_1_to_f94a069.patch/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 (C) 1999-2008 Novell, Inc. (www.novell.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 "camel-imap-folder.h"
32
 
#include "camel-imap-wrapper.h"
33
 
 
34
 
struct _CamelImapWrapperPrivate {
35
 
        GMutex *lock;
36
 
};
37
 
 
38
 
#define CAMEL_IMAP_WRAPPER_LOCK(f, l) (g_mutex_lock(((CamelImapWrapper *)f)->priv->l))
39
 
#define CAMEL_IMAP_WRAPPER_UNLOCK(f, l) (g_mutex_unlock(((CamelImapWrapper *)f)->priv->l))
40
 
 
41
 
G_DEFINE_TYPE (CamelImapWrapper, camel_imap_wrapper, CAMEL_TYPE_DATA_WRAPPER)
42
 
 
43
 
static void
44
 
imap_wrapper_hydrate (CamelImapWrapper *imap_wrapper,
45
 
                      CamelStream *stream)
46
 
{
47
 
        CamelDataWrapper *data_wrapper = (CamelDataWrapper *) imap_wrapper;
48
 
 
49
 
        data_wrapper->stream = g_object_ref (stream);
50
 
        data_wrapper->offline = FALSE;
51
 
 
52
 
        g_object_unref (imap_wrapper->folder);
53
 
        imap_wrapper->folder = NULL;
54
 
        g_free (imap_wrapper->uid);
55
 
        imap_wrapper->uid = NULL;
56
 
        g_free (imap_wrapper->part_spec);
57
 
        imap_wrapper->part_spec = NULL;
58
 
}
59
 
 
60
 
static void
61
 
imap_wrapper_dispose (GObject *object)
62
 
{
63
 
        CamelImapWrapper *imap_wrapper = CAMEL_IMAP_WRAPPER (object);
64
 
 
65
 
        if (imap_wrapper->folder != NULL) {
66
 
                g_object_unref (imap_wrapper->folder);
67
 
                imap_wrapper->folder = NULL;
68
 
        }
69
 
 
70
 
        /* Chain up to parent's dispose() method. */
71
 
        G_OBJECT_CLASS (camel_imap_wrapper_parent_class)->dispose (object);
72
 
}
73
 
 
74
 
static void
75
 
imap_wrapper_finalize (GObject *object)
76
 
{
77
 
        CamelImapWrapper *imap_wrapper = CAMEL_IMAP_WRAPPER (object);
78
 
 
79
 
        g_free (imap_wrapper->uid);
80
 
        g_free (imap_wrapper->part_spec);
81
 
 
82
 
        g_mutex_free (imap_wrapper->priv->lock);
83
 
 
84
 
        /* Chain up to parent's finalize() method. */
85
 
        G_OBJECT_CLASS (camel_imap_wrapper_parent_class)->finalize (object);
86
 
}
87
 
 
88
 
static gssize
89
 
imap_wrapper_write_to_stream_sync (CamelDataWrapper *data_wrapper,
90
 
                                   CamelStream *stream,
91
 
                                   GCancellable *cancellable,
92
 
                                   GError **error)
93
 
{
94
 
        CamelImapWrapper *imap_wrapper = CAMEL_IMAP_WRAPPER (data_wrapper);
95
 
 
96
 
        CAMEL_IMAP_WRAPPER_LOCK (imap_wrapper, lock);
97
 
        if (data_wrapper->offline) {
98
 
                CamelStream *datastream;
99
 
 
100
 
                datastream = camel_imap_folder_fetch_data (
101
 
                        imap_wrapper->folder, imap_wrapper->uid,
102
 
                        imap_wrapper->part_spec, FALSE, cancellable, error);
103
 
 
104
 
                if (!datastream) {
105
 
                        CAMEL_IMAP_WRAPPER_UNLOCK (imap_wrapper, lock);
106
 
                        return -1;
107
 
                }
108
 
 
109
 
                imap_wrapper_hydrate (imap_wrapper, datastream);
110
 
                g_object_unref (datastream);
111
 
        }
112
 
        CAMEL_IMAP_WRAPPER_UNLOCK (imap_wrapper, lock);
113
 
 
114
 
        return CAMEL_DATA_WRAPPER_CLASS (camel_imap_wrapper_parent_class)->
115
 
                write_to_stream_sync (data_wrapper, stream, cancellable, error);
116
 
}
117
 
 
118
 
static void
119
 
camel_imap_wrapper_class_init (CamelImapWrapperClass *class)
120
 
{
121
 
        GObjectClass *object_class;
122
 
        CamelDataWrapperClass *data_wrapper_class;
123
 
 
124
 
        g_type_class_add_private (class, sizeof (CamelImapWrapperPrivate));
125
 
 
126
 
        object_class = G_OBJECT_CLASS (class);
127
 
        object_class->dispose = imap_wrapper_dispose;
128
 
        object_class->finalize = imap_wrapper_finalize;
129
 
 
130
 
        data_wrapper_class = CAMEL_DATA_WRAPPER_CLASS (class);
131
 
        data_wrapper_class->write_to_stream_sync = imap_wrapper_write_to_stream_sync;
132
 
}
133
 
 
134
 
static void
135
 
camel_imap_wrapper_init (CamelImapWrapper *imap_wrapper)
136
 
{
137
 
        imap_wrapper->priv = G_TYPE_INSTANCE_GET_PRIVATE (
138
 
                imap_wrapper, CAMEL_TYPE_IMAP_WRAPPER,
139
 
                CamelImapWrapperPrivate);
140
 
        imap_wrapper->priv->lock = g_mutex_new ();
141
 
}
142
 
 
143
 
CamelDataWrapper *
144
 
camel_imap_wrapper_new (CamelImapFolder *imap_folder,
145
 
                        CamelContentType *type, CamelTransferEncoding encoding,
146
 
                        const gchar *uid, const gchar *part_spec,
147
 
                        CamelMimePart *part)
148
 
{
149
 
        CamelImapWrapper *imap_wrapper;
150
 
        CamelStore *store;
151
 
        CamelStream *stream;
152
 
        CamelURL *url;
153
 
        gboolean sync_offline = FALSE;
154
 
 
155
 
        store = camel_folder_get_parent_store (CAMEL_FOLDER (imap_folder));
156
 
        url = camel_service_get_camel_url (CAMEL_SERVICE (store));
157
 
        sync_offline =
158
 
                camel_url_get_param (url, "sync_offline") != NULL ||
159
 
                camel_offline_folder_get_offline_sync (
160
 
                        CAMEL_OFFLINE_FOLDER (imap_folder));
161
 
 
162
 
        imap_wrapper = g_object_new (CAMEL_TYPE_IMAP_WRAPPER, NULL);
163
 
        camel_data_wrapper_set_mime_type_field (CAMEL_DATA_WRAPPER (imap_wrapper), type);
164
 
        ((CamelDataWrapper *) imap_wrapper)->offline = !sync_offline;
165
 
        ((CamelDataWrapper *) imap_wrapper)->encoding = encoding;
166
 
 
167
 
        imap_wrapper->folder = g_object_ref (imap_folder);
168
 
        imap_wrapper->uid = g_strdup (uid);
169
 
        imap_wrapper->part_spec = g_strdup (part_spec);
170
 
 
171
 
        /* Don't ref this, it's our parent. */
172
 
        imap_wrapper->part = part;
173
 
 
174
 
        /* Download the attachments if sync_offline is set, else skip them by checking only in cache */
175
 
        stream = camel_imap_folder_fetch_data (imap_folder, uid, part_spec,
176
 
                        !sync_offline, NULL, NULL);
177
 
 
178
 
        if (stream) {
179
 
                imap_wrapper_hydrate (imap_wrapper, stream);
180
 
                g_object_unref (stream);
181
 
        }
182
 
 
183
 
        return (CamelDataWrapper *) imap_wrapper;
184
 
}