query.c

   1 /*
   2  * Copyright (C) 1996-2000,2003 Michael R. Elkins <me@mutt.org>
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include "mutt.h"
  24 #include "mutt_menu.h"
  25 #include "mutt_idna.h"
  26 #include "mapping.h"
  27
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <ctype.h>
  31
  32 typedef struct query
  33 {
  34   int num;
  35   ADDRESS *addr;
  36   char *name;
  37   char *other;
  38   struct query *next;
  39 } QUERY;
  40
  41 typedef struct entry
  42 {
  43   int tagged;
  44   QUERY *data;
  45 } ENTRY;
  46
  47 static struct mapping_t QueryHelp[] = {
  48   { N_("Exit"),   OP_EXIT },
  49   { N_("Mail"),   OP_MAIL },
  50   { N_("New Query"),  OP_QUERY },
  51   { N_("Make Alias"), OP_CREATE_ALIAS },
  52   { N_("Search"), OP_SEARCH },
  53   { N_("Help"),   OP_HELP },
  54   { NULL }
  55 };
  56
  57 static void query_menu (char *buf, size_t buflen, QUERY *results, int retbuf);
  58
  59 static ADDRESS *result_to_addr (QUERY *r)
  60 {
  61   static ADDRESS *tmp;
  62
  63   if (!(tmp = rfc822_cpy_adr (r->addr)))
  64     return NULL;
  65
  66   if(!tmp->next && !tmp->personal)
  67     tmp->personal = safe_strdup (r->name);
  68
  69   mutt_addrlist_to_idna (tmp, NULL);
  70   return tmp;
  71 }
  72
  73 static QUERY *run_query (char *s, int quiet)
  74 {
  75   FILE *fp;
  76   QUERY *first = NULL;
  77   QUERY *cur = NULL;
  78   char cmd[_POSIX_PATH_MAX];
  79   char *buf = NULL;
  80   size_t buflen;
  81   int dummy = 0;
  82   char msg[STRING];
  83   char *p;
  84   pid_t thepid;
  85
  86
  87   mutt_expand_file_fmt (cmd, sizeof(cmd), QueryCmd, s);
  88
  89   if ((thepid = mutt_create_filter (cmd, NULL, &fp, NULL)) < 0)
  90   {
  91     dprint (1, (debugfile, "unable to fork command: %s", cmd));
  92     return 0;
  93   }
  94   if (!quiet)
  95     mutt_message _("Waiting for response...");
  96   fgets (msg, sizeof (msg), fp);
  97   if ((p = strrchr (msg, '\n')))
  98     *p = '\0';
  99   while ((buf = mutt_read_line (buf, &buflen, fp, &dummy)) != NULL)
 100   {
 101     if ((p = strtok(buf, "\t\n")))
 102     {
 103       if (first == NULL)
 104       {
 105         first = (QUERY *) safe_calloc (1, sizeof (QUERY));
 106         cur = first;
 107       }
 108       else
 109       {
 110         cur->next = (QUERY *) safe_calloc (1, sizeof (QUERY));
 111         cur = cur->next;
 112       }
 113
 114       cur->addr = rfc822_parse_adrlist (cur->addr, p);
 115       p = strtok(NULL, "\t\n");
 116       if (p)
 117       {
 118         cur->name = safe_strdup (p);
 119         p = strtok(NULL, "\t\n");
 120         if (p)
 121           cur->other = safe_strdup (p);
 122       }
 123     }
 124   }
 125   FREE (&buf);
 126   fclose (fp);
 127   if (mutt_wait_filter (thepid))
 128   {
 129     dprint (1, (debugfile, "Error: %s\n", msg));
 130     if (!quiet)  mutt_error ("%s", msg);
 131   }
 132   else
 133   {
 134     if (!quiet)
 135       mutt_message ("%s", msg);
 136   }
 137
 138   return first;
 139 }
 140
 141 static int query_search (MUTTMENU *m, regex_t *re, int n)
 142 {
 143   ENTRY *table = (ENTRY *) m->data;
 144
 145   if (table[n].data->name && !regexec (re, table[n].data->name, 0, NULL, 0))
 146     return 0;
 147   if (table[n].data->other && !regexec (re, table[n].data->other, 0, NULL, 0))
 148     return 0;
 149   if (table[n].data->addr)
 150   {
 151     if (table[n].data->addr->personal &&
 152         !regexec (re, table[n].data->addr->personal, 0, NULL, 0))
 153       return 0;
 154     if (table[n].data->addr->mailbox &&
 155         !regexec (re, table[n].data->addr->mailbox, 0, NULL, 0))
 156       return 0;
 157 #ifdef EXACT_ADDRESS
 158     if (table[n].data->addr->val &&
 159         !regexec (re, table[n].data->addr->val, 0, NULL, 0))
 160       return 0;
 161 #endif
 162   }
 163
 164   return REG_NOMATCH;
 165 }
 166
 167 static const char * query_format_str (char *dest, size_t destlen, size_t col,
 168                                       char op, const char *src,
 169                                       const char *fmt, const char *ifstring,
 170                                       const char *elsestring,
 171                                       unsigned long data, format_flag flags)
 172 {
 173   ENTRY *entry = (ENTRY *)data;
 174   QUERY *query = entry->data;
 175   char tmp[SHORT_STRING];
 176   char buf2[STRING] = "";
 177   int optional = (flags & M_FORMAT_OPTIONAL);
 178
 179   switch (op)
 180   {
 181   case 'a':
 182     rfc822_write_address (buf2, sizeof (buf2), query->addr, 1);
 183     snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
 184     snprintf (dest, destlen, tmp, buf2);
 185     break;
 186   case 'c':
 187     snprintf (tmp, sizeof (tmp), "%%%sd", fmt);
 188     snprintf (dest, destlen, tmp, query->num + 1);
 189     break;
 190   case 'e':
 191     if (!optional)
 192     {
 193       snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
 194       snprintf (dest, destlen, tmp, NONULL (query->other));
 195     }
 196     else if (!query->other || !*query->other)
 197       optional = 0;
 198     break;
 199   case 'n':
 200     snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
 201     snprintf (dest, destlen, tmp, NONULL (query->name));
 202     break;
 203   case 't':
 204     snprintf (tmp, sizeof (tmp), "%%%sc", fmt);
 205     snprintf (dest, destlen, tmp, entry->tagged ? '*' : ' ');
 206     break;
 207   default:
 208     snprintf (tmp, sizeof (tmp), "%%%sc", fmt);
 209     snprintf (dest, destlen, tmp, op);
 210     break;
 211   }
 212
 213   if (optional)
 214     mutt_FormatString (dest, destlen, col, ifstring, query_format_str, data, 0);
 215   else if (flags & M_FORMAT_OPTIONAL)
 216     mutt_FormatString (dest, destlen, col, elsestring, query_format_str, data, 0);
 217
 218   return src;
 219 }
 220
 221 static void query_entry (char *s, size_t slen, MUTTMENU *m, int num)
 222 {
 223   ENTRY *entry = &((ENTRY *) m->data)[num];
 224
 225   entry->data->num = num;
 226   mutt_FormatString (s, slen, 0, NONULL (QueryFormat), query_format_str,
 227                      (unsigned long) entry, M_FORMAT_ARROWCURSOR);
 228 }
 229
 230 static int query_tag (MUTTMENU *menu, int n, int m)
 231 {
 232   ENTRY *cur = &((ENTRY *) menu->data)[n];
 233   int ot = cur->tagged;
 234
 235   cur->tagged = m >= 0 ? m : !cur->tagged;
 236   return cur->tagged - ot;
 237 }
 238
 239 int mutt_query_complete (char *buf, size_t buflen)
 240 {
 241   QUERY *results = NULL;
 242   ADDRESS *tmpa;
 243
 244   if (!QueryCmd)
 245   {
 246     mutt_error _("Query command not defined.");
 247     return 0;
 248   }
 249
 250   results = run_query (buf, 1);
 251   if (results)
 252   {
 253     /* only one response? */
 254     if (results->next == NULL)
 255     {
 256       tmpa = result_to_addr (results);
 257       mutt_addrlist_to_local (tmpa);
 258       buf[0] = '\0';
 259       rfc822_write_address (buf, buflen, tmpa, 0);
 260       rfc822_free_address (&tmpa);
 261       mutt_clear_error ();
 262       return (0);
 263     }
 264     /* multiple results, choose from query menu */
 265     query_menu (buf, buflen, results, 1);
 266   }
 267   return (0);
 268 }
 269
 270 void mutt_query_menu (char *buf, size_t buflen)
 271 {
 272   if (!QueryCmd)
 273   {
 274     mutt_error _("Query command not defined.");
 275     return;
 276   }
 277
 278   if (buf == NULL)
 279   {
 280     char buffer[STRING] = "";
 281
 282     query_menu (buffer, sizeof (buffer), NULL, 0);
 283   }
 284   else
 285   {
 286     query_menu (buf, buflen, NULL, 1);
 287   }
 288 }
 289
 290 static void query_menu (char *buf, size_t buflen, QUERY *results, int retbuf)
 291 {
 292   MUTTMENU *menu;
 293   HEADER *msg = NULL;
 294   ENTRY *QueryTable = NULL;
 295   QUERY *queryp = NULL;
 296   int i, done = 0;
 297   int op;
 298   char helpstr[LONG_STRING];
 299   char title[STRING];
 300
 301   snprintf (title, sizeof (title), _("Query")); /* FIXME */
 302
 303   menu = mutt_new_menu (MENU_QUERY);
 304   menu->make_entry = query_entry;
 305   menu->search = query_search;
 306   menu->tag = query_tag;
 307   menu->title = title;
 308   menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_QUERY, QueryHelp);
 309
 310   if (results == NULL)
 311   {
 312     /* Prompt for Query */
 313     if (mutt_get_field (_("Query: "), buf, buflen, 0) == 0 && buf[0])
 314     {
 315       results = run_query (buf, 0);
 316     }
 317   }
 318
 319   if (results)
 320   {
 321     snprintf (title, sizeof (title), _("Query '%s'"), buf);
 322
 323     /* count the number of results */
 324     for (queryp = results; queryp; queryp = queryp->next)
 325       menu->max++;
 326
 327     menu->data = QueryTable = (ENTRY *) safe_calloc (menu->max, sizeof (ENTRY));
 328
 329     for (i = 0, queryp = results; queryp; queryp = queryp->next, i++)
 330       QueryTable[i].data = queryp;
 331
 332     while (!done)
 333     {
 334       switch ((op = mutt_menuLoop (menu)))
 335       {
 336         case OP_QUERY_APPEND:
 337         case OP_QUERY:
 338           if (mutt_get_field (_("Query: "), buf, buflen, 0) == 0 && buf[0])
 339           {
 340             QUERY *newresults = NULL;
 341
 342             newresults = run_query (buf, 0);
 343
 344             menu->redraw = REDRAW_FULL;
 345             if (newresults)
 346             {
 347               snprintf (title, sizeof (title), _("Query '%s'"), buf);
 348
 349               if (op == OP_QUERY)
 350               {
 351                 queryp = results;
 352                 while (queryp)
 353                 {
 354                   rfc822_free_address (&queryp->addr);
 355                   FREE (&queryp->name);
 356                   FREE (&queryp->other);
 357                   results = queryp->next;
 358                   FREE (&queryp);
 359                   queryp = results;
 360                 }
 361                 results = newresults;
 362                 FREE (&QueryTable);
 363               }
 364               else
 365               {
 366                 /* append */
 367                 for (queryp = results; queryp->next; queryp = queryp->next);
 368
 369                 queryp->next = newresults;
 370               }
 371
 372
 373               menu->current = 0;
 374               mutt_menuDestroy (&menu);
 375               menu = mutt_new_menu (MENU_QUERY);
 376               menu->make_entry = query_entry;
 377               menu->search = query_search;
 378               menu->tag = query_tag;
 379               menu->title = title;
 380               menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_QUERY, QueryHelp);
 381
 382               /* count the number of results */
 383               for (queryp = results; queryp; queryp = queryp->next)
 384                 menu->max++;
 385
 386               if (op == OP_QUERY)
 387               {
 388                 menu->data = QueryTable =
 389                   (ENTRY *) safe_calloc (menu->max, sizeof (ENTRY));
 390
 391                 for (i = 0, queryp = results; queryp;
 392                      queryp = queryp->next, i++)
 393                   QueryTable[i].data = queryp;
 394               }
 395               else
 396               {
 397                 int clear = 0;
 398
 399                 /* append */
 400                 safe_realloc (&QueryTable, menu->max * sizeof (ENTRY));
 401
 402                 menu->data = QueryTable;
 403
 404                 for (i = 0, queryp = results; queryp;
 405                      queryp = queryp->next, i++)
 406                 {
 407                   /* once we hit new entries, clear/init the tag */
 408                   if (queryp == newresults)
 409                     clear = 1;
 410
 411                   QueryTable[i].data = queryp;
 412                   if (clear)
 413                     QueryTable[i].tagged = 0;
 414                 }
 415               }
 416             }
 417           }
 418           break;
 419
 420         case OP_CREATE_ALIAS:
 421           if (menu->tagprefix)
 422           {
 423             ADDRESS *naddr = NULL;
 424
 425             for (i = 0; i < menu->max; i++)
 426               if (QueryTable[i].tagged)
 427               {
 428                 ADDRESS *a = result_to_addr(QueryTable[i].data);
 429                 rfc822_append (&naddr, a);
 430                 rfc822_free_address (&a);
 431               }
 432
 433             mutt_create_alias (NULL, naddr);
 434           }
 435           else
 436           {
 437             ADDRESS *a = result_to_addr(QueryTable[menu->current].data);
 438             mutt_create_alias (NULL, a);
 439             rfc822_free_address (&a);
 440           }
 441           break;
 442
 443         case OP_GENERIC_SELECT_ENTRY:
 444           if (retbuf)
 445           {
 446             done = 2;
 447             break;
 448           }
 449           /* fall through to OP_MAIL */
 450
 451         case OP_MAIL:
 452           msg = mutt_new_header ();
 453           msg->env = mutt_new_envelope ();
 454           if (!menu->tagprefix)
 455           {
 456             msg->env->to = result_to_addr(QueryTable[menu->current].data);
 457           }
 458           else
 459           {
 460             for (i = 0; i < menu->max; i++)
 461               if (QueryTable[i].tagged)
 462               {
 463                 ADDRESS *a = result_to_addr(QueryTable[i].data);
 464                 rfc822_append (&msg->env->to, a);
 465                 rfc822_free_address (&a);
 466               }
 467           }
 468           ci_send_message (0, msg, NULL, Context, NULL);
 469           menu->redraw = REDRAW_FULL;
 470           break;
 471
 472         case OP_EXIT:
 473           done = 1;
 474           break;
 475       }
 476     }
 477
 478     /* if we need to return the selected entries */
 479     if (retbuf && (done == 2))
 480     {
 481       int tagged = 0;
 482       size_t curpos = 0;
 483
 484       memset (buf, 0, buflen);
 485
 486       /* check for tagged entries */
 487       for (i = 0; i < menu->max; i++)
 488       {
 489         if (QueryTable[i].tagged)
 490         {
 491           if (curpos == 0)
 492           {
 493             ADDRESS *tmpa = result_to_addr (QueryTable[i].data);
 494             mutt_addrlist_to_local (tmpa);
 495             tagged = 1;
 496             rfc822_write_address (buf, buflen, tmpa, 0);
 497             curpos = mutt_strlen (buf);
 498             rfc822_free_address (&tmpa);
 499           }
 500           else if (curpos + 2 < buflen)
 501           {
 502             ADDRESS *tmpa = result_to_addr (QueryTable[i].data);
 503             mutt_addrlist_to_local (tmpa);
 504             strcat (buf, ", "); /* __STRCAT_CHECKED__ */
 505             rfc822_write_address ((char *) buf + curpos + 1, buflen - curpos - 1,
 506                                   tmpa, 0);
 507             curpos = mutt_strlen (buf);
 508             rfc822_free_address (&tmpa);
 509           }
 510         }
 511       }
 512       /* then enter current message */
 513       if (!tagged)
 514       {
 515         ADDRESS *tmpa = result_to_addr (QueryTable[menu->current].data);
 516         mutt_addrlist_to_local (tmpa);
 517         rfc822_write_address (buf, buflen, tmpa, 0);
 518         rfc822_free_address (&tmpa);
 519       }
 520
 521     }
 522
 523     queryp = results;
 524     while (queryp)
 525     {
 526       rfc822_free_address (&queryp->addr);
 527       FREE (&queryp->name);
 528       FREE (&queryp->other);
 529       results = queryp->next;
 530       FREE (&queryp);
 531       queryp = results;
 532     }
 533     FREE (&QueryTable);
 534
 535     /* tell whoever called me to redraw the screen when I return */
 536     set_option (OPTNEEDREDRAW);
 537   }
 538
 539   mutt_menuDestroy (&menu);
 540 }