src/plugins/mailmbox/mailimf_types_helper.c

   1 /*
   2  * libEtPan! -- a mail stuff library
   3  *
   4  * Copyright (C) 2001, 2002 - DINH Viet Hoa
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the libEtPan! project nor the names of its
  16  *    contributors may be used to endorse or promote products derived
  17  *    from this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include "mailimf_types_helper.h"
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <time.h>
  37 #include <unistd.h>
  38
  39 #include "mailimf.h"
  40
  41 struct mailimf_mailbox_list *
  42 mailimf_mailbox_list_new_empty()
  43 {
  44   clist * list;
  45   struct mailimf_mailbox_list * mb_list;
  46
  47   list = clist_new();
  48   if (list == NULL)
  49     return NULL;
  50
  51   mb_list = mailimf_mailbox_list_new(list);
  52   if (mb_list == NULL)
  53     return NULL;
  54
  55   return mb_list;
  56 }
  57
  58 int mailimf_mailbox_list_add(struct mailimf_mailbox_list * mailbox_list,
  59                              struct mailimf_mailbox * mb)
  60 {
  61   int r;
  62
  63   r = clist_append(mailbox_list->mb_list, mb);
  64   if (r < 0)
  65     return MAILIMF_ERROR_MEMORY;
  66
  67   return MAILIMF_NO_ERROR;
  68 }
  69
  70 int mailimf_mailbox_list_add_parse(struct mailimf_mailbox_list * mailbox_list,
  71                                    char * mb_str)
  72 {
  73   int r;
  74   size_t cur_token;
  75   struct mailimf_mailbox * mb;
  76   int res;
  77
  78   cur_token = 0;
  79   r = mailimf_mailbox_parse(mb_str, strlen(mb_str), &cur_token, &mb);
  80   if (r != MAILIMF_NO_ERROR) {
  81     res = r;
  82     goto err;
  83   }
  84
  85   r = mailimf_mailbox_list_add(mailbox_list, mb);
  86   if (r != MAILIMF_NO_ERROR) {
  87     res = r;
  88     goto free;
  89   }
  90
  91   return MAILIMF_NO_ERROR;
  92
  93  free:
  94   mailimf_mailbox_free(mb);
  95  err:
  96   return res;
  97 }
  98
  99 int mailimf_mailbox_list_add_mb(struct mailimf_mailbox_list * mailbox_list,
 100                                 char * display_name, char * address)
 101 {
 102   int r;
 103   struct mailimf_mailbox * mb;
 104   int res;
 105
 106   mb = mailimf_mailbox_new(display_name, address);
 107   if (mb == NULL) {
 108     res = MAILIMF_ERROR_MEMORY;
 109     goto err;
 110   }
 111
 112   r = mailimf_mailbox_list_add(mailbox_list, mb);
 113   if (r != MAILIMF_NO_ERROR) {
 114     res = r;
 115     goto free;
 116   }
 117
 118   return MAILIMF_NO_ERROR;
 119
 120  free:
 121   mailimf_mailbox_free(mb);
 122  err:
 123   return res;
 124 }
 125
 126
 127
 128 struct mailimf_address_list *
 129 mailimf_address_list_new_empty()
 130 {
 131   clist * list;
 132   struct mailimf_address_list * addr_list;
 133
 134   list = clist_new();
 135   if (list == NULL)
 136     return NULL;
 137
 138   addr_list = mailimf_address_list_new(list);
 139   if (addr_list == NULL)
 140     return NULL;
 141
 142   return addr_list;
 143 }
 144
 145 int mailimf_address_list_add(struct mailimf_address_list * address_list,
 146                              struct mailimf_address * addr)
 147 {
 148   int r;
 149
 150   r = clist_append(address_list->ad_list, addr);
 151   if (r < 0)
 152     return MAILIMF_ERROR_MEMORY;
 153
 154   return MAILIMF_NO_ERROR;
 155 }
 156
 157 int mailimf_address_list_add_parse(struct mailimf_address_list * address_list,
 158                                    char * addr_str)
 159 {
 160   int r;
 161   size_t cur_token;
 162   struct mailimf_address * addr;
 163   int res;
 164
 165   cur_token = 0;
 166   r = mailimf_address_parse(addr_str, strlen(addr_str), &cur_token, &addr);
 167   if (r != MAILIMF_NO_ERROR) {
 168     res = r;
 169     goto err;
 170   }
 171
 172   r = mailimf_address_list_add(address_list, addr);
 173   if (r != MAILIMF_NO_ERROR) {
 174     res = r;
 175     goto free;
 176   }
 177
 178   return MAILIMF_NO_ERROR;
 179
 180  free:
 181   mailimf_address_free(addr);
 182  err:
 183   return res;
 184 }
 185
 186 int mailimf_address_list_add_mb(struct mailimf_address_list * address_list,
 187                                 char * display_name, char * address)
 188 {
 189   int r;
 190   struct mailimf_mailbox * mb;
 191   struct mailimf_address * addr;
 192   int res;
 193
 194   mb = mailimf_mailbox_new(display_name, address);
 195   if (mb == NULL) {
 196     res = MAILIMF_ERROR_MEMORY;
 197     goto err;
 198   }
 199
 200   addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
 201   if (addr == NULL) {
 202     res = MAILIMF_ERROR_MEMORY;
 203     goto free_mb;
 204   }
 205
 206   r = mailimf_address_list_add(address_list, addr);
 207   if (r != MAILIMF_NO_ERROR) {
 208     res = r;
 209     goto free_addr;
 210   }
 211
 212   return MAILIMF_NO_ERROR;
 213
 214  free_addr:
 215   mailimf_address_free(addr);
 216  free_mb:
 217   mailimf_mailbox_free(mb);
 218  err:
 219   return res;
 220 }
 221
 222
 223 #if 0
 224 struct mailimf_resent_fields_list *
 225 mailimf_resent_fields_list_new_empty()
 226 {
 227   clist * list;
 228   struct mailimf_resent_fields_list * rf_list;
 229
 230   list = clist_new();
 231   if (list == NULL)
 232     return NULL;
 233
 234   rf_list = mailimf_resent_fields_list_new(list);
 235   if (rf_list == NULL)
 236     return NULL;
 237
 238   return rf_list;
 239 }
 240
 241 int mailimf_resent_fields_add(struct mailimf_resent_fields_list * fields,
 242                               struct mailimf_resent_field * field)
 243 {
 244   int r;
 245
 246   r = clist_append(fields->list, field);
 247   if (r < 0)
 248     return MAILIMF_ERROR_MEMORY;
 249
 250   return MAILIMF_NO_ERROR;
 251 }
 252 #endif
 253
 254
 255 static void detach_free_common_fields(struct mailimf_orig_date * imf_date,
 256                                       struct mailimf_from * imf_from,
 257                                       struct mailimf_sender * imf_sender,
 258                                       struct mailimf_to * imf_to,
 259                                       struct mailimf_cc * imf_cc,
 260                                       struct mailimf_bcc * imf_bcc,
 261                                       struct mailimf_message_id * imf_msg_id)
 262 {
 263   if (imf_date != NULL) {
 264     imf_date->dt_date_time = NULL;
 265     mailimf_orig_date_free(imf_date);
 266   }
 267   if (imf_from != NULL) {
 268     imf_from->frm_mb_list = NULL;
 269     mailimf_from_free(imf_from);
 270   }
 271   if (imf_sender != NULL) {
 272     imf_sender->snd_mb = NULL;
 273     mailimf_sender_free(imf_sender);
 274   }
 275   if (imf_to != NULL) {
 276     imf_to->to_addr_list = NULL;
 277     mailimf_to_free(imf_to);
 278   }
 279   if (imf_cc != NULL) {
 280     imf_cc->cc_addr_list = NULL;
 281     mailimf_to_free(imf_to);
 282   }
 283   if (imf_bcc != NULL) {
 284     imf_bcc->bcc_addr_list = NULL;
 285     mailimf_bcc_free(imf_bcc);
 286   }
 287   if (imf_msg_id != NULL) {
 288     imf_msg_id->mid_value = NULL;
 289     mailimf_message_id_free(imf_msg_id);
 290   }
 291 }
 292
 293 static void detach_resent_field(struct mailimf_field * field)
 294 {
 295   field->fld_type = MAILIMF_FIELD_NONE;
 296   mailimf_field_free(field);
 297 }
 298
 299 int
 300 mailimf_resent_fields_add_data(struct mailimf_fields * fields,
 301     struct mailimf_date_time * resent_date,
 302     struct mailimf_mailbox_list * resent_from,
 303     struct mailimf_mailbox * resent_sender,
 304     struct mailimf_address_list * resent_to,
 305     struct mailimf_address_list * resent_cc,
 306     struct mailimf_address_list * resent_bcc,
 307     char * resent_msg_id)
 308 {
 309   struct mailimf_orig_date * imf_resent_date;
 310   struct mailimf_from * imf_resent_from;
 311   struct mailimf_sender * imf_resent_sender;
 312   struct mailimf_to * imf_resent_to;
 313   struct mailimf_cc * imf_resent_cc;
 314   struct mailimf_bcc * imf_resent_bcc;
 315   struct mailimf_message_id * imf_resent_msg_id;
 316   struct mailimf_field * field;
 317   int r;
 318
 319   imf_resent_date = NULL;
 320   imf_resent_from = NULL;
 321   imf_resent_sender = NULL;
 322   imf_resent_to = NULL;
 323   imf_resent_cc = NULL;
 324   imf_resent_bcc = NULL;
 325   imf_resent_msg_id = NULL;
 326   field = NULL;
 327
 328   if (resent_date != NULL) {
 329     imf_resent_date = mailimf_orig_date_new(resent_date);
 330     if (imf_resent_date == NULL)
 331       goto free;
 332     field = mailimf_field_new(MAILIMF_FIELD_RESENT_DATE,
 333         NULL /* return-path */,
 334         imf_resent_date /* resent date */,
 335         NULL /* resent from */,
 336         NULL /* resent sender */,
 337         NULL /* resent to */,
 338         NULL /* resent cc */,
 339         NULL /* resent bcc */,
 340         NULL /* resent msg id */,
 341         NULL /* date */,
 342         NULL /* from */,
 343         NULL /* sender */,
 344         NULL /* reply-to */,
 345         NULL /* to */,
 346         NULL /* cc */,
 347         NULL /* bcc */,
 348         NULL /* message id */,
 349         NULL /* in reply to */,
 350         NULL /* references */,
 351         NULL /* subject */,
 352         NULL /* comments */,
 353         NULL /* keywords */,
 354         NULL /* optional field */);
 355     if (field == NULL)
 356       goto free;
 357     r =  mailimf_fields_add(fields, field);
 358     if (r != MAILIMF_NO_ERROR)
 359       goto free_field;
 360   }
 361
 362   if (resent_from != NULL) {
 363     imf_resent_from = mailimf_from_new(resent_from);
 364     if (imf_resent_from == NULL)
 365       goto free_field;
 366     field = mailimf_field_new(MAILIMF_FIELD_RESENT_FROM,
 367         NULL /* return-path */,
 368         NULL /* resent date */,
 369         imf_resent_from /* resent from */,
 370         NULL /* resent sender */,
 371         NULL /* resent to */,
 372         NULL /* resent cc */,
 373         NULL /* resent bcc */,
 374         NULL /* resent msg id */,
 375         NULL /* date */,
 376         NULL /* from */,
 377         NULL /* sender */,
 378         NULL /* reply-to */,
 379         NULL /* to */,
 380         NULL /* cc */,
 381         NULL /* bcc */,
 382         NULL /* message id */,
 383         NULL /* in reply to */,
 384         NULL /* references */,
 385         NULL /* subject */,
 386         NULL /* comments */,
 387         NULL /* keywords */,
 388         NULL /* optional field */);
 389     if (field == NULL)
 390       goto free;
 391     r =  mailimf_fields_add(fields, field);
 392     if (r != MAILIMF_NO_ERROR)
 393       goto free_field;
 394   }
 395
 396   if (resent_sender != NULL) {
 397     imf_resent_sender = mailimf_sender_new(resent_sender);
 398     if (imf_resent_sender == NULL)
 399       goto free;
 400     field = mailimf_field_new(MAILIMF_FIELD_RESENT_SENDER,
 401         NULL /* return-path */,
 402         NULL /* resent date */,
 403         NULL /* resent from */,
 404         imf_resent_sender /* resent sender */,
 405         NULL /* resent to */,
 406         NULL /* resent cc */,
 407         NULL /* resent bcc */,
 408         NULL /* resent msg id */,
 409         NULL /* date */,
 410         NULL /* from */,
 411         NULL /* sender */,
 412         NULL /* reply-to */,
 413         NULL /* to */,
 414         NULL /* cc */,
 415         NULL /* bcc */,
 416         NULL /* message id */,
 417         NULL /* in reply to */,
 418         NULL /* references */,
 419         NULL /* subject */,
 420         NULL /* comments */,
 421         NULL /* keywords */,
 422         NULL /* optional field */);
 423     if (field == NULL)
 424       goto free;
 425     r =  mailimf_fields_add(fields, field);
 426     if (r != MAILIMF_NO_ERROR)
 427       goto free_field;
 428   }
 429
 430   if (resent_to != NULL) {
 431     imf_resent_to = mailimf_to_new(resent_to);
 432     if (imf_resent_to == NULL)
 433       goto free;
 434     field = mailimf_field_new(MAILIMF_FIELD_RESENT_TO,
 435         NULL /* return-path */,
 436         NULL /* resent date */,
 437         NULL /* resent from */,
 438         NULL /* resent sender */,
 439         imf_resent_to /* resent to */,
 440         NULL /* resent cc */,
 441         NULL /* resent bcc */,
 442         NULL /* resent msg id */,
 443         NULL /* date */,
 444         NULL /* from */,
 445         NULL /* sender */,
 446         NULL /* reply-to */,
 447         NULL /* to */,
 448         NULL /* cc */,
 449         NULL /* bcc */,
 450         NULL /* message id */,
 451         NULL /* in reply to */,
 452         NULL /* references */,
 453         NULL /* subject */,
 454         NULL /* comments */,
 455         NULL /* keywords */,
 456         NULL /* optional field */);
 457     if (field == NULL)
 458       goto free;
 459     r =  mailimf_fields_add(fields, field);
 460     if (r != MAILIMF_NO_ERROR)
 461       goto free_field;
 462   }
 463
 464   if (resent_cc != NULL) {
 465     imf_resent_cc = mailimf_cc_new(resent_cc);
 466     if (imf_resent_cc == NULL)
 467       goto free;
 468     field = mailimf_field_new(MAILIMF_FIELD_RESENT_CC,
 469         NULL /* return-path */,
 470         NULL /* resent date */,
 471         NULL /* resent from */,
 472         NULL /* resent sender */,
 473         NULL /* resent to */,
 474         imf_resent_cc /* resent cc */,
 475         NULL /* resent bcc */,
 476         NULL /* resent msg id */,
 477         NULL /* date */,
 478         NULL /* from */,
 479         NULL /* sender */,
 480         NULL /* reply-to */,
 481         NULL /* to */,
 482         NULL /* cc */,
 483         NULL /* bcc */,
 484         NULL /* message id */,
 485         NULL /* in reply to */,
 486         NULL /* references */,
 487         NULL /* subject */,
 488         NULL /* comments */,
 489         NULL /* keywords */,
 490         NULL /* optional field */);
 491     if (field == NULL)
 492       goto free;
 493     r =  mailimf_fields_add(fields, field);
 494     if (r != MAILIMF_NO_ERROR)
 495       goto free_field;
 496   }
 497
 498   if (resent_bcc != NULL) {
 499     imf_resent_bcc = mailimf_bcc_new(resent_bcc);
 500     if (imf_resent_bcc == NULL)
 501       goto free;
 502     field = mailimf_field_new(MAILIMF_FIELD_RESENT_BCC,
 503         NULL /* return-path */,
 504         NULL /* resent date */,
 505         NULL /* resent from */,
 506         NULL /* resent sender */,
 507         NULL /* resent to */,
 508         NULL /* resent cc */,
 509         imf_resent_bcc /* resent bcc */,
 510         NULL /* resent msg id */,
 511         NULL /* date */,
 512         NULL /* from */,
 513         NULL /* sender */,
 514         NULL /* reply-to */,
 515         NULL /* to */,
 516         NULL /* cc */,
 517         NULL /* bcc */,
 518         NULL /* message id */,
 519         NULL /* in reply to */,
 520         NULL /* references */,
 521         NULL /* subject */,
 522         NULL /* comments */,
 523         NULL /* keywords */,
 524         NULL /* optional field */);
 525     if (field == NULL)
 526       goto free;
 527     r =  mailimf_fields_add(fields, field);
 528     if (r != MAILIMF_NO_ERROR)
 529       goto free_field;
 530   }
 531
 532   if (resent_msg_id != NULL) {
 533     imf_resent_msg_id = mailimf_message_id_new(resent_msg_id);
 534     if (imf_resent_msg_id == NULL)
 535       goto free;
 536     field = mailimf_field_new(MAILIMF_FIELD_RESENT_MSG_ID,
 537         NULL /* return-path */,
 538         NULL /* resent date */,
 539         NULL /* resent from */,
 540         NULL /* resent sender */,
 541         NULL /* resent to */,
 542         NULL /* resent cc */,
 543         NULL /* resent bcc */,
 544         imf_resent_msg_id /* resent msg id */,
 545         NULL /* date */,
 546         NULL /* from */,
 547         NULL /* sender */,
 548         NULL /* reply-to */,
 549         NULL /* to */,
 550         NULL /* cc */,
 551         NULL /* bcc */,
 552         NULL /* message id */,
 553         NULL /* in reply to */,
 554         NULL /* references */,
 555         NULL /* subject */,
 556         NULL /* comments */,
 557         NULL /* keywords */,
 558         NULL /* optional field */);
 559     if (field == NULL)
 560       goto free;
 561     r =  mailimf_fields_add(fields, field);
 562     if (r != MAILIMF_NO_ERROR)
 563       goto free_field;
 564   }
 565
 566   return MAILIMF_NO_ERROR;
 567
 568  free_field:
 569   if (field != NULL) {
 570     detach_resent_field(field);
 571   }
 572  free:
 573   detach_free_common_fields(imf_resent_date,
 574                             imf_resent_from,
 575                             imf_resent_sender,
 576                             imf_resent_to,
 577                             imf_resent_cc,
 578                             imf_resent_bcc,
 579                             imf_resent_msg_id);
 580   return MAILIMF_ERROR_MEMORY;
 581 }
 582
 583 struct mailimf_fields *
 584 mailimf_resent_fields_new_with_data_all(struct mailimf_date_time *
 585     resent_date,
 586     struct mailimf_mailbox_list *
 587     resent_from,
 588     struct mailimf_mailbox *
 589     resent_sender,
 590     struct mailimf_address_list *
 591     resent_to,
 592     struct mailimf_address_list *
 593     resent_cc,
 594     struct mailimf_address_list *
 595     resent_bcc,
 596     char * resent_msg_id)
 597 {
 598   struct mailimf_fields * resent_fields;
 599   int r;
 600
 601   resent_fields = mailimf_fields_new_empty();
 602   if (resent_fields == NULL)
 603     goto err;
 604
 605   r = mailimf_resent_fields_add_data(resent_fields,
 606       resent_date, resent_from,
 607       resent_sender, resent_to,
 608       resent_cc, resent_bcc,
 609       resent_msg_id);
 610   if (r != MAILIMF_NO_ERROR)
 611     goto free;
 612
 613   return resent_fields;
 614
 615  free:
 616   mailimf_fields_free(resent_fields);
 617  err:
 618   return NULL;
 619 }
 620
 621
 622 struct mailimf_fields *
 623 mailimf_resent_fields_new_with_data(struct mailimf_mailbox_list * from,
 624     struct mailimf_mailbox * sender,
 625     struct mailimf_address_list * to,
 626     struct mailimf_address_list * cc,
 627     struct mailimf_address_list * bcc)
 628 {
 629   struct mailimf_date_time * date;
 630   char * msg_id;
 631   struct mailimf_fields * fields;
 632
 633   date = mailimf_get_current_date();
 634   if (date == NULL)
 635     goto err;
 636
 637   msg_id = mailimf_get_message_id();
 638   if (msg_id == NULL)
 639     goto free_date;
 640
 641   fields = mailimf_resent_fields_new_with_data_all(date,
 642       from, sender, to, cc, bcc, msg_id);
 643   if (fields == NULL)
 644     goto free_msg_id;
 645
 646   return fields;
 647
 648  free_msg_id:
 649   free(msg_id);
 650  free_date:
 651   mailimf_date_time_free(date);
 652  err:
 653   return NULL;
 654 }
 655
 656
 657 struct mailimf_fields *
 658 mailimf_fields_new_empty(void)
 659 {
 660   clist * list;
 661   struct mailimf_fields * fields_list;
 662
 663   list = clist_new();
 664   if (list == NULL)
 665     return NULL;
 666
 667   fields_list = mailimf_fields_new(list);
 668   if (fields_list == NULL)
 669     return NULL;
 670
 671   return fields_list;
 672 }
 673
 674 int mailimf_fields_add(struct mailimf_fields * fields,
 675                        struct mailimf_field * field)
 676 {
 677   int r;
 678
 679   r = clist_append(fields->fld_list, field);
 680   if (r < 0)
 681     return MAILIMF_ERROR_MEMORY;
 682
 683   return MAILIMF_NO_ERROR;
 684 }
 685
 686 static void detach_free_fields(struct mailimf_orig_date * date,
 687                                struct mailimf_from * from,
 688                                struct mailimf_sender * sender,
 689                                struct mailimf_reply_to * reply_to,
 690                                struct mailimf_to * to,
 691                                struct mailimf_cc * cc,
 692                                struct mailimf_bcc * bcc,
 693                                struct mailimf_message_id * msg_id,
 694                                struct mailimf_in_reply_to * in_reply_to,
 695                                struct mailimf_references * references,
 696                                struct mailimf_subject * subject)
 697 {
 698   detach_free_common_fields(date,
 699       from,
 700       sender,
 701       to,
 702       cc,
 703       bcc,
 704       msg_id);
 705
 706   if (reply_to != NULL) {
 707     reply_to->rt_addr_list = NULL;
 708     mailimf_reply_to_free(reply_to);
 709   }
 710
 711   if (in_reply_to != NULL) {
 712     in_reply_to->mid_list = NULL;
 713     mailimf_in_reply_to_free(in_reply_to);
 714   }
 715
 716   if (references != NULL) {
 717     references->mid_list = NULL;
 718     mailimf_references_free(references);
 719   }
 720
 721   if (subject != NULL) {
 722     subject->sbj_value = NULL;
 723     mailimf_subject_free(subject);
 724   }
 725 }
 726
 727
 728 static void detach_field(struct mailimf_field * field)
 729 {
 730   field->fld_type = MAILIMF_FIELD_NONE;
 731   mailimf_field_free(field);
 732 }
 733
 734 int mailimf_fields_add_data(struct mailimf_fields * fields,
 735                             struct mailimf_date_time * date,
 736                             struct mailimf_mailbox_list * from,
 737                             struct mailimf_mailbox * sender,
 738                             struct mailimf_address_list * reply_to,
 739                             struct mailimf_address_list * to,
 740                             struct mailimf_address_list * cc,
 741                             struct mailimf_address_list * bcc,
 742                             char * msg_id,
 743                             clist * in_reply_to,
 744                             clist * references,
 745                             char * subject)
 746 {
 747   struct mailimf_orig_date * imf_date;
 748   struct mailimf_from * imf_from;
 749   struct mailimf_sender * imf_sender;
 750   struct mailimf_reply_to * imf_reply_to;
 751   struct mailimf_to * imf_to;
 752   struct mailimf_cc * imf_cc;
 753   struct mailimf_bcc * imf_bcc;
 754   struct mailimf_message_id * imf_msg_id;
 755   struct mailimf_references * imf_references;
 756   struct mailimf_in_reply_to * imf_in_reply_to;
 757   struct mailimf_subject * imf_subject;
 758   struct mailimf_field * field;
 759   int r;
 760
 761   imf_date = NULL;
 762   imf_from = NULL;
 763   imf_sender = NULL;
 764   imf_reply_to = NULL;
 765   imf_to = NULL;
 766   imf_cc = NULL;
 767   imf_bcc = NULL;
 768   imf_msg_id = NULL;
 769   imf_references = NULL;
 770   imf_in_reply_to = NULL;
 771   imf_subject =NULL;
 772   field = NULL;
 773
 774   if (date != NULL) {
 775     imf_date = mailimf_orig_date_new(date);
 776     if (imf_date == NULL)
 777       goto free;
 778     field = mailimf_field_new(MAILIMF_FIELD_ORIG_DATE,
 779         NULL /* return-path */,
 780         NULL /* resent date */,
 781         NULL /* resent from */,
 782         NULL /* resent sender */,
 783         NULL /* resent to */,
 784         NULL /* resent cc */,
 785         NULL /* resent bcc */,
 786         NULL /* resent msg id */,
 787         imf_date /* date */,
 788         NULL /* from */,
 789         NULL /* sender */,
 790         NULL /* reply-to */,
 791         NULL /* to */,
 792         NULL /* cc */,
 793         NULL /* bcc */,
 794         NULL /* message id */,
 795         NULL /* in reply to */,
 796         NULL /* references */,
 797         NULL /* subject */,
 798         NULL /* comments */,
 799         NULL /* keywords */,
 800         NULL /* optional field */);
 801     if (field == NULL)
 802       goto free;
 803     r =  mailimf_fields_add(fields, field);
 804     if (r != MAILIMF_NO_ERROR)
 805       goto free_field;
 806   }
 807
 808   if (from != NULL) {
 809     imf_from = mailimf_from_new(from);
 810     if (imf_from == NULL)
 811       goto free_field;
 812     field = mailimf_field_new(MAILIMF_FIELD_FROM,
 813         NULL /* return-path */,
 814         NULL /* resent date */,
 815         NULL /* resent from */,
 816         NULL /* resent sender */,
 817         NULL /* resent to */,
 818         NULL /* resent cc */,
 819         NULL /* resent bcc */,
 820         NULL /* resent msg id */,
 821         NULL /* date */,
 822         imf_from /* from */,
 823         NULL /* sender */,
 824         NULL /* reply-to */,
 825         NULL /* to */,
 826         NULL /* cc */,
 827         NULL /* bcc */,
 828         NULL /* message id */,
 829         NULL /* in reply to */,
 830         NULL /* references */,
 831         NULL /* subject */,
 832         NULL /* comments */,
 833         NULL /* keywords */,
 834         NULL /* optional field */);
 835     if (field == NULL)
 836       goto free;
 837     r =  mailimf_fields_add(fields, field);
 838     if (r != MAILIMF_NO_ERROR)
 839       goto free_field;
 840   }
 841
 842   if (sender != NULL) {
 843     imf_sender = mailimf_sender_new(sender);
 844     if (imf_sender == NULL)
 845       goto free;
 846     field = mailimf_field_new(MAILIMF_FIELD_SENDER,
 847         NULL /* return-path */,
 848         NULL /* resent date */,
 849         NULL /* resent from */,
 850         NULL /* resent sender */,
 851         NULL /* resent to */,
 852         NULL /* resent cc */,
 853         NULL /* resent bcc */,
 854         NULL /* resent msg id */,
 855         NULL /* date */,
 856         NULL /* from */,
 857         imf_sender /* sender */,
 858         NULL /* reply-to */,
 859         NULL /* to */,
 860         NULL /* cc */,
 861         NULL /* bcc */,
 862         NULL /* message id */,
 863         NULL /* in reply to */,
 864         NULL /* references */,
 865         NULL /* subject */,
 866         NULL /* comments */,
 867         NULL /* keywords */,
 868         NULL /* optional field */);
 869     if (field == NULL)
 870       goto free;
 871     r =  mailimf_fields_add(fields, field);
 872     if (r != MAILIMF_NO_ERROR)
 873       goto free_field;
 874   }
 875
 876   if (reply_to != NULL) {
 877     imf_reply_to = mailimf_reply_to_new(reply_to);
 878     if (imf_reply_to == NULL)
 879       goto free;
 880     field = mailimf_field_new(MAILIMF_FIELD_REPLY_TO,
 881         NULL /* return-path */,
 882         NULL /* resent date */,
 883         NULL /* resent from */,
 884         NULL /* resent sender */,
 885         NULL /* resent to */,
 886         NULL /* resent cc */,
 887         NULL /* resent bcc */,
 888         NULL /* resent msg id */,
 889         NULL /* date */,
 890         NULL /* from */,
 891         NULL /* sender */,
 892         imf_reply_to /* reply-to */,
 893         NULL /* to */,
 894         NULL /* cc */,
 895         NULL /* bcc */,
 896         NULL /* message id */,
 897         NULL /* in reply to */,
 898         NULL /* references */,
 899         NULL /* subject */,
 900         NULL /* comments */,
 901         NULL /* keywords */,
 902         NULL /* optional field */);
 903     if (field == NULL)
 904       goto free;
 905     r =  mailimf_fields_add(fields, field);
 906     if (r != MAILIMF_NO_ERROR)
 907       goto free_field;
 908   }
 909
 910   if (to != NULL) {
 911     imf_to = mailimf_to_new(to);
 912     if (imf_to == NULL)
 913       goto free;
 914     field = mailimf_field_new(MAILIMF_FIELD_TO,
 915         NULL /* return-path */,
 916         NULL /* resent date */,
 917         NULL /* resent from */,
 918         NULL /* resent sender */,
 919         NULL /* resent to */,
 920         NULL /* resent cc */,
 921         NULL /* resent bcc */,
 922         NULL /* resent msg id */,
 923         NULL /* date */,
 924         NULL /* from */,
 925         NULL /* sender */,
 926         NULL /* reply-to */,
 927         imf_to /* to */,
 928         NULL /* cc */,
 929         NULL /* bcc */,
 930         NULL /* message id */,
 931         NULL /* in reply to */,
 932         NULL /* references */,
 933         NULL /* subject */,
 934         NULL /* comments */,
 935         NULL /* keywords */,
 936         NULL /* optional field */);
 937     if (field == NULL)
 938       goto free;
 939     r =  mailimf_fields_add(fields, field);
 940     if (r != MAILIMF_NO_ERROR)
 941       goto free_field;
 942   }
 943
 944   if (cc != NULL) {
 945     imf_cc = mailimf_cc_new(cc);
 946     if (imf_cc == NULL)
 947       goto free;
 948     field = mailimf_field_new(MAILIMF_FIELD_CC,
 949         NULL /* return-path */,
 950         NULL /* resent date */,
 951         NULL /* resent from */,
 952         NULL /* resent sender */,
 953         NULL /* resent to */,
 954         NULL /* resent cc */,
 955         NULL /* resent bcc */,
 956         NULL /* resent msg id */,
 957         NULL /* date */,
 958         NULL /* from */,
 959         NULL /* sender */,
 960         NULL /* reply-to */,
 961         NULL /* to */,
 962         imf_cc /* cc */,
 963         NULL /* bcc */,
 964         NULL /* message id */,
 965         NULL /* in reply to */,
 966         NULL /* references */,
 967         NULL /* subject */,
 968         NULL /* comments */,
 969         NULL /* keywords */,
 970         NULL /* optional field */);
 971     if (field == NULL)
 972       goto free;
 973     r =  mailimf_fields_add(fields, field);
 974     if (r != MAILIMF_NO_ERROR)
 975       goto free_field;
 976   }
 977
 978   if (bcc != NULL) {
 979     imf_bcc = mailimf_bcc_new(bcc);
 980     if (imf_bcc == NULL)
 981       goto free;
 982     field = mailimf_field_new(MAILIMF_FIELD_BCC,
 983         NULL /* return-path */,
 984         NULL /* resent date */,
 985         NULL /* resent from */,
 986         NULL /* resent sender */,
 987         NULL /* resent to */,
 988         NULL /* resent cc */,
 989         NULL /* resent bcc */,
 990         NULL /* resent msg id */,
 991         NULL /* date */,
 992         NULL /* from */,
 993         NULL /* sender */,
 994         NULL /* reply-to */,
 995         NULL /* to */,
 996         NULL /* cc */,
 997         imf_bcc /* bcc */,
 998         NULL /* message id */,
 999         NULL /* in reply to */,
1000         NULL /* references */,
1001         NULL /* subject */,
1002         NULL /* comments */,
1003         NULL /* keywords */,
1004         NULL /* optional field */);
1005     if (field == NULL)
1006       goto free;
1007     r =  mailimf_fields_add(fields, field);
1008     if (r != MAILIMF_NO_ERROR)
1009       goto free_field;
1010   }
1011
1012   if (msg_id != NULL) {
1013     imf_msg_id = mailimf_message_id_new(msg_id);
1014     if (imf_msg_id == NULL)
1015       goto free;
1016     field = mailimf_field_new(MAILIMF_FIELD_MESSAGE_ID,
1017         NULL /* return-path */,
1018         NULL /* resent date */,
1019         NULL /* resent from */,
1020         NULL /* resent sender */,
1021         NULL /* resent to */,
1022         NULL /* resent cc */,
1023         NULL /* resent bcc */,
1024         NULL /* resent msg id */,
1025         NULL /* date */,
1026         NULL /* from */,
1027         NULL /* sender */,
1028         NULL /* reply-to */,
1029         NULL /* to */,
1030         NULL /* cc */,
1031         NULL /* bcc */,
1032         imf_msg_id /* message id */,
1033         NULL /* in reply to */,
1034         NULL /* references */,
1035         NULL /* subject */,
1036         NULL /* comments */,
1037         NULL /* keywords */,
1038         NULL /* optional field */);
1039     if (field == NULL)
1040       goto free;
1041     r =  mailimf_fields_add(fields, field);
1042     if (r != MAILIMF_NO_ERROR)
1043       goto free_field;
1044   }
1045
1046   if (in_reply_to != NULL) {
1047     imf_in_reply_to = mailimf_in_reply_to_new(in_reply_to);
1048     if (imf_in_reply_to == NULL)
1049       goto free;
1050     field = mailimf_field_new(MAILIMF_FIELD_IN_REPLY_TO,
1051         NULL /* return-path */,
1052         NULL /* resent date */,
1053         NULL /* resent from */,
1054         NULL /* resent sender */,
1055         NULL /* resent to */,
1056         NULL /* resent cc */,
1057         NULL /* resent bcc */,
1058         NULL /* resent msg id */,
1059         NULL /* date */,
1060         NULL /* from */,
1061         NULL /* sender */,
1062         NULL /* reply-to */,
1063         NULL /* to */,
1064         NULL /* cc */,
1065         NULL /* bcc */,
1066         NULL /* message id */,
1067         imf_in_reply_to /* in reply to */,
1068         NULL /* references */,
1069         NULL /* subject */,
1070         NULL /* comments */,
1071         NULL /* keywords */,
1072         NULL /* optional field */);
1073     if (field == NULL)
1074       goto free;
1075     r =  mailimf_fields_add(fields, field);
1076     if (r != MAILIMF_NO_ERROR)
1077       goto free_field;
1078   }
1079
1080   if (references != NULL) {
1081     imf_references = mailimf_references_new(references);
1082     if (imf_references == NULL)
1083       goto free;
1084     field = mailimf_field_new(MAILIMF_FIELD_REFERENCES,
1085         NULL /* return-path */,
1086         NULL /* resent date */,
1087         NULL /* resent from */,
1088         NULL /* resent sender */,
1089         NULL /* resent to */,
1090         NULL /* resent cc */,
1091         NULL /* resent bcc */,
1092         NULL /* resent msg id */,
1093         NULL /* date */,
1094         NULL /* from */,
1095         NULL /* sender */,
1096         NULL /* reply-to */,
1097         NULL /* to */,
1098         NULL /* cc */,
1099         NULL /* bcc */,
1100         NULL /* message id */,
1101         NULL /* in reply to */,
1102         imf_references /* references */,
1103         NULL /* subject */,
1104         NULL /* comments */,
1105         NULL /* keywords */,
1106         NULL /* optional field */);
1107     if (field == NULL)
1108       goto free;
1109     r =  mailimf_fields_add(fields, field);
1110     if (r != MAILIMF_NO_ERROR)
1111       goto free_field;
1112   }
1113
1114   if (subject != NULL) {
1115     imf_subject = mailimf_subject_new(subject);
1116     if (imf_subject == NULL)
1117       goto free;
1118     field = mailimf_field_new(MAILIMF_FIELD_SUBJECT,
1119         NULL /* return-path */,
1120         NULL /* resent date */,
1121         NULL /* resent from */,
1122         NULL /* resent sender */,
1123         NULL /* resent to */,
1124         NULL /* resent cc */,
1125         NULL /* resent bcc */,
1126         NULL /* resent msg id */,
1127         NULL /* date */,
1128         NULL /* from */,
1129         NULL /* sender */,
1130         NULL /* reply-to */,
1131         NULL /* to */,
1132         NULL /* cc */,
1133         NULL /* bcc */,
1134         NULL /* message id */,
1135         NULL /* in reply to */,
1136         NULL /* references */,
1137         imf_subject /* subject */,
1138         NULL /* comments */,
1139         NULL /* keywords */,
1140         NULL /* optional field */);
1141     if (field == NULL)
1142       goto free;
1143     r =  mailimf_fields_add(fields, field);
1144     if (r != MAILIMF_NO_ERROR)
1145       goto free_field;
1146   }
1147
1148   return MAILIMF_NO_ERROR;
1149
1150  free_field:
1151   if (field != NULL) {
1152     detach_field(field);
1153   }
1154  free:
1155   detach_free_fields(imf_date,
1156                      imf_from,
1157                      imf_sender,
1158                      imf_reply_to,
1159                      imf_to,
1160                      imf_cc,
1161                      imf_bcc,
1162                      imf_msg_id,
1163                      imf_in_reply_to,
1164                      imf_references,
1165                      imf_subject);
1166
1167   return MAILIMF_ERROR_MEMORY;
1168 }
1169
1170 struct mailimf_fields *
1171 mailimf_fields_new_with_data_all(struct mailimf_date_time * date,
1172                                  struct mailimf_mailbox_list * from,
1173                                  struct mailimf_mailbox * sender,
1174                                  struct mailimf_address_list * reply_to,
1175                                  struct mailimf_address_list * to,
1176                                  struct mailimf_address_list * cc,
1177                                  struct mailimf_address_list * bcc,
1178                                  char * message_id,
1179                                  clist * in_reply_to,
1180                                  clist * references,
1181                                  char * subject)
1182 {
1183   struct mailimf_fields * fields;
1184   int r;
1185
1186   fields = mailimf_fields_new_empty();
1187   if (fields == NULL)
1188     goto err;
1189
1190   r = mailimf_fields_add_data(fields,
1191                               date,
1192                               from,
1193                               sender,
1194                               reply_to,
1195                               to,
1196                               cc,
1197                               bcc,
1198                               message_id,
1199                               in_reply_to,
1200                               references,
1201                               subject);
1202   if (r != MAILIMF_NO_ERROR)
1203     goto free;
1204
1205   return fields;
1206
1207  free:
1208   mailimf_fields_free(fields);
1209  err:
1210   return NULL;
1211 }
1212
1213 struct mailimf_fields *
1214 mailimf_fields_new_with_data(struct mailimf_mailbox_list * from,
1215                              struct mailimf_mailbox * sender,
1216                              struct mailimf_address_list * reply_to,
1217                              struct mailimf_address_list * to,
1218                              struct mailimf_address_list * cc,
1219                              struct mailimf_address_list * bcc,
1220                              clist * in_reply_to,
1221                              clist * references,
1222                              char * subject)
1223 {
1224   struct mailimf_date_time * date;
1225   char * msg_id;
1226   struct mailimf_fields * fields;
1227
1228   date = mailimf_get_current_date();
1229   if (date == NULL)
1230     goto err;
1231
1232   msg_id = mailimf_get_message_id();
1233   if (msg_id == NULL)
1234     goto free_date;
1235
1236   fields = mailimf_fields_new_with_data_all(date,
1237                                             from, sender, reply_to,
1238                                             to, cc, bcc,
1239                                             msg_id,
1240                                             in_reply_to, references,
1241                                             subject);
1242   if (fields == NULL)
1243     goto free_msg_id;
1244
1245   return fields;
1246
1247  free_msg_id:
1248   free(msg_id);
1249  free_date:
1250   mailimf_date_time_free(date);
1251  err:
1252   return NULL;
1253 }
1254
1255
1256
1257 #define MAX_MESSAGE_ID 512
1258
1259 char * mailimf_get_message_id(void)
1260 {
1261   char id[MAX_MESSAGE_ID];
1262   time_t now;
1263   char name[MAX_MESSAGE_ID];
1264   long value;
1265
1266   now = time(NULL);
1267   value = random();
1268
1269   gethostname(name, MAX_MESSAGE_ID);
1270   snprintf(id, MAX_MESSAGE_ID, "etPan.%lx.%lx.%x@%s",
1271            now, value, getpid(), name);
1272
1273   return strdup(id);
1274 }
1275
1276
1277
1278 static time_t mkgmtime(struct tm * tmp);
1279
1280
1281 struct mailimf_date_time * mailimf_get_current_date(void)
1282 {
1283   struct tm gmt;
1284   struct tm lt;
1285   int off;
1286   time_t now;
1287   struct mailimf_date_time * date_time;
1288
1289   now = time(NULL);
1290
1291   if (gmtime_r(&now, &gmt) == NULL)
1292     return NULL;
1293
1294   if (localtime_r(&now, &lt) == NULL)
1295     return NULL;
1296
1297   off = (mkgmtime(&lt) - mkgmtime(&gmt)) / (60 * 60) * 100;
1298
1299   date_time = mailimf_date_time_new(lt.tm_mday, lt.tm_mon + 1, lt.tm_year + 1900,
1300                                     lt.tm_hour, lt.tm_min, lt.tm_sec,
1301                                     off);
1302
1303   return date_time;
1304 }
1305
1306
1307
1308 /* mkgmtime.c - make time corresponding to a GMT timeval struct
1309  $Id$
1310
1311  * Copyright (c) 1998-2000 Carnegie Mellon University.  All rights reserved.
1312  *
1313  * Redistribution and use in source and binary forms, with or without
1314  * modification, are permitted provided that the following conditions
1315  * are met:
1316  *
1317  * 1. Redistributions of source code must retain the above copyright
1318  *    notice, this list of conditions and the following disclaimer.
1319  *
1320  * 2. Redistributions in binary form must reproduce the above copyright
1321  *    notice, this list of conditions and the following disclaimer in
1322  *    the documentation and/or other materials provided with the
1323  *    distribution.
1324  *
1325  * 3. The name "Carnegie Mellon University" must not be used to
1326  *    endorse or promote products derived from this software without
1327  *    prior written permission. For permission or any other legal
1328  *    details, please contact
1329  *      Office of Technology Transfer
1330  *      Carnegie Mellon University
1331  *      5000 Forbes Avenue
1332  *      Pittsburgh, PA  15213-3890
1333  *      (412) 268-4387, fax: (412) 268-7395
1334  *      tech-transfer@andrew.cmu.edu
1335  *
1336  * 4. Redistributions of any form whatsoever must retain the following
1337  *    acknowledgment:
1338  *    "This product includes software developed by Computing Services
1339  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
1340  *
1341  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
1342  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
1343  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
1344  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
1345  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
1346  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
1347  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1348  *
1349  *
1350  */
1351 /*
1352  * Copyright (c) 1987, 1989, 1993
1353  *      The Regents of the University of California.  All rights reserved.
1354  *
1355  * This code is derived from software contributed to Berkeley by
1356  * Arthur David Olson of the National Cancer Institute.
1357  *
1358  * Redistribution and use in source and binary forms, with or without
1359  * modification, are permitted provided that the following conditions
1360  * are met:
1361  * 1. Redistributions of source code must retain the above copyright
1362  *    notice, this list of conditions and the following disclaimer.
1363  * 2. Redistributions in binary form must reproduce the above copyright
1364  *    notice, this list of conditions and the following disclaimer in the
1365  *    documentation and/or other materials provided with the distribution.
1366  * 3. All advertising materials mentioning features or use of this software
1367  *    must display the following acknowledgement:
1368  *      This product includes software developed by the University of
1369  *      California, Berkeley and its contributors.
1370  * 4. Neither the name of the University nor the names of its contributors
1371  *    may be used to endorse or promote products derived from this software
1372  *    without specific prior written permission.
1373  *
1374  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
1375  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1376  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1377  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
1378  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1379  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1380  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1381  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1382  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1383  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1384  * SUCH DAMAGE.
1385  */
1386
1387 /*
1388 ** Adapted from code provided by Robert Elz, who writes:
1389 **      The "best" way to do mktime I think is based on an idea of Bob
1390 **      Kridle's (so its said...) from a long time ago. (mtxinu!kridle now).
1391 **      It does a binary search of the time_t space.  Since time_t's are
1392 **      just 32 bits, its a max of 32 iterations (even at 64 bits it
1393 **      would still be very reasonable).
1394 */
1395
1396 /*
1397   adapted for libEtPan! by DINH V. Hoa
1398 */
1399
1400 #ifndef WRONG
1401 #define WRONG   (-1)
1402 #endif /* !defined WRONG */
1403
1404 static int tmcomp(struct tm * atmp, struct tm * btmp)
1405 {
1406   register int  result;
1407
1408   if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
1409       (result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
1410       (result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
1411       (result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
1412       (result = (atmp->tm_min - btmp->tm_min)) == 0)
1413     result = atmp->tm_sec - btmp->tm_sec;
1414   return result;
1415 }
1416
1417 static time_t mkgmtime(struct tm * tmp)
1418 {
1419   register int                  dir;
1420   register int                  bits;
1421   register int                  saved_seconds;
1422   time_t                                t;
1423   struct tm                     yourtm, *mytm, buft;
1424
1425   yourtm = *tmp;
1426   saved_seconds = yourtm.tm_sec;
1427   yourtm.tm_sec = 0;
1428   /*
1429   ** Calculate the number of magnitude bits in a time_t
1430   ** (this works regardless of whether time_t is
1431   ** signed or unsigned, though lint complains if unsigned).
1432   */
1433   for (bits = 0, t = 1; t > 0; ++bits, t <<= 1)
1434     ;
1435   /*
1436   ** If time_t is signed, then 0 is the median value,
1437   ** if time_t is unsigned, then 1 << bits is median.
1438   */
1439   t = (t < 0) ? 0 : ((time_t) 1 << bits);
1440   for ( ; ; ) {
1441     mytm = gmtime_r(&t, &buft);
1442     dir = tmcomp(mytm, &yourtm);
1443     if (dir != 0) {
1444       if (bits-- < 0)
1445         return WRONG;
1446       if (bits < 0)
1447         --t;
1448       else if (dir > 0)
1449         t -= (time_t) 1 << bits;
1450       else      t += (time_t) 1 << bits;
1451       continue;
1452     }
1453     break;
1454   }
1455   t += saved_seconds;
1456   return t;
1457 }
1458
1459
1460
1461
1462
1463
1464
1465 void mailimf_single_fields_init(struct mailimf_single_fields * single_fields,
1466                                 struct mailimf_fields * fields)
1467 {
1468   clistiter * cur;
1469
1470   memset(single_fields, 0, sizeof(struct mailimf_single_fields));
1471
1472   cur = clist_begin(fields->fld_list);
1473   while (cur != NULL) {
1474     struct mailimf_field * field;
1475
1476     field = clist_content(cur);
1477
1478     switch (field->fld_type) {
1479     case MAILIMF_FIELD_ORIG_DATE:
1480       if (single_fields->fld_orig_date == NULL)
1481         single_fields->fld_orig_date = field->fld_data.fld_orig_date;
1482       cur = clist_next(cur);
1483       break;
1484     case MAILIMF_FIELD_FROM:
1485       if (single_fields->fld_from == NULL) {
1486         single_fields->fld_from = field->fld_data.fld_from;
1487         cur = clist_next(cur);
1488       }
1489       else {
1490         clist_concat(single_fields->fld_from->frm_mb_list->mb_list,
1491                      field->fld_data.fld_from->frm_mb_list->mb_list);
1492         mailimf_field_free(field);
1493         cur = clist_delete(fields->fld_list, cur);
1494       }
1495       break;
1496     case MAILIMF_FIELD_SENDER:
1497       if (single_fields->fld_sender == NULL)
1498         single_fields->fld_sender = field->fld_data.fld_sender;
1499       cur = clist_next(cur);
1500       break;
1501     case MAILIMF_FIELD_REPLY_TO:
1502       if (single_fields->fld_reply_to == NULL) {
1503         single_fields->fld_reply_to = field->fld_data.fld_reply_to;
1504         cur = clist_next(cur);
1505       }
1506       else {
1507         clist_concat(single_fields->fld_reply_to->rt_addr_list->ad_list,
1508                      field->fld_data.fld_reply_to->rt_addr_list->ad_list);
1509         mailimf_field_free(field);
1510         cur = clist_delete(fields->fld_list, cur);
1511       }
1512       break;
1513     case MAILIMF_FIELD_TO:
1514       if (single_fields->fld_to == NULL) {
1515         single_fields->fld_to = field->fld_data.fld_to;
1516         cur = clist_next(cur);
1517       }
1518       else {
1519         clist_concat(single_fields->fld_to->to_addr_list->ad_list,
1520                      field->fld_data.fld_to->to_addr_list->ad_list);
1521         mailimf_field_free(field);
1522         cur = clist_delete(fields->fld_list, cur);
1523       }
1524       break;
1525     case MAILIMF_FIELD_CC:
1526       if (single_fields->fld_cc == NULL) {
1527         single_fields->fld_cc = field->fld_data.fld_cc;
1528         cur = clist_next(cur);
1529       }
1530       else {
1531         clist_concat(single_fields->fld_cc->cc_addr_list->ad_list,
1532                      field->fld_data.fld_cc->cc_addr_list->ad_list);
1533         mailimf_field_free(field);
1534         cur = clist_delete(fields->fld_list, cur);
1535       }
1536       break;
1537     case MAILIMF_FIELD_BCC:
1538       if (single_fields->fld_bcc == NULL) {
1539         single_fields->fld_bcc = field->fld_data.fld_bcc;
1540         cur = clist_next(cur);
1541       }
1542       else {
1543         clist_concat(single_fields->fld_bcc->bcc_addr_list->ad_list,
1544                      field->fld_data.fld_bcc->bcc_addr_list->ad_list);
1545         mailimf_field_free(field);
1546         cur = clist_delete(fields->fld_list, cur);
1547       }
1548       break;
1549     case MAILIMF_FIELD_MESSAGE_ID:
1550       if (single_fields->fld_message_id == NULL)
1551         single_fields->fld_message_id = field->fld_data.fld_message_id;
1552       cur = clist_next(cur);
1553       break;
1554     case MAILIMF_FIELD_IN_REPLY_TO:
1555       if (single_fields->fld_in_reply_to == NULL)
1556         single_fields->fld_in_reply_to = field->fld_data.fld_in_reply_to;
1557       cur = clist_next(cur);
1558       break;
1559     case MAILIMF_FIELD_REFERENCES:
1560       if (single_fields->fld_references == NULL)
1561         single_fields->fld_references = field->fld_data.fld_references;
1562       cur = clist_next(cur);
1563       break;
1564     case MAILIMF_FIELD_SUBJECT:
1565       if (single_fields->fld_subject == NULL)
1566         single_fields->fld_subject = field->fld_data.fld_subject;
1567       cur = clist_next(cur);
1568       break;
1569     case MAILIMF_FIELD_COMMENTS:
1570       if (single_fields->fld_comments == NULL)
1571         single_fields->fld_comments = field->fld_data.fld_comments;
1572       cur = clist_next(cur);
1573       break;
1574     case MAILIMF_FIELD_KEYWORDS:
1575       if (single_fields->fld_keywords == NULL)
1576         single_fields->fld_keywords = field->fld_data.fld_keywords;
1577       cur = clist_next(cur);
1578       break;
1579     default:
1580       cur = clist_next(cur);
1581       break;
1582     }
1583   }
1584 }
1585
1586
1587 struct mailimf_single_fields *
1588 mailimf_single_fields_new(struct mailimf_fields * fields)
1589 {
1590   struct mailimf_single_fields * single_fields;
1591
1592   single_fields = malloc(sizeof(struct mailimf_single_fields));
1593   if (single_fields == NULL)
1594     goto err;
1595
1596   mailimf_single_fields_init(single_fields, fields);
1597
1598   return single_fields;
1599
1600  err:
1601   return NULL;
1602 }
1603
1604 void mailimf_single_fields_free(struct mailimf_single_fields *
1605                                 single_fields)
1606 {
1607   free(single_fields);
1608 }
1609
1610 struct mailimf_field * mailimf_field_new_custom(char * name, char * value)
1611 {
1612   struct mailimf_optional_field * opt_field;
1613   struct mailimf_field * field;
1614
1615   opt_field = mailimf_optional_field_new(name, value);
1616   if (opt_field == NULL)
1617     goto err;
1618
1619   field = mailimf_field_new(MAILIMF_FIELD_OPTIONAL_FIELD,
1620       NULL, NULL, NULL, NULL, NULL, NULL, NULL,
1621       NULL, NULL, NULL, NULL,
1622       NULL, NULL, NULL, NULL,
1623       NULL, NULL, NULL, NULL,
1624       NULL, NULL, opt_field);
1625   if (field == NULL)
1626     goto free_opt_field;
1627
1628   return field;
1629
1630  free_opt_field:
1631   mailimf_optional_field_free(opt_field);
1632  err:
1633   return NULL;
1634 }