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