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: mailimap_types.c,v 1.31 2011/03/16 22:40:04 hoa Exp $
34 */
35
36 #ifdef HAVE_CONFIG_H
37 # include <config.h>
38 #endif
39
40 #include "mailimap_types.h"
41 #include "mmapstring.h"
42 #include "mail.h"
43 #include "mailimap_extension.h"
44 #include "mailimap.h"
45
46 #include <stdlib.h>
47 #include <stdio.h>
48 #include <stdbool.h>
49
50 /* ************************************************************************* */
51 /* ************************************************************************* */
52 /* ************************************************************************* */
53 /* ************************************************************************* */
54 /* ************************************************************************* */
55 /* ************************************************************************* */
56
57
58
59
60
61
62 /* from parser */
63
64
65 LIBETPAN_EXPORT
mailimap_number_alloc_new(uint32_t number)66 uint32_t * mailimap_number_alloc_new(uint32_t number)
67 {
68 uint32_t * pnumber;
69
70 pnumber = malloc(sizeof(* pnumber));
71 if (pnumber == NULL)
72 return NULL;
73
74 * pnumber = number;
75
76 return pnumber;
77 }
78
79 LIBETPAN_EXPORT
mailimap_number_alloc_free(uint32_t * pnumber)80 void mailimap_number_alloc_free(uint32_t * pnumber)
81 {
82 free(pnumber);
83 }
84
85
86 /* ************************************************************************* */
87
88
89 LIBETPAN_EXPORT
90 struct mailimap_address *
mailimap_address_new(char * ad_personal_name,char * ad_source_route,char * ad_mailbox_name,char * ad_host_name)91 mailimap_address_new(char * ad_personal_name, char * ad_source_route,
92 char * ad_mailbox_name, char * ad_host_name)
93 {
94 struct mailimap_address * addr;
95
96 addr = malloc(sizeof(* addr));
97 if (addr == NULL)
98 return NULL;
99
100 addr->ad_personal_name = ad_personal_name;
101 addr->ad_source_route = ad_source_route;
102 addr->ad_mailbox_name = ad_mailbox_name;
103 addr->ad_host_name = ad_host_name;
104
105 return addr;
106 }
107
108 LIBETPAN_EXPORT
mailimap_address_free(struct mailimap_address * addr)109 void mailimap_address_free(struct mailimap_address * addr)
110 {
111 mailimap_addr_host_free(addr->ad_host_name);
112 mailimap_addr_mailbox_free(addr->ad_mailbox_name);
113 mailimap_addr_adl_free(addr->ad_source_route);
114 mailimap_addr_name_free(addr->ad_personal_name);
115 free(addr);
116 }
117
118 LIBETPAN_EXPORT
mailimap_addr_host_free(char * addr_host)119 void mailimap_addr_host_free(char * addr_host)
120 {
121 mailimap_nstring_free(addr_host);
122 }
123
124 LIBETPAN_EXPORT
mailimap_addr_mailbox_free(char * addr_mailbox)125 void mailimap_addr_mailbox_free(char * addr_mailbox)
126 {
127 mailimap_nstring_free(addr_mailbox);
128 }
129
130 LIBETPAN_EXPORT
mailimap_addr_adl_free(char * addr_adl)131 void mailimap_addr_adl_free(char * addr_adl)
132 {
133 mailimap_nstring_free(addr_adl);
134 }
135
136 LIBETPAN_EXPORT
mailimap_addr_name_free(char * addr_name)137 void mailimap_addr_name_free(char * addr_name)
138 {
139 mailimap_nstring_free(addr_name);
140 }
141
142
143
144
145
146 LIBETPAN_EXPORT
mailimap_astring_free(char * astring)147 void mailimap_astring_free(char * astring)
148 {
149 if (mmap_string_unref(astring) != 0)
150 free(astring);
151 }
152
mailimap_custom_string_free(char * str)153 static void mailimap_custom_string_free(char * str)
154 {
155 free(str);
156 }
157
158
159 LIBETPAN_EXPORT
mailimap_atom_free(char * atom)160 void mailimap_atom_free(char * atom)
161 {
162 free(atom);
163 }
164
165
166
167
168 LIBETPAN_EXPORT
mailimap_auth_type_free(char * auth_type)169 void mailimap_auth_type_free(char * auth_type)
170 {
171 mailimap_atom_free(auth_type);
172 }
173
174
175
176
177
178 LIBETPAN_EXPORT
mailimap_base64_free(char * base64)179 void mailimap_base64_free(char * base64)
180 {
181 free(base64);
182 }
183
184
185
186
187 LIBETPAN_EXPORT
188 struct mailimap_body *
mailimap_body_new(int bd_type,struct mailimap_body_type_1part * bd_body_1part,struct mailimap_body_type_mpart * bd_body_mpart)189 mailimap_body_new(int bd_type,
190 struct mailimap_body_type_1part * bd_body_1part,
191 struct mailimap_body_type_mpart * bd_body_mpart)
192 {
193 struct mailimap_body * body;
194
195 body = malloc(sizeof(* body));
196 if (body == NULL)
197 return NULL;
198
199 body->bd_type = bd_type;
200 switch (bd_type) {
201 case MAILIMAP_BODY_1PART:
202 body->bd_data.bd_body_1part = bd_body_1part;
203 break;
204 case MAILIMAP_BODY_MPART:
205 body->bd_data.bd_body_mpart = bd_body_mpart;
206 break;
207 }
208
209 return body;
210 }
211
212 LIBETPAN_EXPORT
mailimap_body_free(struct mailimap_body * body)213 void mailimap_body_free(struct mailimap_body * body)
214 {
215 switch (body->bd_type) {
216 case MAILIMAP_BODY_1PART:
217 mailimap_body_type_1part_free(body->bd_data.bd_body_1part);
218 break;
219 case MAILIMAP_BODY_MPART:
220 mailimap_body_type_mpart_free(body->bd_data.bd_body_mpart);
221 break;
222 }
223 free(body);
224 }
225
226
227 LIBETPAN_EXPORT
228 struct mailimap_body_extension *
mailimap_body_extension_new(int ext_type,char * ext_nstring,uint32_t ext_number,clist * ext_body_extension_list)229 mailimap_body_extension_new(int ext_type, char * ext_nstring,
230 uint32_t ext_number,
231 clist * ext_body_extension_list)
232 {
233 struct mailimap_body_extension * body_extension;
234
235 body_extension = malloc(sizeof(* body_extension));
236 if (body_extension == NULL)
237 return NULL;
238
239 body_extension->ext_type = ext_type;
240 switch (ext_type) {
241 case MAILIMAP_BODY_EXTENSION_NSTRING:
242 body_extension->ext_data.ext_nstring = ext_nstring;
243 break;
244 case MAILIMAP_BODY_EXTENSION_NUMBER:
245 body_extension->ext_data.ext_number = ext_number;
246 break;
247 case MAILIMAP_BODY_EXTENSION_LIST:
248 body_extension->ext_data.ext_body_extension_list = ext_body_extension_list;
249 break;
250 }
251
252 return body_extension;
253 }
254
255 static void
256 mailimap_body_ext_list_free(clist * body_ext_list);
257
258 LIBETPAN_EXPORT
mailimap_body_extension_free(struct mailimap_body_extension * be)259 void mailimap_body_extension_free(struct mailimap_body_extension * be)
260 {
261 switch (be->ext_type) {
262 case MAILIMAP_BODY_EXTENSION_NSTRING:
263 mailimap_nstring_free(be->ext_data.ext_nstring);
264 break;
265 case MAILIMAP_BODY_EXTENSION_LIST:
266 mailimap_body_ext_list_free(be->ext_data.ext_body_extension_list);
267 break;
268 }
269
270 free(be);
271 }
272
273
274 static void
mailimap_body_ext_list_free(clist * body_ext_list)275 mailimap_body_ext_list_free(clist * body_ext_list)
276 {
277 clist_foreach(body_ext_list, (clist_func) mailimap_body_extension_free,
278 NULL);
279 clist_free(body_ext_list);
280 }
281
282
283 LIBETPAN_EXPORT
284 struct mailimap_body_ext_1part *
mailimap_body_ext_1part_new(char * bd_md5,struct mailimap_body_fld_dsp * bd_disposition,struct mailimap_body_fld_lang * bd_language,char * bd_loc,clist * bd_extension_list)285 mailimap_body_ext_1part_new(char * bd_md5,
286 struct mailimap_body_fld_dsp * bd_disposition,
287 struct mailimap_body_fld_lang * bd_language,
288 char * bd_loc,
289 clist * bd_extension_list)
290 {
291 struct mailimap_body_ext_1part * body_ext_1part;
292
293 body_ext_1part = malloc(sizeof(* body_ext_1part));
294 if (body_ext_1part == NULL)
295 return NULL;
296
297 body_ext_1part->bd_md5 = bd_md5;
298 body_ext_1part->bd_disposition = bd_disposition;
299 body_ext_1part->bd_language = bd_language;
300 body_ext_1part->bd_loc = bd_loc;
301 body_ext_1part->bd_extension_list = bd_extension_list;
302
303 return body_ext_1part;
304 }
305
306 LIBETPAN_EXPORT
307 void
mailimap_body_ext_1part_free(struct mailimap_body_ext_1part * body_ext_1part)308 mailimap_body_ext_1part_free(struct mailimap_body_ext_1part * body_ext_1part)
309 {
310 mailimap_body_fld_md5_free(body_ext_1part->bd_md5);
311 if (body_ext_1part->bd_disposition)
312 mailimap_body_fld_dsp_free(body_ext_1part->bd_disposition);
313 if (body_ext_1part->bd_language)
314 mailimap_body_fld_lang_free(body_ext_1part->bd_language);
315 if (body_ext_1part->bd_extension_list)
316 mailimap_body_ext_list_free(body_ext_1part->bd_extension_list);
317 mailimap_body_fld_loc_free(body_ext_1part->bd_loc);
318
319 free(body_ext_1part);
320 }
321
322 LIBETPAN_EXPORT
323 struct mailimap_body_ext_mpart *
mailimap_body_ext_mpart_new(struct mailimap_body_fld_param * bd_parameter,struct mailimap_body_fld_dsp * bd_disposition,struct mailimap_body_fld_lang * bd_language,char * bd_loc,clist * bd_extension_list)324 mailimap_body_ext_mpart_new(struct mailimap_body_fld_param * bd_parameter,
325 struct mailimap_body_fld_dsp * bd_disposition,
326 struct mailimap_body_fld_lang * bd_language,
327 char * bd_loc,
328 clist * bd_extension_list)
329 {
330 struct mailimap_body_ext_mpart * body_ext_mpart;
331
332 body_ext_mpart = malloc(sizeof(* body_ext_mpart));
333 if (body_ext_mpart == NULL)
334 return NULL;
335
336 body_ext_mpart->bd_parameter = bd_parameter;
337 body_ext_mpart->bd_disposition = bd_disposition;
338 body_ext_mpart->bd_language = bd_language;
339 body_ext_mpart->bd_extension_list = bd_extension_list;
340 body_ext_mpart->bd_loc = bd_loc;
341
342 return body_ext_mpart;
343 }
344
345 LIBETPAN_EXPORT
346 void
mailimap_body_ext_mpart_free(struct mailimap_body_ext_mpart * body_ext_mpart)347 mailimap_body_ext_mpart_free(struct mailimap_body_ext_mpart * body_ext_mpart)
348 {
349 if (body_ext_mpart->bd_parameter != NULL)
350 mailimap_body_fld_param_free(body_ext_mpart->bd_parameter);
351 if (body_ext_mpart->bd_disposition)
352 mailimap_body_fld_dsp_free(body_ext_mpart->bd_disposition);
353 if (body_ext_mpart->bd_language)
354 mailimap_body_fld_lang_free(body_ext_mpart->bd_language);
355 if (body_ext_mpart->bd_extension_list)
356 mailimap_body_ext_list_free(body_ext_mpart->bd_extension_list);
357 mailimap_body_fld_loc_free(body_ext_mpart->bd_loc);
358 free(body_ext_mpart);
359 }
360
361
362 LIBETPAN_EXPORT
363 struct mailimap_body_fields *
mailimap_body_fields_new(struct mailimap_body_fld_param * bd_parameter,char * bd_id,char * bd_description,struct mailimap_body_fld_enc * bd_encoding,uint32_t bd_size)364 mailimap_body_fields_new(struct mailimap_body_fld_param * bd_parameter,
365 char * bd_id,
366 char * bd_description,
367 struct mailimap_body_fld_enc * bd_encoding,
368 uint32_t bd_size)
369 {
370 struct mailimap_body_fields * body_fields;
371
372 body_fields = malloc(sizeof(* body_fields));
373 if (body_fields == NULL)
374 return NULL;
375 body_fields->bd_parameter = bd_parameter;
376 body_fields->bd_id = bd_id;
377 body_fields->bd_description = bd_description;
378 body_fields->bd_encoding = bd_encoding;
379 body_fields->bd_size = bd_size;
380
381 return body_fields;
382 }
383
384 LIBETPAN_EXPORT
385 void
mailimap_body_fields_free(struct mailimap_body_fields * body_fields)386 mailimap_body_fields_free(struct mailimap_body_fields * body_fields)
387 {
388 if (body_fields->bd_parameter != NULL)
389 mailimap_body_fld_param_free(body_fields->bd_parameter);
390 mailimap_body_fld_id_free(body_fields->bd_id);
391 mailimap_body_fld_desc_free(body_fields->bd_description);
392 mailimap_body_fld_enc_free(body_fields->bd_encoding);
393 free(body_fields);
394 }
395
396
397
398
399
400
401 LIBETPAN_EXPORT
mailimap_body_fld_desc_free(char * body_fld_desc)402 void mailimap_body_fld_desc_free(char * body_fld_desc)
403 {
404 mailimap_nstring_free(body_fld_desc);
405 }
406
407
408
409
410 LIBETPAN_EXPORT
411 struct mailimap_body_fld_dsp *
mailimap_body_fld_dsp_new(char * dsp_type,struct mailimap_body_fld_param * dsp_attributes)412 mailimap_body_fld_dsp_new(char * dsp_type,
413 struct mailimap_body_fld_param * dsp_attributes)
414 {
415 struct mailimap_body_fld_dsp * body_fld_dsp;
416
417 body_fld_dsp = malloc(sizeof(* body_fld_dsp));
418 if (body_fld_dsp == NULL)
419 return NULL;
420
421 body_fld_dsp->dsp_type = dsp_type;
422 body_fld_dsp->dsp_attributes = dsp_attributes;
423
424 return body_fld_dsp;
425 }
426
427 LIBETPAN_EXPORT
mailimap_body_fld_dsp_free(struct mailimap_body_fld_dsp * bfd)428 void mailimap_body_fld_dsp_free(struct mailimap_body_fld_dsp * bfd)
429 {
430 if (bfd->dsp_type != NULL)
431 mailimap_string_free(bfd->dsp_type);
432 if (bfd->dsp_attributes != NULL)
433 mailimap_body_fld_param_free(bfd->dsp_attributes);
434 free(bfd);
435 }
436
437
438
439 LIBETPAN_EXPORT
440 struct mailimap_body_fld_enc *
mailimap_body_fld_enc_new(int enc_type,char * enc_value)441 mailimap_body_fld_enc_new(int enc_type, char * enc_value)
442 {
443 struct mailimap_body_fld_enc * body_fld_enc;
444
445 body_fld_enc = malloc(sizeof(* body_fld_enc));
446 if (body_fld_enc == NULL)
447 return NULL;
448
449 body_fld_enc->enc_type = enc_type;
450 body_fld_enc->enc_value = enc_value;
451
452 return body_fld_enc;
453 }
454
455 LIBETPAN_EXPORT
mailimap_body_fld_enc_free(struct mailimap_body_fld_enc * bfe)456 void mailimap_body_fld_enc_free(struct mailimap_body_fld_enc * bfe)
457 {
458 if (bfe->enc_value)
459 mailimap_string_free(bfe->enc_value);
460 free(bfe);
461 }
462
463
464
465 LIBETPAN_EXPORT
mailimap_body_fld_id_free(char * body_fld_id)466 void mailimap_body_fld_id_free(char * body_fld_id)
467 {
468 mailimap_nstring_free(body_fld_id);
469 }
470
471
472
473 LIBETPAN_EXPORT
474 struct mailimap_body_fld_lang *
mailimap_body_fld_lang_new(int lg_type,char * lg_single,clist * lg_list)475 mailimap_body_fld_lang_new(int lg_type, char * lg_single, clist * lg_list)
476 {
477 struct mailimap_body_fld_lang * fld_lang;
478
479 fld_lang = malloc(sizeof(* fld_lang));
480 if (fld_lang == NULL)
481 return NULL;
482
483 fld_lang->lg_type = lg_type;
484 switch (lg_type) {
485 case MAILIMAP_BODY_FLD_LANG_SINGLE:
486 fld_lang->lg_data.lg_single = lg_single;
487 break;
488 case MAILIMAP_BODY_FLD_LANG_LIST:
489 fld_lang->lg_data.lg_list = lg_list;
490 break;
491 }
492
493 return fld_lang;
494 }
495
496 LIBETPAN_EXPORT
497 void
mailimap_body_fld_lang_free(struct mailimap_body_fld_lang * fld_lang)498 mailimap_body_fld_lang_free(struct mailimap_body_fld_lang * fld_lang)
499 {
500 switch (fld_lang->lg_type) {
501 case MAILIMAP_BODY_FLD_LANG_SINGLE:
502 mailimap_nstring_free(fld_lang->lg_data.lg_single);
503 break;
504 case MAILIMAP_BODY_FLD_LANG_LIST:
505 clist_foreach(fld_lang->lg_data.lg_list,
506 (clist_func) mailimap_string_free, NULL);
507 clist_free(fld_lang->lg_data.lg_list);
508 break;
509 }
510 free(fld_lang);
511 }
512
513
514
515 LIBETPAN_EXPORT
mailimap_body_fld_md5_free(char * body_fld_md5)516 void mailimap_body_fld_md5_free(char * body_fld_md5)
517 {
518 mailimap_nstring_free(body_fld_md5);
519 }
520
521 LIBETPAN_EXPORT
mailimap_body_fld_loc_free(char * body_fld_loc)522 void mailimap_body_fld_loc_free(char * body_fld_loc)
523 {
524 mailimap_nstring_free(body_fld_loc);
525 }
526
527
528 LIBETPAN_EXPORT
529 struct mailimap_single_body_fld_param *
mailimap_single_body_fld_param_new(char * pa_name,char * pa_value)530 mailimap_single_body_fld_param_new(char * pa_name, char * pa_value)
531 {
532 struct mailimap_single_body_fld_param * param;
533
534 param = malloc(sizeof(* param));
535 if (param == NULL)
536 return NULL;
537 param->pa_name = pa_name;
538 param->pa_value = pa_value;
539
540 return param;
541 }
542
543 LIBETPAN_EXPORT
544 void
mailimap_single_body_fld_param_free(struct mailimap_single_body_fld_param * p)545 mailimap_single_body_fld_param_free(struct mailimap_single_body_fld_param * p)
546 {
547 mailimap_string_free(p->pa_name);
548 mailimap_string_free(p->pa_value);
549 free(p);
550 }
551
552
553 LIBETPAN_EXPORT
554 struct mailimap_body_fld_param *
mailimap_body_fld_param_new(clist * pa_list)555 mailimap_body_fld_param_new(clist * pa_list)
556 {
557 struct mailimap_body_fld_param * fld_param;
558
559 fld_param = malloc(sizeof(* fld_param));
560 if (fld_param == NULL)
561 return NULL;
562 fld_param->pa_list = pa_list;
563
564 return fld_param;
565 }
566
567 LIBETPAN_EXPORT
568 void
mailimap_body_fld_param_free(struct mailimap_body_fld_param * fld_param)569 mailimap_body_fld_param_free(struct mailimap_body_fld_param * fld_param)
570 {
571 clist_foreach(fld_param->pa_list,
572 (clist_func) mailimap_single_body_fld_param_free, NULL);
573 clist_free(fld_param->pa_list);
574 free(fld_param);
575 }
576
577
578 LIBETPAN_EXPORT
579 struct mailimap_body_type_1part *
mailimap_body_type_1part_new(int bd_type,struct mailimap_body_type_basic * bd_type_basic,struct mailimap_body_type_msg * bd_type_msg,struct mailimap_body_type_text * bd_type_text,struct mailimap_body_ext_1part * bd_ext_1part)580 mailimap_body_type_1part_new(int bd_type,
581 struct mailimap_body_type_basic * bd_type_basic,
582 struct mailimap_body_type_msg * bd_type_msg,
583 struct mailimap_body_type_text * bd_type_text,
584 struct mailimap_body_ext_1part * bd_ext_1part)
585 {
586 struct mailimap_body_type_1part * body_type_1part;
587
588 body_type_1part = malloc(sizeof(* body_type_1part));
589 if (body_type_1part == NULL)
590 return NULL;
591
592 body_type_1part->bd_type = bd_type;
593 switch (bd_type) {
594 case MAILIMAP_BODY_TYPE_1PART_BASIC:
595 body_type_1part->bd_data.bd_type_basic = bd_type_basic;
596 break;
597 case MAILIMAP_BODY_TYPE_1PART_MSG:
598 body_type_1part->bd_data.bd_type_msg = bd_type_msg;
599 break;
600 case MAILIMAP_BODY_TYPE_1PART_TEXT:
601 body_type_1part->bd_data.bd_type_text = bd_type_text;
602 break;
603 }
604 body_type_1part->bd_ext_1part = bd_ext_1part;
605
606 return body_type_1part;
607 }
608
609 LIBETPAN_EXPORT
610 void
mailimap_body_type_1part_free(struct mailimap_body_type_1part * bt1p)611 mailimap_body_type_1part_free(struct mailimap_body_type_1part * bt1p)
612 {
613 switch (bt1p->bd_type) {
614 case MAILIMAP_BODY_TYPE_1PART_BASIC:
615 mailimap_body_type_basic_free(bt1p->bd_data.bd_type_basic);
616 break;
617 case MAILIMAP_BODY_TYPE_1PART_MSG:
618 mailimap_body_type_msg_free(bt1p->bd_data.bd_type_msg);
619 break;
620 case MAILIMAP_BODY_TYPE_1PART_TEXT:
621 mailimap_body_type_text_free(bt1p->bd_data.bd_type_text);
622 break;
623 }
624 if (bt1p->bd_ext_1part)
625 mailimap_body_ext_1part_free(bt1p->bd_ext_1part);
626
627 free(bt1p);
628 }
629
630
631
632 LIBETPAN_EXPORT
633 struct mailimap_body_type_basic *
mailimap_body_type_basic_new(struct mailimap_media_basic * bd_media_basic,struct mailimap_body_fields * bd_fields)634 mailimap_body_type_basic_new(struct mailimap_media_basic * bd_media_basic,
635 struct mailimap_body_fields * bd_fields)
636 {
637 struct mailimap_body_type_basic * body_type_basic;
638
639 body_type_basic = malloc(sizeof(* body_type_basic));
640 if (body_type_basic == NULL)
641 return NULL;
642
643 body_type_basic->bd_media_basic = bd_media_basic;
644 body_type_basic->bd_fields = bd_fields;
645
646 return body_type_basic;
647 }
648
649 LIBETPAN_EXPORT
mailimap_body_type_basic_free(struct mailimap_body_type_basic * body_type_basic)650 void mailimap_body_type_basic_free(struct mailimap_body_type_basic *
651 body_type_basic)
652 {
653 mailimap_media_basic_free(body_type_basic->bd_media_basic);
654 mailimap_body_fields_free(body_type_basic->bd_fields);
655 free(body_type_basic);
656 }
657
658
659 LIBETPAN_EXPORT
660 struct mailimap_body_type_mpart *
mailimap_body_type_mpart_new(clist * bd_list,char * bd_media_subtype,struct mailimap_body_ext_mpart * bd_ext_mpart)661 mailimap_body_type_mpart_new(clist * bd_list, char * bd_media_subtype,
662 struct mailimap_body_ext_mpart * bd_ext_mpart)
663 {
664 struct mailimap_body_type_mpart * body_type_mpart;
665
666 body_type_mpart = malloc(sizeof(* body_type_mpart));
667 if (body_type_mpart == NULL)
668 return NULL;
669
670 body_type_mpart->bd_list = bd_list;
671 body_type_mpart->bd_media_subtype = bd_media_subtype;
672 body_type_mpart->bd_ext_mpart = bd_ext_mpart;
673
674 return body_type_mpart;
675 }
676
677 LIBETPAN_EXPORT
mailimap_body_type_mpart_free(struct mailimap_body_type_mpart * body_type_mpart)678 void mailimap_body_type_mpart_free(struct mailimap_body_type_mpart *
679 body_type_mpart)
680 {
681 clist_foreach(body_type_mpart->bd_list,
682 (clist_func) mailimap_body_free, NULL);
683 clist_free(body_type_mpart->bd_list);
684 mailimap_media_subtype_free(body_type_mpart->bd_media_subtype);
685 if (body_type_mpart->bd_ext_mpart)
686 mailimap_body_ext_mpart_free(body_type_mpart->bd_ext_mpart);
687
688 free(body_type_mpart);
689 }
690
691
692 LIBETPAN_EXPORT
693 struct mailimap_body_type_msg *
mailimap_body_type_msg_new(struct mailimap_body_fields * bd_fields,struct mailimap_envelope * bd_envelope,struct mailimap_body * bd_body,uint32_t bd_lines)694 mailimap_body_type_msg_new(struct mailimap_body_fields * bd_fields,
695 struct mailimap_envelope * bd_envelope,
696 struct mailimap_body * bd_body,
697 uint32_t bd_lines)
698 {
699 struct mailimap_body_type_msg * body_type_msg;
700
701 body_type_msg = malloc(sizeof(* body_type_msg));
702 if (body_type_msg == NULL)
703 return NULL;
704
705 body_type_msg->bd_fields = bd_fields;
706 body_type_msg->bd_envelope = bd_envelope;
707 body_type_msg->bd_body = bd_body;
708 body_type_msg->bd_lines = bd_lines;
709
710 return body_type_msg;
711 }
712
713 LIBETPAN_EXPORT
714 void
mailimap_body_type_msg_free(struct mailimap_body_type_msg * body_type_msg)715 mailimap_body_type_msg_free(struct mailimap_body_type_msg * body_type_msg)
716 {
717 mailimap_body_fields_free(body_type_msg->bd_fields);
718 mailimap_envelope_free(body_type_msg->bd_envelope);
719 mailimap_body_free(body_type_msg->bd_body);
720 free(body_type_msg);
721 }
722
723
724
725 LIBETPAN_EXPORT
726 struct mailimap_body_type_text *
mailimap_body_type_text_new(char * bd_media_text,struct mailimap_body_fields * bd_fields,uint32_t bd_lines)727 mailimap_body_type_text_new(char * bd_media_text,
728 struct mailimap_body_fields * bd_fields,
729 uint32_t bd_lines)
730 {
731 struct mailimap_body_type_text * body_type_text;
732
733 body_type_text = malloc(sizeof(* body_type_text));
734 if (body_type_text == NULL)
735 return NULL;
736
737 body_type_text->bd_media_text = bd_media_text;
738 body_type_text->bd_fields = bd_fields;
739 body_type_text->bd_lines = bd_lines;
740
741 return body_type_text;
742 }
743
744 LIBETPAN_EXPORT
745 void
mailimap_body_type_text_free(struct mailimap_body_type_text * body_type_text)746 mailimap_body_type_text_free(struct mailimap_body_type_text * body_type_text)
747 {
748 mailimap_media_text_free(body_type_text->bd_media_text);
749 mailimap_body_fields_free(body_type_text->bd_fields);
750 free(body_type_text);
751 }
752
753
754
755 LIBETPAN_EXPORT
756 struct mailimap_capability *
mailimap_capability_new(int cap_type,char * cap_auth_type,char * cap_name)757 mailimap_capability_new(int cap_type, char * cap_auth_type, char * cap_name)
758 {
759 struct mailimap_capability * cap;
760
761 cap = malloc(sizeof(* cap));
762 if (cap == NULL)
763 return NULL;
764 cap->cap_type = cap_type;
765 switch (cap_type) {
766 case MAILIMAP_CAPABILITY_AUTH_TYPE:
767 cap->cap_data.cap_auth_type = cap_auth_type;
768 break;
769 case MAILIMAP_CAPABILITY_NAME:
770 cap->cap_data.cap_name = cap_name;
771 break;
772 }
773
774 return cap;
775 }
776
777 LIBETPAN_EXPORT
mailimap_capability_free(struct mailimap_capability * c)778 void mailimap_capability_free(struct mailimap_capability * c)
779 {
780 switch (c->cap_type) {
781 case MAILIMAP_CAPABILITY_AUTH_TYPE:
782 free(c->cap_data.cap_auth_type);
783 break;
784 case MAILIMAP_CAPABILITY_NAME:
785 free(c->cap_data.cap_name);
786 break;
787 }
788 free(c);
789 }
790
791
792 LIBETPAN_EXPORT
793 struct mailimap_capability_data *
mailimap_capability_data_new(clist * cap_list)794 mailimap_capability_data_new(clist * cap_list)
795 {
796 struct mailimap_capability_data * cap_data;
797
798 cap_data = malloc(sizeof(* cap_data));
799 if (cap_data == NULL)
800 return NULL;
801
802 cap_data->cap_list = cap_list;
803
804 return cap_data;
805 }
806
807 LIBETPAN_EXPORT
808 void
mailimap_capability_data_free(struct mailimap_capability_data * cap_data)809 mailimap_capability_data_free(struct mailimap_capability_data * cap_data)
810 {
811 if (cap_data->cap_list) {
812 clist_foreach(cap_data->cap_list,
813 (clist_func) mailimap_capability_free, NULL);
814 clist_free(cap_data->cap_list);
815 }
816 free(cap_data);
817 }
818
819
820
821
822 LIBETPAN_EXPORT
823 struct mailimap_continue_req *
mailimap_continue_req_new(int cr_type,struct mailimap_resp_text * cr_text,char * cr_base64)824 mailimap_continue_req_new(int cr_type, struct mailimap_resp_text * cr_text,
825 char * cr_base64)
826 {
827 struct mailimap_continue_req * cont_req;
828
829 cont_req = malloc(sizeof(* cont_req));
830 if (cont_req == NULL)
831 return NULL;
832 cont_req->cr_type = cr_type;
833 switch (cr_type) {
834 case MAILIMAP_CONTINUE_REQ_TEXT:
835 cont_req->cr_data.cr_text = cr_text;
836 break;
837 case MAILIMAP_CONTINUE_REQ_BASE64:
838 cont_req->cr_data.cr_base64 = cr_base64;
839 break;
840 }
841
842 return cont_req;
843 }
844
845 LIBETPAN_EXPORT
mailimap_continue_req_free(struct mailimap_continue_req * cont_req)846 void mailimap_continue_req_free(struct mailimap_continue_req * cont_req)
847 {
848 switch (cont_req->cr_type) {
849 case MAILIMAP_CONTINUE_REQ_TEXT:
850 mailimap_resp_text_free(cont_req->cr_data.cr_text);
851 break;
852 case MAILIMAP_CONTINUE_REQ_BASE64:
853 mailimap_base64_free(cont_req->cr_data.cr_base64);
854 break;
855 }
856 free(cont_req);
857 }
858
859 LIBETPAN_EXPORT
860 struct mailimap_date_time *
mailimap_date_time_new(int dt_day,int dt_month,int dt_year,int dt_hour,int dt_min,int dt_sec,int dt_zone)861 mailimap_date_time_new(int dt_day, int dt_month, int dt_year, int dt_hour,
862 int dt_min, int dt_sec, int dt_zone)
863 {
864 struct mailimap_date_time * date_time;
865
866 date_time = malloc(sizeof(* date_time));
867 if (date_time == NULL)
868 return NULL;
869
870 date_time->dt_day = dt_day;
871 date_time->dt_month = dt_month;
872 date_time->dt_year = dt_year;
873 date_time->dt_hour = dt_hour;
874 date_time->dt_min = dt_min;
875 date_time->dt_sec = dt_sec;
876 date_time->dt_zone = dt_zone;
877
878 return date_time;
879 }
880
881 LIBETPAN_EXPORT
mailimap_date_time_free(struct mailimap_date_time * date_time)882 void mailimap_date_time_free(struct mailimap_date_time * date_time)
883 {
884 free(date_time);
885 }
886
887
888
889 LIBETPAN_EXPORT
890 struct mailimap_envelope *
mailimap_envelope_new(char * env_date,char * env_subject,struct mailimap_env_from * env_from,struct mailimap_env_sender * env_sender,struct mailimap_env_reply_to * env_reply_to,struct mailimap_env_to * env_to,struct mailimap_env_cc * env_cc,struct mailimap_env_bcc * env_bcc,char * env_in_reply_to,char * env_message_id)891 mailimap_envelope_new(char * env_date, char * env_subject,
892 struct mailimap_env_from * env_from,
893 struct mailimap_env_sender * env_sender,
894 struct mailimap_env_reply_to * env_reply_to,
895 struct mailimap_env_to * env_to,
896 struct mailimap_env_cc* env_cc,
897 struct mailimap_env_bcc * env_bcc,
898 char * env_in_reply_to, char * env_message_id)
899 {
900 struct mailimap_envelope * env;
901
902 env = malloc(sizeof(* env));
903 if (env == NULL)
904 return NULL;
905
906 env->env_date = env_date;
907 env->env_subject = env_subject;
908 env->env_from = env_from;
909 env->env_sender = env_sender;
910 env->env_reply_to = env_reply_to;
911 env->env_to = env_to;
912 env->env_cc = env_cc;
913 env->env_bcc = env_bcc;
914 env->env_in_reply_to = env_in_reply_to;
915 env->env_message_id = env_message_id;
916
917 return env;
918 }
919
920
921 LIBETPAN_EXPORT
mailimap_envelope_free(struct mailimap_envelope * env)922 void mailimap_envelope_free(struct mailimap_envelope * env)
923 {
924 if (env->env_date)
925 mailimap_env_date_free(env->env_date);
926 if (env->env_subject)
927 mailimap_env_subject_free(env->env_subject);
928 if (env->env_from)
929 mailimap_env_from_free(env->env_from);
930 if (env->env_sender)
931 mailimap_env_sender_free(env->env_sender);
932 if (env->env_reply_to)
933 mailimap_env_reply_to_free(env->env_reply_to);
934 if (env->env_to)
935 mailimap_env_to_free(env->env_to);
936 if (env->env_cc)
937 mailimap_env_cc_free(env->env_cc);
938 if (env->env_bcc)
939 mailimap_env_bcc_free(env->env_bcc);
940 if (env->env_in_reply_to)
941 mailimap_env_in_reply_to_free(env->env_in_reply_to);
942 if (env->env_message_id)
943 mailimap_env_message_id_free(env->env_message_id);
944
945 free(env);
946 }
947
948
mailimap_address_list_free(clist * addr_list)949 static void mailimap_address_list_free(clist * addr_list)
950 {
951 if (addr_list != NULL) {
952 clist_foreach(addr_list, (clist_func) mailimap_address_free, NULL);
953 clist_free(addr_list);
954 }
955 }
956
957
958 LIBETPAN_EXPORT
mailimap_env_bcc_new(clist * bcc_list)959 struct mailimap_env_bcc * mailimap_env_bcc_new(clist * bcc_list)
960 {
961 struct mailimap_env_bcc * env_bcc;
962
963 env_bcc = malloc(sizeof(* env_bcc));
964 if (env_bcc == NULL)
965 return NULL;
966 env_bcc->bcc_list = bcc_list;
967
968 return env_bcc;
969 }
970
971 LIBETPAN_EXPORT
mailimap_env_bcc_free(struct mailimap_env_bcc * env_bcc)972 void mailimap_env_bcc_free(struct mailimap_env_bcc * env_bcc)
973 {
974 mailimap_address_list_free(env_bcc->bcc_list);
975 free(env_bcc);
976 }
977
978
979 LIBETPAN_EXPORT
mailimap_env_cc_new(clist * cc_list)980 struct mailimap_env_cc * mailimap_env_cc_new(clist * cc_list)
981 {
982 struct mailimap_env_cc * env_cc;
983
984 env_cc = malloc(sizeof(* env_cc));
985 if (env_cc == NULL)
986 return NULL;
987 env_cc->cc_list = cc_list;
988
989 return env_cc;
990 }
991
992 LIBETPAN_EXPORT
mailimap_env_cc_free(struct mailimap_env_cc * env_cc)993 void mailimap_env_cc_free(struct mailimap_env_cc * env_cc)
994 {
995 mailimap_address_list_free(env_cc->cc_list);
996 free(env_cc);
997 }
998
999
1000 LIBETPAN_EXPORT
mailimap_env_date_free(char * date)1001 void mailimap_env_date_free(char * date)
1002 {
1003 mailimap_nstring_free(date);
1004 }
1005
1006
1007 LIBETPAN_EXPORT
mailimap_env_from_new(clist * frm_list)1008 struct mailimap_env_from * mailimap_env_from_new(clist * frm_list)
1009 {
1010 struct mailimap_env_from * env_from;
1011
1012 env_from = malloc(sizeof(* env_from));
1013 if (env_from == NULL)
1014 return NULL;
1015 env_from->frm_list = frm_list;
1016
1017 return env_from;
1018 }
1019
1020 LIBETPAN_EXPORT
mailimap_env_from_free(struct mailimap_env_from * env_from)1021 void mailimap_env_from_free(struct mailimap_env_from * env_from)
1022 {
1023 mailimap_address_list_free(env_from->frm_list);
1024 free(env_from);
1025 }
1026
1027
mailimap_env_in_reply_to_free(char * in_reply_to)1028 void mailimap_env_in_reply_to_free(char * in_reply_to)
1029 {
1030 mailimap_nstring_free(in_reply_to);
1031 }
1032
mailimap_env_message_id_free(char * message_id)1033 void mailimap_env_message_id_free(char * message_id)
1034 {
1035 mailimap_nstring_free(message_id);
1036 }
1037
1038 LIBETPAN_EXPORT
mailimap_env_reply_to_new(clist * rt_list)1039 struct mailimap_env_reply_to * mailimap_env_reply_to_new(clist * rt_list)
1040 {
1041 struct mailimap_env_reply_to * env_reply_to;
1042
1043 env_reply_to = malloc(sizeof(* env_reply_to));
1044 if (env_reply_to == NULL)
1045 return NULL;
1046 env_reply_to->rt_list = rt_list;
1047
1048 return env_reply_to;
1049 }
1050
1051 LIBETPAN_EXPORT
1052 void
mailimap_env_reply_to_free(struct mailimap_env_reply_to * env_reply_to)1053 mailimap_env_reply_to_free(struct mailimap_env_reply_to * env_reply_to)
1054 {
1055 mailimap_address_list_free(env_reply_to->rt_list);
1056 free(env_reply_to);
1057 }
1058
1059 LIBETPAN_EXPORT
mailimap_env_sender_new(clist * snd_list)1060 struct mailimap_env_sender * mailimap_env_sender_new(clist * snd_list)
1061 {
1062 struct mailimap_env_sender * env_sender;
1063
1064 env_sender = malloc(sizeof(* env_sender));
1065 if (env_sender == NULL)
1066 return NULL;
1067 env_sender->snd_list = snd_list;
1068
1069 return env_sender;
1070 }
1071
1072 LIBETPAN_EXPORT
mailimap_env_sender_free(struct mailimap_env_sender * env_sender)1073 void mailimap_env_sender_free(struct mailimap_env_sender * env_sender)
1074 {
1075 mailimap_address_list_free(env_sender->snd_list);
1076 free(env_sender);
1077 }
1078
mailimap_env_subject_free(char * subject)1079 void mailimap_env_subject_free(char * subject)
1080 {
1081 mailimap_nstring_free(subject);
1082 }
1083
1084 LIBETPAN_EXPORT
mailimap_env_to_new(clist * to_list)1085 struct mailimap_env_to * mailimap_env_to_new(clist * to_list)
1086 {
1087 struct mailimap_env_to * env_to;
1088
1089 env_to = malloc(sizeof(* env_to));
1090 if (env_to == NULL)
1091 return NULL;
1092 env_to->to_list = to_list;
1093
1094 return env_to;
1095 }
1096
1097 LIBETPAN_EXPORT
mailimap_env_to_free(struct mailimap_env_to * env_to)1098 void mailimap_env_to_free(struct mailimap_env_to * env_to)
1099 {
1100 mailimap_address_list_free(env_to->to_list);
1101 free(env_to);
1102 }
1103
1104
1105
1106 LIBETPAN_EXPORT
mailimap_flag_new(int fl_type,char * fl_keyword,char * fl_extension)1107 struct mailimap_flag * mailimap_flag_new(int fl_type,
1108 char * fl_keyword, char * fl_extension)
1109 {
1110 struct mailimap_flag * f;
1111
1112 f = malloc(sizeof(* f));
1113 if (f == NULL)
1114 return NULL;
1115 f->fl_type = fl_type;
1116 switch (fl_type) {
1117 case MAILIMAP_FLAG_KEYWORD:
1118 f->fl_data.fl_keyword = fl_keyword;
1119 break;
1120 case MAILIMAP_FLAG_EXTENSION:
1121 f->fl_data.fl_extension = fl_extension;
1122 break;
1123 }
1124
1125 return f;
1126 }
1127
1128 LIBETPAN_EXPORT
mailimap_flag_free(struct mailimap_flag * f)1129 void mailimap_flag_free(struct mailimap_flag * f)
1130 {
1131 switch (f->fl_type) {
1132 case MAILIMAP_FLAG_KEYWORD:
1133 mailimap_flag_keyword_free(f->fl_data.fl_keyword);
1134 break;
1135 case MAILIMAP_FLAG_EXTENSION:
1136 mailimap_flag_extension_free(f->fl_data.fl_extension);
1137 break;
1138 }
1139 free(f);
1140 }
1141
1142
1143
1144 LIBETPAN_EXPORT
mailimap_flag_extension_free(char * flag_extension)1145 void mailimap_flag_extension_free(char * flag_extension)
1146 {
1147 mailimap_atom_free(flag_extension);
1148 }
1149
1150
1151
1152 LIBETPAN_EXPORT
1153 struct mailimap_flag_fetch *
mailimap_flag_fetch_new(int fl_type,struct mailimap_flag * fl_flag)1154 mailimap_flag_fetch_new(int fl_type, struct mailimap_flag * fl_flag)
1155 {
1156 struct mailimap_flag_fetch * flag_fetch;
1157
1158 flag_fetch = malloc(sizeof(* flag_fetch));
1159 if (flag_fetch == NULL)
1160 return NULL;
1161
1162 flag_fetch->fl_type = fl_type;
1163 flag_fetch->fl_flag = fl_flag;
1164
1165 return flag_fetch;
1166 }
1167
1168 LIBETPAN_EXPORT
mailimap_flag_fetch_free(struct mailimap_flag_fetch * flag_fetch)1169 void mailimap_flag_fetch_free(struct mailimap_flag_fetch * flag_fetch)
1170 {
1171 if (flag_fetch->fl_flag)
1172 mailimap_flag_free(flag_fetch->fl_flag);
1173 free(flag_fetch);
1174 }
1175
1176
1177
1178 LIBETPAN_EXPORT
mailimap_flag_keyword_free(char * flag_keyword)1179 void mailimap_flag_keyword_free(char * flag_keyword)
1180 {
1181 mailimap_atom_free(flag_keyword);
1182 }
1183
1184
1185
1186
1187 LIBETPAN_EXPORT
1188 struct mailimap_flag_list *
mailimap_flag_list_new(clist * fl_list)1189 mailimap_flag_list_new(clist * fl_list)
1190 {
1191 struct mailimap_flag_list * flag_list;
1192
1193 flag_list = malloc(sizeof(* flag_list));
1194 if (flag_list == NULL)
1195 return NULL;
1196 flag_list->fl_list = fl_list;
1197
1198 return flag_list;
1199 }
1200
1201 LIBETPAN_EXPORT
mailimap_flag_list_free(struct mailimap_flag_list * flag_list)1202 void mailimap_flag_list_free(struct mailimap_flag_list * flag_list)
1203 {
1204 if (flag_list->fl_list) {
1205 clist_foreach(flag_list->fl_list, (clist_func) mailimap_flag_free, NULL);
1206 clist_free(flag_list->fl_list);
1207 }
1208 free(flag_list);
1209 }
1210
1211
1212
1213
1214
1215 LIBETPAN_EXPORT
1216 struct mailimap_flag_perm *
mailimap_flag_perm_new(int fl_type,struct mailimap_flag * fl_flag)1217 mailimap_flag_perm_new(int fl_type, struct mailimap_flag * fl_flag)
1218 {
1219 struct mailimap_flag_perm * flag_perm;
1220
1221 flag_perm = malloc(sizeof(* flag_perm));
1222 if (flag_perm == NULL)
1223 return NULL;
1224
1225 flag_perm->fl_type = fl_type;
1226 flag_perm->fl_flag = fl_flag;
1227
1228 return flag_perm;
1229 }
1230
1231 LIBETPAN_EXPORT
mailimap_flag_perm_free(struct mailimap_flag_perm * flag_perm)1232 void mailimap_flag_perm_free(struct mailimap_flag_perm * flag_perm)
1233 {
1234 if (flag_perm->fl_flag != NULL)
1235 mailimap_flag_free(flag_perm->fl_flag);
1236 free(flag_perm);
1237 }
1238
1239
1240
1241
1242 LIBETPAN_EXPORT
1243 struct mailimap_greeting *
mailimap_greeting_new(int gr_type,struct mailimap_resp_cond_auth * gr_auth,struct mailimap_resp_cond_bye * gr_bye)1244 mailimap_greeting_new(int gr_type,
1245 struct mailimap_resp_cond_auth * gr_auth,
1246 struct mailimap_resp_cond_bye * gr_bye)
1247 {
1248 struct mailimap_greeting * greeting;
1249
1250 greeting = malloc(sizeof(* greeting));
1251 if (greeting == NULL)
1252 return NULL;
1253 greeting->gr_type = gr_type;
1254 switch (gr_type) {
1255 case MAILIMAP_GREETING_RESP_COND_AUTH:
1256 greeting->gr_data.gr_auth = gr_auth;
1257 break;
1258 case MAILIMAP_GREETING_RESP_COND_BYE:
1259 greeting->gr_data.gr_bye = gr_bye;
1260 break;
1261 }
1262
1263 return greeting;
1264 }
1265
1266 LIBETPAN_EXPORT
mailimap_greeting_free(struct mailimap_greeting * greeting)1267 void mailimap_greeting_free(struct mailimap_greeting * greeting)
1268 {
1269 switch (greeting->gr_type) {
1270 case MAILIMAP_GREETING_RESP_COND_AUTH:
1271 mailimap_resp_cond_auth_free(greeting->gr_data.gr_auth);
1272 break;
1273 case MAILIMAP_GREETING_RESP_COND_BYE:
1274 mailimap_resp_cond_bye_free(greeting->gr_data.gr_bye);
1275 break;
1276 }
1277 free(greeting);
1278 }
1279
1280
1281
1282 LIBETPAN_EXPORT
1283 void
mailimap_header_fld_name_free(char * header_fld_name)1284 mailimap_header_fld_name_free(char * header_fld_name)
1285 {
1286 mailimap_astring_free(header_fld_name);
1287 }
1288
1289
1290
1291 LIBETPAN_EXPORT
1292 struct mailimap_header_list *
mailimap_header_list_new(clist * hdr_list)1293 mailimap_header_list_new(clist * hdr_list)
1294 {
1295 struct mailimap_header_list * header_list;
1296
1297 header_list = malloc(sizeof(* header_list));
1298 if (header_list == NULL)
1299 return NULL;
1300
1301 header_list->hdr_list = hdr_list;
1302
1303 return header_list;
1304 }
1305
1306 LIBETPAN_EXPORT
1307 void
mailimap_header_list_free(struct mailimap_header_list * header_list)1308 mailimap_header_list_free(struct mailimap_header_list * header_list)
1309 {
1310 clist_foreach(header_list->hdr_list,
1311 (clist_func) mailimap_header_fld_name_free,
1312 NULL);
1313 clist_free(header_list->hdr_list);
1314 free(header_list);
1315 }
1316
1317
1318
1319 LIBETPAN_EXPORT
mailimap_literal_free(char * literal)1320 void mailimap_literal_free(char * literal)
1321 {
1322 /* free(literal); */
1323 mmap_string_unref(literal);
1324 }
1325
1326 LIBETPAN_EXPORT
mailimap_mailbox_free(char * mb)1327 void mailimap_mailbox_free(char * mb)
1328 {
1329 mailimap_astring_free(mb);
1330 }
1331
1332
1333
1334
1335 LIBETPAN_EXPORT
1336 struct mailimap_status_info *
mailimap_status_info_new(int st_att,uint32_t st_value,struct mailimap_extension_data * st_ext_data)1337 mailimap_status_info_new(int st_att, uint32_t st_value,
1338 struct mailimap_extension_data * st_ext_data)
1339 {
1340 struct mailimap_status_info * info;
1341
1342 info = malloc(sizeof(* info));
1343 if (info == NULL)
1344 return NULL;
1345 info->st_att = st_att;
1346 info->st_value = st_value;
1347 info->st_ext_data = st_ext_data;
1348
1349 return info;
1350 }
1351
1352 LIBETPAN_EXPORT
mailimap_status_info_free(struct mailimap_status_info * info)1353 void mailimap_status_info_free(struct mailimap_status_info * info)
1354 {
1355 if (info->st_ext_data != NULL) {
1356 mailimap_extension_data_free(info->st_ext_data);
1357 }
1358 free(info);
1359 }
1360
1361
1362
1363 LIBETPAN_EXPORT
1364 struct mailimap_mailbox_data_status *
mailimap_mailbox_data_status_new(char * st_mailbox,clist * st_info_list)1365 mailimap_mailbox_data_status_new(char * st_mailbox,
1366 clist * st_info_list)
1367 {
1368 struct mailimap_mailbox_data_status * mb_data_status;
1369
1370 mb_data_status = malloc(sizeof(* mb_data_status));
1371 if (mb_data_status == NULL)
1372 return NULL;
1373 mb_data_status->st_mailbox = st_mailbox;
1374 mb_data_status->st_info_list = st_info_list;
1375
1376 return mb_data_status;
1377 }
1378
1379 LIBETPAN_EXPORT
1380 void
mailimap_mailbox_data_search_free(clist * data_search)1381 mailimap_mailbox_data_search_free(clist * data_search)
1382 {
1383 clist_foreach(data_search, (clist_func) mailimap_number_alloc_free, NULL);
1384 clist_free(data_search);
1385 }
1386
1387 LIBETPAN_EXPORT
1388 void
mailimap_mailbox_data_status_free(struct mailimap_mailbox_data_status * info)1389 mailimap_mailbox_data_status_free(struct mailimap_mailbox_data_status * info)
1390 {
1391 mailimap_mailbox_free(info->st_mailbox);
1392 clist_foreach(info->st_info_list, (clist_func) mailimap_status_info_free,
1393 NULL);
1394 clist_free(info->st_info_list);
1395 free(info);
1396 }
1397
1398
1399 static void
mailimap_mailbox_data_flags_free(struct mailimap_flag_list * flag_list)1400 mailimap_mailbox_data_flags_free(struct mailimap_flag_list * flag_list)
1401 {
1402 mailimap_flag_list_free(flag_list);
1403 }
1404
1405 static void
mailimap_mailbox_data_list_free(struct mailimap_mailbox_list * mb_list)1406 mailimap_mailbox_data_list_free(struct mailimap_mailbox_list * mb_list)
1407 {
1408 mailimap_mailbox_list_free(mb_list);
1409 }
1410
1411 static void
mailimap_mailbox_data_lsub_free(struct mailimap_mailbox_list * mb_lsub)1412 mailimap_mailbox_data_lsub_free(struct mailimap_mailbox_list * mb_lsub)
1413 {
1414 mailimap_mailbox_list_free(mb_lsub);
1415 }
1416
1417
1418
1419
1420
1421
1422 LIBETPAN_EXPORT
1423 struct mailimap_mailbox_data *
mailimap_mailbox_data_new(int mbd_type,struct mailimap_flag_list * mbd_flags,struct mailimap_mailbox_list * mbd_list,struct mailimap_mailbox_list * mbd_lsub,clist * mbd_search,struct mailimap_mailbox_data_status * mbd_status,uint32_t mbd_exists,uint32_t mbd_recent,struct mailimap_extension_data * mbd_extension)1424 mailimap_mailbox_data_new(int mbd_type, struct mailimap_flag_list * mbd_flags,
1425 struct mailimap_mailbox_list * mbd_list,
1426 struct mailimap_mailbox_list * mbd_lsub,
1427 clist * mbd_search,
1428 struct mailimap_mailbox_data_status * mbd_status,
1429 uint32_t mbd_exists,
1430 uint32_t mbd_recent,
1431 struct mailimap_extension_data * mbd_extension)
1432 {
1433 struct mailimap_mailbox_data * data;
1434
1435 data = malloc(sizeof(* data));
1436 if (data == NULL)
1437 return NULL;
1438
1439 data->mbd_type = mbd_type;
1440 switch (mbd_type) {
1441 case MAILIMAP_MAILBOX_DATA_FLAGS:
1442 data->mbd_data.mbd_flags = mbd_flags;
1443 break;
1444 case MAILIMAP_MAILBOX_DATA_LIST:
1445 data->mbd_data.mbd_list = mbd_list;
1446 break;
1447 case MAILIMAP_MAILBOX_DATA_LSUB:
1448 data->mbd_data.mbd_lsub = mbd_lsub;
1449 break;
1450 case MAILIMAP_MAILBOX_DATA_SEARCH:
1451 data->mbd_data.mbd_search = mbd_search;
1452 break;
1453 case MAILIMAP_MAILBOX_DATA_STATUS:
1454 data->mbd_data.mbd_status = mbd_status;
1455 break;
1456 case MAILIMAP_MAILBOX_DATA_EXISTS:
1457 data->mbd_data.mbd_exists = mbd_exists;
1458 break;
1459 case MAILIMAP_MAILBOX_DATA_RECENT:
1460 data->mbd_data.mbd_recent = mbd_recent;
1461 break;
1462 case MAILIMAP_MAILBOX_DATA_EXTENSION_DATA:
1463 data->mbd_data.mbd_extension = mbd_extension;
1464 break;
1465 }
1466
1467 return data;
1468 }
1469
1470 LIBETPAN_EXPORT
1471 void
mailimap_mailbox_data_free(struct mailimap_mailbox_data * mb_data)1472 mailimap_mailbox_data_free(struct mailimap_mailbox_data * mb_data)
1473 {
1474 switch (mb_data->mbd_type) {
1475 case MAILIMAP_MAILBOX_DATA_FLAGS:
1476 if (mb_data->mbd_data.mbd_flags != NULL)
1477 mailimap_mailbox_data_flags_free(mb_data->mbd_data.mbd_flags);
1478 break;
1479 case MAILIMAP_MAILBOX_DATA_LIST:
1480 if (mb_data->mbd_data.mbd_list != NULL)
1481 mailimap_mailbox_data_list_free(mb_data->mbd_data.mbd_list);
1482 break;
1483 case MAILIMAP_MAILBOX_DATA_LSUB:
1484 if (mb_data->mbd_data.mbd_lsub != NULL)
1485 mailimap_mailbox_data_lsub_free(mb_data->mbd_data.mbd_lsub);
1486 break;
1487 case MAILIMAP_MAILBOX_DATA_SEARCH:
1488 if (mb_data->mbd_data.mbd_search != NULL)
1489 mailimap_mailbox_data_search_free(mb_data->mbd_data.mbd_search);
1490 break;
1491 case MAILIMAP_MAILBOX_DATA_STATUS:
1492 if (mb_data->mbd_data.mbd_status != NULL)
1493 mailimap_mailbox_data_status_free(mb_data->mbd_data.mbd_status);
1494 break;
1495 case MAILIMAP_MAILBOX_DATA_EXTENSION_DATA:
1496 if (mb_data->mbd_data.mbd_extension != NULL)
1497 mailimap_extension_data_free(mb_data->mbd_data.mbd_extension);
1498 break;
1499 }
1500 free(mb_data);
1501 }
1502
1503
1504
1505
1506
1507 LIBETPAN_EXPORT
1508 struct mailimap_mbx_list_flags *
mailimap_mbx_list_flags_new(int mbf_type,clist * mbf_oflags,int mbf_sflag)1509 mailimap_mbx_list_flags_new(int mbf_type, clist * mbf_oflags,
1510 int mbf_sflag)
1511 {
1512 struct mailimap_mbx_list_flags * mbx_list_flags;
1513
1514 mbx_list_flags = malloc(sizeof(* mbx_list_flags));
1515 if (mbx_list_flags == NULL)
1516 return NULL;
1517
1518 mbx_list_flags->mbf_type = mbf_type;
1519 mbx_list_flags->mbf_oflags = mbf_oflags;
1520 mbx_list_flags->mbf_sflag = mbf_sflag;
1521
1522 return mbx_list_flags;
1523 }
1524
1525 LIBETPAN_EXPORT
1526 void
mailimap_mbx_list_flags_free(struct mailimap_mbx_list_flags * mbx_list_flags)1527 mailimap_mbx_list_flags_free(struct mailimap_mbx_list_flags * mbx_list_flags)
1528 {
1529 clist_foreach(mbx_list_flags->mbf_oflags,
1530 (clist_func) mailimap_mbx_list_oflag_free,
1531 NULL);
1532 clist_free(mbx_list_flags->mbf_oflags);
1533
1534 free(mbx_list_flags);
1535 }
1536
1537
1538 LIBETPAN_EXPORT
1539 struct mailimap_mbx_list_oflag *
mailimap_mbx_list_oflag_new(int of_type,char * of_flag_ext)1540 mailimap_mbx_list_oflag_new(int of_type, char * of_flag_ext)
1541 {
1542 struct mailimap_mbx_list_oflag * oflag;
1543
1544 oflag = malloc(sizeof(* oflag));
1545 if (oflag == NULL)
1546 return NULL;
1547
1548 oflag->of_type = of_type;
1549 oflag->of_flag_ext = of_flag_ext;
1550
1551 return oflag;
1552 }
1553
1554 LIBETPAN_EXPORT
1555 void
mailimap_mbx_list_oflag_free(struct mailimap_mbx_list_oflag * oflag)1556 mailimap_mbx_list_oflag_free(struct mailimap_mbx_list_oflag * oflag)
1557 {
1558 if (oflag->of_flag_ext != NULL)
1559 mailimap_flag_extension_free(oflag->of_flag_ext);
1560 free(oflag);
1561 }
1562
1563
1564
1565 LIBETPAN_EXPORT
1566 struct mailimap_mailbox_list *
mailimap_mailbox_list_new(struct mailimap_mbx_list_flags * mbx_flags,char mb_delimiter,char * mb_name)1567 mailimap_mailbox_list_new(struct mailimap_mbx_list_flags * mbx_flags,
1568 char mb_delimiter, char * mb_name)
1569 {
1570 struct mailimap_mailbox_list * mb_list;
1571
1572 mb_list = malloc(sizeof(* mb_list));
1573 if (mb_list == NULL)
1574 return NULL;
1575
1576 mb_list->mb_flag = mbx_flags;
1577 mb_list->mb_delimiter = mb_delimiter;
1578 mb_list->mb_name = mb_name;
1579
1580 return mb_list;
1581 }
1582
1583 LIBETPAN_EXPORT
1584 void
mailimap_mailbox_list_free(struct mailimap_mailbox_list * mb_list)1585 mailimap_mailbox_list_free(struct mailimap_mailbox_list * mb_list)
1586 {
1587 if (mb_list->mb_flag != NULL)
1588 mailimap_mbx_list_flags_free(mb_list->mb_flag);
1589 if (mb_list->mb_name != NULL)
1590 mailimap_mailbox_free(mb_list->mb_name);
1591 free(mb_list);
1592 }
1593
1594
1595
1596 LIBETPAN_EXPORT
1597 struct mailimap_media_basic *
mailimap_media_basic_new(int med_type,char * med_basic_type,char * med_subtype)1598 mailimap_media_basic_new(int med_type,
1599 char * med_basic_type, char * med_subtype)
1600 {
1601 struct mailimap_media_basic * media_basic;
1602
1603 media_basic = malloc(sizeof(* media_basic));
1604 if (media_basic == NULL)
1605 return NULL;
1606 media_basic->med_type = med_type;
1607 media_basic->med_basic_type = med_basic_type;
1608 media_basic->med_subtype = med_subtype;
1609
1610 return media_basic;
1611 }
1612
1613 LIBETPAN_EXPORT
1614 void
mailimap_media_basic_free(struct mailimap_media_basic * media_basic)1615 mailimap_media_basic_free(struct mailimap_media_basic * media_basic)
1616 {
1617 mailimap_string_free(media_basic->med_basic_type);
1618 mailimap_media_subtype_free(media_basic->med_subtype);
1619 free(media_basic);
1620 }
1621
1622
1623
1624 LIBETPAN_EXPORT
mailimap_media_subtype_free(char * media_subtype)1625 void mailimap_media_subtype_free(char * media_subtype)
1626 {
1627 mmap_string_unref(media_subtype);
1628 }
1629
1630
1631 LIBETPAN_EXPORT
mailimap_media_text_free(char * media_text)1632 void mailimap_media_text_free(char * media_text)
1633 {
1634 mailimap_media_subtype_free(media_text);
1635 }
1636
1637
1638
1639 LIBETPAN_EXPORT
1640 struct mailimap_message_data *
mailimap_message_data_new(uint32_t mdt_number,int mdt_type,struct mailimap_msg_att * mdt_msg_att)1641 mailimap_message_data_new(uint32_t mdt_number, int mdt_type,
1642 struct mailimap_msg_att * mdt_msg_att)
1643 {
1644 struct mailimap_message_data * msg_data;
1645
1646 msg_data = malloc(sizeof(* msg_data));
1647 if (msg_data == NULL) {
1648 return NULL;
1649 }
1650
1651 msg_data->mdt_number = mdt_number;
1652 msg_data->mdt_type = mdt_type;
1653 msg_data->mdt_msg_att = mdt_msg_att;
1654
1655 return msg_data;
1656 }
1657
1658 LIBETPAN_EXPORT
1659 void
mailimap_message_data_free(struct mailimap_message_data * msg_data)1660 mailimap_message_data_free(struct mailimap_message_data * msg_data)
1661 {
1662 if (msg_data->mdt_msg_att != NULL)
1663 mailimap_msg_att_free(msg_data->mdt_msg_att);
1664 free(msg_data);
1665 }
1666
1667
1668
1669
1670 LIBETPAN_EXPORT
1671 struct mailimap_msg_att_item *
mailimap_msg_att_item_new(int att_type,struct mailimap_msg_att_dynamic * att_dyn,struct mailimap_msg_att_static * att_static,struct mailimap_extension_data * att_extension_data)1672 mailimap_msg_att_item_new(int att_type,
1673 struct mailimap_msg_att_dynamic * att_dyn,
1674 struct mailimap_msg_att_static * att_static,
1675 struct mailimap_extension_data * att_extension_data)
1676 {
1677 struct mailimap_msg_att_item * item;
1678
1679 item = malloc(sizeof(* item));
1680 if (item == NULL)
1681 return item;
1682
1683 item->att_type = att_type;
1684 switch (att_type) {
1685 case MAILIMAP_MSG_ATT_ITEM_DYNAMIC:
1686 item->att_data.att_dyn = att_dyn;
1687 break;
1688 case MAILIMAP_MSG_ATT_ITEM_STATIC:
1689 item->att_data.att_static = att_static;
1690 break;
1691 case MAILIMAP_MSG_ATT_ITEM_EXTENSION:
1692 item->att_data.att_extension_data = att_extension_data;
1693 break;
1694 }
1695
1696 return item;
1697 }
1698
1699 LIBETPAN_EXPORT
1700 void
mailimap_msg_att_item_free(struct mailimap_msg_att_item * item)1701 mailimap_msg_att_item_free(struct mailimap_msg_att_item * item)
1702 {
1703 switch (item->att_type) {
1704 case MAILIMAP_MSG_ATT_ITEM_DYNAMIC:
1705 mailimap_msg_att_dynamic_free(item->att_data.att_dyn);
1706 break;
1707 case MAILIMAP_MSG_ATT_ITEM_STATIC:
1708 mailimap_msg_att_static_free(item->att_data.att_static);
1709 break;
1710 case MAILIMAP_MSG_ATT_ITEM_EXTENSION:
1711 mailimap_extension_data_free(item->att_data.att_extension_data);
1712 break;
1713 }
1714 free(item);
1715 }
1716
1717
1718 LIBETPAN_EXPORT
1719 struct mailimap_msg_att *
mailimap_msg_att_new(clist * att_list)1720 mailimap_msg_att_new(clist * att_list)
1721 {
1722 struct mailimap_msg_att * msg_att;
1723
1724 msg_att = malloc(sizeof(* msg_att));
1725 if (msg_att == NULL)
1726 return NULL;
1727
1728 msg_att->att_list = att_list;
1729 msg_att->att_number = 0;
1730
1731 return msg_att;
1732 }
1733
1734 LIBETPAN_EXPORT
mailimap_msg_att_free(struct mailimap_msg_att * msg_att)1735 void mailimap_msg_att_free(struct mailimap_msg_att * msg_att)
1736 {
1737 clist_foreach(msg_att->att_list,
1738 (clist_func) mailimap_msg_att_item_free, NULL);
1739 clist_free(msg_att->att_list);
1740 free(msg_att);
1741 }
1742
1743
1744
1745 LIBETPAN_EXPORT
1746 struct mailimap_msg_att_dynamic *
mailimap_msg_att_dynamic_new(clist * att_list)1747 mailimap_msg_att_dynamic_new(clist * att_list)
1748 {
1749 struct mailimap_msg_att_dynamic * msg_att_dyn;
1750
1751 msg_att_dyn = malloc(sizeof(* msg_att_dyn));
1752 if (msg_att_dyn == NULL)
1753 return NULL;
1754
1755 msg_att_dyn->att_list = att_list;
1756
1757 return msg_att_dyn;
1758 }
1759
1760 LIBETPAN_EXPORT
1761 void
mailimap_msg_att_dynamic_free(struct mailimap_msg_att_dynamic * msg_att_dyn)1762 mailimap_msg_att_dynamic_free(struct mailimap_msg_att_dynamic * msg_att_dyn)
1763 {
1764 if (msg_att_dyn->att_list != NULL) {
1765 clist_foreach(msg_att_dyn->att_list,
1766 (clist_func) mailimap_flag_fetch_free,
1767 NULL);
1768 clist_free(msg_att_dyn->att_list);
1769 }
1770 free(msg_att_dyn);
1771 }
1772
1773
1774 LIBETPAN_EXPORT
1775 struct mailimap_msg_att_body_section *
mailimap_msg_att_body_section_new(struct mailimap_section * sec_section,uint32_t sec_origin_octet,char * sec_body_part,size_t sec_length)1776 mailimap_msg_att_body_section_new(struct mailimap_section * sec_section,
1777 uint32_t sec_origin_octet,
1778 char * sec_body_part,
1779 size_t sec_length)
1780 {
1781 struct mailimap_msg_att_body_section * msg_att_body_section;
1782
1783 msg_att_body_section = malloc(sizeof(* msg_att_body_section));
1784 if (msg_att_body_section == NULL)
1785 return NULL;
1786
1787 msg_att_body_section->sec_section = sec_section;
1788 msg_att_body_section->sec_origin_octet = sec_origin_octet;
1789 msg_att_body_section->sec_body_part = sec_body_part;
1790 msg_att_body_section->sec_length = sec_length;
1791
1792 return msg_att_body_section;
1793 }
1794
1795 LIBETPAN_EXPORT
1796 void
mailimap_msg_att_body_section_free(struct mailimap_msg_att_body_section * msg_att_body_section)1797 mailimap_msg_att_body_section_free(struct mailimap_msg_att_body_section *
1798 msg_att_body_section)
1799 {
1800 if (msg_att_body_section->sec_section != NULL)
1801 mailimap_section_free(msg_att_body_section->sec_section);
1802 if (msg_att_body_section->sec_body_part != NULL)
1803 mailimap_nstring_free(msg_att_body_section->sec_body_part);
1804 free(msg_att_body_section);
1805 }
1806
1807
1808
1809
1810
1811
1812 LIBETPAN_EXPORT
mailimap_msg_att_envelope_free(struct mailimap_envelope * env)1813 void mailimap_msg_att_envelope_free(struct mailimap_envelope * env)
1814 {
1815 mailimap_envelope_free(env);
1816 }
1817
1818 LIBETPAN_EXPORT
1819 void
mailimap_msg_att_internaldate_free(struct mailimap_date_time * date_time)1820 mailimap_msg_att_internaldate_free(struct mailimap_date_time * date_time)
1821 {
1822 mailimap_date_time_free(date_time);
1823 }
1824
1825 LIBETPAN_EXPORT
1826 void
mailimap_msg_att_rfc822_free(char * str)1827 mailimap_msg_att_rfc822_free(char * str)
1828 {
1829 mailimap_nstring_free(str);
1830 }
1831
1832
1833 LIBETPAN_EXPORT
1834 void
mailimap_msg_att_rfc822_header_free(char * str)1835 mailimap_msg_att_rfc822_header_free(char * str)
1836 {
1837 mailimap_nstring_free(str);
1838 }
1839
1840 LIBETPAN_EXPORT
1841 void
mailimap_msg_att_rfc822_text_free(char * str)1842 mailimap_msg_att_rfc822_text_free(char * str)
1843 {
1844 mailimap_nstring_free(str);
1845 }
1846
1847 LIBETPAN_EXPORT
1848 void
mailimap_msg_att_body_free(struct mailimap_body * body)1849 mailimap_msg_att_body_free(struct mailimap_body * body)
1850 {
1851 mailimap_body_free(body);
1852 }
1853
1854 LIBETPAN_EXPORT
1855 void
mailimap_msg_att_bodystructure_free(struct mailimap_body * body)1856 mailimap_msg_att_bodystructure_free(struct mailimap_body * body)
1857 {
1858 mailimap_body_free(body);
1859 }
1860
1861
1862
1863 LIBETPAN_EXPORT
1864 struct mailimap_msg_att_static *
mailimap_msg_att_static_new(int att_type,struct mailimap_envelope * att_env,struct mailimap_date_time * att_internal_date,char * att_rfc822,char * att_rfc822_header,char * att_rfc822_text,size_t att_length,uint32_t att_rfc822_size,struct mailimap_body * att_bodystructure,struct mailimap_body * att_body,struct mailimap_msg_att_body_section * att_body_section,uint32_t att_uid)1865 mailimap_msg_att_static_new(int att_type, struct mailimap_envelope * att_env,
1866 struct mailimap_date_time * att_internal_date,
1867 char * att_rfc822,
1868 char * att_rfc822_header,
1869 char * att_rfc822_text,
1870 size_t att_length,
1871 uint32_t att_rfc822_size,
1872 struct mailimap_body * att_bodystructure,
1873 struct mailimap_body * att_body,
1874 struct mailimap_msg_att_body_section * att_body_section,
1875 uint32_t att_uid)
1876 {
1877 struct mailimap_msg_att_static * item;
1878
1879 item = malloc(sizeof(* item));
1880 if (item == NULL)
1881 return FALSE;
1882
1883 item->att_type = att_type;
1884 switch (att_type) {
1885 case MAILIMAP_MSG_ATT_ENVELOPE:
1886 item->att_data.att_env = att_env;
1887 break;
1888 case MAILIMAP_MSG_ATT_INTERNALDATE:
1889 item->att_data.att_internal_date = att_internal_date;
1890 break;
1891 case MAILIMAP_MSG_ATT_RFC822:
1892 item->att_data.att_rfc822.att_content = att_rfc822;
1893 item->att_data.att_rfc822.att_length = att_length;
1894 break;
1895 case MAILIMAP_MSG_ATT_RFC822_HEADER:
1896 item->att_data.att_rfc822_header.att_content = att_rfc822_header;
1897 item->att_data.att_rfc822_header.att_length = att_length;
1898 break;
1899 case MAILIMAP_MSG_ATT_RFC822_TEXT:
1900 item->att_data.att_rfc822_text.att_content = att_rfc822_text;
1901 item->att_data.att_rfc822_text.att_length = att_length;
1902 break;
1903 case MAILIMAP_MSG_ATT_RFC822_SIZE:
1904 item->att_data.att_rfc822_size = att_rfc822_size;
1905 break;
1906 case MAILIMAP_MSG_ATT_BODY:
1907 item->att_data.att_body = att_body;
1908 break;
1909 case MAILIMAP_MSG_ATT_BODYSTRUCTURE:
1910 item->att_data.att_bodystructure = att_bodystructure;
1911 break;
1912 case MAILIMAP_MSG_ATT_BODY_SECTION:
1913 item->att_data.att_body_section = att_body_section;
1914 break;
1915 case MAILIMAP_MSG_ATT_UID:
1916 item->att_data.att_uid = att_uid;
1917 break;
1918 }
1919
1920 return item;
1921 }
1922
1923 LIBETPAN_EXPORT
1924 void
mailimap_msg_att_static_free(struct mailimap_msg_att_static * item)1925 mailimap_msg_att_static_free(struct mailimap_msg_att_static * item)
1926 {
1927 switch (item->att_type) {
1928 case MAILIMAP_MSG_ATT_ENVELOPE:
1929 if (item->att_data.att_env != NULL)
1930 mailimap_msg_att_envelope_free(item->att_data.att_env);
1931 break;
1932 case MAILIMAP_MSG_ATT_INTERNALDATE:
1933 if (item->att_data.att_internal_date != NULL)
1934 mailimap_msg_att_internaldate_free(item->att_data.att_internal_date);
1935 break;
1936 case MAILIMAP_MSG_ATT_RFC822:
1937 if (item->att_data.att_rfc822.att_content != NULL)
1938 mailimap_msg_att_rfc822_free(item->att_data.att_rfc822.att_content);
1939 break;
1940 case MAILIMAP_MSG_ATT_RFC822_HEADER:
1941 if (item->att_data.att_rfc822_header.att_content != NULL)
1942 mailimap_msg_att_rfc822_header_free(item->att_data.att_rfc822_header.att_content);
1943 break;
1944 case MAILIMAP_MSG_ATT_RFC822_TEXT:
1945 if (item->att_data.att_rfc822_text.att_content != NULL)
1946 mailimap_msg_att_rfc822_text_free(item->att_data.att_rfc822_text.att_content);
1947 break;
1948 case MAILIMAP_MSG_ATT_BODYSTRUCTURE:
1949 if (item->att_data.att_bodystructure != NULL)
1950 mailimap_msg_att_bodystructure_free(item->att_data.att_bodystructure);
1951 break;
1952 case MAILIMAP_MSG_ATT_BODY:
1953 if (item->att_data.att_body != NULL)
1954 mailimap_msg_att_body_free(item->att_data.att_body);
1955 break;
1956 case MAILIMAP_MSG_ATT_BODY_SECTION:
1957 if (item->att_data.att_body_section != NULL)
1958 mailimap_msg_att_body_section_free(item->att_data.att_body_section);
1959 break;
1960 }
1961 free(item);
1962 }
1963
1964
1965
1966
1967 LIBETPAN_EXPORT
mailimap_nstring_free(char * str)1968 void mailimap_nstring_free(char * str)
1969 {
1970 if (str != NULL)
1971 mailimap_string_free(str);
1972 }
1973
1974
1975
1976
1977
1978
1979
1980 LIBETPAN_EXPORT
1981 struct mailimap_cont_req_or_resp_data *
mailimap_cont_req_or_resp_data_new(int rsp_type,struct mailimap_continue_req * rsp_cont_req,struct mailimap_response_data * rsp_resp_data)1982 mailimap_cont_req_or_resp_data_new(int rsp_type,
1983 struct mailimap_continue_req * rsp_cont_req,
1984 struct mailimap_response_data * rsp_resp_data)
1985 {
1986 struct mailimap_cont_req_or_resp_data * cont_req_or_resp_data;
1987
1988 cont_req_or_resp_data = malloc(sizeof(* cont_req_or_resp_data));
1989 if (cont_req_or_resp_data == NULL)
1990 return NULL;
1991
1992 cont_req_or_resp_data->rsp_type = rsp_type;
1993 switch (rsp_type) {
1994 case MAILIMAP_RESP_CONT_REQ:
1995 cont_req_or_resp_data->rsp_data.rsp_cont_req = rsp_cont_req;
1996 break;
1997 case MAILIMAP_RESP_RESP_DATA:
1998 cont_req_or_resp_data->rsp_data.rsp_resp_data = rsp_resp_data;
1999 break;
2000 }
2001
2002 return cont_req_or_resp_data;
2003 }
2004
2005 LIBETPAN_EXPORT
2006 void
mailimap_cont_req_or_resp_data_free(struct mailimap_cont_req_or_resp_data * cont_req_or_resp_data)2007 mailimap_cont_req_or_resp_data_free(struct mailimap_cont_req_or_resp_data *
2008 cont_req_or_resp_data)
2009 {
2010 switch (cont_req_or_resp_data->rsp_type) {
2011 case MAILIMAP_RESP_CONT_REQ:
2012 if (cont_req_or_resp_data->rsp_data.rsp_cont_req != NULL)
2013 mailimap_continue_req_free(cont_req_or_resp_data->rsp_data.rsp_cont_req);
2014 break;
2015 case MAILIMAP_RESP_RESP_DATA:
2016 if (cont_req_or_resp_data->rsp_data.rsp_resp_data != NULL)
2017 mailimap_response_data_free(cont_req_or_resp_data->rsp_data.rsp_resp_data);
2018 break;
2019 }
2020 free(cont_req_or_resp_data);
2021 }
2022
2023
2024
2025
2026 LIBETPAN_EXPORT
2027 struct mailimap_response *
mailimap_response_new(clist * rsp_cont_req_or_resp_data_list,struct mailimap_response_done * rsp_resp_done)2028 mailimap_response_new(clist * rsp_cont_req_or_resp_data_list,
2029 struct mailimap_response_done * rsp_resp_done)
2030 {
2031 struct mailimap_response * resp;
2032
2033 resp = malloc(sizeof(* resp));
2034 if (resp == NULL)
2035 return NULL;
2036
2037 resp->rsp_cont_req_or_resp_data_list = rsp_cont_req_or_resp_data_list;
2038 resp->rsp_resp_done = rsp_resp_done;
2039
2040 return resp;
2041 }
2042
2043 LIBETPAN_EXPORT
2044 void
mailimap_response_free(struct mailimap_response * resp)2045 mailimap_response_free(struct mailimap_response * resp)
2046 {
2047 if (resp->rsp_cont_req_or_resp_data_list != NULL) {
2048 clist_foreach(resp->rsp_cont_req_or_resp_data_list,
2049 (clist_func) mailimap_cont_req_or_resp_data_free, NULL);
2050 clist_free(resp->rsp_cont_req_or_resp_data_list);
2051 }
2052 mailimap_response_done_free(resp->rsp_resp_done);
2053 free(resp);
2054 }
2055
2056
2057
2058 LIBETPAN_EXPORT
2059 struct mailimap_response_data *
mailimap_response_data_new(int rsp_type,struct mailimap_resp_cond_state * rsp_cond_state,struct mailimap_resp_cond_bye * rsp_bye,struct mailimap_mailbox_data * rsp_mailbox_data,struct mailimap_message_data * rsp_message_data,struct mailimap_capability_data * rsp_capability_data,struct mailimap_extension_data * rsp_extension_data)2060 mailimap_response_data_new(int rsp_type,
2061 struct mailimap_resp_cond_state * rsp_cond_state,
2062 struct mailimap_resp_cond_bye * rsp_bye,
2063 struct mailimap_mailbox_data * rsp_mailbox_data,
2064 struct mailimap_message_data * rsp_message_data,
2065 struct mailimap_capability_data * rsp_capability_data,
2066 struct mailimap_extension_data * rsp_extension_data)
2067 {
2068 struct mailimap_response_data * resp_data;
2069
2070 resp_data = malloc(sizeof(* resp_data));
2071 if (resp_data == NULL)
2072 return NULL;
2073 resp_data->rsp_type = rsp_type;
2074
2075 switch (rsp_type) {
2076 case MAILIMAP_RESP_DATA_TYPE_COND_STATE:
2077 resp_data->rsp_data.rsp_cond_state = rsp_cond_state;
2078 break;
2079 case MAILIMAP_RESP_DATA_TYPE_COND_BYE:
2080 resp_data->rsp_data.rsp_bye = rsp_bye;
2081 break;
2082 case MAILIMAP_RESP_DATA_TYPE_MAILBOX_DATA:
2083 resp_data->rsp_data.rsp_mailbox_data = rsp_mailbox_data;
2084 break;
2085 case MAILIMAP_RESP_DATA_TYPE_MESSAGE_DATA:
2086 resp_data->rsp_data.rsp_message_data = rsp_message_data;
2087 break;
2088 case MAILIMAP_RESP_DATA_TYPE_CAPABILITY_DATA:
2089 resp_data->rsp_data.rsp_capability_data = rsp_capability_data;
2090 break;
2091 case MAILIMAP_RESP_DATA_TYPE_EXTENSION_DATA:
2092 resp_data->rsp_data.rsp_extension_data = rsp_extension_data;
2093 break;
2094 }
2095
2096 return resp_data;
2097 }
2098
2099 LIBETPAN_EXPORT
2100 void
mailimap_response_data_free(struct mailimap_response_data * resp_data)2101 mailimap_response_data_free(struct mailimap_response_data * resp_data)
2102 {
2103 switch (resp_data->rsp_type) {
2104 case MAILIMAP_RESP_DATA_TYPE_COND_STATE:
2105 if (resp_data->rsp_data.rsp_cond_state != NULL)
2106 mailimap_resp_cond_state_free(resp_data->rsp_data.rsp_cond_state);
2107 break;
2108 case MAILIMAP_RESP_DATA_TYPE_COND_BYE:
2109 if (resp_data->rsp_data.rsp_bye != NULL)
2110 mailimap_resp_cond_bye_free(resp_data->rsp_data.rsp_bye);
2111 break;
2112 case MAILIMAP_RESP_DATA_TYPE_MAILBOX_DATA:
2113 if (resp_data->rsp_data.rsp_mailbox_data != NULL)
2114 mailimap_mailbox_data_free(resp_data->rsp_data.rsp_mailbox_data);
2115 break;
2116 case MAILIMAP_RESP_DATA_TYPE_MESSAGE_DATA:
2117 if (resp_data->rsp_data.rsp_message_data != NULL)
2118 mailimap_message_data_free(resp_data->rsp_data.rsp_message_data);
2119 break;
2120 case MAILIMAP_RESP_DATA_TYPE_CAPABILITY_DATA:
2121 if (resp_data->rsp_data.rsp_capability_data != NULL)
2122 mailimap_capability_data_free(resp_data->rsp_data.rsp_capability_data);
2123 break;
2124 case MAILIMAP_RESP_DATA_TYPE_EXTENSION_DATA:
2125 if (resp_data->rsp_data.rsp_extension_data != NULL)
2126 mailimap_extension_data_free(resp_data->rsp_data.rsp_extension_data);
2127 break;
2128 }
2129 free(resp_data);
2130 }
2131
2132
2133
2134 LIBETPAN_EXPORT
2135 struct mailimap_response_done *
mailimap_response_done_new(int rsp_type,struct mailimap_response_tagged * rsp_tagged,struct mailimap_response_fatal * rsp_fatal)2136 mailimap_response_done_new(int rsp_type,
2137 struct mailimap_response_tagged * rsp_tagged,
2138 struct mailimap_response_fatal * rsp_fatal)
2139 {
2140 struct mailimap_response_done * resp_done;
2141
2142 resp_done = malloc(sizeof(* resp_done));
2143 if (resp_done == NULL)
2144 return NULL;
2145
2146 resp_done->rsp_type = rsp_type;
2147 switch (rsp_type) {
2148 case MAILIMAP_RESP_DONE_TYPE_TAGGED:
2149 resp_done->rsp_data.rsp_tagged = rsp_tagged;
2150 break;
2151 case MAILIMAP_RESP_DONE_TYPE_FATAL:
2152 resp_done->rsp_data.rsp_fatal = rsp_fatal;
2153 break;
2154 }
2155
2156 return resp_done;
2157 }
2158
2159 LIBETPAN_EXPORT
mailimap_response_done_free(struct mailimap_response_done * resp_done)2160 void mailimap_response_done_free(struct mailimap_response_done *
2161 resp_done)
2162 {
2163 switch (resp_done->rsp_type) {
2164 case MAILIMAP_RESP_DONE_TYPE_TAGGED:
2165 mailimap_response_tagged_free(resp_done->rsp_data.rsp_tagged);
2166 break;
2167 case MAILIMAP_RESP_DONE_TYPE_FATAL:
2168 mailimap_response_fatal_free(resp_done->rsp_data.rsp_fatal);
2169 break;
2170 }
2171 free(resp_done);
2172 }
2173
2174 LIBETPAN_EXPORT
2175 struct mailimap_response_fatal *
mailimap_response_fatal_new(struct mailimap_resp_cond_bye * rsp_bye)2176 mailimap_response_fatal_new(struct mailimap_resp_cond_bye * rsp_bye)
2177 {
2178 struct mailimap_response_fatal * resp_fatal;
2179
2180 resp_fatal = malloc(sizeof(* resp_fatal));
2181 if (resp_fatal == NULL)
2182 return NULL;
2183
2184 resp_fatal->rsp_bye = rsp_bye;
2185
2186 return resp_fatal;
2187 }
2188
2189 LIBETPAN_EXPORT
mailimap_response_fatal_free(struct mailimap_response_fatal * resp_fatal)2190 void mailimap_response_fatal_free(struct mailimap_response_fatal * resp_fatal)
2191 {
2192 mailimap_resp_cond_bye_free(resp_fatal->rsp_bye);
2193 free(resp_fatal);
2194 }
2195
2196 LIBETPAN_EXPORT
2197 struct mailimap_response_tagged *
mailimap_response_tagged_new(char * rsp_tag,struct mailimap_resp_cond_state * rsp_cond_state)2198 mailimap_response_tagged_new(char * rsp_tag,
2199 struct mailimap_resp_cond_state * rsp_cond_state)
2200 {
2201 struct mailimap_response_tagged * resp_tagged;
2202
2203 resp_tagged = malloc(sizeof(* resp_tagged));
2204 if (resp_tagged == NULL)
2205 return NULL;
2206
2207 resp_tagged->rsp_tag = rsp_tag;
2208 resp_tagged->rsp_cond_state = rsp_cond_state;
2209
2210 return resp_tagged;
2211 }
2212
2213 LIBETPAN_EXPORT
2214 void
mailimap_response_tagged_free(struct mailimap_response_tagged * tagged)2215 mailimap_response_tagged_free(struct mailimap_response_tagged * tagged)
2216 {
2217 mailimap_tag_free(tagged->rsp_tag);
2218 mailimap_resp_cond_state_free(tagged->rsp_cond_state);
2219 free(tagged);
2220 }
2221
2222
2223
2224 LIBETPAN_EXPORT
2225 struct mailimap_resp_cond_auth *
mailimap_resp_cond_auth_new(int rsp_type,struct mailimap_resp_text * rsp_text)2226 mailimap_resp_cond_auth_new(int rsp_type,
2227 struct mailimap_resp_text * rsp_text)
2228 {
2229 struct mailimap_resp_cond_auth * cond_auth;
2230
2231 cond_auth = malloc(sizeof(* cond_auth));
2232 if (cond_auth == NULL)
2233 return NULL;
2234
2235 cond_auth->rsp_type = rsp_type;
2236 cond_auth->rsp_text = rsp_text;
2237
2238 return cond_auth;
2239 }
2240
2241 LIBETPAN_EXPORT
2242 void
mailimap_resp_cond_auth_free(struct mailimap_resp_cond_auth * cond_auth)2243 mailimap_resp_cond_auth_free(struct mailimap_resp_cond_auth * cond_auth)
2244 {
2245 mailimap_resp_text_free(cond_auth->rsp_text);
2246 free(cond_auth);
2247 }
2248
2249
2250
2251 LIBETPAN_EXPORT
2252 struct mailimap_resp_cond_bye *
mailimap_resp_cond_bye_new(struct mailimap_resp_text * rsp_text)2253 mailimap_resp_cond_bye_new(struct mailimap_resp_text * rsp_text)
2254 {
2255 struct mailimap_resp_cond_bye * cond_bye;
2256
2257 cond_bye = malloc(sizeof(* cond_bye));
2258 if (cond_bye == NULL)
2259 return NULL;
2260
2261 cond_bye->rsp_text = rsp_text;
2262
2263 return cond_bye;
2264 }
2265
2266
2267 LIBETPAN_EXPORT
2268 void
mailimap_resp_cond_bye_free(struct mailimap_resp_cond_bye * cond_bye)2269 mailimap_resp_cond_bye_free(struct mailimap_resp_cond_bye * cond_bye)
2270 {
2271 mailimap_resp_text_free(cond_bye->rsp_text);
2272 free(cond_bye);
2273 }
2274
2275
2276 LIBETPAN_EXPORT
2277 struct mailimap_resp_cond_state *
mailimap_resp_cond_state_new(int rsp_type,struct mailimap_resp_text * rsp_text)2278 mailimap_resp_cond_state_new(int rsp_type,
2279 struct mailimap_resp_text * rsp_text)
2280 {
2281 struct mailimap_resp_cond_state * cond_state;
2282
2283 cond_state = malloc(sizeof(* cond_state));
2284 if (cond_state == NULL)
2285 return NULL;
2286
2287 cond_state->rsp_type = rsp_type;
2288 cond_state->rsp_text = rsp_text;
2289
2290 return cond_state;
2291 }
2292
2293 LIBETPAN_EXPORT
2294 void
mailimap_resp_cond_state_free(struct mailimap_resp_cond_state * cond_state)2295 mailimap_resp_cond_state_free(struct mailimap_resp_cond_state * cond_state)
2296 {
2297 mailimap_resp_text_free(cond_state->rsp_text);
2298 free(cond_state);
2299 }
2300
2301
2302 LIBETPAN_EXPORT
2303 struct mailimap_resp_text *
mailimap_resp_text_new(struct mailimap_resp_text_code * rsp_code,char * rsp_text)2304 mailimap_resp_text_new(struct mailimap_resp_text_code * rsp_code,
2305 char * rsp_text)
2306 {
2307 struct mailimap_resp_text * resp_text;
2308
2309 resp_text = malloc(sizeof(* resp_text));
2310 if (resp_text == NULL)
2311 return NULL;
2312
2313 resp_text->rsp_code = rsp_code;
2314 resp_text->rsp_text = rsp_text;
2315
2316 return resp_text;
2317 }
2318
2319 LIBETPAN_EXPORT
mailimap_resp_text_free(struct mailimap_resp_text * resp_text)2320 void mailimap_resp_text_free(struct mailimap_resp_text * resp_text)
2321 {
2322 if (resp_text->rsp_code)
2323 mailimap_resp_text_code_free(resp_text->rsp_code);
2324 if (resp_text->rsp_text)
2325 mailimap_text_free(resp_text->rsp_text);
2326 free(resp_text);
2327 }
2328
2329
2330
2331
2332 LIBETPAN_EXPORT
2333 struct mailimap_resp_text_code *
mailimap_resp_text_code_new(int rc_type,clist * rc_badcharset,struct mailimap_capability_data * rc_cap_data,clist * rc_perm_flags,uint32_t rc_uidnext,uint32_t rc_uidvalidity,uint32_t rc_first_unseen,char * rc_atom,char * rc_atom_value,struct mailimap_extension_data * rc_ext_data)2334 mailimap_resp_text_code_new(int rc_type, clist * rc_badcharset,
2335 struct mailimap_capability_data * rc_cap_data,
2336 clist * rc_perm_flags,
2337 uint32_t rc_uidnext, uint32_t rc_uidvalidity,
2338 uint32_t rc_first_unseen, char * rc_atom, char * rc_atom_value,
2339 struct mailimap_extension_data * rc_ext_data)
2340 {
2341 struct mailimap_resp_text_code * resp_text_code;
2342
2343 resp_text_code = malloc(sizeof(* resp_text_code));
2344 if (resp_text_code == NULL)
2345 return NULL;
2346
2347 resp_text_code->rc_type = rc_type;
2348 switch (rc_type) {
2349 case MAILIMAP_RESP_TEXT_CODE_BADCHARSET:
2350 resp_text_code->rc_data.rc_badcharset = rc_badcharset;
2351 break;
2352 case MAILIMAP_RESP_TEXT_CODE_CAPABILITY_DATA:
2353 resp_text_code->rc_data.rc_cap_data = rc_cap_data;
2354 break;
2355 case MAILIMAP_RESP_TEXT_CODE_PERMANENTFLAGS:
2356 resp_text_code->rc_data.rc_perm_flags = rc_perm_flags;
2357 break;
2358 case MAILIMAP_RESP_TEXT_CODE_UIDNEXT:
2359 resp_text_code->rc_data.rc_uidnext = rc_uidnext;
2360 break;
2361 case MAILIMAP_RESP_TEXT_CODE_UIDVALIDITY:
2362 resp_text_code->rc_data.rc_uidvalidity = rc_uidvalidity;
2363 break;
2364 case MAILIMAP_RESP_TEXT_CODE_UNSEEN:
2365 resp_text_code->rc_data.rc_first_unseen = rc_first_unseen;
2366 break;
2367 case MAILIMAP_RESP_TEXT_CODE_OTHER:
2368 resp_text_code->rc_data.rc_atom.atom_name = rc_atom;
2369 resp_text_code->rc_data.rc_atom.atom_value = rc_atom_value;
2370 break;
2371 case MAILIMAP_RESP_TEXT_CODE_EXTENSION:
2372 resp_text_code->rc_data.rc_ext_data = rc_ext_data;
2373 break;
2374 }
2375
2376 return resp_text_code;
2377 }
2378
2379 LIBETPAN_EXPORT
2380 void
mailimap_resp_text_code_free(struct mailimap_resp_text_code * resp_text_code)2381 mailimap_resp_text_code_free(struct mailimap_resp_text_code * resp_text_code)
2382 {
2383 switch (resp_text_code->rc_type) {
2384 case MAILIMAP_RESP_TEXT_CODE_BADCHARSET:
2385 if (resp_text_code->rc_data.rc_badcharset != NULL) {
2386 clist_foreach(resp_text_code->rc_data.rc_badcharset,
2387 (clist_func) mailimap_astring_free,
2388 NULL);
2389 clist_free(resp_text_code->rc_data.rc_badcharset);
2390 }
2391 break;
2392 case MAILIMAP_RESP_TEXT_CODE_CAPABILITY_DATA:
2393 if (resp_text_code->rc_data.rc_cap_data != NULL)
2394 mailimap_capability_data_free(resp_text_code->rc_data.rc_cap_data);
2395 break;
2396 case MAILIMAP_RESP_TEXT_CODE_PERMANENTFLAGS:
2397 if (resp_text_code->rc_data.rc_perm_flags != NULL) {
2398 clist_foreach(resp_text_code->rc_data.rc_perm_flags,
2399 (clist_func) mailimap_flag_perm_free, NULL);
2400 clist_free(resp_text_code->rc_data.rc_perm_flags);
2401 }
2402 break;
2403 case MAILIMAP_RESP_TEXT_CODE_OTHER:
2404 if (resp_text_code->rc_data.rc_atom.atom_name != NULL)
2405 mailimap_atom_free(resp_text_code->rc_data.rc_atom.atom_name);
2406 if (resp_text_code->rc_data.rc_atom.atom_value != NULL)
2407 mailimap_custom_string_free(resp_text_code->rc_data.rc_atom.atom_value);
2408 break;
2409 case MAILIMAP_RESP_TEXT_CODE_EXTENSION:
2410 if (resp_text_code->rc_data.rc_ext_data != NULL)
2411 mailimap_extension_data_free(resp_text_code->rc_data.rc_ext_data);
2412 break;
2413 }
2414 free(resp_text_code);
2415 }
2416
2417
2418 LIBETPAN_EXPORT
2419 struct mailimap_section *
mailimap_section_new(struct mailimap_section_spec * sec_spec)2420 mailimap_section_new(struct mailimap_section_spec * sec_spec)
2421 {
2422 struct mailimap_section * section;
2423
2424 section = malloc(sizeof(* section));
2425 if (section == NULL)
2426 return NULL;
2427
2428 section->sec_spec = sec_spec;
2429
2430 return section;
2431 }
2432
2433 LIBETPAN_EXPORT
mailimap_section_free(struct mailimap_section * section)2434 void mailimap_section_free(struct mailimap_section * section)
2435 {
2436 if (section->sec_spec != NULL)
2437 mailimap_section_spec_free(section->sec_spec);
2438 free(section);
2439 }
2440
2441
2442
2443 LIBETPAN_EXPORT
2444 struct mailimap_section_msgtext *
mailimap_section_msgtext_new(int sec_type,struct mailimap_header_list * sec_header_list)2445 mailimap_section_msgtext_new(int sec_type,
2446 struct mailimap_header_list * sec_header_list)
2447 {
2448 struct mailimap_section_msgtext * msgtext;
2449
2450 msgtext = malloc(sizeof(* msgtext));
2451 if (msgtext == NULL)
2452 return FALSE;
2453
2454 msgtext->sec_type = sec_type;
2455 msgtext->sec_header_list = sec_header_list;
2456
2457 return msgtext;
2458 }
2459
2460 LIBETPAN_EXPORT
2461 void
mailimap_section_msgtext_free(struct mailimap_section_msgtext * msgtext)2462 mailimap_section_msgtext_free(struct mailimap_section_msgtext * msgtext)
2463 {
2464 if (msgtext->sec_header_list != NULL)
2465 mailimap_header_list_free(msgtext->sec_header_list);
2466 free(msgtext);
2467 }
2468
2469
2470 LIBETPAN_EXPORT
2471 struct mailimap_section_part *
mailimap_section_part_new(clist * sec_id)2472 mailimap_section_part_new(clist * sec_id)
2473 {
2474 struct mailimap_section_part * section_part;
2475
2476 section_part = malloc(sizeof(* section_part));
2477 if (section_part == NULL)
2478 return NULL;
2479
2480 section_part->sec_id = sec_id;
2481
2482 return section_part;
2483 }
2484
2485 LIBETPAN_EXPORT
2486 void
mailimap_section_part_free(struct mailimap_section_part * section_part)2487 mailimap_section_part_free(struct mailimap_section_part * section_part)
2488 {
2489 clist_foreach(section_part->sec_id,
2490 (clist_func) mailimap_number_alloc_free, NULL);
2491 clist_free(section_part->sec_id);
2492 free(section_part);
2493 }
2494
2495
2496 LIBETPAN_EXPORT
2497 struct mailimap_section_spec *
mailimap_section_spec_new(int sec_type,struct mailimap_section_msgtext * sec_msgtext,struct mailimap_section_part * sec_part,struct mailimap_section_text * sec_text)2498 mailimap_section_spec_new(int sec_type,
2499 struct mailimap_section_msgtext * sec_msgtext,
2500 struct mailimap_section_part * sec_part,
2501 struct mailimap_section_text * sec_text)
2502 {
2503 struct mailimap_section_spec * section_spec;
2504
2505 section_spec = malloc(sizeof(* section_spec));
2506 if (section_spec == NULL)
2507 return NULL;
2508
2509 section_spec->sec_type = sec_type;
2510 switch (sec_type) {
2511 case MAILIMAP_SECTION_SPEC_SECTION_MSGTEXT:
2512 section_spec->sec_data.sec_msgtext = sec_msgtext;
2513 break;
2514 case MAILIMAP_SECTION_SPEC_SECTION_PART:
2515 section_spec->sec_data.sec_part = sec_part;
2516 break;
2517 }
2518 section_spec->sec_text = sec_text;
2519
2520 return section_spec;
2521 }
2522
2523 LIBETPAN_EXPORT
2524 void
mailimap_section_spec_free(struct mailimap_section_spec * section_spec)2525 mailimap_section_spec_free(struct mailimap_section_spec * section_spec)
2526 {
2527 if (section_spec->sec_text)
2528 mailimap_section_text_free(section_spec->sec_text);
2529
2530 switch (section_spec->sec_type) {
2531 case MAILIMAP_SECTION_SPEC_SECTION_PART:
2532 if (section_spec->sec_data.sec_part != NULL)
2533 mailimap_section_part_free(section_spec->sec_data.sec_part);
2534 break;
2535 case MAILIMAP_SECTION_SPEC_SECTION_MSGTEXT:
2536 /* handle case where it can be detached */
2537 if (section_spec->sec_data.sec_msgtext != NULL)
2538 mailimap_section_msgtext_free(section_spec->sec_data.sec_msgtext);
2539 break;
2540 }
2541 free(section_spec);
2542 }
2543
2544
2545 LIBETPAN_EXPORT
2546 struct mailimap_section_text *
mailimap_section_text_new(int sec_type,struct mailimap_section_msgtext * sec_msgtext)2547 mailimap_section_text_new(int sec_type,
2548 struct mailimap_section_msgtext * sec_msgtext)
2549 {
2550 struct mailimap_section_text * section_text;
2551
2552 section_text = malloc(sizeof(* section_text));
2553 if (section_text == NULL)
2554 return NULL;
2555
2556 section_text->sec_type = sec_type;
2557 section_text->sec_msgtext = sec_msgtext;
2558
2559 return section_text;
2560 }
2561
2562 LIBETPAN_EXPORT
2563 void
mailimap_section_text_free(struct mailimap_section_text * section_text)2564 mailimap_section_text_free(struct mailimap_section_text * section_text)
2565 {
2566 if (section_text->sec_msgtext != NULL)
2567 mailimap_section_msgtext_free(section_text->sec_msgtext);
2568 free(section_text);
2569 }
2570
2571
2572
2573
2574 LIBETPAN_EXPORT
2575 void
mailimap_string_free(char * str)2576 mailimap_string_free(char * str)
2577 {
2578 mmap_string_unref(str);
2579 }
2580
2581
2582
2583
2584
2585 LIBETPAN_EXPORT
mailimap_tag_free(char * tag)2586 void mailimap_tag_free(char * tag)
2587 {
2588 mailimap_custom_string_free(tag);
2589 }
2590
2591
2592 LIBETPAN_EXPORT
mailimap_text_free(char * text)2593 void mailimap_text_free(char * text)
2594 {
2595 mailimap_custom_string_free(text);
2596 }
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619 /* ************************************************************************* */
2620 /* ************************************************************************* */
2621 /* ************************************************************************* */
2622 /* ************************************************************************* */
2623 /* ************************************************************************* */
2624 /* ************************************************************************* */
2625
2626
2627
2628
2629
2630
2631 /* sender only */
2632
2633
2634 /* COPY FETCH SEARCH STORE */
2635 /* set */
2636
2637 LIBETPAN_EXPORT
2638 struct mailimap_set_item *
mailimap_set_item_new(uint32_t set_first,uint32_t set_last)2639 mailimap_set_item_new(uint32_t set_first, uint32_t set_last)
2640 {
2641 struct mailimap_set_item * item;
2642
2643 item = malloc(sizeof(* item));
2644 if (item == NULL)
2645 return NULL;
2646
2647 item->set_first = set_first;
2648 item->set_last = set_last;
2649
2650 return item;
2651 }
2652
2653 LIBETPAN_EXPORT
mailimap_set_item_free(struct mailimap_set_item * set_item)2654 void mailimap_set_item_free(struct mailimap_set_item * set_item)
2655 {
2656 free(set_item);
2657 }
2658
2659 LIBETPAN_EXPORT
mailimap_set_new(clist * set_list)2660 struct mailimap_set * mailimap_set_new(clist * set_list)
2661 {
2662 struct mailimap_set * set;
2663
2664 set = malloc(sizeof(* set));
2665 if (set == NULL)
2666 return NULL;
2667
2668 set->set_list = set_list;
2669
2670 return set;
2671 }
2672
2673 LIBETPAN_EXPORT
mailimap_set_free(struct mailimap_set * set)2674 void mailimap_set_free(struct mailimap_set * set)
2675 {
2676 clist_foreach(set->set_list, (clist_func) mailimap_set_item_free, NULL);
2677 clist_free(set->set_list);
2678 free(set);
2679 }
2680
2681 /* SEARCH with date key */
2682 /* date */
2683
2684 LIBETPAN_EXPORT
2685 struct mailimap_date *
mailimap_date_new(int dt_day,int dt_month,int dt_year)2686 mailimap_date_new(int dt_day, int dt_month, int dt_year)
2687 {
2688 struct mailimap_date * date;
2689
2690 date = malloc(sizeof(* date));
2691 if (date == NULL)
2692 return NULL;
2693
2694 date->dt_day = dt_day;
2695 date->dt_month = dt_month;
2696 date->dt_year = dt_year;
2697
2698 return date;
2699 }
2700
2701 LIBETPAN_EXPORT
mailimap_date_free(struct mailimap_date * date)2702 void mailimap_date_free(struct mailimap_date * date)
2703 {
2704 free(date);
2705 }
2706
2707
2708
2709 LIBETPAN_EXPORT
2710 struct mailimap_fetch_att *
mailimap_fetch_att_new(int att_type,struct mailimap_section * att_section,uint32_t att_offset,uint32_t att_size,char * att_extension)2711 mailimap_fetch_att_new(int att_type, struct mailimap_section * att_section,
2712 uint32_t att_offset, uint32_t att_size, char * att_extension)
2713 {
2714 struct mailimap_fetch_att * fetch_att;
2715
2716 fetch_att = malloc(sizeof(* fetch_att));
2717 if (fetch_att == NULL)
2718 return NULL;
2719 fetch_att->att_type = att_type;
2720 fetch_att->att_section = att_section;
2721 fetch_att->att_offset = att_offset;
2722 fetch_att->att_size = att_size;
2723 fetch_att->att_extension = att_extension;
2724
2725 return fetch_att;
2726 }
2727
2728 LIBETPAN_EXPORT
mailimap_fetch_att_free(struct mailimap_fetch_att * fetch_att)2729 void mailimap_fetch_att_free(struct mailimap_fetch_att * fetch_att)
2730 {
2731 if (fetch_att->att_extension != NULL)
2732 free(fetch_att->att_extension);
2733 if (fetch_att->att_section != NULL)
2734 mailimap_section_free(fetch_att->att_section);
2735 free(fetch_att);
2736 }
2737
2738
2739
2740 LIBETPAN_EXPORT
2741 struct mailimap_fetch_type *
mailimap_fetch_type_new(int ft_type,struct mailimap_fetch_att * ft_fetch_att,clist * ft_fetch_att_list)2742 mailimap_fetch_type_new(int ft_type,
2743 struct mailimap_fetch_att * ft_fetch_att,
2744 clist * ft_fetch_att_list)
2745 {
2746 struct mailimap_fetch_type * fetch_type;
2747
2748 fetch_type = malloc(sizeof(* fetch_type));
2749 if (fetch_type == NULL)
2750 return NULL;
2751 fetch_type->ft_type = ft_type;
2752 switch (ft_type) {
2753 case MAILIMAP_FETCH_TYPE_FETCH_ATT:
2754 fetch_type->ft_data.ft_fetch_att = ft_fetch_att;
2755 break;
2756 case MAILIMAP_FETCH_TYPE_FETCH_ATT_LIST:
2757 fetch_type->ft_data.ft_fetch_att_list = ft_fetch_att_list;
2758 break;
2759 }
2760
2761 return fetch_type;
2762 }
2763
2764 LIBETPAN_EXPORT
mailimap_fetch_type_free(struct mailimap_fetch_type * fetch_type)2765 void mailimap_fetch_type_free(struct mailimap_fetch_type * fetch_type)
2766 {
2767 switch (fetch_type->ft_type) {
2768 case MAILIMAP_FETCH_TYPE_FETCH_ATT:
2769 mailimap_fetch_att_free(fetch_type->ft_data.ft_fetch_att);
2770 break;
2771 case MAILIMAP_FETCH_TYPE_FETCH_ATT_LIST:
2772 clist_foreach(fetch_type->ft_data.ft_fetch_att_list,
2773 (clist_func) mailimap_fetch_att_free, NULL);
2774 clist_free(fetch_type->ft_data.ft_fetch_att_list);
2775 break;
2776 }
2777 free(fetch_type);
2778 }
2779
2780
2781
2782
2783 LIBETPAN_EXPORT
2784 struct mailimap_store_att_flags *
mailimap_store_att_flags_new(int fl_sign,int fl_silent,struct mailimap_flag_list * fl_flag_list)2785 mailimap_store_att_flags_new(int fl_sign, int fl_silent,
2786 struct mailimap_flag_list * fl_flag_list)
2787 {
2788 struct mailimap_store_att_flags * store_att_flags;
2789
2790 store_att_flags = malloc(sizeof(* store_att_flags));
2791 if (store_att_flags == NULL)
2792 return NULL;
2793
2794 store_att_flags->fl_sign = fl_sign;
2795 store_att_flags->fl_silent = fl_silent;
2796 store_att_flags->fl_flag_list = fl_flag_list;
2797
2798 return store_att_flags;
2799 }
2800
2801 LIBETPAN_EXPORT
mailimap_store_att_flags_free(struct mailimap_store_att_flags * store_att_flags)2802 void mailimap_store_att_flags_free(struct mailimap_store_att_flags *
2803 store_att_flags)
2804 {
2805 mailimap_flag_list_free(store_att_flags->fl_flag_list);
2806 free(store_att_flags);
2807 }
2808
2809
2810 LIBETPAN_EXPORT
2811 struct mailimap_search_key *
mailimap_search_key_new(int sk_type,char * sk_bcc,struct mailimap_date * sk_before,char * sk_body,char * sk_cc,char * sk_from,char * sk_keyword,struct mailimap_date * sk_on,struct mailimap_date * sk_since,char * sk_subject,char * sk_text,char * sk_to,char * sk_unkeyword,char * sk_header_name,char * sk_header_value,uint32_t sk_larger,struct mailimap_search_key * sk_not,struct mailimap_search_key * sk_or1,struct mailimap_search_key * sk_or2,struct mailimap_date * sk_sentbefore,struct mailimap_date * sk_senton,struct mailimap_date * sk_sentsince,uint32_t sk_smaller,struct mailimap_set * sk_uid,struct mailimap_set * sk_set,clist * sk_multiple)2812 mailimap_search_key_new(int sk_type,
2813 char * sk_bcc, struct mailimap_date * sk_before, char * sk_body,
2814 char * sk_cc, char * sk_from, char * sk_keyword,
2815 struct mailimap_date * sk_on, struct mailimap_date * sk_since,
2816 char * sk_subject, char * sk_text, char * sk_to,
2817 char * sk_unkeyword, char * sk_header_name,
2818 char * sk_header_value, uint32_t sk_larger,
2819 struct mailimap_search_key * sk_not,
2820 struct mailimap_search_key * sk_or1,
2821 struct mailimap_search_key * sk_or2,
2822 struct mailimap_date * sk_sentbefore,
2823 struct mailimap_date * sk_senton,
2824 struct mailimap_date * sk_sentsince,
2825 uint32_t sk_smaller, struct mailimap_set * sk_uid,
2826 struct mailimap_set * sk_set, clist * sk_multiple)
2827 {
2828 struct mailimap_search_key * key;
2829
2830 key = malloc(sizeof(* key));
2831 if (key == NULL)
2832 return NULL;
2833
2834 key->sk_type = sk_type;
2835 switch (sk_type) {
2836 case MAILIMAP_SEARCH_KEY_BCC:
2837 key->sk_data.sk_bcc = sk_bcc;
2838 break;
2839 case MAILIMAP_SEARCH_KEY_BEFORE:
2840 key->sk_data.sk_before = sk_before;
2841 break;
2842 case MAILIMAP_SEARCH_KEY_BODY:
2843 key->sk_data.sk_body = sk_body;
2844 break;
2845 case MAILIMAP_SEARCH_KEY_CC:
2846 key->sk_data.sk_cc = sk_cc;
2847 break;
2848 case MAILIMAP_SEARCH_KEY_FROM:
2849 key->sk_data.sk_from = sk_from;
2850 break;
2851 case MAILIMAP_SEARCH_KEY_KEYWORD:
2852 key->sk_data.sk_keyword = sk_keyword;
2853 break;
2854 case MAILIMAP_SEARCH_KEY_ON:
2855 key->sk_data.sk_on = sk_on;
2856 break;
2857 case MAILIMAP_SEARCH_KEY_SINCE:
2858 key->sk_data.sk_since = sk_since;
2859 break;
2860 case MAILIMAP_SEARCH_KEY_SUBJECT:
2861 key->sk_data.sk_subject = sk_subject;
2862 break;
2863 case MAILIMAP_SEARCH_KEY_TEXT:
2864 key->sk_data.sk_text = sk_text;
2865 break;
2866 case MAILIMAP_SEARCH_KEY_TO:
2867 key->sk_data.sk_to = sk_to;
2868 break;
2869 case MAILIMAP_SEARCH_KEY_UNKEYWORD:
2870 key->sk_data.sk_unkeyword = sk_unkeyword;
2871 break;
2872 case MAILIMAP_SEARCH_KEY_HEADER:
2873 key->sk_data.sk_header.sk_header_name = sk_header_name;
2874 key->sk_data.sk_header.sk_header_value = sk_header_value;
2875 break;
2876 case MAILIMAP_SEARCH_KEY_LARGER:
2877 key->sk_data.sk_larger = sk_larger;
2878 break;
2879 case MAILIMAP_SEARCH_KEY_NOT:
2880 key->sk_data.sk_not = sk_not;
2881 break;
2882 case MAILIMAP_SEARCH_KEY_OR:
2883 key->sk_data.sk_or.sk_or1 = sk_or1;
2884 key->sk_data.sk_or.sk_or2 = sk_or2;
2885 break;
2886 case MAILIMAP_SEARCH_KEY_SENTBEFORE:
2887 key->sk_data.sk_sentbefore = sk_sentbefore;
2888 break;
2889 case MAILIMAP_SEARCH_KEY_SENTON:
2890 key->sk_data.sk_senton = sk_senton;
2891 break;
2892 case MAILIMAP_SEARCH_KEY_SENTSINCE:
2893 key->sk_data.sk_sentsince = sk_sentsince;
2894 break;
2895 case MAILIMAP_SEARCH_KEY_SMALLER:
2896 key->sk_data.sk_smaller = sk_smaller;
2897 break;
2898 case MAILIMAP_SEARCH_KEY_UID:
2899 key->sk_data.sk_uid = sk_uid;
2900 break;
2901 case MAILIMAP_SEARCH_KEY_SET:
2902 key->sk_data.sk_set = sk_set;
2903 break;
2904 case MAILIMAP_SEARCH_KEY_MULTIPLE:
2905 key->sk_data.sk_multiple = sk_multiple;
2906 break;
2907 }
2908 return key;
2909 }
2910
2911 LIBETPAN_EXPORT
2912 struct mailimap_search_key *
mailimap_search_key_new_xgmthrid(uint64_t sk_xgmthrid)2913 mailimap_search_key_new_xgmthrid(uint64_t sk_xgmthrid)
2914 {
2915 struct mailimap_search_key * key;
2916
2917 key = malloc(sizeof(* key));
2918 if (key == NULL)
2919 return NULL;
2920
2921 key->sk_type = MAILIMAP_SEARCH_KEY_XGMTHRID;
2922 key->sk_data.sk_xgmthrid = sk_xgmthrid;
2923
2924 return key;
2925 }
2926
2927 LIBETPAN_EXPORT
2928 struct mailimap_search_key *
mailimap_search_key_new_xgmmsgid(uint64_t sk_xgmmsgid)2929 mailimap_search_key_new_xgmmsgid(uint64_t sk_xgmmsgid)
2930 {
2931 struct mailimap_search_key * key;
2932
2933 key = malloc(sizeof(* key));
2934 if (key == NULL)
2935 return NULL;
2936
2937 key->sk_type = MAILIMAP_SEARCH_KEY_XGMMSGID;
2938 key->sk_data.sk_xgmmsgid = sk_xgmmsgid;
2939
2940 return key;
2941 }
2942
2943 LIBETPAN_EXPORT
2944 struct mailimap_search_key *
mailimap_search_key_new_xgmraw(char * sk_xgmraw)2945 mailimap_search_key_new_xgmraw(char * sk_xgmraw)
2946 {
2947 struct mailimap_search_key * key;
2948
2949 key = malloc(sizeof(* key));
2950 if (key == NULL)
2951 return NULL;
2952
2953 key->sk_type = MAILIMAP_SEARCH_KEY_XGMRAW;
2954 key->sk_data.sk_xgmraw = sk_xgmraw;
2955
2956 return key;
2957 }
2958
2959 LIBETPAN_EXPORT
mailimap_search_key_free(struct mailimap_search_key * key)2960 void mailimap_search_key_free(struct mailimap_search_key * key)
2961 {
2962 switch (key->sk_type) {
2963 case MAILIMAP_SEARCH_KEY_BCC:
2964 mailimap_astring_free(key->sk_data.sk_bcc);
2965 break;
2966 case MAILIMAP_SEARCH_KEY_BEFORE:
2967 mailimap_date_free(key->sk_data.sk_before);
2968 break;
2969 case MAILIMAP_SEARCH_KEY_BODY:
2970 mailimap_astring_free(key->sk_data.sk_body);
2971 break;
2972 case MAILIMAP_SEARCH_KEY_CC:
2973 mailimap_astring_free(key->sk_data.sk_cc);
2974 break;
2975 case MAILIMAP_SEARCH_KEY_FROM:
2976 mailimap_astring_free(key->sk_data.sk_from);
2977 break;
2978 case MAILIMAP_SEARCH_KEY_KEYWORD:
2979 mailimap_flag_keyword_free(key->sk_data.sk_keyword);
2980 break;
2981 case MAILIMAP_SEARCH_KEY_ON:
2982 mailimap_date_free(key->sk_data.sk_on);
2983 break;
2984 case MAILIMAP_SEARCH_KEY_SINCE:
2985 mailimap_date_free(key->sk_data.sk_since);
2986 break;
2987 case MAILIMAP_SEARCH_KEY_SUBJECT:
2988 mailimap_astring_free(key->sk_data.sk_subject);
2989 break;
2990 case MAILIMAP_SEARCH_KEY_TEXT:
2991 mailimap_astring_free(key->sk_data.sk_text);
2992 break;
2993 case MAILIMAP_SEARCH_KEY_TO:
2994 mailimap_astring_free(key->sk_data.sk_to);
2995 break;
2996 case MAILIMAP_SEARCH_KEY_UNKEYWORD:
2997 mailimap_flag_keyword_free(key->sk_data.sk_unkeyword);
2998 break;
2999 case MAILIMAP_SEARCH_KEY_HEADER:
3000 mailimap_header_fld_name_free(key->sk_data.sk_header.sk_header_name);
3001 mailimap_astring_free(key->sk_data.sk_header.sk_header_value);
3002 break;
3003 case MAILIMAP_SEARCH_KEY_NOT:
3004 mailimap_search_key_free(key->sk_data.sk_not);
3005 break;
3006 case MAILIMAP_SEARCH_KEY_OR:
3007 mailimap_search_key_free(key->sk_data.sk_or.sk_or1);
3008 mailimap_search_key_free(key->sk_data.sk_or.sk_or2);
3009 break;
3010 case MAILIMAP_SEARCH_KEY_SENTBEFORE:
3011 mailimap_date_free(key->sk_data.sk_sentbefore);
3012 break;
3013 case MAILIMAP_SEARCH_KEY_SENTON:
3014 mailimap_date_free(key->sk_data.sk_senton);
3015 break;
3016 case MAILIMAP_SEARCH_KEY_SENTSINCE:
3017 mailimap_date_free(key->sk_data.sk_sentsince);
3018 break;
3019 case MAILIMAP_SEARCH_KEY_UID:
3020 mailimap_set_free(key->sk_data.sk_uid);
3021 break;
3022 case MAILIMAP_SEARCH_KEY_SET:
3023 mailimap_set_free(key->sk_data.sk_set);
3024 break;
3025 case MAILIMAP_SEARCH_KEY_MULTIPLE:
3026 clist_foreach(key->sk_data.sk_multiple,
3027 (clist_func) mailimap_search_key_free, NULL);
3028 clist_free(key->sk_data.sk_multiple);
3029 break;
3030 case MAILIMAP_SEARCH_KEY_MODSEQ:
3031 if (key->sk_data.sk_modseq.sk_entry_name != NULL) {
3032 mailimap_flag_free(key->sk_data.sk_modseq.sk_entry_name);
3033 }
3034 break;
3035 case MAILIMAP_SEARCH_KEY_XGMRAW:
3036 mailimap_astring_free(key->sk_data.sk_xgmraw);
3037 break;
3038 }
3039
3040 free(key);
3041 }
3042
3043
3044
3045
3046
3047 LIBETPAN_EXPORT
3048 struct mailimap_status_att_list *
mailimap_status_att_list_new(clist * att_list)3049 mailimap_status_att_list_new(clist * att_list)
3050 {
3051 struct mailimap_status_att_list * status_att_list;
3052
3053 status_att_list = malloc(sizeof(* status_att_list));
3054 if (status_att_list == NULL)
3055 return NULL;
3056 status_att_list->att_list = att_list;
3057
3058 return status_att_list;
3059 }
3060
3061 LIBETPAN_EXPORT
mailimap_status_att_list_free(struct mailimap_status_att_list * status_att_list)3062 void mailimap_status_att_list_free(struct mailimap_status_att_list *
3063 status_att_list)
3064 {
3065 clist_foreach(status_att_list->att_list, (clist_func) free, NULL);
3066 clist_free(status_att_list->att_list);
3067 free(status_att_list);
3068 }
3069
3070
3071
3072
3073 /* main */
3074
3075
3076 LIBETPAN_EXPORT
3077 struct mailimap_selection_info *
mailimap_selection_info_new(void)3078 mailimap_selection_info_new(void)
3079 {
3080 struct mailimap_selection_info * sel_info;
3081
3082 sel_info = malloc(sizeof(* sel_info));
3083 if (sel_info == NULL)
3084 return NULL;
3085
3086 sel_info->sel_perm_flags = NULL;
3087 sel_info->sel_perm = MAILIMAP_MAILBOX_READWRITE;
3088 sel_info->sel_uidnext = 0;
3089 sel_info->sel_uidvalidity = 0;
3090 sel_info->sel_first_unseen = 0;
3091 sel_info->sel_flags = NULL;
3092 sel_info->sel_exists = 0;
3093 sel_info->sel_recent = 0;
3094 sel_info->sel_unseen = 0;
3095 sel_info->sel_has_exists = 0;
3096 sel_info->sel_has_recent = 0 ;
3097
3098 return sel_info;
3099 }
3100
3101 LIBETPAN_EXPORT
3102 void
mailimap_selection_info_free(struct mailimap_selection_info * sel_info)3103 mailimap_selection_info_free(struct mailimap_selection_info * sel_info)
3104 {
3105 if (sel_info->sel_perm_flags != NULL) {
3106 clist_foreach(sel_info->sel_perm_flags,
3107 (clist_func) mailimap_flag_perm_free, NULL);
3108 clist_free(sel_info->sel_perm_flags);
3109 }
3110 if (sel_info->sel_flags)
3111 mailimap_flag_list_free(sel_info->sel_flags);
3112
3113 free(sel_info);
3114 }
3115
3116 LIBETPAN_EXPORT
3117 struct mailimap_connection_info *
mailimap_connection_info_new(void)3118 mailimap_connection_info_new(void)
3119 {
3120 struct mailimap_connection_info * conn_info;
3121
3122 conn_info = malloc(sizeof(* conn_info));
3123 if (conn_info == NULL)
3124 return NULL;
3125
3126 conn_info->imap_capability = NULL;
3127
3128 return conn_info;
3129 }
3130
3131 LIBETPAN_EXPORT
3132 void
mailimap_connection_info_free(struct mailimap_connection_info * conn_info)3133 mailimap_connection_info_free(struct mailimap_connection_info * conn_info)
3134 {
3135 if (conn_info->imap_capability != NULL)
3136 mailimap_capability_data_free(conn_info->imap_capability);
3137 free(conn_info);
3138 }
3139
3140 LIBETPAN_EXPORT
3141 struct mailimap_response_info *
mailimap_response_info_new(void)3142 mailimap_response_info_new(void)
3143 {
3144 struct mailimap_response_info * resp_info;
3145
3146 resp_info = malloc(sizeof(* resp_info));
3147 if (resp_info == NULL)
3148 goto err;
3149
3150 resp_info->rsp_alert = NULL;
3151 resp_info->rsp_parse = NULL;
3152 resp_info->rsp_badcharset = NULL;
3153 resp_info->rsp_trycreate = FALSE;
3154 resp_info->rsp_mailbox_list = clist_new();
3155 if (resp_info->rsp_mailbox_list == NULL)
3156 goto free;
3157 resp_info->rsp_extension_list = clist_new();
3158 if (resp_info->rsp_extension_list == NULL)
3159 goto free_mb_list;
3160 resp_info->rsp_mailbox_lsub = clist_new();
3161 if (resp_info->rsp_mailbox_lsub == NULL)
3162 goto free_extension_list;
3163 resp_info->rsp_search_result = clist_new();
3164 if (resp_info->rsp_search_result == NULL)
3165 goto free_mb_lsub;
3166 resp_info->rsp_status = NULL;
3167 resp_info->rsp_expunged = clist_new();
3168 if (resp_info->rsp_expunged == NULL)
3169 goto free_search_result;
3170 resp_info->rsp_fetch_list = clist_new();
3171 if (resp_info->rsp_fetch_list == NULL)
3172 goto free_expunged;
3173 resp_info->rsp_atom = NULL;
3174 resp_info->rsp_value = NULL;
3175
3176 return resp_info;
3177
3178 free_expunged:
3179 clist_free(resp_info->rsp_expunged);
3180 free_search_result:
3181 clist_free(resp_info->rsp_search_result);
3182 free_mb_lsub:
3183 clist_free(resp_info->rsp_mailbox_lsub);
3184 free_extension_list:
3185 clist_free(resp_info->rsp_extension_list);
3186 free_mb_list:
3187 clist_free(resp_info->rsp_mailbox_list);
3188 free:
3189 free(resp_info);
3190 err:
3191 return NULL;
3192 }
3193
3194 LIBETPAN_EXPORT
3195 void
mailimap_response_info_free(struct mailimap_response_info * resp_info)3196 mailimap_response_info_free(struct mailimap_response_info * resp_info)
3197 {
3198 free(resp_info->rsp_value);
3199 free(resp_info->rsp_atom);
3200 if (resp_info->rsp_alert != NULL)
3201 free(resp_info->rsp_alert);
3202 if (resp_info->rsp_parse != NULL)
3203 free(resp_info->rsp_parse);
3204 if (resp_info->rsp_badcharset != NULL) {
3205 clist_foreach(resp_info->rsp_badcharset,
3206 (clist_func) mailimap_astring_free, NULL);
3207 clist_free(resp_info->rsp_badcharset);
3208 }
3209 if (resp_info->rsp_mailbox_list != NULL) {
3210 clist_foreach(resp_info->rsp_mailbox_list,
3211 (clist_func) mailimap_mailbox_list_free, NULL);
3212 clist_free(resp_info->rsp_mailbox_list);
3213 }
3214 if (resp_info->rsp_extension_list != NULL) {
3215 clist_foreach(resp_info->rsp_extension_list,
3216 (clist_func) mailimap_extension_data_free, NULL);
3217 clist_free(resp_info->rsp_extension_list);
3218 }
3219 if (resp_info->rsp_mailbox_lsub != NULL) {
3220 clist_foreach(resp_info->rsp_mailbox_lsub,
3221 (clist_func) mailimap_mailbox_list_free, NULL);
3222 clist_free(resp_info->rsp_mailbox_lsub);
3223 }
3224 if (resp_info->rsp_search_result != NULL)
3225 mailimap_mailbox_data_search_free(resp_info->rsp_search_result);
3226 if (resp_info->rsp_status != NULL)
3227 mailimap_mailbox_data_status_free(resp_info->rsp_status);
3228 if (resp_info->rsp_expunged != NULL) {
3229 clist_foreach(resp_info->rsp_expunged,
3230 (clist_func) mailimap_number_alloc_free, NULL);
3231 clist_free(resp_info->rsp_expunged);
3232 }
3233 if (resp_info->rsp_fetch_list != NULL) {
3234 clist_foreach(resp_info->rsp_fetch_list,
3235 (clist_func) mailimap_msg_att_free, NULL);
3236 clist_free(resp_info->rsp_fetch_list);
3237 }
3238
3239 free(resp_info);
3240 }
3241
3242
3243 LIBETPAN_EXPORT
3244 int
mailimap_parser_context_is_rambler_workaround_enabled(struct mailimap_parser_context * parser_ctx)3245 mailimap_parser_context_is_rambler_workaround_enabled(struct mailimap_parser_context * parser_ctx)
3246 {
3247 return parser_ctx != NULL && parser_ctx->is_rambler_workaround_enabled;
3248 }
3249
3250 LIBETPAN_EXPORT
3251 int
mailimap_parser_context_is_qip_workaround_enabled(struct mailimap_parser_context * parser_ctx)3252 mailimap_parser_context_is_qip_workaround_enabled(struct mailimap_parser_context * parser_ctx)
3253 {
3254 return parser_ctx != NULL && parser_ctx->is_qip_workaround_enabled;
3255 }
3256
3257 LIBETPAN_EXPORT
3258 struct mailimap_parser_context *
mailimap_parser_context_new(mailimap * session)3259 mailimap_parser_context_new(mailimap * session)
3260 {
3261 struct mailimap_parser_context * ctx;
3262
3263 ctx = malloc(sizeof(* ctx));
3264 if (ctx == NULL)
3265 goto err;
3266
3267 ctx->is_rambler_workaround_enabled = mailimap_is_rambler_workaround_enabled(session);
3268 ctx->is_qip_workaround_enabled = mailimap_is_qip_workaround_enabled(session);
3269
3270 ctx->msg_body_handler = session->imap_msg_body_handler;
3271 ctx->msg_body_handler_context = session->imap_msg_body_handler_context;
3272 ctx->msg_body_parse_in_progress = false;
3273 ctx->msg_body_section = NULL;
3274 ctx->msg_body_att_type = 0;
3275
3276 return ctx;
3277
3278 err:
3279 return NULL;
3280 }
3281
3282 LIBETPAN_EXPORT
3283 void
mailimap_parser_context_free(struct mailimap_parser_context * ctx)3284 mailimap_parser_context_free(struct mailimap_parser_context * ctx)
3285 {
3286 free(ctx);
3287 }
3288