author | zautrix <zautrix> | 2005-03-18 20:17:03 (UTC) |
---|---|---|
committer | zautrix <zautrix> | 2005-03-18 20:17:03 (UTC) |
commit | 9e549686b23b6dffdcbd09c9b10dc2cb795fbcdf (patch) (unidiff) | |
tree | 2528e6cc740225ca0f47d5ac8ff70f7d3bb10621 /libetpan/src/driver/implementation/imap/imapdriver_message.c | |
parent | 9319998f20f03dcc217fbb39656755dc65226276 (diff) | |
download | kdepimpi-9e549686b23b6dffdcbd09c9b10dc2cb795fbcdf.zip kdepimpi-9e549686b23b6dffdcbd09c9b10dc2cb795fbcdf.tar.gz kdepimpi-9e549686b23b6dffdcbd09c9b10dc2cb795fbcdf.tar.bz2 |
Initial revision
Diffstat (limited to 'libetpan/src/driver/implementation/imap/imapdriver_message.c') (more/less context) (ignore whitespace changes)
-rw-r--r-- | libetpan/src/driver/implementation/imap/imapdriver_message.c | 1239 |
1 files changed, 1239 insertions, 0 deletions
diff --git a/libetpan/src/driver/implementation/imap/imapdriver_message.c b/libetpan/src/driver/implementation/imap/imapdriver_message.c new file mode 100644 index 0000000..42e645d --- a/dev/null +++ b/libetpan/src/driver/implementation/imap/imapdriver_message.c | |||
@@ -0,0 +1,1239 @@ | |||
1 | /* | ||
2 | * libEtPan! -- a mail stuff library | ||
3 | * | ||
4 | * Copyright (C) 2001, 2005 - 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 AUTHORS 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 AUTHORS 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 "imapdriver_message.h" | ||
37 | |||
38 | #include "imapdriver_tools.h" | ||
39 | #include "imapdriver.h" | ||
40 | #include "imapdriver_types.h" | ||
41 | #include "mailimap.h" | ||
42 | #include "maildriver_tools.h" | ||
43 | #include "generic_cache.h" | ||
44 | |||
45 | #include <stdlib.h> | ||
46 | #include <string.h> | ||
47 | |||
48 | static int imap_initialize(mailmessage * msg_info); | ||
49 | |||
50 | static void imap_fetch_result_free(mailmessage * msg_info, | ||
51 | char * msg); | ||
52 | |||
53 | static int imap_fetch(mailmessage * msg_info, | ||
54 | char ** result, | ||
55 | size_t * result_len); | ||
56 | |||
57 | static int imap_fetch_header(mailmessage * msg_info, | ||
58 | char ** result, | ||
59 | size_t * result_len); | ||
60 | |||
61 | static int imap_fetch_body(mailmessage * msg_info, | ||
62 | char ** result, size_t * result_len); | ||
63 | |||
64 | static int imap_fetch_size(mailmessage * msg_info, | ||
65 | size_t * result); | ||
66 | |||
67 | static int imap_get_bodystructure(mailmessage * msg_info, | ||
68 | struct mailmime ** result); | ||
69 | |||
70 | static int imap_fetch_section(mailmessage * msg_info, | ||
71 | struct mailmime * mime, | ||
72 | char ** result, size_t * result_len); | ||
73 | |||
74 | static int imap_fetch_section_header(mailmessage * msg_info, | ||
75 | struct mailmime * mime, | ||
76 | char ** result, | ||
77 | size_t * result_len); | ||
78 | |||
79 | static int imap_fetch_section_mime(mailmessage * msg_info, | ||
80 | struct mailmime * mime, | ||
81 | char ** result, | ||
82 | size_t * result_len); | ||
83 | |||
84 | static int imap_fetch_section_body(mailmessage * msg_info, | ||
85 | struct mailmime * mime, | ||
86 | char ** result, | ||
87 | size_t * result_len); | ||
88 | |||
89 | static int imap_fetch_envelope(mailmessage * msg_info, | ||
90 | struct mailimf_fields ** result); | ||
91 | |||
92 | static int imap_get_flags(mailmessage * msg_info, | ||
93 | struct mail_flags ** result); | ||
94 | |||
95 | static void imap_flush(mailmessage * msg_info); | ||
96 | |||
97 | static void imap_check(mailmessage * msg_info); | ||
98 | |||
99 | static mailmessage_driver local_imap_message_driver = { | ||
100 | .msg_name = "imap", | ||
101 | |||
102 | .msg_initialize = imap_initialize, | ||
103 | .msg_uninitialize = NULL, | ||
104 | |||
105 | .msg_flush = imap_flush, | ||
106 | .msg_check = imap_check, | ||
107 | |||
108 | .msg_fetch_result_free = imap_fetch_result_free, | ||
109 | |||
110 | .msg_fetch = imap_fetch, | ||
111 | .msg_fetch_header = imap_fetch_header, | ||
112 | .msg_fetch_body = imap_fetch_body, | ||
113 | .msg_fetch_size = imap_fetch_size, | ||
114 | .msg_get_bodystructure = imap_get_bodystructure, | ||
115 | .msg_fetch_section = imap_fetch_section, | ||
116 | .msg_fetch_section_header = imap_fetch_section_header, | ||
117 | .msg_fetch_section_mime = imap_fetch_section_mime, | ||
118 | .msg_fetch_section_body = imap_fetch_section_body, | ||
119 | .msg_fetch_envelope = imap_fetch_envelope, | ||
120 | |||
121 | .msg_get_flags = imap_get_flags, | ||
122 | }; | ||
123 | |||
124 | mailmessage_driver * imap_message_driver = &local_imap_message_driver; | ||
125 | |||
126 | static inline struct imap_session_state_data * | ||
127 | get_session_data(mailmessage * msg) | ||
128 | { | ||
129 | return msg->msg_session->sess_data; | ||
130 | } | ||
131 | |||
132 | static inline mailimap * get_imap_session(mailmessage * msg) | ||
133 | { | ||
134 | return get_session_data(msg)->imap_session; | ||
135 | } | ||
136 | |||
137 | |||
138 | |||
139 | static int imap_initialize(mailmessage * msg_info) | ||
140 | { | ||
141 | char key[PATH_MAX]; | ||
142 | char * uid; | ||
143 | mailimap * imap; | ||
144 | |||
145 | imap = get_imap_session(msg_info); | ||
146 | |||
147 | snprintf(key, PATH_MAX, "%u-%u", | ||
148 | imap->imap_selection_info->sel_uidvalidity, msg_info->msg_index); | ||
149 | |||
150 | uid = strdup(key); | ||
151 | if (uid == NULL) { | ||
152 | return MAIL_ERROR_MEMORY; | ||
153 | } | ||
154 | |||
155 | msg_info->msg_uid = uid; | ||
156 | |||
157 | return MAIL_NO_ERROR; | ||
158 | } | ||
159 | |||
160 | |||
161 | static void imap_fetch_result_free(mailmessage * msg_info, | ||
162 | char * msg) | ||
163 | { | ||
164 | if (msg != NULL) { | ||
165 | if (mmap_string_unref(msg) != 0) | ||
166 | free(msg); | ||
167 | } | ||
168 | } | ||
169 | |||
170 | |||
171 | static void imap_flush(mailmessage * msg_info) | ||
172 | { | ||
173 | if (msg_info->msg_mime != NULL) { | ||
174 | mailmime_free(msg_info->msg_mime); | ||
175 | msg_info->msg_mime = NULL; | ||
176 | } | ||
177 | } | ||
178 | |||
179 | static void imap_check(mailmessage * msg_info) | ||
180 | { | ||
181 | int r; | ||
182 | |||
183 | if (msg_info->msg_flags != NULL) { | ||
184 | r = mail_flags_store_set(get_session_data(msg_info)->imap_flags_store, | ||
185 | msg_info); | ||
186 | /* ignore errors */ | ||
187 | } | ||
188 | } | ||
189 | |||
190 | static int imap_fetch(mailmessage * msg_info, | ||
191 | char ** result, | ||
192 | size_t * result_len) | ||
193 | { | ||
194 | int r; | ||
195 | struct mailimap_set * set; | ||
196 | struct mailimap_fetch_att * fetch_att; | ||
197 | struct mailimap_fetch_type * fetch_type; | ||
198 | clist * fetch_result; | ||
199 | struct mailimap_msg_att * msg_att; | ||
200 | struct mailimap_msg_att_item * msg_att_item; | ||
201 | char * text; | ||
202 | size_t text_length; | ||
203 | int res; | ||
204 | clistiter * cur; | ||
205 | struct mailimap_section * section; | ||
206 | |||
207 | set = mailimap_set_new_single(msg_info->msg_index); | ||
208 | if (set == NULL) { | ||
209 | res = MAIL_ERROR_MEMORY; | ||
210 | goto err; | ||
211 | } | ||
212 | |||
213 | #if 0 | ||
214 | fetch_att = mailimap_fetch_att_new_rfc822(); | ||
215 | if (fetch_att == NULL) { | ||
216 | res = MAIL_ERROR_MEMORY; | ||
217 | goto free_set; | ||
218 | } | ||
219 | |||
220 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
221 | if (fetch_type == NULL) { | ||
222 | res = MAIL_ERROR_MEMORY; | ||
223 | goto free_fetch_att; | ||
224 | } | ||
225 | |||
226 | r = mailimap_uid_fetch(get_imap_session(msg_info->session), set, | ||
227 | fetch_type, &fetch_result); | ||
228 | |||
229 | mailimap_fetch_type_free(fetch_type); | ||
230 | #endif | ||
231 | |||
232 | section = mailimap_section_new(NULL); | ||
233 | if (section == NULL) { | ||
234 | res = MAIL_ERROR_MEMORY; | ||
235 | goto free_set; | ||
236 | } | ||
237 | |||
238 | fetch_att = mailimap_fetch_att_new_body_peek_section(section); | ||
239 | if (fetch_att == NULL) { | ||
240 | mailimap_section_free(section); | ||
241 | res = MAIL_ERROR_MEMORY; | ||
242 | goto free_set; | ||
243 | } | ||
244 | |||
245 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
246 | if (fetch_type == NULL) { | ||
247 | res = MAIL_ERROR_MEMORY; | ||
248 | goto free_fetch_att; | ||
249 | } | ||
250 | |||
251 | r = mailimap_uid_fetch(get_imap_session(msg_info), set, | ||
252 | fetch_type, &fetch_result); | ||
253 | |||
254 | mailimap_fetch_type_free(fetch_type); | ||
255 | mailimap_set_free(set); | ||
256 | |||
257 | switch (r) { | ||
258 | case MAILIMAP_NO_ERROR: | ||
259 | break; | ||
260 | default: | ||
261 | return imap_error_to_mail_error(r); | ||
262 | } | ||
263 | |||
264 | if (clist_begin(fetch_result) == NULL) { | ||
265 | mailimap_fetch_list_free(fetch_result); | ||
266 | return MAIL_ERROR_FETCH; | ||
267 | } | ||
268 | |||
269 | msg_att = clist_begin(fetch_result)->data; | ||
270 | |||
271 | text = NULL; | ||
272 | text_length = 0; | ||
273 | |||
274 | for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; | ||
275 | cur = clist_next(cur)) { | ||
276 | msg_att_item = clist_content(cur); | ||
277 | |||
278 | if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) { | ||
279 | #if 0 | ||
280 | if (msg_att_item->msg_att_static->type == MAILIMAP_MSG_ATT_RFC822) { | ||
281 | text = msg_att_item->msg_att_static->rfc822; | ||
282 | msg_att_item->msg_att_static->rfc822 = NULL; | ||
283 | text_length = msg_att_item->msg_att_static->length; | ||
284 | } | ||
285 | #endif | ||
286 | if (msg_att_item->att_data.att_static->att_type == | ||
287 | MAILIMAP_MSG_ATT_BODY_SECTION) { | ||
288 | text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part; | ||
289 | /* detach */ | ||
290 | msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = NULL; | ||
291 | text_length = | ||
292 | msg_att_item->att_data.att_static->att_data.att_body_section->sec_length; | ||
293 | } | ||
294 | } | ||
295 | } | ||
296 | |||
297 | mailimap_fetch_list_free(fetch_result); | ||
298 | |||
299 | if (text == NULL) | ||
300 | return MAIL_ERROR_FETCH; | ||
301 | |||
302 | * result = text; | ||
303 | * result_len = text_length; | ||
304 | |||
305 | return MAIL_NO_ERROR; | ||
306 | |||
307 | free_fetch_att: | ||
308 | mailimap_fetch_att_free(fetch_att); | ||
309 | free_set: | ||
310 | mailimap_set_free(set); | ||
311 | err: | ||
312 | return res; | ||
313 | } | ||
314 | |||
315 | static int imap_fetch_header(mailmessage * msg_info, | ||
316 | char ** result, | ||
317 | size_t * result_len) | ||
318 | { | ||
319 | int r; | ||
320 | struct mailimap_set * set; | ||
321 | struct mailimap_fetch_att * fetch_att; | ||
322 | struct mailimap_fetch_type * fetch_type; | ||
323 | clist * fetch_result; | ||
324 | struct mailimap_msg_att * msg_att; | ||
325 | struct mailimap_msg_att_item * msg_att_item; | ||
326 | char * text; | ||
327 | size_t text_length; | ||
328 | int res; | ||
329 | clistiter * cur; | ||
330 | struct mailimap_section * section; | ||
331 | |||
332 | set = mailimap_set_new_single(msg_info->msg_index); | ||
333 | if (set == NULL) { | ||
334 | res = MAIL_ERROR_MEMORY; | ||
335 | goto err; | ||
336 | } | ||
337 | |||
338 | #if 0 | ||
339 | fetch_att = mailimap_fetch_att_new_rfc822_header(); | ||
340 | if (fetch_att == NULL) { | ||
341 | res = MAIL_ERROR_MEMORY; | ||
342 | goto free_set; | ||
343 | } | ||
344 | |||
345 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
346 | if (fetch_type == NULL) { | ||
347 | res = MAIL_ERROR_MEMORY; | ||
348 | goto free_fetch_att; | ||
349 | } | ||
350 | |||
351 | r = mailimap_uid_fetch(get_imap_session(msg_info->session), | ||
352 | set, fetch_type, &fetch_result); | ||
353 | |||
354 | mailimap_fetch_type_free(fetch_type); | ||
355 | #endif | ||
356 | |||
357 | section = mailimap_section_new_header(); | ||
358 | if (section == NULL) { | ||
359 | res = MAIL_ERROR_MEMORY; | ||
360 | goto free_set; | ||
361 | } | ||
362 | |||
363 | fetch_att = mailimap_fetch_att_new_body_peek_section(section); | ||
364 | if (fetch_att == NULL) { | ||
365 | mailimap_section_free(section); | ||
366 | res = MAIL_ERROR_MEMORY; | ||
367 | goto free_set; | ||
368 | } | ||
369 | |||
370 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
371 | if (fetch_type == NULL) { | ||
372 | res = MAIL_ERROR_MEMORY; | ||
373 | goto free_fetch_att; | ||
374 | } | ||
375 | |||
376 | r = mailimap_uid_fetch(get_imap_session(msg_info), set, | ||
377 | fetch_type, &fetch_result); | ||
378 | |||
379 | mailimap_fetch_type_free(fetch_type); | ||
380 | mailimap_set_free(set); | ||
381 | |||
382 | switch (r) { | ||
383 | case MAILIMAP_NO_ERROR: | ||
384 | break; | ||
385 | default: | ||
386 | return imap_error_to_mail_error(r); | ||
387 | } | ||
388 | |||
389 | if (clist_begin(fetch_result) == NULL) { | ||
390 | mailimap_fetch_list_free(fetch_result); | ||
391 | return MAIL_ERROR_FETCH; | ||
392 | } | ||
393 | |||
394 | msg_att = clist_begin(fetch_result)->data; | ||
395 | |||
396 | text = NULL; | ||
397 | text_length = 0; | ||
398 | |||
399 | for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; | ||
400 | cur = clist_next(cur)) { | ||
401 | msg_att_item = clist_content(cur); | ||
402 | |||
403 | if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) { | ||
404 | #if 0 | ||
405 | if (msg_att_item->msg_att_static->type == | ||
406 | MAILIMAP_MSG_ATT_RFC822_HEADER) { | ||
407 | text = msg_att_item->msg_att_static->rfc822_header; | ||
408 | msg_att_item->msg_att_static->rfc822_header = NULL; | ||
409 | text_length = msg_att_item->msg_att_static->length; | ||
410 | } | ||
411 | #endif | ||
412 | if (msg_att_item->att_data.att_static->att_type == | ||
413 | MAILIMAP_MSG_ATT_BODY_SECTION) { | ||
414 | text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part; | ||
415 | msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = NULL; | ||
416 | text_length = | ||
417 | msg_att_item->att_data.att_static->att_data.att_body_section->sec_length; | ||
418 | } | ||
419 | } | ||
420 | } | ||
421 | |||
422 | mailimap_fetch_list_free(fetch_result); | ||
423 | |||
424 | if (text == NULL) | ||
425 | return MAIL_ERROR_FETCH; | ||
426 | |||
427 | * result = text; | ||
428 | * result_len = text_length; | ||
429 | |||
430 | return MAIL_NO_ERROR; | ||
431 | |||
432 | free_fetch_att: | ||
433 | mailimap_fetch_att_free(fetch_att); | ||
434 | free_set: | ||
435 | mailimap_set_free(set); | ||
436 | err: | ||
437 | return res; | ||
438 | } | ||
439 | |||
440 | static int imap_fetch_body(mailmessage * msg_info, | ||
441 | char ** result, size_t * result_len) | ||
442 | { | ||
443 | int r; | ||
444 | struct mailimap_set * set; | ||
445 | struct mailimap_fetch_att * fetch_att; | ||
446 | struct mailimap_fetch_type * fetch_type; | ||
447 | clist * fetch_result; | ||
448 | struct mailimap_msg_att * msg_att; | ||
449 | struct mailimap_msg_att_item * msg_att_item; | ||
450 | char * text; | ||
451 | size_t text_length; | ||
452 | int res; | ||
453 | clistiter * cur; | ||
454 | struct mailimap_section * section; | ||
455 | |||
456 | set = mailimap_set_new_single(msg_info->msg_index); | ||
457 | if (set == NULL) { | ||
458 | res = MAIL_ERROR_MEMORY; | ||
459 | goto err; | ||
460 | } | ||
461 | |||
462 | #if 0 | ||
463 | fetch_att = mailimap_fetch_att_new_rfc822_text(); | ||
464 | if (fetch_att == NULL) { | ||
465 | res = MAIL_ERROR_MEMORY; | ||
466 | goto free_set; | ||
467 | } | ||
468 | |||
469 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
470 | if (fetch_type == NULL) { | ||
471 | res = MAIL_ERROR_MEMORY; | ||
472 | goto free_fetch_att; | ||
473 | } | ||
474 | |||
475 | r = mailimap_uid_fetch(get_imap_session(msg_info->session), set, | ||
476 | fetch_type, &fetch_result); | ||
477 | |||
478 | mailimap_fetch_type_free(fetch_type); | ||
479 | #endif | ||
480 | section = mailimap_section_new_text(); | ||
481 | if (section == NULL) { | ||
482 | res = MAIL_ERROR_MEMORY; | ||
483 | goto free_set; | ||
484 | } | ||
485 | |||
486 | fetch_att = mailimap_fetch_att_new_body_peek_section(section); | ||
487 | if (fetch_att == NULL) { | ||
488 | mailimap_section_free(section); | ||
489 | res = MAIL_ERROR_MEMORY; | ||
490 | goto free_set; | ||
491 | } | ||
492 | |||
493 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
494 | if (fetch_type == NULL) { | ||
495 | res = MAIL_ERROR_MEMORY; | ||
496 | goto free_fetch_att; | ||
497 | } | ||
498 | |||
499 | r = mailimap_uid_fetch(get_imap_session(msg_info), set, | ||
500 | fetch_type, &fetch_result); | ||
501 | |||
502 | mailimap_fetch_type_free(fetch_type); | ||
503 | mailimap_set_free(set); | ||
504 | |||
505 | switch (r) { | ||
506 | case MAILIMAP_NO_ERROR: | ||
507 | break; | ||
508 | default: | ||
509 | return imap_error_to_mail_error(r); | ||
510 | } | ||
511 | |||
512 | cur = clist_begin(fetch_result); | ||
513 | if (cur == NULL) { | ||
514 | mailimap_fetch_list_free(fetch_result); | ||
515 | return MAIL_ERROR_FETCH; | ||
516 | } | ||
517 | |||
518 | msg_att = clist_content(cur); | ||
519 | |||
520 | text = NULL; | ||
521 | text_length = 0; | ||
522 | |||
523 | for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; | ||
524 | cur = clist_next(cur)) { | ||
525 | msg_att_item = clist_content(cur); | ||
526 | |||
527 | if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) { | ||
528 | #if 0 | ||
529 | if (msg_att_item->msg_att_static->type == | ||
530 | MAILIMAP_MSG_ATT_RFC822_TEXT) { | ||
531 | text = msg_att_item->msg_att_static->rfc822_text; | ||
532 | msg_att_item->msg_att_static->rfc822_text = NULL; | ||
533 | text_length = msg_att_item->msg_att_static->length; | ||
534 | } | ||
535 | #endif | ||
536 | if (msg_att_item->att_data.att_static->att_type == | ||
537 | MAILIMAP_MSG_ATT_BODY_SECTION) { | ||
538 | text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part; | ||
539 | msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = NULL; | ||
540 | text_length = | ||
541 | msg_att_item->att_data.att_static->att_data.att_body_section->sec_length; | ||
542 | } | ||
543 | } | ||
544 | } | ||
545 | |||
546 | mailimap_fetch_list_free(fetch_result); | ||
547 | |||
548 | if (text == NULL) | ||
549 | return MAIL_ERROR_FETCH; | ||
550 | |||
551 | * result = text; | ||
552 | * result_len = text_length; | ||
553 | |||
554 | return MAIL_NO_ERROR; | ||
555 | |||
556 | free_fetch_att: | ||
557 | mailimap_fetch_att_free(fetch_att); | ||
558 | free_set: | ||
559 | mailimap_set_free(set); | ||
560 | err: | ||
561 | return res; | ||
562 | } | ||
563 | |||
564 | static int imap_fetch_size(mailmessage * msg_info, | ||
565 | size_t * result) | ||
566 | { | ||
567 | int r; | ||
568 | struct mailimap_set * set; | ||
569 | struct mailimap_fetch_att * fetch_att; | ||
570 | struct mailimap_fetch_type * fetch_type; | ||
571 | clist * fetch_result; | ||
572 | struct mailimap_msg_att * msg_att; | ||
573 | struct mailimap_msg_att_item * msg_att_item; | ||
574 | size_t size; | ||
575 | int res; | ||
576 | clistiter * cur; | ||
577 | |||
578 | set = mailimap_set_new_single(msg_info->msg_index); | ||
579 | if (set == NULL) { | ||
580 | res = MAIL_ERROR_MEMORY; | ||
581 | goto err; | ||
582 | } | ||
583 | |||
584 | fetch_att = mailimap_fetch_att_new_rfc822_size(); | ||
585 | if (fetch_att == NULL) { | ||
586 | res = MAIL_ERROR_MEMORY; | ||
587 | goto free_set; | ||
588 | } | ||
589 | |||
590 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
591 | if (fetch_type == NULL) { | ||
592 | res = MAIL_ERROR_MEMORY; | ||
593 | goto free_fetch_att; | ||
594 | } | ||
595 | |||
596 | r = mailimap_uid_fetch(get_imap_session(msg_info), set, | ||
597 | fetch_type, &fetch_result); | ||
598 | |||
599 | mailimap_fetch_type_free(fetch_type); | ||
600 | mailimap_set_free(set); | ||
601 | |||
602 | switch (r) { | ||
603 | case MAILIMAP_ERROR_BAD_STATE: | ||
604 | return MAIL_ERROR_BAD_STATE; | ||
605 | case MAILIMAP_ERROR_STREAM: | ||
606 | return MAIL_ERROR_STREAM; | ||
607 | case MAILIMAP_NO_ERROR: | ||
608 | break; | ||
609 | default: | ||
610 | return MAIL_ERROR_FETCH; | ||
611 | } | ||
612 | |||
613 | if (clist_begin(fetch_result) == NULL) { | ||
614 | mailimap_fetch_list_free(fetch_result); | ||
615 | return MAIL_ERROR_FETCH; | ||
616 | } | ||
617 | |||
618 | msg_att = clist_begin(fetch_result)->data; | ||
619 | |||
620 | for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; | ||
621 | cur = clist_next(cur)) { | ||
622 | msg_att_item = clist_content(cur); | ||
623 | |||
624 | if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) { | ||
625 | |||
626 | if (msg_att_item->att_data.att_static->att_type == | ||
627 | MAILIMAP_MSG_ATT_RFC822_SIZE) { | ||
628 | size = msg_att_item->att_data.att_static->att_data.att_rfc822_size; | ||
629 | |||
630 | * result = size; | ||
631 | |||
632 | mailimap_fetch_list_free(fetch_result); | ||
633 | return MAIL_NO_ERROR; | ||
634 | } | ||
635 | } | ||
636 | } | ||
637 | |||
638 | mailimap_fetch_list_free(fetch_result); | ||
639 | |||
640 | return MAIL_ERROR_FETCH; | ||
641 | |||
642 | free_fetch_att: | ||
643 | mailimap_fetch_att_free(fetch_att); | ||
644 | free_set: | ||
645 | mailimap_set_free(set); | ||
646 | err: | ||
647 | return res; | ||
648 | } | ||
649 | |||
650 | static int imap_get_bodystructure(mailmessage * msg_info, | ||
651 | struct mailmime ** result) | ||
652 | { | ||
653 | int r; | ||
654 | struct mailimap_set * set; | ||
655 | struct mailimap_fetch_att * fetch_att; | ||
656 | struct mailimap_fetch_type * fetch_type; | ||
657 | clist * fetch_result; | ||
658 | struct mailimap_msg_att * msg_att; | ||
659 | struct mailimap_body * imap_body; | ||
660 | struct mailmime * body; | ||
661 | int res; | ||
662 | struct mailimf_fields * fields; | ||
663 | struct mailmime * new_body; | ||
664 | struct mailmime_content * content_message; | ||
665 | struct mailimap_envelope * envelope; | ||
666 | uint32_t uid; | ||
667 | char * references; | ||
668 | size_t ref_size; | ||
669 | clistiter * cur; | ||
670 | |||
671 | if (msg_info->msg_mime != NULL) { | ||
672 | * result = msg_info->msg_mime; | ||
673 | |||
674 | return MAIL_NO_ERROR; | ||
675 | } | ||
676 | |||
677 | set = mailimap_set_new_single(msg_info->msg_index); | ||
678 | if (set == NULL) { | ||
679 | res = MAIL_ERROR_MEMORY; | ||
680 | goto err; | ||
681 | } | ||
682 | |||
683 | fetch_type = mailimap_fetch_type_new_fetch_att_list_empty(); | ||
684 | if (fetch_type == NULL) { | ||
685 | res = MAIL_ERROR_MEMORY; | ||
686 | goto free_set; | ||
687 | } | ||
688 | |||
689 | fetch_att = mailimap_fetch_att_new_uid(); | ||
690 | if (fetch_att == NULL) { | ||
691 | res = MAIL_ERROR_MEMORY; | ||
692 | goto free_fetch_type; | ||
693 | } | ||
694 | |||
695 | r = mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att); | ||
696 | if (r != MAILIMAP_NO_ERROR) { | ||
697 | mailimap_fetch_att_free(fetch_att); | ||
698 | res = MAIL_ERROR_MEMORY; | ||
699 | goto free_fetch_type; | ||
700 | } | ||
701 | |||
702 | fetch_att = mailimap_fetch_att_new_bodystructure(); | ||
703 | if (fetch_att == NULL) { | ||
704 | res = MAIL_ERROR_MEMORY; | ||
705 | goto free_fetch_type; | ||
706 | } | ||
707 | |||
708 | r = mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att); | ||
709 | if (r != MAILIMAP_NO_ERROR) { | ||
710 | mailimap_fetch_att_free(fetch_att); | ||
711 | res = MAIL_ERROR_MEMORY; | ||
712 | goto free_fetch_type; | ||
713 | } | ||
714 | |||
715 | r = imap_add_envelope_fetch_att(fetch_type); | ||
716 | if (r != MAIL_NO_ERROR) { | ||
717 | res = r; | ||
718 | goto free_fetch_type; | ||
719 | } | ||
720 | |||
721 | |||
722 | r = mailimap_uid_fetch(get_imap_session(msg_info), set, | ||
723 | fetch_type, &fetch_result); | ||
724 | |||
725 | mailimap_fetch_type_free(fetch_type); | ||
726 | mailimap_set_free(set); | ||
727 | |||
728 | switch (r) { | ||
729 | case MAILIMAP_NO_ERROR: | ||
730 | break; | ||
731 | default: | ||
732 | return imap_error_to_mail_error(r); | ||
733 | } | ||
734 | |||
735 | cur = clist_begin(fetch_result); | ||
736 | if (cur == NULL) { | ||
737 | mailimap_fetch_list_free(fetch_result); | ||
738 | return MAIL_ERROR_FETCH; | ||
739 | } | ||
740 | |||
741 | msg_att = clist_content(cur); | ||
742 | |||
743 | uid = 0; | ||
744 | references = NULL; | ||
745 | ref_size = 0; | ||
746 | imap_body = NULL; | ||
747 | envelope = NULL; | ||
748 | |||
749 | r = imap_get_msg_att_info(msg_att, | ||
750 | &uid, &envelope, &references, &ref_size, NULL, &imap_body); | ||
751 | if (r != MAIL_NO_ERROR) { | ||
752 | mailimap_fetch_list_free(fetch_result); | ||
753 | res = r; | ||
754 | goto err; | ||
755 | } | ||
756 | |||
757 | if (uid != msg_info->msg_index) { | ||
758 | mailimap_fetch_list_free(fetch_result); | ||
759 | res = MAIL_ERROR_MSG_NOT_FOUND; | ||
760 | goto err; | ||
761 | } | ||
762 | |||
763 | if (imap_body == NULL) { | ||
764 | mailimap_fetch_list_free(fetch_result); | ||
765 | res = MAIL_ERROR_FETCH; | ||
766 | goto err; | ||
767 | } | ||
768 | |||
769 | r = imap_body_to_body(imap_body, &body); | ||
770 | if (r != MAIL_NO_ERROR) { | ||
771 | mailimap_fetch_list_free(fetch_result); | ||
772 | res = r; | ||
773 | goto err; | ||
774 | } | ||
775 | |||
776 | fields = NULL; | ||
777 | if (envelope != NULL) { | ||
778 | r = imap_env_to_fields(envelope, references, ref_size, &fields); | ||
779 | if (r != MAIL_NO_ERROR) { | ||
780 | mailmime_free(body); | ||
781 | mailimap_fetch_list_free(fetch_result); | ||
782 | res = r; | ||
783 | goto err; | ||
784 | } | ||
785 | } | ||
786 | |||
787 | content_message = mailmime_get_content_message(); | ||
788 | if (content_message == NULL) { | ||
789 | if (fields != NULL) | ||
790 | mailimf_fields_free(fields); | ||
791 | mailmime_free(body); | ||
792 | mailimap_fetch_list_free(fetch_result); | ||
793 | res = MAIL_ERROR_MEMORY; | ||
794 | goto err; | ||
795 | } | ||
796 | |||
797 | new_body = mailmime_new(MAILMIME_MESSAGE, NULL, | ||
798 | 0, NULL, content_message, | ||
799 | NULL, NULL, NULL, NULL, fields, body); | ||
800 | |||
801 | if (new_body == NULL) { | ||
802 | mailmime_content_free(content_message); | ||
803 | if (fields != NULL) | ||
804 | mailimf_fields_free(fields); | ||
805 | mailmime_free(body); | ||
806 | mailimap_fetch_list_free(fetch_result); | ||
807 | res = MAIL_ERROR_MEMORY; | ||
808 | goto err; | ||
809 | } | ||
810 | msg_info->msg_mime = new_body; | ||
811 | |||
812 | mailimap_fetch_list_free(fetch_result); | ||
813 | |||
814 | * result = new_body; | ||
815 | |||
816 | return MAIL_NO_ERROR; | ||
817 | |||
818 | free_fetch_type: | ||
819 | mailimap_fetch_type_free(fetch_type); | ||
820 | free_set: | ||
821 | mailimap_set_free(set); | ||
822 | err: | ||
823 | return res; | ||
824 | } | ||
825 | |||
826 | static int | ||
827 | fetch_imap(mailmessage * msg, | ||
828 | struct mailimap_fetch_type * fetch_type, | ||
829 | char ** result, size_t * result_len) | ||
830 | { | ||
831 | int r; | ||
832 | struct mailimap_msg_att * msg_att; | ||
833 | struct mailimap_msg_att_item * msg_att_item; | ||
834 | clist * fetch_result; | ||
835 | struct mailimap_set * set; | ||
836 | char * text; | ||
837 | size_t text_length; | ||
838 | clistiter * cur; | ||
839 | |||
840 | set = mailimap_set_new_single(msg->msg_index); | ||
841 | if (set == NULL) | ||
842 | return MAIL_ERROR_MEMORY; | ||
843 | |||
844 | r = mailimap_uid_fetch(get_imap_session(msg), set, | ||
845 | fetch_type, &fetch_result); | ||
846 | |||
847 | mailimap_set_free(set); | ||
848 | |||
849 | switch (r) { | ||
850 | case MAILIMAP_NO_ERROR: | ||
851 | break; | ||
852 | default: | ||
853 | return imap_error_to_mail_error(r); | ||
854 | } | ||
855 | |||
856 | if (clist_begin(fetch_result) == NULL) { | ||
857 | mailimap_fetch_list_free(fetch_result); | ||
858 | return MAIL_ERROR_FETCH; | ||
859 | } | ||
860 | |||
861 | msg_att = clist_begin(fetch_result)->data; | ||
862 | |||
863 | text = NULL; | ||
864 | text_length = 0; | ||
865 | |||
866 | for(cur = clist_begin(msg_att->att_list) ; cur != NULL ; | ||
867 | cur = clist_next(cur)) { | ||
868 | msg_att_item = clist_content(cur); | ||
869 | |||
870 | if (msg_att_item->att_type == MAILIMAP_MSG_ATT_ITEM_STATIC) { | ||
871 | |||
872 | if (msg_att_item->att_data.att_static->att_type == | ||
873 | MAILIMAP_MSG_ATT_BODY_SECTION) { | ||
874 | text = msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part; | ||
875 | msg_att_item->att_data.att_static->att_data.att_body_section->sec_body_part = NULL; | ||
876 | text_length = | ||
877 | msg_att_item->att_data.att_static->att_data.att_body_section->sec_length; | ||
878 | } | ||
879 | } | ||
880 | } | ||
881 | |||
882 | mailimap_fetch_list_free(fetch_result); | ||
883 | |||
884 | if (text == NULL) | ||
885 | return MAIL_ERROR_FETCH; | ||
886 | |||
887 | * result = text; | ||
888 | * result_len = text_length; | ||
889 | |||
890 | return MAIL_NO_ERROR; | ||
891 | } | ||
892 | |||
893 | |||
894 | static int imap_fetch_section(mailmessage * msg_info, | ||
895 | struct mailmime * mime, | ||
896 | char ** result, size_t * result_len) | ||
897 | { | ||
898 | struct mailimap_section * section; | ||
899 | struct mailimap_fetch_att * fetch_att; | ||
900 | int r; | ||
901 | struct mailimap_fetch_type * fetch_type; | ||
902 | char * text; | ||
903 | size_t text_length; | ||
904 | struct mailmime_section * part; | ||
905 | |||
906 | if (mime->mm_parent == NULL) | ||
907 | return imap_fetch(msg_info, result, result_len); | ||
908 | |||
909 | r = mailmime_get_section_id(mime, &part); | ||
910 | if (r != MAILIMF_NO_ERROR) | ||
911 | return maildriver_imf_error_to_mail_error(r); | ||
912 | |||
913 | r = section_to_imap_section(part, IMAP_SECTION_MESSAGE, §ion); | ||
914 | mailmime_section_free(part); | ||
915 | if (r != MAIL_NO_ERROR) | ||
916 | return r; | ||
917 | |||
918 | fetch_att = mailimap_fetch_att_new_body_peek_section(section); | ||
919 | if (fetch_att == NULL) { | ||
920 | mailimap_section_free(section); | ||
921 | return MAIL_ERROR_MEMORY; | ||
922 | } | ||
923 | |||
924 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
925 | if (fetch_type == NULL) { | ||
926 | mailimap_fetch_att_free(fetch_att); | ||
927 | return MAIL_ERROR_MEMORY; | ||
928 | } | ||
929 | |||
930 | r = fetch_imap(msg_info, fetch_type, &text, &text_length); | ||
931 | |||
932 | mailimap_fetch_type_free(fetch_type); | ||
933 | |||
934 | if (r != MAIL_NO_ERROR) | ||
935 | return r; | ||
936 | |||
937 | * result = text; | ||
938 | * result_len = text_length; | ||
939 | |||
940 | return MAIL_NO_ERROR; | ||
941 | } | ||
942 | |||
943 | static int imap_fetch_section_header(mailmessage * msg_info, | ||
944 | struct mailmime * mime, | ||
945 | char ** result, | ||
946 | size_t * result_len) | ||
947 | { | ||
948 | struct mailimap_section * section; | ||
949 | struct mailimap_fetch_att * fetch_att; | ||
950 | int r; | ||
951 | struct mailimap_fetch_type * fetch_type; | ||
952 | char * text; | ||
953 | size_t text_length; | ||
954 | struct mailmime_section * part; | ||
955 | |||
956 | if (mime->mm_parent == NULL) | ||
957 | return imap_fetch_header(msg_info, result, result_len); | ||
958 | |||
959 | r = mailmime_get_section_id(mime, &part); | ||
960 | if (r != MAILIMF_NO_ERROR) | ||
961 | return maildriver_imf_error_to_mail_error(r); | ||
962 | |||
963 | r = section_to_imap_section(part, IMAP_SECTION_HEADER, §ion); | ||
964 | mailmime_section_free(part); | ||
965 | if (r != MAIL_NO_ERROR) | ||
966 | return r; | ||
967 | |||
968 | fetch_att = mailimap_fetch_att_new_body_peek_section(section); | ||
969 | if (fetch_att == NULL) { | ||
970 | mailimap_section_free(section); | ||
971 | return MAIL_ERROR_MEMORY; | ||
972 | } | ||
973 | |||
974 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
975 | if (fetch_type == NULL) { | ||
976 | mailimap_fetch_att_free(fetch_att); | ||
977 | return MAIL_ERROR_MEMORY; | ||
978 | } | ||
979 | |||
980 | r = fetch_imap(msg_info, fetch_type, &text, &text_length); | ||
981 | mailimap_fetch_type_free(fetch_type); | ||
982 | |||
983 | if (r != MAIL_NO_ERROR) | ||
984 | return r; | ||
985 | |||
986 | * result = text; | ||
987 | * result_len = text_length; | ||
988 | |||
989 | return MAIL_NO_ERROR; | ||
990 | } | ||
991 | |||
992 | static int imap_fetch_section_mime(mailmessage * msg_info, | ||
993 | struct mailmime * mime, | ||
994 | char ** result, | ||
995 | size_t * result_len) | ||
996 | { | ||
997 | struct mailimap_section * section; | ||
998 | struct mailimap_fetch_att * fetch_att; | ||
999 | int r; | ||
1000 | struct mailimap_fetch_type * fetch_type; | ||
1001 | char * text; | ||
1002 | size_t text_length; | ||
1003 | struct mailmime_section * part; | ||
1004 | |||
1005 | if (mime->mm_parent == NULL) | ||
1006 | return MAIL_ERROR_INVAL; | ||
1007 | |||
1008 | if (mime->mm_parent->mm_parent == NULL) | ||
1009 | return imap_fetch_header(msg_info, result, result_len); | ||
1010 | |||
1011 | r = mailmime_get_section_id(mime, &part); | ||
1012 | if (r != MAILIMF_NO_ERROR) | ||
1013 | return maildriver_imf_error_to_mail_error(r); | ||
1014 | |||
1015 | r = section_to_imap_section(part, IMAP_SECTION_MIME, §ion); | ||
1016 | mailmime_section_free(part); | ||
1017 | if (r != MAIL_NO_ERROR) | ||
1018 | return MAIL_ERROR_MEMORY; | ||
1019 | |||
1020 | fetch_att = mailimap_fetch_att_new_body_peek_section(section); | ||
1021 | if (fetch_att == NULL) { | ||
1022 | mailimap_section_free(section); | ||
1023 | return MAIL_ERROR_MEMORY; | ||
1024 | } | ||
1025 | |||
1026 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
1027 | if (fetch_type == NULL) { | ||
1028 | mailimap_fetch_att_free(fetch_att); | ||
1029 | return MAIL_ERROR_MEMORY; | ||
1030 | } | ||
1031 | |||
1032 | r = fetch_imap(msg_info, fetch_type, &text, &text_length); | ||
1033 | |||
1034 | mailimap_fetch_type_free(fetch_type); | ||
1035 | |||
1036 | if (r != MAIL_NO_ERROR) | ||
1037 | return r; | ||
1038 | |||
1039 | * result = text; | ||
1040 | * result_len = text_length; | ||
1041 | |||
1042 | return MAIL_NO_ERROR; | ||
1043 | } | ||
1044 | |||
1045 | static int imap_fetch_section_body(mailmessage * msg_info, | ||
1046 | struct mailmime * mime, | ||
1047 | char ** result, | ||
1048 | size_t * result_len) | ||
1049 | { | ||
1050 | struct mailimap_section * section; | ||
1051 | struct mailimap_fetch_att * fetch_att; | ||
1052 | int r; | ||
1053 | struct mailimap_fetch_type * fetch_type; | ||
1054 | char * text; | ||
1055 | size_t text_length; | ||
1056 | struct mailmime_section * part; | ||
1057 | |||
1058 | if (mime->mm_parent == NULL) | ||
1059 | return imap_fetch_body(msg_info, result, result_len); | ||
1060 | |||
1061 | if (mime->mm_parent->mm_parent == NULL) | ||
1062 | return imap_fetch_body(msg_info, result, result_len); | ||
1063 | |||
1064 | r = mailmime_get_section_id(mime, &part); | ||
1065 | if (r != MAILIMF_NO_ERROR) | ||
1066 | return maildriver_imf_error_to_mail_error(r); | ||
1067 | |||
1068 | r = section_to_imap_section(part, IMAP_SECTION_BODY, §ion); | ||
1069 | mailmime_section_free(part); | ||
1070 | if (r != MAIL_NO_ERROR) | ||
1071 | return MAIL_ERROR_MEMORY; | ||
1072 | |||
1073 | fetch_att = mailimap_fetch_att_new_body_peek_section(section); | ||
1074 | if (fetch_att == NULL) { | ||
1075 | mailimap_section_free(section); | ||
1076 | return MAIL_ERROR_MEMORY; | ||
1077 | } | ||
1078 | |||
1079 | fetch_type = mailimap_fetch_type_new_fetch_att(fetch_att); | ||
1080 | if (fetch_type == NULL) { | ||
1081 | mailimap_fetch_att_free(fetch_att); | ||
1082 | return MAIL_ERROR_MEMORY; | ||
1083 | } | ||
1084 | |||
1085 | r = fetch_imap(msg_info, fetch_type, &text, &text_length); | ||
1086 | |||
1087 | mailimap_fetch_type_free(fetch_type); | ||
1088 | |||
1089 | if (r != MAIL_NO_ERROR) | ||
1090 | return r; | ||
1091 | |||
1092 | * result = text; | ||
1093 | * result_len = text_length; | ||
1094 | |||
1095 | return MAIL_NO_ERROR; | ||
1096 | } | ||
1097 | |||
1098 | static int imap_get_flags(mailmessage * msg_info, | ||
1099 | struct mail_flags ** result) | ||
1100 | { | ||
1101 | int r; | ||
1102 | struct mail_flags * flags; | ||
1103 | |||
1104 | if (msg_info->msg_flags != NULL) { | ||
1105 | * result = msg_info->msg_flags; | ||
1106 | return MAIL_NO_ERROR; | ||
1107 | } | ||
1108 | |||
1109 | flags = mail_flags_store_get(get_session_data(msg_info)->imap_flags_store, | ||
1110 | msg_info->msg_index); | ||
1111 | |||
1112 | if (flags == NULL) { | ||
1113 | r = imap_fetch_flags(get_imap_session(msg_info), | ||
1114 | msg_info->msg_index, &flags); | ||
1115 | if (r != MAIL_NO_ERROR) | ||
1116 | return r; | ||
1117 | } | ||
1118 | |||
1119 | msg_info->msg_flags = flags; | ||
1120 | |||
1121 | * result = flags; | ||
1122 | |||
1123 | return MAIL_NO_ERROR; | ||
1124 | } | ||
1125 | |||
1126 | static int imap_fetch_envelope(mailmessage * msg_info, | ||
1127 | struct mailimf_fields ** result) | ||
1128 | { | ||
1129 | int r; | ||
1130 | struct mailimap_set * set; | ||
1131 | struct mailimap_fetch_att * fetch_att; | ||
1132 | struct mailimap_fetch_type * fetch_type; | ||
1133 | clist * fetch_result; | ||
1134 | struct mailimap_msg_att * msg_att; | ||
1135 | int res; | ||
1136 | struct mailimf_fields * fields; | ||
1137 | struct mailimap_envelope * envelope; | ||
1138 | uint32_t uid; | ||
1139 | char * references; | ||
1140 | size_t ref_size; | ||
1141 | |||
1142 | set = mailimap_set_new_single(msg_info->msg_index); | ||
1143 | if (set == NULL) { | ||
1144 | res = MAIL_ERROR_MEMORY; | ||
1145 | goto err; | ||
1146 | } | ||
1147 | |||
1148 | fetch_type = mailimap_fetch_type_new_fetch_att_list_empty(); | ||
1149 | if (fetch_type == NULL) { | ||
1150 | res = MAIL_ERROR_MEMORY; | ||
1151 | goto free_set; | ||
1152 | } | ||
1153 | |||
1154 | fetch_att = mailimap_fetch_att_new_uid(); | ||
1155 | if (fetch_att == NULL) { | ||
1156 | res = MAIL_ERROR_MEMORY; | ||
1157 | goto free_fetch_type; | ||
1158 | } | ||
1159 | |||
1160 | r = mailimap_fetch_type_new_fetch_att_list_add(fetch_type, fetch_att); | ||
1161 | if (r != MAILIMAP_NO_ERROR) { | ||
1162 | mailimap_fetch_att_free(fetch_att); | ||
1163 | res = MAIL_ERROR_MEMORY; | ||
1164 | goto free_fetch_type; | ||
1165 | } | ||
1166 | |||
1167 | r = imap_add_envelope_fetch_att(fetch_type); | ||
1168 | if (r != MAIL_NO_ERROR) { | ||
1169 | res = r; | ||
1170 | goto free_fetch_type; | ||
1171 | } | ||
1172 | |||
1173 | r = mailimap_uid_fetch(get_imap_session(msg_info), set, | ||
1174 | fetch_type, &fetch_result); | ||
1175 | |||
1176 | mailimap_fetch_type_free(fetch_type); | ||
1177 | mailimap_set_free(set); | ||
1178 | |||
1179 | switch (r) { | ||
1180 | case MAILIMAP_NO_ERROR: | ||
1181 | break; | ||
1182 | default: | ||
1183 | return imap_error_to_mail_error(r); | ||
1184 | } | ||
1185 | |||
1186 | if (clist_begin(fetch_result) == NULL) { | ||
1187 | mailimap_fetch_list_free(fetch_result); | ||
1188 | return MAIL_ERROR_FETCH; | ||
1189 | } | ||
1190 | |||
1191 | msg_att = clist_begin(fetch_result)->data; | ||
1192 | |||
1193 | uid = 0; | ||
1194 | references = NULL; | ||
1195 | ref_size = 0; | ||
1196 | envelope = NULL; | ||
1197 | |||
1198 | r = imap_get_msg_att_info(msg_att, | ||
1199 | &uid, | ||
1200 | &envelope, | ||
1201 | &references, | ||
1202 | &ref_size, | ||
1203 | NULL, | ||
1204 | NULL); | ||
1205 | if (r != MAIL_NO_ERROR) { | ||
1206 | mailimap_fetch_list_free(fetch_result); | ||
1207 | res = r; | ||
1208 | goto err; | ||
1209 | } | ||
1210 | |||
1211 | if (uid != msg_info->msg_index) { | ||
1212 | mailimap_fetch_list_free(fetch_result); | ||
1213 | res = MAIL_ERROR_MSG_NOT_FOUND; | ||
1214 | goto err; | ||
1215 | } | ||
1216 | |||
1217 | fields = NULL; | ||
1218 | if (envelope != NULL) { | ||
1219 | r = imap_env_to_fields(envelope, references, ref_size, &fields); | ||
1220 | if (r != MAIL_NO_ERROR) { | ||
1221 | mailimap_fetch_list_free(fetch_result); | ||
1222 | res = r; | ||
1223 | goto err; | ||
1224 | } | ||
1225 | } | ||
1226 | |||
1227 | mailimap_fetch_list_free(fetch_result); | ||
1228 | |||
1229 | * result = fields; | ||
1230 | |||
1231 | return MAIL_NO_ERROR; | ||
1232 | |||
1233 | free_fetch_type: | ||
1234 | mailimap_fetch_type_free(fetch_type); | ||
1235 | free_set: | ||
1236 | mailimap_set_free(set); | ||
1237 | err: | ||
1238 | return res; | ||
1239 | } | ||