Diffstat (limited to 'kmicromail/libetpan/generic/mailstorage.c') (more/less context) (ignore whitespace changes)
-rw-r--r-- | kmicromail/libetpan/generic/mailstorage.c | 334 |
1 files changed, 334 insertions, 0 deletions
diff --git a/kmicromail/libetpan/generic/mailstorage.c b/kmicromail/libetpan/generic/mailstorage.c new file mode 100644 index 0000000..25e561e --- a/dev/null +++ b/kmicromail/libetpan/generic/mailstorage.c | |||
@@ -0,0 +1,334 @@ | |||
1 | /* | ||
2 | * libEtPan! -- a mail stuff library | ||
3 | * | ||
4 | * Copyright (C) 2001, 2002 - DINH Viet Hoa | ||
5 | * All rights reserved. | ||
6 | * | ||
7 | * Redistribution and use in source and binary forms, with or without | ||
8 | * modification, are permitted provided that the following conditions | ||
9 | * are met: | ||
10 | * 1. Redistributions of source code must retain the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer. | ||
12 | * 2. Redistributions in binary form must reproduce the above copyright | ||
13 | * notice, this list of conditions and the following disclaimer in the | ||
14 | * documentation and/or other materials provided with the distribution. | ||
15 | * 3. Neither the name of the libEtPan! project nor the names of its | ||
16 | * contributors may be used to endorse or promote products derived | ||
17 | * from this software without specific prior written permission. | ||
18 | * | ||
19 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
20 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
21 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
22 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
23 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
24 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
25 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
26 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
27 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
28 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
29 | * SUCH DAMAGE. | ||
30 | */ | ||
31 | |||
32 | /* | ||
33 | * $Id$ | ||
34 | */ | ||
35 | |||
36 | #include "mailstorage.h" | ||
37 | |||
38 | #include "maildriver.h" | ||
39 | |||
40 | #include <stdlib.h> | ||
41 | #include <string.h> | ||
42 | |||
43 | static int mailstorage_get_folder(struct mailstorage * storage, | ||
44 | char * pathname, mailsession ** result); | ||
45 | |||
46 | struct mailfolder * mailfolder_new(struct mailstorage * storage, | ||
47 | char * pathname, char * virtual_name) | ||
48 | { | ||
49 | struct mailfolder * folder; | ||
50 | |||
51 | folder = malloc(sizeof(struct mailfolder)); | ||
52 | if (folder == NULL) | ||
53 | goto err; | ||
54 | |||
55 | if (pathname != NULL) { | ||
56 | folder->fld_pathname = strdup(pathname); | ||
57 | if (folder->fld_pathname == NULL) | ||
58 | goto free; | ||
59 | } | ||
60 | else | ||
61 | folder->fld_pathname = NULL; | ||
62 | |||
63 | if (virtual_name != NULL) { | ||
64 | folder->fld_virtual_name = strdup(virtual_name); | ||
65 | if (folder->fld_virtual_name == NULL) | ||
66 | goto free_pathname; | ||
67 | } | ||
68 | else | ||
69 | folder->fld_virtual_name = NULL; | ||
70 | |||
71 | folder->fld_storage = storage; | ||
72 | |||
73 | folder->fld_session = NULL; | ||
74 | folder->fld_shared_session = 0; | ||
75 | folder->fld_pos = NULL; | ||
76 | |||
77 | folder->fld_parent = NULL; | ||
78 | folder->fld_sibling_index = 0; | ||
79 | folder->fld_children = carray_new(128); | ||
80 | if (folder->fld_children == NULL) | ||
81 | goto free_virtualname; | ||
82 | |||
83 | return folder; | ||
84 | |||
85 | free_virtualname: | ||
86 | if (folder->fld_virtual_name != NULL) | ||
87 | free(folder->fld_virtual_name); | ||
88 | free_pathname: | ||
89 | if (folder->fld_pathname != NULL) | ||
90 | free(folder->fld_pathname); | ||
91 | free: | ||
92 | free(folder); | ||
93 | err: | ||
94 | return NULL; | ||
95 | } | ||
96 | |||
97 | void mailfolder_free(struct mailfolder * folder) | ||
98 | { | ||
99 | if (folder->fld_parent != NULL) | ||
100 | mailfolder_detach_parent(folder); | ||
101 | |||
102 | while (carray_count(folder->fld_children) > 0) { | ||
103 | struct mailfolder * child; | ||
104 | |||
105 | child = carray_get(folder->fld_children, 0); | ||
106 | mailfolder_detach_parent(child); | ||
107 | } | ||
108 | |||
109 | carray_free(folder->fld_children); | ||
110 | |||
111 | if (folder->fld_session != NULL) | ||
112 | mailfolder_disconnect(folder); | ||
113 | |||
114 | if (folder->fld_virtual_name != NULL) | ||
115 | free(folder->fld_virtual_name); | ||
116 | if (folder->fld_pathname != NULL) | ||
117 | free(folder->fld_pathname); | ||
118 | free(folder); | ||
119 | } | ||
120 | |||
121 | int mailfolder_connect(struct mailfolder * folder) | ||
122 | { | ||
123 | mailsession * session; | ||
124 | int res; | ||
125 | int r; | ||
126 | |||
127 | if (folder->fld_storage == NULL) { | ||
128 | res = MAIL_ERROR_INVAL; | ||
129 | goto err; | ||
130 | } | ||
131 | |||
132 | if (folder->fld_storage->sto_session == NULL) { | ||
133 | r = mailstorage_connect(folder->fld_storage); | ||
134 | if (r != MAIL_NO_ERROR) { | ||
135 | res = r; | ||
136 | goto err; | ||
137 | } | ||
138 | } | ||
139 | |||
140 | if (folder->fld_session != NULL) { | ||
141 | if ((folder->fld_pathname != NULL) && (folder->fld_shared_session)) { | ||
142 | if (folder->fld_session->sess_driver->sess_select_folder != NULL) { | ||
143 | r = mailsession_select_folder(folder->fld_session, | ||
144 | folder->fld_pathname); | ||
145 | if (r != MAIL_NO_ERROR) { | ||
146 | res = r; | ||
147 | goto err; | ||
148 | } | ||
149 | } | ||
150 | } | ||
151 | |||
152 | return MAIL_NO_ERROR; | ||
153 | } | ||
154 | |||
155 | r = mailstorage_get_folder(folder->fld_storage, folder->fld_pathname, | ||
156 | &session); | ||
157 | if (r != MAIL_NO_ERROR) { | ||
158 | res = r; | ||
159 | goto err; | ||
160 | } | ||
161 | folder->fld_session = session; | ||
162 | folder->fld_shared_session = (session == folder->fld_storage->sto_session); | ||
163 | if (folder->fld_shared_session) { | ||
164 | r = clist_append(folder->fld_storage->sto_shared_folders, folder); | ||
165 | if (r < 0) { | ||
166 | folder->fld_session = NULL; | ||
167 | res = MAIL_ERROR_MEMORY; | ||
168 | goto err; | ||
169 | } | ||
170 | folder->fld_pos = clist_end(folder->fld_storage->sto_shared_folders); | ||
171 | } | ||
172 | |||
173 | return MAIL_NO_ERROR; | ||
174 | |||
175 | err: | ||
176 | return res; | ||
177 | } | ||
178 | |||
179 | void mailfolder_disconnect(struct mailfolder * folder) | ||
180 | { | ||
181 | if (folder->fld_session == NULL) | ||
182 | return; | ||
183 | |||
184 | if (folder->fld_shared_session) { | ||
185 | clist_delete(folder->fld_storage->sto_shared_folders, folder->fld_pos); | ||
186 | folder->fld_pos = NULL; | ||
187 | } | ||
188 | else { | ||
189 | mailsession_logout(folder->fld_session); | ||
190 | mailsession_free(folder->fld_session); | ||
191 | } | ||
192 | |||
193 | folder->fld_session = NULL; | ||
194 | } | ||
195 | |||
196 | int mailfolder_add_child(struct mailfolder * parent, | ||
197 | struct mailfolder * child) | ||
198 | { | ||
199 | unsigned int index; | ||
200 | int r; | ||
201 | |||
202 | r = carray_add(parent->fld_children, child, &index); | ||
203 | if (r < 0) | ||
204 | return MAIL_ERROR_MEMORY; | ||
205 | |||
206 | child->fld_sibling_index = index; | ||
207 | child->fld_parent = parent; | ||
208 | |||
209 | return MAIL_NO_ERROR; | ||
210 | } | ||
211 | |||
212 | int mailfolder_detach_parent(struct mailfolder * folder) | ||
213 | { | ||
214 | unsigned int i; | ||
215 | int r; | ||
216 | |||
217 | if (folder->fld_parent == NULL) | ||
218 | return MAIL_ERROR_INVAL; | ||
219 | |||
220 | r = carray_delete_slow(folder->fld_parent->fld_children, | ||
221 | folder->fld_sibling_index); | ||
222 | if (r < 0) | ||
223 | return MAIL_ERROR_INVAL; | ||
224 | |||
225 | for(i = 0 ; i < carray_count(folder->fld_parent->fld_children) ; i ++) { | ||
226 | struct mailfolder * child; | ||
227 | |||
228 | child = carray_get(folder->fld_parent->fld_children, i); | ||
229 | child->fld_sibling_index = i; | ||
230 | } | ||
231 | |||
232 | folder->fld_parent = NULL; | ||
233 | folder->fld_sibling_index = 0; | ||
234 | |||
235 | return MAIL_NO_ERROR; | ||
236 | } | ||
237 | |||
238 | struct mailstorage * mailstorage_new(char * sto_id) | ||
239 | { | ||
240 | struct mailstorage * storage; | ||
241 | |||
242 | storage = malloc(sizeof(struct mailstorage)); | ||
243 | if (storage == NULL) | ||
244 | goto err; | ||
245 | |||
246 | if (sto_id != NULL) { | ||
247 | storage->sto_id = strdup(sto_id); | ||
248 | if (storage->sto_id == NULL) | ||
249 | goto free; | ||
250 | } | ||
251 | else | ||
252 | storage->sto_id = NULL; | ||
253 | |||
254 | storage->sto_data = NULL; | ||
255 | storage->sto_session = NULL; | ||
256 | storage->sto_driver = NULL; | ||
257 | storage->sto_shared_folders = clist_new(); | ||
258 | if (storage->sto_shared_folders == NULL) | ||
259 | goto free_id; | ||
260 | |||
261 | return storage; | ||
262 | |||
263 | free_id: | ||
264 | if (storage->sto_id != NULL) | ||
265 | free(storage->sto_id); | ||
266 | free: | ||
267 | free(storage); | ||
268 | err: | ||
269 | return NULL; | ||
270 | } | ||
271 | |||
272 | void mailstorage_free(struct mailstorage * storage) | ||
273 | { | ||
274 | if (storage->sto_session != NULL) | ||
275 | mailstorage_disconnect(storage); | ||
276 | |||
277 | if (storage->sto_driver != NULL) { | ||
278 | if (storage->sto_driver->sto_uninitialize != NULL) | ||
279 | storage->sto_driver->sto_uninitialize(storage); | ||
280 | } | ||
281 | |||
282 | clist_free(storage->sto_shared_folders); | ||
283 | |||
284 | if (storage->sto_id != NULL) | ||
285 | free(storage->sto_id); | ||
286 | |||
287 | free(storage); | ||
288 | } | ||
289 | |||
290 | int mailstorage_connect(struct mailstorage * storage) | ||
291 | { | ||
292 | if (storage->sto_session != NULL) | ||
293 | return MAIL_NO_ERROR; | ||
294 | |||
295 | if (!clist_isempty(storage->sto_shared_folders)) | ||
296 | return MAIL_ERROR_BAD_STATE; | ||
297 | |||
298 | if (storage->sto_driver->sto_connect == NULL) | ||
299 | return MAIL_ERROR_NOT_IMPLEMENTED; | ||
300 | |||
301 | return storage->sto_driver->sto_connect(storage); | ||
302 | } | ||
303 | |||
304 | |||
305 | void mailstorage_disconnect(struct mailstorage * storage) | ||
306 | { | ||
307 | int r; | ||
308 | clistiter * cur; | ||
309 | |||
310 | while ((cur = clist_begin(storage->sto_shared_folders)) != NULL) { | ||
311 | struct mailfolder * folder; | ||
312 | |||
313 | folder = cur->data; | ||
314 | mailfolder_disconnect(folder); | ||
315 | } | ||
316 | |||
317 | if (storage->sto_session == NULL) | ||
318 | return; | ||
319 | |||
320 | r = mailsession_logout(storage->sto_session); | ||
321 | |||
322 | mailsession_free(storage->sto_session); | ||
323 | storage->sto_session = NULL; | ||
324 | } | ||
325 | |||
326 | static int mailstorage_get_folder(struct mailstorage * storage, | ||
327 | char * pathname, mailsession ** result) | ||
328 | { | ||
329 | if (storage->sto_driver->sto_get_folder_session == NULL) | ||
330 | return MAIL_ERROR_NOT_IMPLEMENTED; | ||
331 | |||
332 | return storage->sto_driver->sto_get_folder_session(storage, | ||
333 | pathname, result); | ||
334 | } | ||