imap/util.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 1996-8 Michael R. Elkins <me@mutt.org>
   4  * Copyright (C) 1996-9 Brandon Long <blong@fiction.net>
   5  * Copyright (C) 1999-2002 Brendan Cully <brendan@kublai.com>
   6  *
   7  * This file is part of mutt-ng, see http://www.muttng.org/.
   8  * It's licensed under the GNU General Public License,
   9  * please see the file GPL in the top level source directory.
  10  */
  11
  12 /* general IMAP utility functions */
  13
  14 #include "config.h"
  15
  16 #include "mutt.h"
  17 #include "mx.h"                 /* for M_IMAP */
  18 #include "url.h"
  19 #include "imap_private.h"
  20 #include "mutt_ssl.h"
  21
  22 #include "lib/mem.h"
  23 #include "lib/intl.h"
  24 #include "lib/debug.h"
  25
  26 #include <stdlib.h>
  27 #include <ctype.h>
  28
  29 #include <sys/types.h>
  30 #include <sys/wait.h>
  31 #include <signal.h>
  32 #include <netdb.h>
  33 #include <netinet/in.h>
  34
  35 #include <errno.h>
  36
  37 /* -- public functions -- */
  38
  39 /* imap_expand_path: IMAP implementation of mutt_expand_path. Rewrite
  40  *   an IMAP path in canonical and absolute form.
  41  * Inputs: a buffer containing an IMAP path, and the number of bytes in
  42  *   that buffer.
  43  * Outputs: The buffer is rewritten in place with the canonical IMAP path.
  44  * Returns 0 on success, or -1 if imap_parse_path chokes or url_ciss_tostring
  45  *   fails, which it might if there isn't enough room in the buffer. */
  46 int imap_expand_path (char *path, size_t len)
  47 {
  48   IMAP_MBOX mx;
  49   ciss_url_t url;
  50   int rc;
  51
  52   if (imap_parse_path (path, &mx) < 0)
  53     return -1;
  54
  55   mutt_account_tourl (&mx.account, &url);
  56   url.path = mx.mbox;
  57
  58   rc = url_ciss_tostring (&url, path, len, U_DECODE_PASSWD);
  59   FREE (&mx.mbox);
  60
  61   return rc;
  62 }
  63
  64 /* imap_parse_path: given an IMAP mailbox name, return host, port
  65  *   and a path IMAP servers will recognise.
  66  * mx.mbox is malloc'd, caller must free it */
  67 int imap_parse_path (const char *path, IMAP_MBOX * mx)
  68 {
  69   static unsigned short ImapPort = 0;
  70   static unsigned short ImapsPort = 0;
  71   struct servent *service;
  72   ciss_url_t url;
  73   char *c;
  74
  75   if (!ImapPort) {
  76     service = getservbyname ("imap", "tcp");
  77     if (service)
  78       ImapPort = ntohs (service->s_port);
  79     else
  80       ImapPort = IMAP_PORT;
  81     debug_print (3, ("Using default IMAP port %d\n", ImapPort));
  82   }
  83   if (!ImapsPort) {
  84     service = getservbyname ("imaps", "tcp");
  85     if (service)
  86       ImapsPort = ntohs (service->s_port);
  87     else
  88       ImapsPort = IMAP_SSL_PORT;
  89     debug_print (3, ("Using default IMAPS port %d\n", ImapsPort));
  90   }
  91
  92   /* Defaults */
  93   mx->account.flags = 0;
  94   mx->account.port = ImapPort;
  95   mx->account.type = M_ACCT_TYPE_IMAP;
  96
  97   c = safe_strdup (path);
  98   url_parse_ciss (&url, c);
  99
 100   if (!(url.scheme == U_IMAP || url.scheme == U_IMAPS) ||
 101       mutt_account_fromurl (&mx->account, &url) < 0) {
 102     FREE (&c);
 103     return -1;
 104   }
 105
 106   mx->mbox = safe_strdup (url.path);
 107
 108   if (url.scheme == U_IMAPS)
 109     mx->account.flags |= M_ACCT_SSL;
 110
 111   FREE (&c);
 112
 113 #if defined(USE_SSL) || defined(USE_GNUTLS)
 114   if (option (OPTIMAPFORCESSL))
 115     mx->account.flags |= M_ACCT_SSL;
 116 #endif
 117
 118   if ((mx->account.flags & M_ACCT_SSL) && !(mx->account.flags & M_ACCT_PORT))
 119     mx->account.port = ImapsPort;
 120
 121   return 0;
 122 }
 123
 124 /* imap_pretty_mailbox: called by mutt_pretty_mailbox to make IMAP paths
 125  *   look nice. */
 126 void imap_pretty_mailbox (char *path)
 127 {
 128   IMAP_MBOX home, target;
 129   ciss_url_t url;
 130   char *delim;
 131   int tlen;
 132   int hlen = 0;
 133   char home_match = 0;
 134
 135   if (imap_parse_path (path, &target) < 0)
 136     return;
 137
 138   tlen = mutt_strlen (target.mbox);
 139   /* check whether we can do '=' substitution */
 140   if (mx_get_magic (Maildir) == M_IMAP && !imap_parse_path (Maildir, &home)) {
 141     hlen = mutt_strlen (home.mbox);
 142     if (tlen && mutt_account_match (&home.account, &target.account) &&
 143         !safe_strncmp (home.mbox, target.mbox, hlen)) {
 144       if (!hlen)
 145         home_match = 1;
 146       else
 147         for (delim = ImapDelimChars; *delim != '\0'; delim++)
 148           if (target.mbox[hlen] == *delim)
 149             home_match = 1;
 150     }
 151     FREE (&home.mbox);
 152   }
 153
 154   /* do the '=' substitution */
 155   if (home_match) {
 156     *path++ = '=';
 157     /* copy remaining path, skipping delimiter */
 158     if (!hlen)
 159       hlen = -1;
 160     memcpy (path, target.mbox + hlen + 1, tlen - hlen - 1);
 161     path[tlen - hlen - 1] = '\0';
 162   }
 163   else {
 164     mutt_account_tourl (&target.account, &url);
 165     url.path = target.mbox;
 166     /* FIXME: That hard-coded constant is bogus. But we need the actual
 167      *   size of the buffer from mutt_pretty_mailbox. And these pretty
 168      *   operations usually shrink the result. Still... */
 169     url_ciss_tostring (&url, path, 1024, 0);
 170   }
 171
 172   FREE (&target.mbox);
 173 }
 174
 175 /* -- library functions -- */
 176
 177 /* imap_continue: display a message and ask the user if she wants to
 178  *   go on. */
 179 int imap_continue (const char *msg, const char *resp)
 180 {
 181   imap_error (msg, resp);
 182   return mutt_yesorno (_("Continue?"), 0);
 183 }
 184
 185 /* imap_error: show an error and abort */
 186 void imap_error (const char *where, const char *msg)
 187 {
 188   mutt_error ("%s [%s]\n", where, msg);
 189   mutt_sleep (2);
 190 }
 191
 192 /* imap_new_idata: Allocate and initialise a new IMAP_DATA structure.
 193  *   Returns NULL on failure (no mem) */
 194 IMAP_DATA *imap_new_idata (void)
 195 {
 196   return safe_calloc (1, sizeof (IMAP_DATA));
 197 }
 198
 199 /* imap_free_idata: Release and clear storage in an IMAP_DATA structure. */
 200 void imap_free_idata (IMAP_DATA ** idata)
 201 {
 202   if (!idata)
 203     return;
 204
 205   FREE (&(*idata)->capstr);
 206   mutt_free_list (&(*idata)->flags);
 207   FREE (&((*idata)->cmd.buf));
 208   FREE (idata);
 209 }
 210
 211 /*
 212  * Fix up the imap path.  This is necessary because the rest of mutt
 213  * assumes a hierarchy delimiter of '/', which is not necessarily true
 214  * in IMAP.  Additionally, the filesystem converts multiple hierarchy
 215  * delimiters into a single one, ie "///" is equal to "/".  IMAP servers
 216  * are not required to do this.
 217  * Moreover, IMAP servers may dislike the path ending with the delimiter.
 218  */
 219 char *imap_fix_path (IMAP_DATA * idata, char *mailbox, char *path,
 220                      size_t plen)
 221 {
 222   int x = 0;
 223
 224   if (!mailbox || !*mailbox) {
 225     strfcpy (path, "INBOX", plen);
 226     return path;
 227   }
 228
 229   while (mailbox && *mailbox && (x < (plen - 1))) {
 230     if ((*mailbox == '/') || (*mailbox == idata->delim)) {
 231       while ((*mailbox == '/') || (*mailbox == idata->delim))
 232         mailbox++;
 233       path[x] = idata->delim;
 234     }
 235     else {
 236       path[x] = *mailbox;
 237       mailbox++;
 238     }
 239     x++;
 240   }
 241   if (x && path[--x] != idata->delim)
 242     x++;
 243   path[x] = '\0';
 244   return path;
 245 }
 246
 247 /* imap_get_literal_count: write number of bytes in an IMAP literal into
 248  *   bytes, return 0 on success, -1 on failure. */
 249 int imap_get_literal_count (const char *buf, long *bytes)
 250 {
 251   char *pc;
 252   char *pn;
 253
 254   if (!(pc = strchr (buf, '{')))
 255     return (-1);
 256   pc++;
 257   pn = pc;
 258   while (isdigit ((unsigned char) *pc))
 259     pc++;
 260   *pc = 0;
 261   *bytes = atoi (pn);
 262   return (0);
 263 }
 264
 265 /* imap_get_qualifier: in a tagged response, skip tag and status for
 266  *   the qualifier message. Used by imap_copy_message for TRYCREATE */
 267 char *imap_get_qualifier (char *buf)
 268 {
 269   char *s = buf;
 270
 271   /* skip tag */
 272   s = imap_next_word (s);
 273   /* skip OK/NO/BAD response */
 274   s = imap_next_word (s);
 275
 276   return s;
 277 }
 278
 279 /* imap_next_word: return index into string where next IMAP word begins */
 280 char *imap_next_word (char *s)
 281 {
 282   int quoted = 0;
 283
 284   while (*s) {
 285     if (*s == '\\') {
 286       s++;
 287       if (*s)
 288         s++;
 289       continue;
 290     }
 291     if (*s == '\"')
 292       quoted = quoted ? 0 : 1;
 293     if (!quoted && ISSPACE (*s))
 294       break;
 295     s++;
 296   }
 297
 298   SKIPWS (s);
 299   return s;
 300 }
 301
 302 /* imap_parse_date: date is of the form: DD-MMM-YYYY HH:MM:SS +ZZzz */
 303 time_t imap_parse_date (char *s)
 304 {
 305   struct tm t;
 306   time_t tz;
 307
 308   t.tm_mday = (s[0] == ' ' ? s[1] - '0' : (s[0] - '0') * 10 + (s[1] - '0'));
 309   s += 2;
 310   if (*s != '-')
 311     return 0;
 312   s++;
 313   t.tm_mon = mutt_check_month (s);
 314   s += 3;
 315   if (*s != '-')
 316     return 0;
 317   s++;
 318   t.tm_year =
 319     (s[0] - '0') * 1000 + (s[1] - '0') * 100 + (s[2] - '0') * 10 + (s[3] -
 320                                                                     '0') -
 321     1900;
 322   s += 4;
 323   if (*s != ' ')
 324     return 0;
 325   s++;
 326
 327   /* time */
 328   t.tm_hour = (s[0] - '0') * 10 + (s[1] - '0');
 329   s += 2;
 330   if (*s != ':')
 331     return 0;
 332   s++;
 333   t.tm_min = (s[0] - '0') * 10 + (s[1] - '0');
 334   s += 2;
 335   if (*s != ':')
 336     return 0;
 337   s++;
 338   t.tm_sec = (s[0] - '0') * 10 + (s[1] - '0');
 339   s += 2;
 340   if (*s != ' ')
 341     return 0;
 342   s++;
 343
 344   /* timezone */
 345   tz = ((s[1] - '0') * 10 + (s[2] - '0')) * 3600 +
 346     ((s[3] - '0') * 10 + (s[4] - '0')) * 60;
 347   if (s[0] == '+')
 348     tz = -tz;
 349
 350   return (mutt_mktime (&t, 0) + tz);
 351 }
 352
 353 /* imap_qualify_path: make an absolute IMAP folder target, given IMAP_MBOX
 354  *   and relative path. */
 355 void imap_qualify_path (char *dest, size_t len, IMAP_MBOX * mx, char *path)
 356 {
 357   ciss_url_t url;
 358
 359   mutt_account_tourl (&mx->account, &url);
 360   url.path = path;
 361
 362   url_ciss_tostring (&url, dest, len, 0);
 363 }
 364
 365
 366 /* imap_quote_string: quote string according to IMAP rules:
 367  *   surround string with quotes, escape " and \ with \ */
 368 void imap_quote_string (char *dest, size_t dlen, const char *src)
 369 {
 370   char quote[] = "\"\\", *pt;
 371   const char *s;
 372
 373   pt = dest;
 374   s = src;
 375
 376   *pt++ = '"';
 377   /* save room for trailing quote-char */
 378   dlen -= 2;
 379
 380   for (; *s && dlen; s++) {
 381     if (strchr (quote, *s)) {
 382       dlen -= 2;
 383       if (!dlen)
 384         break;
 385       *pt++ = '\\';
 386       *pt++ = *s;
 387     }
 388     else {
 389       *pt++ = *s;
 390       dlen--;
 391     }
 392   }
 393   *pt++ = '"';
 394   *pt = 0;
 395 }
 396
 397 /* imap_unquote_string: equally stupid unquoting routine */
 398 void imap_unquote_string (char *s)
 399 {
 400   char *d = s;
 401
 402   if (*s == '\"')
 403     s++;
 404   else
 405     return;
 406
 407   while (*s) {
 408     if (*s == '\"') {
 409       *d = '\0';
 410       return;
 411     }
 412     if (*s == '\\') {
 413       s++;
 414     }
 415     if (*s) {
 416       *d = *s;
 417       d++;
 418       s++;
 419     }
 420   }
 421   *d = '\0';
 422 }
 423
 424 /*
 425  * Quoting and UTF-7 conversion
 426  */
 427
 428 void imap_munge_mbox_name (char *dest, size_t dlen, const char *src)
 429 {
 430   char *buf;
 431
 432   buf = safe_strdup (src);
 433   imap_utf7_encode (&buf);
 434
 435   imap_quote_string (dest, dlen, buf);
 436
 437   FREE (&buf);
 438 }
 439
 440 void imap_unmunge_mbox_name (char *s)
 441 {
 442   char *buf;
 443
 444   imap_unquote_string (s);
 445
 446   buf = safe_strdup (s);
 447   if (buf) {
 448     imap_utf7_decode (&buf);
 449     strncpy (s, buf, mutt_strlen (s));
 450   }
 451
 452   FREE (&buf);
 453 }
 454
 455 /* imap_wordcasecmp: find word a in word list b */
 456 int imap_wordcasecmp (const char *a, const char *b)
 457 {
 458   char tmp[SHORT_STRING];
 459   char *s = (char *) b;
 460   int i;
 461
 462   tmp[SHORT_STRING - 1] = 0;
 463   for (i = 0; i < SHORT_STRING - 2; i++, s++) {
 464     if (!*s || ISSPACE (*s)) {
 465       tmp[i] = 0;
 466       break;
 467     }
 468     tmp[i] = *s;
 469   }
 470   tmp[i + 1] = 0;
 471
 472   return ascii_strcasecmp (a, tmp);
 473 }
 474
 475 /*
 476  * Imap keepalive: poll the current folder to keep the
 477  * connection alive.
 478  *
 479  */
 480
 481 static RETSIGTYPE alrm_handler (int sig)
 482 {
 483   /* empty */
 484 }
 485
 486 void imap_keepalive (void)
 487 {
 488   CONNECTION *conn;
 489   CONTEXT *ctx = NULL;
 490   IMAP_DATA *idata;
 491
 492   conn = mutt_socket_head ();
 493   while (conn) {
 494     if (conn->account.type == M_ACCT_TYPE_IMAP) {
 495       idata = (IMAP_DATA *) conn->data;
 496
 497       if (idata->state >= IMAP_AUTHENTICATED
 498           && time (NULL) >= idata->lastread + ImapKeepalive) {
 499         if (idata->ctx)
 500           ctx = idata->ctx;
 501         else {
 502           ctx = safe_calloc (1, sizeof (CONTEXT));
 503           ctx->data = idata;
 504         }
 505         imap_check_mailbox (ctx, NULL, 1);
 506         if (!idata->ctx)
 507           FREE (&ctx);
 508       }
 509     }
 510
 511     conn = conn->next;
 512   }
 513 }
 514
 515 int imap_wait_keepalive (pid_t pid)
 516 {
 517   struct sigaction oldalrm;
 518   struct sigaction act;
 519   sigset_t oldmask;
 520   int rc;
 521
 522   short imap_passive = option (OPTIMAPPASSIVE);
 523
 524   set_option (OPTIMAPPASSIVE);
 525   set_option (OPTKEEPQUIET);
 526
 527   sigprocmask (SIG_SETMASK, NULL, &oldmask);
 528
 529   sigemptyset (&act.sa_mask);
 530   act.sa_handler = alrm_handler;
 531 #ifdef SA_INTERRUPT
 532   act.sa_flags = SA_INTERRUPT;
 533 #else
 534   act.sa_flags = 0;
 535 #endif
 536
 537   sigaction (SIGALRM, &act, &oldalrm);
 538
 539   alarm (ImapKeepalive);
 540   while (waitpid (pid, &rc, 0) < 0 && errno == EINTR) {
 541     alarm (0);                  /* cancel a possibly pending alarm */
 542     imap_keepalive ();
 543     alarm (ImapKeepalive);
 544   }
 545
 546   alarm (0);                    /* cancel a possibly pending alarm */
 547
 548   sigaction (SIGALRM, &oldalrm, NULL);
 549   sigprocmask (SIG_SETMASK, &oldmask, NULL);
 550
 551   unset_option (OPTKEEPQUIET);
 552   if (!imap_passive)
 553     unset_option (OPTIMAPPASSIVE);
 554
 555   return rc;
 556 }
 557
 558 /* Allow/disallow re-opening a folder upon expunge. */
 559
 560 void imap_allow_reopen (CONTEXT * ctx)
 561 {
 562   if (ctx && ctx->magic == M_IMAP && CTX_DATA->ctx == ctx)
 563     CTX_DATA->reopen |= IMAP_REOPEN_ALLOW;
 564 }
 565
 566 void imap_disallow_reopen (CONTEXT * ctx)
 567 {
 568   if (ctx && ctx->magic == M_IMAP && CTX_DATA->ctx == ctx)
 569     CTX_DATA->reopen &= ~IMAP_REOPEN_ALLOW;
 570 }