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: mhdriver.c,v 1.38 2008/02/20 22:15:50 hoa Exp $
34 */
35
36 #ifdef HAVE_CONFIG_H
37 # include <config.h>
38 #endif
39
40 #include "mhdriver.h"
41
42 #include <stdio.h>
43 #include <sys/types.h>
44 #ifdef WIN32
45 # include "win_etpan.h"
46 #else
47 # include <dirent.h>
48 # include <unistd.h>
49 # include <sys/mman.h>
50 #endif
51 #include <sys/stat.h>
52 #include <ctype.h>
53 #include <fcntl.h>
54 #include <stdlib.h>
55 #include <string.h>
56
57 #include "mailmh.h"
58 #include "maildriver_tools.h"
59 #include "mhdriver_tools.h"
60 #include "mhdriver_message.h"
61 #include "mailmessage.h"
62
63 static int mhdriver_initialize(mailsession * session);
64
65 static void mhdriver_uninitialize(mailsession * session);
66
67 static int mhdriver_connect_path(mailsession * session, const char * path);
68 static int mhdriver_logout(mailsession * session);
69
70 static int mhdriver_build_folder_name(mailsession * session, const char * mb,
71 const char * name, char ** result);
72 static int mhdriver_create_folder(mailsession * session, const char * mb);
73
74 static int mhdriver_delete_folder(mailsession * session, const char * mb);
75
76 static int mhdriver_rename_folder(mailsession * session, const char * mb,
77 const char * new_name);
78
79 static int mhdriver_select_folder(mailsession * session, const char * mb);
80
81 static int mhdriver_status_folder(mailsession * session, const char * mb,
82 uint32_t * result_messages, uint32_t * result_recent,
83 uint32_t * result_unseen);
84
85 static int mhdriver_messages_number(mailsession * session, const char * mb,
86 uint32_t * result);
87
88 static int mhdriver_list_folders(mailsession * session, const char * mb,
89 struct mail_list ** result);
90
91 static int mhdriver_lsub_folders(mailsession * session, const char * mb,
92 struct mail_list ** result);
93
94 static int mhdriver_subscribe_folder(mailsession * session, const char * mb);
95
96 static int mhdriver_unsubscribe_folder(mailsession * session, const char * mb);
97
98 static int mhdriver_append_message(mailsession * session,
99 const char * message, size_t size);
100 static int mhdriver_append_message_flags(mailsession * session,
101 const char * message, size_t size, struct mail_flags * flags);
102 static int mhdriver_copy_message(mailsession * session,
103 uint32_t num, const char * mb);
104
105 static int mhdriver_remove_message(mailsession * session, uint32_t num);
106
107 static int mhdriver_move_message(mailsession * session,
108 uint32_t num, const char * mb);
109
110 static int mhdriver_get_messages_list(mailsession * session,
111 struct mailmessage_list ** result);
112
113 static int mhdriver_get_message(mailsession * session,
114 uint32_t num, mailmessage ** result);
115
116 static int mhdriver_get_message_by_uid(mailsession * session,
117 const char * uid,
118 mailmessage ** result);
119
120 static mailsession_driver local_mh_session_driver = {
121 /* sess_name */ "mh",
122
123 /* sess_initialize */ mhdriver_initialize,
124 /* sess_uninitialize */ mhdriver_uninitialize,
125
126 /* sess_parameters */ NULL,
127
128 /* sess_connect_stream */ NULL,
129 /* sess_connect_path */ mhdriver_connect_path,
130 /* sess_starttls */ NULL,
131 /* sess_login */ NULL,
132 /* sess_logout */ mhdriver_logout,
133 /* sess_noop */ NULL,
134
135 /* sess_build_folder_name */ mhdriver_build_folder_name,
136 /* sess_create_folder */ mhdriver_create_folder,
137 /* sess_delete_folder */ mhdriver_delete_folder,
138 /* sess_rename_folder */ mhdriver_rename_folder,
139 /* sess_check_folder */ NULL,
140 /* sess_examine_folder */ NULL,
141 /* sess_select_folder */ mhdriver_select_folder,
142 /* sess_expunge_folder */ NULL,
143 /* sess_status_folder */ mhdriver_status_folder,
144 /* sess_messages_number */ mhdriver_messages_number,
145 /* sess_recent_number */ mhdriver_messages_number,
146 /* sess_unseen_number */ mhdriver_messages_number,
147 /* sess_list_folders */ mhdriver_list_folders,
148 /* sess_lsub_folders */ mhdriver_lsub_folders,
149 /* sess_subscribe_folder */ mhdriver_subscribe_folder,
150 /* sess_unsubscribe_folder */ mhdriver_unsubscribe_folder,
151
152 /* sess_append_message */ mhdriver_append_message,
153 /* sess_append_message_flags */ mhdriver_append_message_flags,
154 /* sess_copy_message */ mhdriver_copy_message,
155 /* sess_move_message */ mhdriver_move_message,
156
157 /* sess_get_message */ mhdriver_get_message,
158 /* sess_get_message_by_uid */ mhdriver_get_message_by_uid,
159
160 /* sess_get_messages_list */ mhdriver_get_messages_list,
161 /* sess_get_envelopes_list */ maildriver_generic_get_envelopes_list,
162 /* sess_remove_message */ mhdriver_remove_message,
163 #if 0
164 /* sess_search_messages */ maildriver_generic_search_messages,
165 #endif
166 /* sess_login_sasl */ NULL
167 };
168
169 mailsession_driver * mh_session_driver = &local_mh_session_driver;
170
get_data(mailsession * session)171 static inline struct mh_session_state_data * get_data(mailsession * session)
172 {
173 return session->sess_data;
174 }
175
get_mh_session(mailsession * session)176 static inline struct mailmh * get_mh_session(mailsession * session)
177 {
178 return get_data(session)->mh_session;
179 }
180
get_mh_cur_folder(mailsession * session)181 static inline struct mailmh_folder * get_mh_cur_folder(mailsession * session)
182 {
183 return get_data(session)->mh_cur_folder;
184 }
185
add_to_list(mailsession * session,const char * mb)186 static int add_to_list(mailsession * session, const char * mb)
187 {
188 char * new_mb;
189 struct mh_session_state_data * data;
190 int r;
191
192 data = get_data(session);
193
194 new_mb = strdup(mb);
195 if (new_mb == NULL)
196 return -1;
197
198 r = clist_append(data->mh_subscribed_list, new_mb);
199 if (r < 0) {
200 free(new_mb);
201 return -1;
202 }
203
204 return 0;
205 }
206
remove_from_list(mailsession * session,const char * mb)207 static int remove_from_list(mailsession * session, const char * mb)
208 {
209 clistiter * cur;
210 struct mh_session_state_data * data;
211
212 data = get_data(session);
213
214 for(cur = clist_begin(data->mh_subscribed_list) ;
215 cur != NULL ; cur = clist_next(cur)) {
216 char * cur_name;
217
218 cur_name = clist_content(cur);
219 if (strcmp(cur_name, mb) == 0) {
220 clist_delete(data->mh_subscribed_list, cur);
221 free(cur_name);
222 return 0;
223 }
224 }
225
226 return -1;
227 }
228
mhdriver_initialize(mailsession * session)229 static int mhdriver_initialize(mailsession * session)
230 {
231 struct mh_session_state_data * data;
232
233 data = malloc(sizeof(* data));
234 if (data == NULL)
235 goto err;
236
237 data->mh_session = NULL;
238 data->mh_cur_folder = NULL;
239
240 data->mh_subscribed_list = clist_new();
241 if (data->mh_subscribed_list == NULL)
242 goto free;
243
244 session->sess_data = data;
245
246 return MAIL_NO_ERROR;
247
248 free:
249 free(data);
250 err:
251 return MAIL_ERROR_MEMORY;
252 }
253
mhdriver_uninitialize(mailsession * session)254 static void mhdriver_uninitialize(mailsession * session)
255 {
256 struct mh_session_state_data * data;
257
258 data = get_data(session);
259
260 if (data->mh_session != NULL)
261 mailmh_free(data->mh_session);
262
263 clist_foreach(data->mh_subscribed_list, (clist_func) free, NULL);
264 clist_free(data->mh_subscribed_list);
265
266 free(data);
267
268 session->sess_data = NULL;
269 }
270
271
mhdriver_connect_path(mailsession * session,const char * path)272 static int mhdriver_connect_path(mailsession * session, const char * path)
273 {
274 struct mailmh * mh;
275
276 if (get_mh_session(session) != NULL)
277 return MAIL_ERROR_BAD_STATE;
278
279 mh = mailmh_new(path);
280 if (mh == NULL)
281 return MAIL_ERROR_MEMORY;
282
283 get_data(session)->mh_session = mh;
284
285 return MAIL_NO_ERROR;
286 }
287
mhdriver_logout(mailsession * session)288 static int mhdriver_logout(mailsession * session)
289 {
290 struct mailmh * mh;
291
292 mh = get_mh_session(session);
293
294 if (mh == NULL)
295 return MAIL_ERROR_BAD_STATE;
296
297 mailmh_free(mh);
298 get_data(session)->mh_session = NULL;
299
300 return MAIL_NO_ERROR;
301 }
302
303 /* folders operations */
304
mhdriver_build_folder_name(mailsession * session,const char * mb,const char * name,char ** result)305 static int mhdriver_build_folder_name(mailsession * session, const char * mb,
306 const char * name, char ** result)
307 {
308 char * folder_name;
309
310 folder_name = malloc(strlen(mb) + 2 + strlen(name));
311 if (folder_name == NULL)
312 return MAIL_ERROR_MEMORY;
313
314 strcpy(folder_name, mb);
315 strcat(folder_name, "/");
316 strcat(folder_name, name);
317
318 * result = folder_name;
319
320 return MAIL_NO_ERROR;
321 }
322
get_parent(mailsession * session,const char * mb,struct mailmh_folder ** result_folder,const char ** result_name)323 static int get_parent(mailsession * session, const char * mb,
324 struct mailmh_folder ** result_folder,
325 const char ** result_name)
326 {
327 const char * name;
328 size_t length;
329 size_t i;
330 char * parent_name;
331 struct mailmh_folder * parent;
332 struct mailmh * mh;
333
334 mh = get_mh_session(session);
335 if (mh == NULL)
336 return MAIL_ERROR_BAD_STATE;
337
338 length = strlen(mb);
339 if (length > 0) {
340 i = length - 1;
341 while (1) {
342 if (i == 0)
343 return MAIL_ERROR_INVAL;
344 if (mb[i] == '/')
345 break;
346 i --;
347 }
348 name = mb + i + 1;
349 }
350 else {
351 return MAIL_ERROR_INVAL;
352 }
353
354 parent_name = malloc(i + 1);
355 /* strndup(mb, i) */
356 if (parent_name == NULL)
357 return MAIL_ERROR_MEMORY;
358
359 strncpy(parent_name, mb, i);
360 parent_name[i] = '\0';
361
362 parent = mailmh_folder_find(mh->mh_main, parent_name);
363 free(parent_name);
364 if (parent == NULL)
365 return MAIL_ERROR_FOLDER_NOT_FOUND;
366
367 * result_folder = parent;
368 * result_name = name;
369
370 return MAIL_NO_ERROR;
371 }
372
mhdriver_create_folder(mailsession * session,const char * mb)373 static int mhdriver_create_folder(mailsession * session, const char * mb)
374 {
375 int r;
376 struct mailmh_folder * parent;
377 const char * name;
378
379 r = get_parent(session, mb, &parent, &name);
380 if (r != MAIL_NO_ERROR)
381 return r;
382
383 r = mailmh_folder_add_subfolder(parent, name);
384
385 return mhdriver_mh_error_to_mail_error(r);
386 }
387
mhdriver_delete_folder(mailsession * session,const char * mb)388 static int mhdriver_delete_folder(mailsession * session, const char * mb)
389 {
390 int r;
391 struct mailmh_folder * folder;
392 struct mailmh * mh;
393
394 mh = get_mh_session(session);
395 if (mh == NULL)
396 return MAIL_ERROR_BAD_STATE;
397
398 folder = mailmh_folder_find(mh->mh_main, mb);
399 if (folder == NULL)
400 return MAIL_ERROR_FOLDER_NOT_FOUND;
401
402 if (get_mh_cur_folder(session) == folder)
403 get_data(session)->mh_cur_folder = NULL;
404
405 r = mailmh_folder_remove_subfolder(folder);
406
407 return mhdriver_mh_error_to_mail_error(r);
408 }
409
mhdriver_rename_folder(mailsession * session,const char * mb,const char * new_name)410 static int mhdriver_rename_folder(mailsession * session, const char * mb,
411 const char * new_name)
412 {
413 struct mailmh_folder * src_folder;
414 struct mailmh_folder * dst_folder;
415 const char * name;
416 struct mailmh * mh;
417 int r;
418
419 r = get_parent(session, new_name, &dst_folder, &name);
420 if (r != MAIL_NO_ERROR)
421 return r;
422
423 mh = get_mh_session(session);
424 if (mh == NULL)
425 return MAIL_ERROR_BAD_STATE;
426
427 src_folder = mailmh_folder_find(mh->mh_main, mb);
428 if (src_folder == NULL)
429 return MAIL_ERROR_FOLDER_NOT_FOUND;
430
431 if (get_mh_cur_folder(session) == src_folder)
432 get_data(session)->mh_cur_folder = NULL;
433
434 r = mailmh_folder_rename_subfolder(src_folder, dst_folder, name);
435
436 return mhdriver_mh_error_to_mail_error(r);
437 }
438
mhdriver_select_folder(mailsession * session,const char * mb)439 static int mhdriver_select_folder(mailsession * session, const char * mb)
440 {
441 struct mailmh_folder * folder;
442 struct mailmh * mh;
443 int r;
444
445 mh = get_mh_session(session);
446 if (mh == NULL)
447 return MAIL_ERROR_BAD_STATE;
448
449 r = mailmh_folder_update(mh->mh_main);
450
451 folder = mailmh_folder_find(mh->mh_main, mb);
452 if (folder == NULL)
453 return MAIL_ERROR_FOLDER_NOT_FOUND;
454
455 get_data(session)->mh_cur_folder = folder;
456 r = mailmh_folder_update(folder);
457
458 return mhdriver_mh_error_to_mail_error(r);
459 }
460
mhdriver_status_folder(mailsession * session,const char * mb,uint32_t * result_messages,uint32_t * result_recent,uint32_t * result_unseen)461 static int mhdriver_status_folder(mailsession * session, const char * mb,
462 uint32_t * result_messages, uint32_t * result_recent,
463 uint32_t * result_unseen)
464 {
465 uint32_t count;
466 int r;
467
468 r = mhdriver_messages_number(session, mb, &count);
469 if (r != MAIL_NO_ERROR)
470 return r;
471
472 * result_messages = count;
473 * result_recent = count;
474 * result_unseen = count;
475
476 return MAIL_NO_ERROR;
477 }
478
mhdriver_messages_number(mailsession * session,const char * mb,uint32_t * result)479 static int mhdriver_messages_number(mailsession * session, const char * mb,
480 uint32_t * result)
481 {
482 struct mailmh_folder * folder;
483 uint32_t count;
484 struct mailmh * mh;
485 unsigned int i;
486
487 mh = get_mh_session(session);
488 if (mh == NULL)
489 return MAIL_ERROR_BAD_STATE;
490
491 if (mb != NULL) {
492 folder = mailmh_folder_find(mh->mh_main, mb);
493 if (folder == NULL)
494 return MAIL_ERROR_FOLDER_NOT_FOUND;
495 }
496 else {
497 folder = get_mh_cur_folder(session);
498 if (folder == NULL)
499 return MAIL_ERROR_BAD_STATE;
500 }
501
502 mailmh_folder_update(folder);
503 count = 0;
504 for (i = 0 ; i < carray_count(folder->fl_msgs_tab) ; i ++) {
505 struct mailmh_msg_info * msg_info;
506
507 msg_info = carray_get(folder->fl_msgs_tab, i);
508 if (msg_info != NULL)
509 count ++;
510 }
511
512 * result = count;
513
514 return MAIL_NO_ERROR;
515 }
516
517
get_list_folders(struct mailmh_folder * folder,clist ** result)518 static int get_list_folders(struct mailmh_folder * folder, clist ** result)
519 {
520 unsigned int i;
521 clist * list;
522 char * new_filename;
523 int res;
524 int r;
525
526 list = * result;
527
528 new_filename = strdup(folder->fl_filename);
529 if (new_filename == NULL) {
530 res = MAIL_ERROR_MEMORY;
531 goto free;
532 }
533
534 r = mailmh_folder_update(folder);
535
536 switch (r) {
537 case MAILMH_NO_ERROR:
538 break;
539
540 default:
541 res = mhdriver_mh_error_to_mail_error(r);
542 free(new_filename);
543 goto free;
544 }
545
546 r = clist_append(list, new_filename);
547 if (r < 0) {
548 free(new_filename);
549 res = MAIL_ERROR_MEMORY;
550 goto free;
551 }
552
553 if (folder->fl_subfolders_tab != NULL) {
554 for(i = 0 ; i < carray_count(folder->fl_subfolders_tab) ; i++) {
555 struct mailmh_folder * subfolder;
556
557 subfolder = carray_get(folder->fl_subfolders_tab, i);
558
559 r = get_list_folders(subfolder, &list);
560 if (r != MAIL_NO_ERROR) {
561 free(new_filename);
562 res = MAIL_ERROR_MEMORY;
563 goto free;
564 }
565 }
566 }
567
568 * result = list;
569
570 free(new_filename);
571 return MAIL_NO_ERROR;
572
573 free:
574 clist_foreach(list, (clist_func) free, NULL);
575 clist_free(list);
576 return res;
577 }
578
579
mhdriver_list_folders(mailsession * session,const char * mb,struct mail_list ** result)580 static int mhdriver_list_folders(mailsession * session, const char * mb,
581 struct mail_list ** result)
582 {
583 clist * list;
584 int r;
585 struct mailmh * mh;
586 struct mail_list * ml;
587
588 mh = get_mh_session(session);
589
590 if (mh == NULL)
591 return MAIL_ERROR_BAD_STATE;
592
593 list = clist_new();
594 if (list == NULL)
595 return MAIL_ERROR_MEMORY;
596
597 r = get_list_folders(mh->mh_main, &list);
598 if (r != MAIL_NO_ERROR)
599 return r;
600
601 ml = mail_list_new(list);
602 if (ml == NULL)
603 goto free;
604
605 * result = ml;
606
607 return MAIL_NO_ERROR;
608
609 free:
610 clist_foreach(list, (clist_func) free, NULL);
611 clist_free(list);
612 return MAIL_ERROR_MEMORY;
613 }
614
mhdriver_lsub_folders(mailsession * session,const char * mb,struct mail_list ** result)615 static int mhdriver_lsub_folders(mailsession * session, const char * mb,
616 struct mail_list ** result)
617 {
618 clist * subscribed;
619 clist * lsub_result;
620 clistiter * cur;
621 struct mail_list * lsub;
622 size_t length;
623 int r;
624
625 length = strlen(mb);
626
627 subscribed = get_data(session)->mh_subscribed_list;
628
629 lsub_result = clist_new();
630 if (lsub_result == NULL)
631 return MAIL_ERROR_MEMORY;
632
633 for(cur = clist_begin(subscribed) ; cur != NULL ;
634 cur = clist_next(cur)) {
635 char * cur_mb;
636 char * new_mb;
637
638 cur_mb = clist_content(cur);
639
640 if (strncmp(mb, cur_mb, length) == 0) {
641 new_mb = strdup(cur_mb);
642 if (new_mb == NULL)
643 goto free_list;
644
645 r = clist_append(lsub_result, new_mb);
646 if (r < 0) {
647 free(new_mb);
648 goto free_list;
649 }
650 }
651 }
652
653 lsub = mail_list_new(lsub_result);
654 if (lsub == NULL)
655 goto free_list;
656
657 * result = lsub;
658
659 return MAIL_NO_ERROR;
660
661 free_list:
662 clist_foreach(lsub_result, (clist_func) free, NULL);
663 clist_free(lsub_result);
664 return MAIL_ERROR_MEMORY;
665 }
666
mhdriver_subscribe_folder(mailsession * session,const char * mb)667 static int mhdriver_subscribe_folder(mailsession * session, const char * mb)
668 {
669 int r;
670
671 r = add_to_list(session, mb);
672 if (r < 0)
673 return MAIL_ERROR_SUBSCRIBE;
674
675 return MAIL_NO_ERROR;
676 }
677
mhdriver_unsubscribe_folder(mailsession * session,const char * mb)678 static int mhdriver_unsubscribe_folder(mailsession * session, const char * mb)
679 {
680 int r;
681
682 r = remove_from_list(session, mb);
683 if (r < 0)
684 return MAIL_ERROR_UNSUBSCRIBE;
685
686 return MAIL_NO_ERROR;
687 }
688
689 /* messages operations */
690
mhdriver_append_message(mailsession * session,const char * message,size_t size)691 static int mhdriver_append_message(mailsession * session,
692 const char * message, size_t size)
693 {
694 int r;
695 struct mailmh_folder * folder;
696
697 folder = get_mh_cur_folder(session);
698 if (folder == NULL)
699 return MAIL_ERROR_BAD_STATE;
700
701 r = mailmh_folder_add_message(folder, message, size);
702
703 switch (r) {
704 case MAILMH_ERROR_FILE:
705 return MAIL_ERROR_DISKSPACE;
706
707 default:
708 return mhdriver_mh_error_to_mail_error(r);
709 }
710 }
711
mhdriver_append_message_flags(mailsession * session,const char * message,size_t size,struct mail_flags * flags)712 static int mhdriver_append_message_flags(mailsession * session,
713 const char * message, size_t size, struct mail_flags * flags)
714 {
715 return mhdriver_append_message(session, message, size);
716 }
717
mhdriver_copy_message(mailsession * session,uint32_t num,const char * mb)718 static int mhdriver_copy_message(mailsession * session,
719 uint32_t num, const char * mb)
720 {
721 int fd;
722 int r;
723 struct mailmh_folder * folder;
724 struct mailmh * mh;
725 int res;
726
727 mh = get_mh_session(session);
728 if (mh == NULL) {
729 res = MAIL_ERROR_BAD_STATE;
730 goto err;
731 }
732
733 folder = get_mh_cur_folder(session);
734 if (folder == NULL) {
735 res = MAIL_ERROR_BAD_STATE;
736 goto err;
737 }
738
739 r = mailmh_folder_get_message_fd(folder, num, O_RDONLY, &fd);
740 if (r != MAIL_NO_ERROR) {
741 res = r;
742 goto err;
743 }
744
745 folder = mailmh_folder_find(mh->mh_main, mb);
746 if (folder == NULL) {
747 res = MAIL_ERROR_FOLDER_NOT_FOUND;
748 goto close;
749 }
750
751 r = mailmh_folder_add_message_file(folder, fd);
752 if (r != MAIL_NO_ERROR) {
753 res = MAIL_ERROR_COPY;
754 goto close;
755 }
756
757 close(fd);
758
759 return MAIL_NO_ERROR;
760
761 close:
762 close(fd);
763 err:
764 return res;
765 }
766
mhdriver_remove_message(mailsession * session,uint32_t num)767 static int mhdriver_remove_message(mailsession * session, uint32_t num)
768 {
769 int r;
770 struct mailmh_folder * folder;
771
772 folder = get_mh_cur_folder(session);
773 if (folder == NULL)
774 return MAIL_ERROR_DELETE;
775
776 r = mailmh_folder_remove_message(folder, num);
777
778 return mhdriver_mh_error_to_mail_error(r);
779 }
780
mhdriver_move_message(mailsession * session,uint32_t num,const char * mb)781 static int mhdriver_move_message(mailsession * session,
782 uint32_t num, const char * mb)
783 {
784 int r;
785 struct mailmh_folder * src_folder;
786 struct mailmh_folder * dest_folder;
787 struct mailmh * mh;
788
789 mh = get_mh_session(session);
790 if (mh == NULL)
791 return MAIL_ERROR_BAD_STATE;
792
793 src_folder = get_mh_cur_folder(session);
794 if (src_folder == NULL)
795 return MAIL_ERROR_BAD_STATE;
796
797 dest_folder = mailmh_folder_find(mh->mh_main, mb);
798 if (dest_folder == NULL)
799 return MAIL_ERROR_FOLDER_NOT_FOUND;
800
801 r = mailmh_folder_move_message(dest_folder, src_folder, num);
802
803 return mhdriver_mh_error_to_mail_error(r);
804 }
805
806
mhdriver_get_messages_list(mailsession * session,struct mailmessage_list ** result)807 static int mhdriver_get_messages_list(mailsession * session,
808 struct mailmessage_list ** result)
809 {
810 struct mailmh_folder * folder;
811 int res;
812
813 folder = get_mh_cur_folder(session);
814 if (folder == NULL) {
815 res = MAIL_ERROR_BAD_STATE;
816 goto err;
817 }
818
819 mailmh_folder_update(folder);
820 return mh_get_messages_list(folder, session, mh_message_driver, result);
821
822 err:
823 return res;
824 }
825
mhdriver_get_message(mailsession * session,uint32_t num,mailmessage ** result)826 static int mhdriver_get_message(mailsession * session,
827 uint32_t num, mailmessage ** result)
828 {
829 mailmessage * msg_info;
830 int r;
831
832 msg_info = mailmessage_new();
833 if (msg_info == NULL)
834 return MAIL_ERROR_MEMORY;
835
836 r = mailmessage_init(msg_info, session, mh_message_driver, num, 0);
837 if (r != MAIL_NO_ERROR) {
838 mailmessage_free(msg_info);
839 return r;
840 }
841
842 * result = msg_info;
843
844 return MAIL_NO_ERROR;
845 }
846
mhdriver_get_message_by_uid(mailsession * session,const char * uid,mailmessage ** result)847 static int mhdriver_get_message_by_uid(mailsession * session,
848 const char * uid,
849 mailmessage ** result)
850 {
851 uint32_t indx;
852 char *p;
853 struct mailmh_msg_info * mh_msg_info;
854 struct mh_session_state_data * mh_data;
855 chashdatum key;
856 chashdatum data;
857 int r;
858 time_t mtime;
859 char * mtime_p;
860
861 if (uid == NULL)
862 return MAIL_ERROR_INVAL;
863
864 indx = (uint32_t) strtoul(uid, &p, 10);
865 if (p == uid || * p != '-')
866 return MAIL_ERROR_INVAL;
867
868 mh_data = session->sess_data;
869 key.data = &indx;
870 key.len = sizeof(indx);
871 r = chash_get(mh_data->mh_cur_folder->fl_msgs_hash, &key, &data);
872 if (r < 0)
873 return MAIL_ERROR_MSG_NOT_FOUND;
874
875 mh_msg_info = data.data;
876
877 mtime_p = p + 1;
878
879 mtime = strtoul(mtime_p, &p, 10);
880 if ((* p == '-') && (mtime == mh_msg_info->msg_mtime)) {
881 size_t size;
882 char *size_p;
883
884 size_p = p + 1;
885 size = strtoul(size_p, &p, 10);
886 if ((* p == '\0') && (size == mh_msg_info->msg_size))
887 return mhdriver_get_message(session, indx, result);
888 }
889 else if (* p != '-') {
890 return MAIL_ERROR_INVAL;
891 }
892
893 return MAIL_ERROR_MSG_NOT_FOUND;
894 }
895