alpine/dispfilt.c

   1 /*
   2  * ========================================================================
   3  * Copyright 2006-2008 University of Washington
   4  * Copyright 2013-2022 Eduardo Chappa
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * ========================================================================
  13  */
  14
  15 /*======================================================================
  16      dispfilt.c
  17      Display filter technology ;)
  18
  19   ====*/
  20
  21 #include "headers.h"
  22
  23 #include "../pith/state.h"
  24 #include "../pith/conf.h"
  25 #include "../pith/filter.h"
  26 #include "../pith/store.h"
  27 #include "../pith/addrstring.h"
  28 #include "../pith/mimedesc.h"
  29 #include "../pith/list.h"
  30 #include "../pith/detach.h"
  31
  32 #include "mailview.h"
  33 #include "signal.h"
  34 #include "busy.h"
  35 #include "dispfilt.h"
  36
  37
  38 /* internal prototypes */
  39 int     df_valid_test(BODY *, char *);
  40
  41
  42
  43 /*
  44  * dfilter - pipe the data from the given storage object thru the
  45  *           global display filter and into whatever the putchar's
  46  *           function points to.
  47  *
  48  *           Input is assumed to be UTF-8.
  49  *           That's converted to user's locale and passed to rawcmd.
  50  *           That's converted back to UTF-8 and passed through aux_filters.
  51  */
  52 char *
  53 dfilter(char *rawcmd, STORE_S *input_so, gf_o_t output_pc, FILTLIST_S *aux_filters)
  54 {
  55     char *status = NULL, *cmd, *resultf = NULL, *tmpfile = NULL;
  56     int   key = 0, silent = 0;
  57
  58     if((cmd = expand_filter_tokens(rawcmd,NULL,&tmpfile,&resultf,NULL,&key,NULL, &silent)) != NULL){
  59         suspend_busy_cue();
  60 #ifndef _WINDOWS
  61         if(!silent){
  62           ps_global->mangled_screen = 1;
  63           ClearScreen();
  64         }
  65         fflush(stdout);
  66 #endif
  67
  68         /*
  69          * If it was requested that the interaction take place via
  70          * a tmpfile, fill it with text from our input_so, and let
  71          * system_pipe handle the rest.  Session key and tmp file
  72          * mode support additions based loosely on a patch
  73          * supplied by Thomas Stroesslin <thomas.stroesslin@epfl.ch>
  74          */
  75         if(tmpfile){
  76             PIPE_S        *filter_pipe;
  77             FILE          *fp;
  78             gf_i_t         gc;
  79             gf_o_t         pc;
  80             STORE_S       *tmpf_so;
  81
  82             /* write the tmp file */
  83             so_seek(input_so, 0L, 0);
  84             if((tmpf_so = so_get(FileStar, tmpfile, WRITE_ACCESS|OWNER_ONLY|WRITE_TO_LOCALE)) != NULL){
  85                 if(key){
  86                     so_puts(tmpf_so, filter_session_key());
  87                     so_puts(tmpf_so, NEWLINE);
  88                 }
  89                 /* copy input to tmp file */
  90                 gf_set_so_readc(&gc, input_so);
  91                 gf_set_so_writec(&pc, tmpf_so);
  92                 gf_filter_init();
  93                 status = gf_pipe(gc, pc);
  94                 gf_clear_so_readc(input_so);
  95                 gf_clear_so_writec(tmpf_so);
  96                 if(so_give(&tmpf_so) != 0 && status == NULL)
  97                   status = error_description(errno);
  98
  99                 /* prepare the terminal in case the filter uses it */
 100                 if(status == NULL){
 101                     if((filter_pipe = open_system_pipe(cmd, NULL, NULL,
 102                                                 PIPE_USER | (silent ? PIPE_SILENT :
 103                                                 (F_ON(F_DISABLE_TERM_RESET_DISP, ps_global) ? 0 : PIPE_RESET)),
 104                                                       0, pipe_callback, NULL)) != NULL){
 105                         if(close_system_pipe(&filter_pipe, NULL, pipe_callback) == 0){
 106                             /* pull result out of tmp file */
 107                             if((fp = our_fopen(tmpfile, "rb")) != NULL){
 108                                 gf_set_readc(&gc, fp, 0L, FileStar, READ_FROM_LOCALE);
 109                                 gf_filter_init();
 110                                 if(aux_filters)
 111                                   for( ; aux_filters->filter; aux_filters++)
 112                                     gf_link_filter(aux_filters->filter,
 113                                                    aux_filters->data);
 114
 115                                 status = gf_pipe(gc, output_pc);
 116                                 fclose(fp);
 117                             }
 118                             else
 119                               status = "Can't read result of display filter";
 120                         }
 121                         else
 122                           status = "Filter command returned error.";
 123                     }
 124                     else
 125                       status = "Can't open pipe for display filter";
 126                 }
 127
 128                 our_unlink(tmpfile);
 129             }
 130             else
 131               status = "Can't open display filter tmp file";
 132         }
 133         else if((status = gf_filter(cmd, key ? filter_session_key() : NULL,
 134                                    input_so, output_pc, aux_filters, silent,
 135                                    F_ON(F_DISABLE_TERM_RESET_DISP, ps_global),
 136                                    pipe_callback)) != NULL){
 137             unsigned long ch;
 138
 139             fprintf(stdout,"\r\n%s  Hit return to continue.", status);
 140             fflush(stdout);
 141             while((ch = read_char(300)) != ctrl('M') && ch != NO_OP_IDLE)
 142               putchar(BELL);
 143         }
 144
 145         if(resultf){
 146             if(name_file_size(resultf) > 0L)
 147               display_output_file(resultf, "Filter", NULL, DOF_BRIEF);
 148             our_unlink(resultf);
 149             fs_give((void **)&resultf);
 150         }
 151
 152         resume_busy_cue(0);
 153 #ifndef _WINDOWS
 154         if(!silent)
 155           ClearScreen();
 156 #endif
 157         fs_give((void **)&cmd);
 158     }
 159
 160     return(status);
 161 }
 162
 163
 164 /*
 165  * expand_filter_tokens - return an alloc'd string with any special tokens
 166  *                        in the given filter expanded, NULL otherwise.
 167  */
 168 char *
 169 expand_filter_tokens(char *filter, ENVELOPE *env, char **tmpf, char **resultf,
 170                      char **mtypef, int *key, int *hdrs, int *silent)
 171 {
 172     char   **array, **q;
 173     char    *bp, *cmd = NULL, *p = NULL,
 174             *tfn = NULL, *rfn = NULL, *dfn = NULL, *mfn = NULL,
 175             *freeme_tfn = NULL, *freeme_rfn = NULL, *freeme_mfn = NULL;
 176     int      n = 0;
 177     size_t   len;
 178
 179     /*
 180      * break filter into words delimited by whitespace so that we can
 181      * look for tokens. First we count how many words.
 182      */
 183     if((bp = cpystr(filter)) != NULL)
 184       p = strtok(bp, " \t");
 185
 186     if(p){
 187         n++;
 188         while(strtok(NULL, " \t") != NULL)
 189           n++;
 190     }
 191
 192     if(!n){
 193         dprint((1, "Unexpected failure creating sending_filter\n"));
 194         if(bp)
 195           fs_give((void **)&bp);
 196
 197         return(cmd);
 198     }
 199
 200     q = array = (char **) fs_get((n+1) * sizeof(*array));
 201     memset(array, 0, (n+1) * sizeof(*array));
 202     /* restore bp and form the array */
 203     strncpy(bp, filter, strlen(filter)+1);
 204     if((p = strtok(bp, " \t")) != NULL){
 205         if(q-array < n+1)
 206           *q++ = cpystr(p);
 207
 208         while((p = strtok(NULL, " \t")) != NULL && (q-array < n+1))
 209           *q++ = cpystr(p);
 210     }
 211
 212     if(bp)
 213       fs_give((void **)&bp);
 214
 215     for(q = array; *q != NULL; q++){
 216         if(!strcmp(*q, "_RECIPIENTS_")){
 217             char *rl = NULL;
 218
 219             if(env){
 220                 size_t l;
 221
 222                 char *to_l = addr_list_string(env->to,
 223                                               simple_addr_string, 0),
 224                      *cc_l = addr_list_string(env->cc,
 225                                               simple_addr_string, 0),
 226                      *bcc_l = addr_list_string(env->bcc,
 227                                                simple_addr_string, 0);
 228
 229                 l = strlen(to_l) + strlen(cc_l) + strlen(bcc_l) + 2;
 230                 rl = (char *) fs_get((l+1) * sizeof(char));
 231                 snprintf(rl, l+1, "%s %s %s", to_l, cc_l, bcc_l);
 232                 fs_give((void **)&to_l);
 233                 fs_give((void **)&cc_l);
 234                 fs_give((void **)&bcc_l);
 235                 for(to_l = rl; *to_l; to_l++)   /* to_l overloaded! */
 236                   if(*to_l == ',')                      /* space delim'd list */
 237                     *to_l = ' ';
 238             }
 239
 240             fs_give((void **)q);
 241             *q = rl ? rl : cpystr("");
 242         }
 243         else if(!strcmp(*q, "_TMPFILE_")){
 244             if(!tfn){
 245                 tfn = temp_nam(NULL, "sf");     /* send filter file */
 246                 if(!tfn)
 247                   dprint((1, "FAILED creat of _TMPFILE_\n"));
 248             }
 249
 250             if(tmpf)
 251               *tmpf = tfn;
 252             else
 253               freeme_tfn = tfn;
 254
 255             fs_give((void **)q);
 256             *q = cpystr(tfn ? tfn : "");
 257         }
 258         else if(!strcmp(*q, "_RESULTFILE_")){
 259             if(!rfn){
 260                 rfn = temp_nam(NULL, "rf");
 261                 /*
 262                  * We don't create the result file, the user does.
 263                  * That means we have to remove it after temp_nam creates it.
 264                  */
 265                 if(rfn)
 266                   our_unlink(rfn);
 267                 else
 268                   dprint((1, "FAILED creat of _RESULTFILE_\n"));
 269             }
 270
 271             if(resultf)
 272               *resultf = rfn;
 273             else
 274               freeme_rfn = rfn;
 275
 276             fs_give((void **)q);
 277             *q = cpystr(rfn ? rfn : "");
 278         }
 279         else if(!strcmp(*q, "_MIMETYPE_")){
 280             if(!mfn){
 281                 mfn = temp_nam(NULL, "mt");
 282                 /*
 283                  * We don't create the mimetype file, the user does.
 284                  * That means we have to remove it after temp_nam creates it.
 285                  */
 286                 if(mfn)
 287                   our_unlink(mfn);
 288                 else
 289                   dprint((1, "FAILED creat of _MIMETYPE_\n"));
 290             }
 291
 292             if(mtypef)
 293               *mtypef = mfn;
 294             else
 295               freeme_mfn = mfn;
 296
 297             fs_give((void **)q);
 298             *q = cpystr(mfn ? mfn : "");
 299         }
 300         else if(!strcmp(*q, "_DATAFILE_")){
 301             if((dfn = filter_data_file(1)) == NULL)     /* filter data file */
 302               dprint((1, "FAILED creat of _DATAFILE_\n"));
 303
 304             fs_give((void **)q);
 305             *q = cpystr(dfn ? dfn : "");
 306         }
 307         else if(!strcmp(*q, "_PREPENDKEY_")){
 308             (*q)[0] = '\0';
 309             if(key)
 310               *key = 1;
 311         }
 312         else if(!strcmp(*q, "_INCLUDEALLHDRS_")){
 313             (*q)[0] = '\0';
 314             if(hdrs)
 315               *hdrs = 1;
 316         }
 317         else if(!strcmp(*q, "_SILENT_")){
 318             (*q)[0] = '\0';
 319             if(silent)
 320               *silent = 1;
 321         }
 322     }
 323
 324     /* count up required length */
 325     for(len = 0, q = array; *q != NULL; q++)
 326       len += (strlen(*q)+1);
 327
 328     cmd = fs_get((len+1) * sizeof(char));
 329     cmd[len] = '\0';
 330
 331     /* cat together all the args */
 332     p = cmd;
 333     for(q = array; *q != NULL; q++){
 334         sstrncpy(&p, *q, len+1-(p-cmd));
 335         sstrncpy(&p, " ", len+1-(p-cmd));
 336     }
 337
 338     cmd[len] = '\0';
 339
 340     if(freeme_rfn)
 341       fs_give((void **) &freeme_rfn);
 342
 343     if(freeme_tfn){                     /* this shouldn't happen */
 344         our_unlink(freeme_tfn);
 345         fs_give((void **) &freeme_tfn);
 346     }
 347
 348     if(freeme_mfn)
 349       fs_give((void **) &freeme_mfn);
 350
 351     free_list_array(&array);
 352
 353     return(cmd);
 354 }
 355
 356
 357 /*
 358  * filter_session_key - function to return randomly generated number
 359  *                      representing a key for this session.  The idea is
 360  *                      the display/sending filter could use it to muddle
 361  *                      up any pass phrase or such stored in the
 362  *                      "_DATAFILE_".
 363  */
 364 char *
 365 filter_session_key(void)
 366 {
 367     static char *key = NULL;
 368
 369     if(!key){
 370         snprintf(tmp_20k_buf, SIZEOF_20KBUF, "%ld", random());
 371         key = cpystr(tmp_20k_buf);
 372     }
 373
 374     return(key);
 375 }
 376
 377
 378
 379
 380 /*
 381  * filter_data_file - function to return filename of scratch file for
 382  *                    display and sending filters.  This file is created
 383  *                    the first time it's needed, and persists until pine
 384  *                    exits.
 385  */
 386 char *
 387 filter_data_file(int create_it)
 388 {
 389     static char *fn = NULL;
 390
 391     if(!fn && create_it)
 392       fn = temp_nam(NULL, "df");
 393
 394     return(fn);
 395 }
 396
 397
 398 /*
 399  * df_static_trigger - look thru the display filter list and set the
 400  *                     filter to any triggers that don't require scanning
 401  *                     the message segment.
 402  */
 403 char *
 404 dfilter_trigger(struct mail_bodystruct *body, char *cmdbuf, size_t cmdbuflen)
 405 {
 406     int    passed = 0;
 407     char **l, *test, *cmd;
 408
 409     for(l = ps_global->VAR_DISPLAY_FILTERS ; l && *l && !passed; l++){
 410
 411         get_pair(*l, &test, &cmd, 1, 1);
 412
 413         dprint((5, "static trigger: \"%s\" --> \"%s\" and \"%s\"",
 414                    (l && *l) ? *l : "?",
 415                    test ? test : "<NULL>", cmd ? cmd : "<NULL>"));
 416
 417         if((passed = (df_valid_test(body, test) && valid_filter_command(&cmd))) != 0){
 418           strncpy(cmdbuf, cmd, cmdbuflen);
 419           cmdbuf[cmdbuflen-1] = '\0';
 420         }
 421
 422         fs_give((void **) &test);
 423         fs_give((void **) &cmd);
 424     }
 425
 426     return(passed ? cmdbuf : NULL);
 427 }
 428
 429
 430
 431 int
 432 df_valid_test(struct mail_bodystruct *body, char *test)
 433 {
 434     int passed = 0;
 435
 436     if(!(passed = !test)){                      /* NO test always wins */
 437         if(!*test){
 438             passed++;                           /* NULL test also wins! */
 439         }
 440         else if(body && !struncmp(test, "_CHARSET(", 9)){
 441             char *p = strrindex(test, ')');
 442
 443             if(p){
 444                 *p = '\0';                      /* tie off user charset */
 445                 if((p = parameter_val(body->parameter,"charset")) != NULL){
 446                     passed = !strucmp(test + 9, p);
 447                     fs_give((void **) &p);
 448                 }
 449                 else
 450                   passed = !strucmp(test + 9, "us-ascii");
 451             }
 452             else
 453               dprint((1,
 454                          "filter trigger: malformed test: %s\n",
 455                          test ? test : "?"));
 456         }
 457     }
 458
 459     return(passed);
 460 }