diplodocus.org Git - nmh/blob - uip/imaptest.c

   1 /* imaptest.c -- A program to send commands to an IMAP server
   2  *
   3  * This code is Copyright (c) 2017, by the authors of nmh.  See the
   4  * COPYRIGHT file in the root directory of the nmh distribution for
   5  * complete copyright information.
   6  */
   7
   8 #include "h/mh.h"
   9 #include "sbr/smatch.h"
  10 #include "sbr/client.h"
  11 #include "sbr/getcpy.h"
  12 #include "sbr/brkstring.h"
  13 #include "sbr/ambigsw.h"
  14 #include "sbr/print_version.h"
  15 #include "sbr/print_help.h"
  16 #include "sbr/error.h"
  17 #include "h/utils.h"
  18 #include "h/netsec.h"
  19 #include <stdarg.h>
  20 #include <sys/time.h>
  21 #include "h/done.h"
  22 #include "sbr/base64.h"
  23
  24 #define IMAPTEST_SWITCHES \
  25     X("host hostname", 0, HOSTSW) \
  26     X("user username", 0, USERSW) \
  27     X("port name/number", 0, PORTSW) \
  28     X("snoop", 0, SNOOPSW) \
  29     X("nosnoop", 0, NOSNOOPSW) \
  30     X("sasl", 0, SASLSW) \
  31     X("nosasl", 0, NOSASLSW) \
  32     X("saslmech", 0, SASLMECHSW) \
  33     X("authservice", 0, AUTHSERVICESW) \
  34     X("tls", 0, TLSSW) \
  35     X("notls", 0, NOTLSSW) \
  36     X("initialtls", 0, INITIALTLSSW) \
  37     X("queue", 0, QUEUESW) \
  38     X("noqueue", 0, NOQUEUESW) \
  39     X("append filename", 0, APPENDSW) \
  40     X("afolder foldername", 0, AFOLDERSW) \
  41     X("batch filename", 0, BATCHSW) \
  42     X("timestamp", 0, TIMESTAMPSW) \
  43     X("notimestamp", 0, NOTIMESTAMPSW) \
  44     X("timeout", 0, TIMEOUTSW) \
  45     X("version", 0, VERSIONSW) \
  46     X("help", 0, HELPSW) \
  47
  48 #define X(sw, minchars, id) id,
  49 DEFINE_SWITCH_ENUM(IMAPTEST);
  50 #undef X
  51
  52 #define X(sw, minchars, id) { sw, minchars, id },
  53 DEFINE_SWITCH_ARRAY(IMAPTEST, switches);
  54 #undef X
  55
  56 struct imap_msg;
  57
  58 struct imap_msg {
  59     char *command;              /* Command to send */
  60     char *folder;               /* Folder (for append) */
  61     bool queue;                 /* If true, queue for later delivery */
  62     bool append;                /* If true, append "command" to mbox */
  63     size_t msgsize;             /* RFC822 size of message */
  64     struct imap_msg *next;      /* Next pointer */
  65 };
  66
  67 struct imap_msg *msgqueue_head = NULL;
  68 struct imap_msg *msgqueue_tail = NULL;
  69
  70 struct imap_cmd;
  71
  72 struct imap_cmd {
  73     char tag[16];               /* Command tag */
  74     struct timeval start;       /* Time command was sent */
  75     char prefix[64];            /* Command prefix */
  76     struct imap_cmd *next;      /* Next pointer */
  77 };
  78
  79 static struct imap_cmd *cmdqueue = NULL;
  80
  81 static char *saslmechs = NULL;
  82 svector_t imap_capabilities = NULL;
  83
  84 static int imap_sasl_callback(enum sasl_message_type, unsigned const char *,
  85                               unsigned int, unsigned char **, unsigned int *,
  86                               void *, char **);
  87
  88 static void parse_capability(const char *, unsigned int len);
  89 static int capability_set(const char *);
  90 static void clear_capability(void);
  91 static int have_capability(void);
  92 static int send_imap_command(netsec_context *, bool noflush, char **errstr,
  93                              const char *fmt, ...) CHECK_PRINTF(4, 5);
  94 static int send_append(netsec_context *, struct imap_msg *, char **errstr);
  95 static int get_imap_response(netsec_context *, const char *token,
  96                              char **tokenresp, char **status, bool contok,
  97                              bool failerr, char **errstr);
  98
  99 static void ts_report(struct timeval *tv, const char *fmt, ...)
 100                       CHECK_PRINTF(2, 3);
 101 static void imap_negotiate_tls(netsec_context *);
 102
 103 static void add_msg(bool queue, struct imap_msg **, const char *fmt, ...)
 104                     CHECK_PRINTF(3, 4);
 105 static void add_append(const char *filename, const char *folder, bool queue);
 106
 107 static void batchfile(const char *filename, char *afolder, bool queue);
 108
 109 static size_t rfc822size(const char *filename);
 110
 111 static bool timestamp = false;
 112
 113 int
 114 main (int argc, char **argv)
 115 {
 116     bool sasl = false, tls = false, initialtls = false;
 117     bool snoop = false, queue = false;
 118     int fd, timeout = 0;
 119     char *saslmech = NULL, *host = NULL, *port = "143", *user = NULL;
 120     char *cp, **argp, buf[BUFSIZ], *oauth_svc = NULL, *errstr, **arguments, *p;
 121     char *afolder = NULL;
 122     netsec_context *nsc = NULL;
 123     struct imap_msg *imsg;
 124     size_t len;
 125     struct timeval tv_start, tv_connect, tv_auth;
 126
 127     if (nmh_init(argv[0], true, true)) { return 1; }
 128
 129     arguments = getarguments (invo_name, argc, argv, 1);
 130     argp = arguments;
 131
 132     while ((cp = *argp++)) {
 133         if (*cp == '-') {
 134             switch (smatch (++cp, switches)) {
 135             case AMBIGSW:
 136                 ambigsw (cp, switches);
 137                 done (1);
 138             case UNKWNSW:
 139                 die("-%s unknown", cp);
 140
 141             case HELPSW:
 142                 snprintf (buf, sizeof(buf), "%s [switches] +folder command "
 143                           "[command ...]", invo_name);
 144                 print_help (buf, switches, 1);
 145                 done (0);
 146             case VERSIONSW:
 147                 print_version(invo_name);
 148                 done (0);
 149
 150             case HOSTSW:
 151                 if (!(host = *argp++) || *host == '-')
 152                     die("missing argument to %s", argp[-2]);
 153                 continue;
 154             case PORTSW:
 155                 if (!(port = *argp++) || *port == '-')
 156                     die("missing argument to %s", argp[-2]);
 157                 continue;
 158             case USERSW:
 159                 if (!(user = *argp++) || *user == '-')
 160                     die("missing argument to %s", argp[-2]);
 161                 continue;
 162
 163             case AFOLDERSW:
 164                 if (!(afolder = *argp++) || *afolder == '-')
 165                     die("missing argument to %s", argp[-2]);
 166                 continue;
 167             case APPENDSW:
 168                 if (!*argp || (**argp == '-'))
 169                     die("missing argument to %s", argp[-1]);
 170                 if (! afolder)
 171                     die("Append folder must be set with -afolder first");
 172                 add_append(*argp++, afolder, queue);
 173                 continue;
 174
 175             case BATCHSW:
 176                 if (! *argp || (**argp == '-'))
 177                     die("missing argument to %s", argp[-1]);
 178                 batchfile(*argp++, afolder, queue);
 179                 continue;
 180
 181             case TIMEOUTSW:
 182                 if (! *argp || (**argp == '-'))
 183                     die("missing argument to %s", argp[-1]);
 184                 if (! (timeout = atoi(*argp++)))
 185                     die("Invalid timeout: %s", argp[-1]);
 186                 continue;
 187
 188             case SNOOPSW:
 189                 snoop = true;
 190                 continue;
 191             case NOSNOOPSW:
 192                 snoop = false;
 193                 continue;
 194             case SASLSW:
 195                 sasl = true;
 196                 continue;
 197             case NOSASLSW:
 198                 sasl = false;
 199                 continue;
 200             case SASLMECHSW:
 201                 if (!(saslmech = *argp++) || *saslmech == '-')
 202                     die("missing argument to %s", argp[-2]);
 203                 continue;
 204             case AUTHSERVICESW:
 205                 if (!(oauth_svc = *argp++) || *oauth_svc == '-')
 206                     die("missing argument to %s", argp[-2]);
 207                 continue;
 208             case TLSSW:
 209                 tls = true;
 210                 initialtls = false;
 211                 continue;
 212             case INITIALTLSSW:
 213                 tls = false;
 214                 initialtls = true;
 215                 continue;
 216             case NOTLSSW:
 217                 tls = false;
 218                 initialtls = false;
 219                 continue;
 220             case QUEUESW:
 221                 queue = true;
 222                 continue;
 223             case NOQUEUESW:
 224                 queue = false;
 225                 continue;
 226             case TIMESTAMPSW:
 227                 timestamp = true;
 228                 continue;
 229             case NOTIMESTAMPSW:
 230                 timestamp = false;
 231                 continue;
 232             }
 233         } else if (*cp == '+') {
 234             if (*(cp + 1) == '\0')
 235                 die("Invalid null folder name");
 236             add_msg(false, NULL, "SELECT \"%s\"", cp + 1);
 237         } else {
 238             add_msg(queue, NULL, "%s", cp);
 239         }
 240     }
 241
 242     if (! host)
 243         die("A hostname must be given with -host");
 244
 245     nsc = netsec_init();
 246
 247     if (user)
 248         netsec_set_userid(nsc, user);
 249
 250     netsec_set_hostname(nsc, host);
 251
 252     if (timeout)
 253         netsec_set_timeout(nsc, timeout);
 254
 255     if (snoop)
 256         netsec_set_snoop(nsc, 1);
 257
 258     if (oauth_svc) {
 259         if (netsec_set_oauth_service(nsc, oauth_svc) != OK) {
 260             die("OAuth2 not supported");
 261         }
 262     }
 263
 264     if (timestamp)
 265         gettimeofday(&tv_start, NULL);
 266
 267     if ((fd = client(host, port, buf, sizeof(buf), snoop)) == NOTOK)
 268         die("Connect failed: %s", buf);
 269
 270     if (timestamp) {
 271         ts_report(&tv_start, "Connect time");
 272         gettimeofday(&tv_connect, NULL);
 273     }
 274
 275     netsec_set_fd(nsc, fd, fd);
 276     netsec_set_snoop(nsc, snoop);
 277
 278     if (initialtls || tls) {
 279         if (netsec_set_tls(nsc, 1, 0, &errstr) != OK)
 280             die("%s", errstr);
 281
 282         if (initialtls)
 283             imap_negotiate_tls(nsc);
 284     }
 285
 286     if (sasl) {
 287         if (netsec_set_sasl_params(nsc, "imap", saslmech, imap_sasl_callback,
 288                                    nsc, &errstr) != OK)
 289             die("%s", errstr);
 290     }
 291
 292     if ((cp = netsec_readline(nsc, &len, &errstr)) == NULL) {
 293         die("%s", errstr);
 294     }
 295
 296     if (has_prefix(cp, "* BYE")) {
 297         fprintf(stderr, "Connection rejected: %s\n", cp + 5);
 298         goto finish;
 299     }
 300
 301     if (!has_prefix(cp, "* OK") && !has_prefix(cp, "* PREAUTH")) {
 302         fprintf(stderr, "Invalid server response: %s\n", cp);
 303         goto finish;
 304     }
 305
 306     if ((p = strchr(cp + 2, ' ')) && *(p + 1) != '\0' &&
 307         has_prefix(p + 1, "[CAPABILITY ")) {
 308         /*
 309          * Parse the capability list out to the end
 310          */
 311         char *q;
 312         p += 13;        /* 1 + [CAPABILITY + space */
 313
 314         if (!(q = strchr(p, ']'))) {
 315             fprintf(stderr, "Cannot find end of CAPABILITY announcement\n");
 316             goto finish;
 317         }
 318
 319         parse_capability(p, q - p);
 320     } else {
 321         char *capstring;
 322
 323         if (send_imap_command(nsc, false, &errstr, "CAPABILITY") != OK) {
 324             fprintf(stderr, "Unable to send CAPABILITY command: %s\n", errstr);
 325             goto finish;
 326         }
 327
 328         if (get_imap_response(nsc, "CAPABILITY ", &capstring, NULL, false, true,
 329                               &errstr) != OK) {
 330             fprintf(stderr, "Cannot get CAPABILITY response: %s\n", errstr);
 331             goto finish;
 332         }
 333
 334         if (! capstring) {
 335             fprintf(stderr, "No CAPABILITY response seen\n");
 336             goto finish;
 337         }
 338
 339         p = capstring + 11;     /* "CAPABILITY " */
 340
 341         parse_capability(p, strlen(p));
 342         free(capstring);
 343     }
 344
 345     if (tls) {
 346         if (!capability_set("STARTTLS")) {
 347             fprintf(stderr, "Requested STARTTLS with -tls, but IMAP server "
 348                     "has no support for STARTTLS\n");
 349             goto finish;
 350         }
 351         if (send_imap_command(nsc, false, &errstr, "STARTTLS") != OK) {
 352             fprintf(stderr, "Unable to issue STARTTLS: %s\n", errstr);
 353             goto finish;
 354         }
 355
 356         if (get_imap_response(nsc, NULL, NULL, NULL, false, true,
 357                               &errstr) != OK) {
 358             fprintf(stderr, "STARTTLS failed: %s\n", errstr);
 359             goto finish;
 360         }
 361
 362         imap_negotiate_tls(nsc);
 363     }
 364
 365     if (sasl) {
 366         if (netsec_negotiate_sasl(nsc, saslmechs, &errstr) != OK) {
 367             fprintf(stderr, "SASL negotiation failed: %s\n", errstr);
 368             goto finish;
 369         }
 370         /*
 371          * Sigh. If we negotiated a SSF AND we got a capability response
 372          * as part of the AUTHENTICATE OK message, we can't actually trust
 373          * it because it's not protected at that point.  So discard the
 374          * capability list and we will generate a fresh CAPABILITY command
 375          * later.
 376          */
 377         if (netsec_get_sasl_ssf(nsc) > 0) {
 378             clear_capability();
 379         }
 380     } else {
 381         if (capability_set("LOGINDISABLED")) {
 382             fprintf(stderr, "User did not request SASL, but LOGIN "
 383                     "is disabled\n");
 384             goto finish;
 385         }
 386     }
 387
 388     if (!have_capability()) {
 389         char *capstring;
 390
 391         if (send_imap_command(nsc, false, &errstr, "CAPABILITY") != OK) {
 392             fprintf(stderr, "Unable to send CAPABILITY command: %s\n", errstr);
 393             goto finish;
 394         }
 395
 396         if (get_imap_response(nsc, "CAPABILITY ", &capstring, NULL, false,
 397                               true, &errstr) != OK) {
 398             fprintf(stderr, "Cannot get CAPABILITY response: %s\n", errstr);
 399             goto finish;
 400         }
 401
 402         if (! capstring) {
 403             fprintf(stderr, "No CAPABILITY response seen\n");
 404             goto finish;
 405         }
 406
 407         p = capstring + 11;     /* "CAPABILITY " */
 408
 409         parse_capability(p, strlen(p));
 410         free(capstring);
 411     }
 412
 413     if (timestamp) {
 414         ts_report(&tv_connect, "Authentication time");
 415         gettimeofday(&tv_auth, NULL);
 416     }
 417
 418     while (msgqueue_head != NULL) {
 419         imsg = msgqueue_head;
 420
 421         if (imsg->append) {
 422             if (send_append(nsc, imsg, &errstr) != OK) {
 423                 fprintf(stderr, "Cannot send APPEND for %s to mbox %s: %s\n",
 424                         imsg->command, imsg->folder, errstr);
 425                 free(errstr);
 426                 goto finish;
 427             }
 428         } else if (send_imap_command(nsc, imsg->queue, &errstr, "%s",
 429                                      imsg->command) != OK) {
 430                 fprintf(stderr, "Cannot send command \"%s\": %s\n",
 431                         imsg->command, errstr);
 432                 free(errstr);
 433                 goto finish;
 434             }
 435
 436         if (! imsg->queue) {
 437             if (get_imap_response(nsc, NULL, NULL, NULL, false, false,
 438                                   &errstr) != OK) {
 439                 fprintf(stderr, "Unable to get response for command "
 440                         "\"%s\": %s\n", imsg->command, errstr);
 441                 goto finish;
 442             }
 443         }
 444
 445         msgqueue_head = imsg->next;
 446
 447         free(imsg->command);
 448         free(imsg->folder);
 449         free(imsg);
 450     }
 451
 452     /*
 453      * Flush out any pending network data and get any responses
 454      */
 455
 456     if (netsec_flush(nsc, &errstr) != OK) {
 457         fprintf(stderr, "Error performing final network flush: %s\n", errstr);
 458         free(errstr);
 459     }
 460
 461     if (get_imap_response(nsc, NULL, NULL, NULL, false, false, &errstr) != OK) {
 462         fprintf(stderr, "Error fetching final command responses: %s\n", errstr);
 463         free(errstr);
 464     }
 465
 466     if (timestamp)
 467         ts_report(&tv_auth, "Total command execution time");
 468
 469     send_imap_command(nsc, false, NULL, "LOGOUT");
 470     get_imap_response(nsc, NULL, NULL, NULL, false, false, NULL);
 471
 472 finish:
 473     netsec_shutdown(nsc);
 474
 475     if (timestamp)
 476         ts_report(&tv_start, "Total elapsed time");
 477
 478     exit(0);
 479 }
 480
 481 /*
 482  * Parse a capability string
 483  *
 484  * Put these into an svector so we can check for stuff later.  But special
 485  * things, like AUTH, we parse now
 486  */
 487
 488 static void
 489 parse_capability(const char *cap, unsigned int len)
 490 {
 491     char *str = mh_xmalloc(len + 1);
 492     char **caplist;
 493     int i;
 494
 495     trunccpy(str, cap, len + 1);
 496     caplist = brkstring(str, " ", NULL);
 497
 498     if (imap_capabilities) {
 499         svector_free(imap_capabilities);
 500     }
 501
 502     imap_capabilities = svector_create(32);
 503
 504     if (saslmechs) {
 505         free(saslmechs);
 506         saslmechs = NULL;
 507     }
 508
 509     for (i = 0; caplist[i] != NULL; i++) {
 510         if (has_prefix(caplist[i], "AUTH=") && *(caplist[i] + 5) != '\0') {
 511             if (saslmechs) {
 512                 saslmechs = add(" ", saslmechs);
 513             }
 514             saslmechs = add(caplist[i] + 5, saslmechs);
 515         } else {
 516             svector_push_back(imap_capabilities, getcpy(caplist[i]));
 517         }
 518     }
 519
 520     free(str);
 521 }
 522
 523 /*
 524  * Return 1 if a particular capability is set
 525  */
 526
 527 static int
 528 capability_set(const char *capability)
 529 {
 530     if (!imap_capabilities)
 531         return 0;
 532
 533     return svector_find(imap_capabilities, capability) != NULL;
 534 }
 535
 536 /*
 537  * Clear the CAPABILITY list (used after we call STARTTLS, for example)
 538  */
 539
 540 static void
 541 clear_capability(void)
 542 {
 543     svector_free(imap_capabilities);
 544     imap_capabilities = NULL;
 545 }
 546
 547 static int
 548 have_capability(void)
 549 {
 550     return imap_capabilities != NULL;
 551 }
 552
 553 /*
 554  * Our SASL callback, which handles the SASL authentication dialog
 555  */
 556
 557 static int
 558 imap_sasl_callback(enum sasl_message_type mtype, unsigned const char *indata,
 559                    unsigned int indatalen, unsigned char **outdata,
 560                    unsigned int *outdatalen, void *context, char **errstr)
 561 {
 562     int rc, snoopoffset;
 563     char *mech, *line, *capstring, *p;
 564     size_t len;
 565     netsec_context *nsc = (netsec_context *) context;
 566
 567     switch (mtype) {
 568     case NETSEC_SASL_START:
 569         /*
 570          * Generate our AUTHENTICATE message.
 571          *
 572          * If SASL-IR capability is set, we can include any initial response
 573          * in the AUTHENTICATE command.  Otherwise we have to wait for
 574          * the first server response (which should be blank).
 575          */
 576
 577         mech = netsec_get_sasl_mechanism(nsc);
 578
 579         if (indatalen) {
 580             char *b64data;
 581             b64data = mh_xmalloc(BASE64SIZE(indatalen));
 582             writeBase64raw(indata, indatalen, (unsigned char *) b64data);
 583             if (capability_set("SASL-IR")) {
 584                 netsec_set_snoop_callback(nsc, netsec_b64_snoop_decoder,
 585                                           &snoopoffset);
 586                 /*
 587                  * Sigh. We're assuming a short tag length here.  Really,
 588                  * I guess we should figure out a way to get the length
 589                  * of the next tag.
 590                  */
 591                 snoopoffset = 17 + strlen(mech);
 592                 rc = send_imap_command(nsc, 0, errstr, "AUTHENTICATE %s %s",
 593                                        mech, b64data);
 594                 free(b64data);
 595                 netsec_set_snoop_callback(nsc, NULL, NULL);
 596                 if (rc)
 597                     return NOTOK;
 598             } else {
 599                 rc = send_imap_command(nsc, 0, errstr, "AUTHENTICATE %s", mech);
 600                 line = netsec_readline(nsc, &len, errstr);
 601                 if (! line)
 602                     return NOTOK;
 603                 /*
 604                  * We should get a "+ ", nothing else.
 605                  */
 606                 if (len != 2 || strcmp(line, "+ ") != 0) {
 607                     netsec_err(errstr, "Did not get expected blank response "
 608                                "for initial challenge response");
 609                     return NOTOK;
 610                 }
 611                 rc = netsec_printf(nsc, errstr, "%s\r\n", b64data);
 612                 free(b64data);
 613                 if (rc != OK)
 614                     return NOTOK;
 615                 netsec_set_snoop_callback(nsc, netsec_b64_snoop_decoder, NULL);
 616                 rc = netsec_flush(nsc, errstr);
 617                 netsec_set_snoop_callback(nsc, NULL, NULL);
 618                 if (rc != OK)
 619                     return NOTOK;
 620             }
 621         } else {
 622             if (send_imap_command(nsc, 0, errstr, "AUTHENTICATE %s",
 623                                   mech) != OK)
 624                 return NOTOK;
 625         }
 626
 627         break;
 628
 629     /*
 630      * Get a response, decode it and process it.
 631      */
 632
 633     case NETSEC_SASL_READ:
 634         netsec_set_snoop_callback(nsc, netsec_b64_snoop_decoder, &snoopoffset);
 635         snoopoffset = 2;
 636         line = netsec_readline(nsc, &len, errstr);
 637         netsec_set_snoop_callback(nsc, NULL, NULL);
 638
 639         if (line == NULL)
 640             return NOTOK;
 641
 642         if (len < 2 || (len == 2 && strcmp(line, "+ ") != 0)) {
 643             netsec_err(errstr, "Invalid format for SASL response");
 644             return NOTOK;
 645         }
 646
 647         if (len == 2) {
 648             *outdata = NULL;
 649             *outdatalen = 0;
 650         } else {
 651             rc = decodeBase64(line + 2, outdata, &len, 0, NULL);
 652             *outdatalen = len;
 653             if (rc != OK) {
 654                 netsec_err(errstr, "Unable to decode base64 response");
 655                 return NOTOK;
 656             }
 657         }
 658         break;
 659
 660     /*
 661      * Simple request encoding
 662      */
 663
 664     case NETSEC_SASL_WRITE:
 665         if (indatalen > 0) {
 666             unsigned char *b64data;
 667             b64data = mh_xmalloc(BASE64SIZE(indatalen));
 668             writeBase64raw(indata, indatalen, b64data);
 669             rc = netsec_printf(nsc, errstr, "%s", b64data);
 670             free(b64data);
 671             if (rc != OK)
 672                 return NOTOK;
 673         }
 674
 675         if (netsec_printf(nsc, errstr, "\r\n") != OK)
 676             return NOTOK;
 677
 678         netsec_set_snoop_callback(nsc, netsec_b64_snoop_decoder, NULL);
 679         rc = netsec_flush(nsc, errstr);
 680         netsec_set_snoop_callback(nsc, NULL, NULL);
 681         if (rc != OK)
 682             return NOTOK;
 683         break;
 684
 685     /*
 686      * Finish protocol
 687      */
 688
 689     case NETSEC_SASL_FINISH:
 690         line = NULL;
 691         if (get_imap_response(nsc, "CAPABILITY ", &capstring, &line,
 692                               false, true, errstr) != OK)
 693             return NOTOK;
 694         /*
 695          * We MIGHT get a capability response here.  If so, be sure we
 696          * parse it.  We ALSO might get a untagged CAPABILITY response.
 697          * Which one should we prefer?  I guess we'll go with the untagged
 698          * one.
 699          */
 700
 701         if (capstring) {
 702             p = capstring + 11;         /* "CAPABILITY " */
 703             parse_capability(p, strlen(p));
 704             free(capstring);
 705         } else if (line && has_prefix(line, "OK [CAPABILITY ")) {
 706             char *q;
 707
 708             p = line + 15;
 709             q = strchr(p, ']');
 710
 711             if (q)
 712                 parse_capability(p, q - p);
 713         }
 714
 715         break;
 716
 717     /*
 718      * Cancel an authentication dialog
 719      */
 720
 721     case NETSEC_SASL_CANCEL:
 722         rc = netsec_printf(nsc, errstr, "*\r\n");
 723         if (rc == OK)
 724             rc = netsec_flush(nsc, errstr);
 725         if (rc != OK)
 726             return NOTOK;
 727         break;
 728     }
 729     return OK;
 730 }
 731
 732 /*
 733  * Send a single command to the IMAP server.
 734  */
 735
 736 static int
 737 send_imap_command(netsec_context *nsc, bool noflush, char **errstr,
 738                   const char *fmt, ...)
 739 {
 740     static unsigned int seq = 0;        /* Tag sequence number */
 741     va_list ap;
 742     int rc;
 743     struct imap_cmd *cmd;
 744
 745     cmd = mh_xmalloc(sizeof(*cmd));
 746
 747     snprintf(cmd->tag, sizeof(cmd->tag), "A%u ", seq++);
 748
 749     if (timestamp) {
 750         char *p;
 751         va_start(ap, fmt);
 752         vsnprintf(cmd->prefix, sizeof(cmd->prefix), fmt, ap);
 753         va_end(ap);
 754
 755         p = strchr(cmd->prefix, ' ');
 756
 757         if (p)
 758             *p = '\0';
 759
 760         gettimeofday(&cmd->start, NULL);
 761     }
 762
 763     if (netsec_write(nsc, cmd->tag, strlen(cmd->tag), errstr) != OK) {
 764         free(cmd);
 765         return NOTOK;
 766     }
 767
 768     va_start(ap, fmt);
 769     rc = netsec_vprintf(nsc, errstr, fmt, ap);
 770     va_end(ap);
 771
 772     if (rc == OK)
 773         rc = netsec_write(nsc, "\r\n", 2, errstr);
 774
 775     if (rc != OK) {
 776         free(cmd);
 777         return NOTOK;
 778     }
 779
 780     if (!noflush && netsec_flush(nsc, errstr) != OK) {
 781         free(cmd);
 782         return NOTOK;
 783     }
 784
 785     cmd->next = cmdqueue;
 786     cmdqueue = cmd;
 787
 788     return OK;
 789 }
 790
 791 /*
 792  * Send an APPEND to the server, which requires some extra semantics
 793  */
 794
 795 static int
 796 send_append(netsec_context *nsc, struct imap_msg *imsg, char **errstr)
 797 {
 798     FILE *f;
 799     bool nonsynlit = false;
 800     char *status = NULL, *line = NULL;
 801     size_t linesize = 0;
 802     ssize_t rc;
 803
 804     /*
 805      * If we have the LITERAL+ extension, or we have LITERAL- and our
 806      * message is 4096 bytes or less, we can do it all in one message.
 807      * Otherwise we have to wait for a contination marker (+).
 808      */
 809
 810     if (capability_set("LITERAL+") ||
 811                 (capability_set("LITERAL-") && imsg->msgsize <= 4096)) {
 812         nonsynlit = true;
 813     }
 814
 815     /*
 816      * Send our APPEND command
 817      */
 818
 819     if (send_imap_command(nsc, nonsynlit, errstr, "APPEND \"%s\" {%u%s}",
 820                           imsg->folder, (unsigned int) imsg->msgsize,
 821                           nonsynlit ? "+" : "") != OK)
 822         return NOTOK;
 823
 824     /*
 825      * If we need to wait for a syncing literal, do that now
 826      */
 827
 828     if (! nonsynlit) {
 829         if (get_imap_response(nsc, NULL, NULL, &status, true,
 830                               true, errstr) != OK) {
 831             imsg->queue = true; /* XXX Sigh */
 832             fprintf(stderr, "APPEND command failed: %s\n", *errstr);
 833             free(*errstr);
 834             return OK;
 835         }
 836         if (!(status && has_prefix(status, "+"))) {
 837             netsec_err(errstr, "Expected contination (+), but got: %s", status);
 838             free(status);
 839             return NOTOK;
 840         }
 841         free(status);
 842     }
 843
 844     /*
 845      * Now write the message out, but make sure we end each line with \r\n
 846      */
 847
 848     if ((f = fopen(imsg->command, "r")) == NULL) {
 849         netsec_err(errstr, "Unable to open %s: %s", imsg->command,
 850                    strerror(errno));
 851         return NOTOK;
 852     }
 853
 854     while ((rc = getline(&line, &linesize, f)) > 0) {
 855         if (rc > 1 && line[rc - 1] == '\n' && line[rc - 2] == '\r') {
 856             if (netsec_write(nsc, line, rc, errstr) != OK) {
 857                 free(line);
 858                 fclose(f);
 859                 return NOTOK;
 860             }
 861         } else {
 862             if (line[rc - 1] == '\n')
 863                 rc--;
 864             if (netsec_write(nsc, line, rc, errstr) != OK) {
 865                 free(line);
 866                 fclose(f);
 867                 return NOTOK;
 868             }
 869             if (netsec_write(nsc, "\r\n", 2, errstr) != OK) {
 870                 free(line);
 871                 fclose(f);
 872                 return NOTOK;
 873             }
 874         }
 875     }
 876
 877     free(line);
 878
 879     if (! feof(f)) {
 880         netsec_err(errstr, "Error reading %s: %s", imsg->command,
 881                    strerror(errno));
 882         fclose(f);
 883         return NOTOK;
 884     }
 885
 886     fclose(f);
 887
 888     /*
 889      * Send a final \r\n for the end of the command
 890      */
 891
 892     if (netsec_write(nsc, "\r\n", 2, errstr) != OK)
 893         return NOTOK;
 894
 895     if (! imsg->queue)
 896         return netsec_flush(nsc, errstr);
 897
 898     return OK;
 899 }
 900
 901 /*
 902  * Get all outstanding responses.  If we were passed in a token string
 903  * to look for, return it.
 904  */
 905
 906 static int
 907 get_imap_response(netsec_context *nsc, const char *token, char **tokenresponse,
 908                   char **status, bool condok, bool failerr, char **errstr)
 909 {
 910     char *line;
 911     struct imap_cmd *cmd;
 912     bool numerrs = false;
 913
 914     if (tokenresponse)
 915         *tokenresponse = NULL;
 916
 917 getline:
 918     while (cmdqueue) {
 919         if (!(line = netsec_readline(nsc, NULL, errstr)))
 920             return NOTOK;
 921         if (has_prefix(line, "* ") && *(line + 2) != '\0') {
 922             if (token && tokenresponse && has_prefix(line + 2, token)) {
 923                 if (*tokenresponse)
 924                     free(*tokenresponse);
 925                 *tokenresponse = getcpy(line + 2);
 926             }
 927         } if (condok && has_prefix(line, "+")) {
 928             if (status) {
 929                 *status = getcpy(line);
 930             }
 931             /*
 932              * Special case; return now but don't dequeue the tag,
 933              * since we will want to get final result later.
 934              */
 935             return OK;
 936         } else {
 937
 938             if (has_prefix(line, cmdqueue->tag)) {
 939                 cmd = cmdqueue;
 940                 if (timestamp)
 941                     ts_report(&cmd->start, "Command (%s) execution time",
 942                               cmd->prefix);
 943                 cmdqueue = cmd->next;
 944                 free(cmd);
 945             } else {
 946                 for (cmd = cmdqueue; cmd->next != NULL; cmd = cmd->next) {
 947                     if (has_prefix(line, cmd->next->tag)) {
 948                         struct imap_cmd *cmd2 = cmd->next;
 949                         cmd->next = cmd->next->next;
 950                         if (failerr && strncmp(line + strlen(cmd2->tag),
 951                                                         "OK ", 3) != 0) {
 952                             numerrs = true;
 953                             netsec_err(errstr, "%s", line + strlen(cmd2->tag));
 954                         }
 955                         if (timestamp)
 956                             ts_report(&cmd2->start, "Command (%s) execution "
 957                                       "time", cmd2->prefix);
 958                         free(cmd2);
 959                         if (status)
 960                             *status = getcpy(line);
 961                         goto getline;
 962                     }
 963                 }
 964             }
 965         }
 966     }
 967
 968     return numerrs ? NOTOK : OK;
 969 }
 970
 971 /*
 972  * Add an IMAP command to the msg queue
 973  */
 974
 975 static void
 976 add_msg(bool queue, struct imap_msg **ret_imsg, const char *fmt, ...)
 977 {
 978     struct imap_msg *imsg;
 979     va_list ap;
 980     size_t msgbufsize;
 981     char *msg = NULL;
 982     int rc = 63;
 983
 984     do {
 985         msgbufsize = rc + 1;
 986         msg = mh_xrealloc(msg, msgbufsize);
 987         va_start(ap, fmt);
 988         rc = vsnprintf(msg, msgbufsize, fmt, ap);
 989         va_end(ap);
 990     } while (rc >= (int) msgbufsize);
 991
 992     imsg = mh_xmalloc(sizeof(*imsg));
 993
 994     imsg->command = msg;
 995     imsg->folder = NULL;
 996     imsg->append = false;
 997     imsg->queue = queue;
 998     imsg->next = NULL;
 999
1000     if (msgqueue_head == NULL) {
1001         msgqueue_head = imsg;
1002         msgqueue_tail = imsg;
1003     } else {
1004         msgqueue_tail->next = imsg;
1005         msgqueue_tail = imsg;
1006     }
1007
1008     if (ret_imsg)
1009         *ret_imsg = imsg;
1010 }
1011
1012 /*
1013  * Add an APPEND command to the queue
1014  */
1015
1016 static void
1017 add_append(const char *filename, const char *folder, bool queue)
1018 {
1019     size_t filesize = rfc822size(filename);
1020     struct imap_msg *imsg;
1021
1022     add_msg(queue, &imsg, "%s", filename);
1023
1024     imsg->folder = getcpy(folder);
1025     imsg->append = true;
1026     imsg->msgsize = filesize;
1027 }
1028
1029 /*
1030  * Process a batch file, which can contain commands (and some arguments)
1031  */
1032
1033 static void
1034 batchfile(const char *filename, char *afolder, bool queue)
1035 {
1036     FILE *f;
1037     char *line = NULL;
1038     size_t linesize = 0;
1039     ssize_t rc;
1040     bool afolder_alloc = false;
1041
1042     if (!(f = fopen(filename, "r"))) {
1043         die("Unable to open batch file %s: %s", filename, strerror(errno));
1044     }
1045
1046     while ((rc = getline(&line, &linesize, f)) > 0) {
1047         line[rc - 1] = '\0';
1048         if (*line == '-') {
1049             switch (smatch (line + 1, switches)) {
1050             case QUEUESW:
1051                 queue = true;
1052                 continue;
1053             case NOQUEUESW:
1054                 queue = false;
1055                 continue;
1056             case AFOLDERSW:
1057                 if (afolder_alloc)
1058                     free(afolder);
1059                 rc = getline(&line, &linesize, f);
1060                 if (rc <= 0)
1061                     die("Unable to read next line for -afolder");
1062                 if (rc == 1)
1063                     die("Folder name cannot be blank");
1064                 line[rc - 1] = '\0';
1065                 afolder = getcpy(line);
1066                 afolder_alloc = true;
1067                 continue;
1068
1069             case APPENDSW:
1070                 rc = getline(&line, &linesize, f);
1071                 if (rc <= 0)
1072                     die("Unable to read filename for -append");
1073                 if (rc == 1)
1074                     die("Filename for -append cannot be blank");
1075                 line[rc - 1] = '\0';
1076                 add_append(line, afolder, queue);
1077                 continue;
1078
1079             case AMBIGSW:
1080                 ambigsw (line, switches);
1081                 done (1);
1082             case UNKWNSW:
1083                 die("%s unknown", line);
1084             default:
1085                 die("Switch %s not supported in batch mode", line);
1086             }
1087         } else if (*line == '+') {
1088             if (*(line + 1) == '\0')
1089                 die("Invalid null folder name");
1090             add_msg(false, NULL, "SELECT \"%s\"", line + 1);
1091         } else {
1092             if (*line == '\0')
1093                 continue;       /* Ignore blank line */
1094             add_msg(queue, NULL, "%s", line);
1095         }
1096     }
1097
1098     if (!feof(f)) {
1099         die("Read of \"%s\" failed: %s", filename, strerror(errno));
1100     }
1101
1102     fclose(f);
1103
1104     if (afolder_alloc)
1105         free(afolder);
1106
1107     free(line);
1108 }
1109
1110 /*
1111  * Negotiate TLS connection, with optional timestamp
1112  */
1113
1114 static void
1115 imap_negotiate_tls(netsec_context *nsc)
1116 {
1117     char *errstr;
1118     struct timeval tv;
1119
1120     if (timestamp)
1121         gettimeofday(&tv, NULL);
1122
1123     if (netsec_negotiate_tls(nsc, &errstr) != OK)
1124             die("%s", errstr);
1125
1126     if (timestamp)
1127         ts_report(&tv, "TLS negotation time");
1128 }
1129
1130 /*
1131  * Give a timestamp report.
1132  */
1133
1134 static void
1135 ts_report(struct timeval *tv, const char *fmt, ...)
1136 {
1137     struct timeval now;
1138     double delta;
1139     va_list ap;
1140
1141     gettimeofday(&now, NULL);
1142
1143     delta = ((double) now.tv_sec) - ((double) tv->tv_sec) +
1144             (now.tv_usec / 1E6 - tv->tv_usec / 1E6);
1145
1146     va_start(ap, fmt);
1147     vfprintf(stdout, fmt, ap);
1148     va_end(ap);
1149
1150     printf(": %f sec\n", delta);
1151 }
1152
1153 /*
1154  * Calculate the RFC 822 size of file.
1155  */
1156
1157 static size_t
1158 rfc822size(const char *filename)
1159 {
1160     FILE *f;
1161     size_t total = 0, linecap = 0;
1162     ssize_t rc;
1163     char *line = NULL;
1164
1165     if (! (f = fopen(filename, "r")))
1166         die("Unable to open %s: %s", filename, strerror(errno));
1167
1168     while ((rc = getline(&line, &linecap, f)) > 0) {
1169         total += rc;
1170         if (line[rc - 1] == '\n' && (rc == 1 || line[rc - 2] != '\r'))
1171             total++;
1172         if (line[rc - 1] != '\n')
1173             total += 2;
1174     }
1175
1176     free(line);
1177
1178     if (! feof(f))
1179         die("Error while reading %s: %s", filename, strerror(errno));
1180
1181     fclose(f);
1182
1183     return total;
1184 }