actions.c

   1 const char actions_rcs[] = "$Id: actions.c,v 1.5 2001/06/03 19:11:48 oes Exp $";
   2 /*********************************************************************
   3  *
   4  * File        :  $Source: /cvsroot/ijbswa/current/actions.c,v $
   5  *
   6  * Purpose     :  Declares functions to work with actions files
   7  *                Functions declared include: FIXME
   8  *
   9  * Copyright   :  Written by and Copyright (C) 2001 the SourceForge
  10  *                IJBSWA team.  http://ijbswa.sourceforge.net
  11  *
  12  *                Based on the Internet Junkbuster originally written
  13  *                by and Copyright (C) 1997 Anonymous Coders and
  14  *                Junkbusters Corporation.  http://www.junkbusters.com
  15  *
  16  *                This program is free software; you can redistribute it
  17  *                and/or modify it under the terms of the GNU General
  18  *                Public License as published by the Free Software
  19  *                Foundation; either version 2 of the License, or (at
  20  *                your option) any later version.
  21  *
  22  *                This program is distributed in the hope that it will
  23  *                be useful, but WITHOUT ANY WARRANTY; without even the
  24  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
  25  *                PARTICULAR PURPOSE.  See the GNU General Public
  26  *                License for more details.
  27  *
  28  *                The GNU General Public License should be included with
  29  *                this file.  If not, you can view it at
  30  *                http://www.gnu.org/copyleft/gpl.html
  31  *                or write to the Free Software Foundation, Inc., 59
  32  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  33  *
  34  * Revisions   :
  35  *    $Log: actions.c,v $
  36  *    Revision 1.5  2001/06/03 19:11:48  oes
  37  *    adapted to new enlist_unique arg format
  38  *
  39  *    Revision 1.5  2001/06/03 11:03:48  oes
  40  *    Makefile/in
  41  *
  42  *    introduced cgi.c
  43  *
  44  *    actions.c:
  45  *
  46  *    adapted to new enlist_unique arg format
  47  *
  48  *    conf loadcfg.c
  49  *
  50  *    introduced confdir option
  51  *
  52  *    filters.c filtrers.h
  53  *
  54  *     extracted-CGI relevant stuff
  55  *
  56  *    jbsockets.c
  57  *
  58  *     filled comment
  59  *
  60  *    jcc.c
  61  *
  62  *     support for new cgi mechansim
  63  *
  64  *    list.c list.h
  65  *
  66  *    functions for new list type: "map"
  67  *    extended enlist_unique
  68  *
  69  *    miscutil.c .h
  70  *    introduced bindup()
  71  *
  72  *    parsers.c parsers.h
  73  *
  74  *    deleted const struct interceptors
  75  *
  76  *    pcrs.c
  77  *    added FIXME
  78  *
  79  *    project.h
  80  *
  81  *    added struct map
  82  *    added struct http_response
  83  *    changes struct interceptors to struct cgi_dispatcher
  84  *    moved HTML stuff to cgi.h
  85  *
  86  *    re_filterfile:
  87  *
  88  *    changed
  89  *
  90  *    showargs.c
  91  *    NO TIME LEFT
  92  *
  93  *    Revision 1.4  2001/06/01 20:03:42  jongfoster
  94  *    Better memory management - current_action->strings[] now
  95  *    contains copies of the strings, not the original.
  96  *
  97  *    Revision 1.3  2001/06/01 18:49:17  jongfoster
  98  *    Replaced "list_share" with "list" - the tiny memory gain was not
  99  *    worth the extra complexity.
 100  *
 101  *    Revision 1.2  2001/05/31 21:40:00  jongfoster
 102  *    Removing some commented out, obsolete blocks of code.
 103  *
 104  *    Revision 1.1  2001/05/31 21:16:46  jongfoster
 105  *    Moved functions to process the action list into this new file.
 106  *
 107  *
 108  *********************************************************************/
 109 \f
 110
 111 #include "config.h"
 112
 113 #include <stdio.h>
 114 #include <string.h>
 115
 116 #include "project.h"
 117 #include "jcc.h"
 118 #include "list.h"
 119 #include "actions.h"
 120 #include "miscutil.h"
 121 #include "errlog.h"
 122 #include "loaders.h"
 123
 124 const char actions_h_rcs[] = ACTIONS_H_VERSION;
 125
 126
 127 /* Turn off everything except forwarding */
 128 /* This structure is used to hold user-defined aliases */
 129 struct action_alias
 130 {
 131    const char * name;
 132    struct action_spec action[1];
 133    struct action_alias * next;
 134 };
 135
 136
 137 /*
 138  * Must declare this in this file for the above structure.
 139  */
 140 static int get_actions (char *line,
 141                         struct action_alias * alias_list,
 142                         struct action_spec *cur_action);
 143
 144 /*
 145  * We need the main list of options.
 146  *
 147  * First, we need a way to tell between boolean, string, and multi-string
 148  * options.  For string and multistring options, we also need to be
 149  * able to tell the difference between a "+" and a "-".  (For bools,
 150  * the "+"/"-" information is encoded in "add" and "mask").  So we use
 151  * an enumerated type (well, the preprocessor equivalent).  Here are
 152  * the values:
 153  */
 154 #define AV_NONE       0 /* +opt -opt */
 155 #define AV_ADD_STRING 1 /* +stropt{string} */
 156 #define AV_REM_STRING 2 /* -stropt */
 157 #define AV_ADD_MULTI  3 /* +multiopt{string} +multiopt{string2} */
 158 #define AV_REM_MULTI  4 /* -multiopt{string} -multiopt{*}       */
 159
 160 /*
 161  * We need a structure to hold the name, flag changes,
 162  * type, and string index.
 163  */
 164 struct action_name
 165 {
 166    const char * name;
 167    unsigned mask;   /* a bit set to "0" = remove action */
 168    unsigned add;    /* a bit set to "1" = add action */
 169    int takes_value; /* an AV_... constant */
 170    int index;       /* index into strings[] or multi[] */
 171 };
 172
 173 /*
 174  * And with those building blocks in place, here's the array.
 175  */
 176 static const struct action_name action_names[] =
 177 {
 178    /*
 179     * Well actually there's no data here - it's in actionlist.h
 180     * This keeps it together to make it easy to change.
 181     *
 182     * Here's the macros used to format it:
 183     */
 184 #define DEFINE_ACTION_MULTI(name,index)                   \
 185    { "+" name, ACTION_MASK_ALL, 0, AV_ADD_MULTI, index }, \
 186    { "-" name, ACTION_MASK_ALL, 0, AV_REM_MULTI, index },
 187 #define DEFINE_ACTION_STRING(name,flag,index)                 \
 188    { "+" name, ACTION_MASK_ALL, flag, AV_ADD_STRING, index }, \
 189    { "-" name, ~flag, 0, AV_REM_STRING, index },
 190 #define DEFINE_ACTION_BOOL(name,flag)   \
 191    { "+" name, ACTION_MASK_ALL, flag }, \
 192    { "-" name, ~flag, 0 },
 193 #define DEFINE_ACTION_ALIAS 1 /* Want aliases please */
 194
 195 #include "actionlist.h"
 196
 197 #undef DEFINE_ACTION_MULTI
 198 #undef DEFINE_ACTION_STRING
 199 #undef DEFINE_ACTION_BOOL
 200 #undef DEFINE_ACTION_ALIAS
 201
 202    { NULL, 0, 0 } /* End marker */
 203 };
 204
 205
 206 /*********************************************************************
 207  *
 208  * Function    :  merge_actions
 209  *
 210  * Description :  Merge two actions together.
 211  *                Similar to "cur_action += new_action".
 212  *
 213  * Parameters  :
 214  *          1  :  cur_action = Current actions, to modify.
 215  *          2  :  new_action = Action to add.
 216  *
 217  * Returns     :  N/A
 218  *
 219  *********************************************************************/
 220 void merge_actions (struct action_spec *dest,
 221                     const struct action_spec *src)
 222 {
 223    int i;
 224
 225    dest->mask &= src->mask;
 226    dest->add  &= src->mask;
 227    dest->add  |= src->add;
 228
 229    for (i = 0; i < ACTION_STRING_COUNT; i++)
 230    {
 231       char * str = src->string[i];
 232       if (str)
 233       {
 234          freez(dest->string[i]);
 235          dest->string[i] = strdup(str);
 236       }
 237    }
 238
 239    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 240    {
 241       if (src->multi_remove_all[i])
 242       {
 243          /* Remove everything from dest */
 244          destroy_list(dest->multi_remove[i]);
 245          destroy_list(dest->multi_add[i]);
 246          dest->multi_remove_all[i] = 1;
 247          list_duplicate(dest->multi_add[i], src->multi_add[i]);
 248       }
 249       else if (dest->multi_remove_all[i])
 250       {
 251          /*
 252           * dest already removes everything, so we only need to worry
 253           * about what we add.
 254           */
 255          list_remove_list(dest->multi_add[i], src->multi_remove[i]);
 256          list_append_list_unique(dest->multi_add[i], src->multi_add[i]);
 257       }
 258       else
 259       {
 260          /* No "remove all"s to worry about. */
 261          list_remove_list(dest->multi_add[i], src->multi_remove[i]);
 262          list_append_list_unique(dest->multi_remove[i], src->multi_remove[i]);
 263          list_append_list_unique(dest->multi_add[i], src->multi_add[i]);
 264       }
 265    }
 266 }
 267
 268
 269 /*********************************************************************
 270  *
 271  * Function    :  copy_action
 272  *
 273  * Description :  Copy an action_specs.
 274  *                Similar to "cur_action = new_action".
 275  *
 276  * Parameters  :
 277  *          1  :  dest = Destination of copy.
 278  *          2  :  src = Source for copy.
 279  *
 280  * Returns     :  N/A
 281  *
 282  *********************************************************************/
 283 void copy_action (struct action_spec *dest,
 284                   const struct action_spec *src)
 285 {
 286    int i;
 287
 288    dest->mask = src->mask;
 289    dest->add  = src->add;
 290
 291    for (i = 0; i < ACTION_STRING_COUNT; i++)
 292    {
 293       char * str = src->string[i];
 294       dest->string[i] = (str ? strdup(str) : NULL);
 295    }
 296
 297    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 298    {
 299       dest->multi_remove_all[i] = src->multi_remove_all[i];
 300       list_duplicate(dest->multi_remove[i], src->multi_remove[i]);
 301       list_duplicate(dest->multi_add[i],    src->multi_add[i]);
 302    }
 303 }
 304
 305
 306 /*********************************************************************
 307  *
 308  * Function    :  free_action
 309  *
 310  * Description :  Free an action_specs.
 311  *
 312  * Parameters  :
 313  *          1  :  src = Source to free.
 314  *
 315  * Returns     :  N/A
 316  *
 317  *********************************************************************/
 318 void free_action (struct action_spec *src)
 319 {
 320    int i;
 321
 322    for (i = 0; i < ACTION_STRING_COUNT; i++)
 323    {
 324       freez(src->string[i]);
 325    }
 326
 327    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 328    {
 329       destroy_list(src->multi_remove[i]);
 330       destroy_list(src->multi_add[i]);
 331    }
 332
 333    memset(src, '\0', sizeof(*src));
 334 }
 335
 336
 337 /*********************************************************************
 338  *
 339  * Function    :  get_action_token
 340  *
 341  * Description :  Parses a line for the first action.
 342  *                Modifies it's input array, doesn't allocate memory.
 343  *                e.g. given:
 344  *                *line="  +abc{def}  -ghi "
 345  *                Returns:
 346  *                *line="  -ghi "
 347  *                *name="+abc"
 348  *                *value="def"
 349  *
 350  * Parameters  :
 351  *          1  :  line = [in] The line containing the action.
 352  *                       [out] Start of next action on line, or
 353  *                       NULL if we reached the end of line before
 354  *                       we found an action.
 355  *          2  :  name = [out] Start of action name, null
 356  *                       terminated.  NULL on EOL
 357  *          3  :  value = [out] Start of action value, null
 358  *                        terminated.  NULL if none or EOL.
 359  *
 360  * Returns     :  0 => Ok
 361  *                nonzero => Mismatched {} (line was trashed anyway)
 362  *
 363  *********************************************************************/
 364 int get_action_token(char **line, char **name, char **value)
 365 {
 366    char * str = *line;
 367    char ch;
 368
 369    /* set default returns */
 370    *line = NULL;
 371    *name = NULL;
 372    *value = NULL;
 373
 374    /* Eat any leading whitespace */
 375    while ((*str == ' ') || (*str == '\t'))
 376    {
 377       str++;
 378    }
 379
 380    if (*str == '\0')
 381    {
 382       return 0;
 383    }
 384
 385    if (*str == '{')
 386    {
 387       /* null name, just value is prohibited */
 388       return 1;
 389    }
 390
 391    *name = str;
 392
 393    /* parse option */
 394    while (((ch = *str) != '\0') &&
 395           (ch != ' ') && (ch != '\t') && (ch != '{'))
 396    {
 397       if (ch == '}')
 398       {
 399          /* error */
 400          return 1;
 401       }
 402       str++;
 403    }
 404    *str = '\0';
 405
 406    if (ch != '{')
 407    {
 408       /* no value */
 409       if (ch == '\0')
 410       {
 411          /* EOL - be careful not to run off buffer */
 412          *line = str;
 413       }
 414       else
 415       {
 416          /* More to parse next time. */
 417          *line = str + 1;
 418       }
 419       return 0;
 420    }
 421
 422    str++;
 423    *value = str;
 424
 425    str = strchr(str, '}');
 426    if (str == NULL)
 427    {
 428       /* error */
 429       *value = NULL;
 430       return 1;
 431    }
 432
 433    /* got value */
 434    *str = '\0';
 435    *line = str + 1;
 436
 437    chomp(*value);
 438
 439    return 0;
 440 }
 441
 442
 443 /*********************************************************************
 444  *
 445  * Function    :  get_actions
 446  *
 447  * Description :  Parses a list of actions.
 448  *
 449  * Parameters  :
 450  *          1  :  line = The string containing the actions.
 451  *                       Will be written to by this function.
 452  *          2  :  aliases = Custom alias list, or NULL for none.
 453  *          3  :  cur_action = Where to store the action.  Caller
 454  *                             allocates memory.
 455  *
 456  * Returns     :  0 => Ok
 457  *                nonzero => Error (line was trashed anyway)
 458  *
 459  *********************************************************************/
 460 static int get_actions(char *line,
 461                        struct action_alias * alias_list,
 462                        struct action_spec *cur_action)
 463 {
 464    memset(cur_action, '\0', sizeof(*cur_action));
 465    cur_action->mask = ACTION_MASK_ALL;
 466
 467    while (line)
 468    {
 469       char * option = NULL;
 470       char * value = NULL;
 471
 472       if (get_action_token(&line, &option, &value))
 473       {
 474          return 1;
 475       }
 476
 477       if (option)
 478       {
 479          /* handle option in 'option' */
 480
 481          /* Check for standard action name */
 482          const struct action_name * action = action_names;
 483
 484          while ( (action->name != NULL) && (0 != strcmpic(action->name, option)) )
 485          {
 486             action++;
 487          }
 488          if (action->name != NULL)
 489          {
 490             /* Found it */
 491             cur_action->mask &= action->mask;
 492             cur_action->add  &= action->mask;
 493             cur_action->add  |= action->add;
 494
 495             switch (action->takes_value)
 496             {
 497             case AV_NONE:
 498                /* ignore any option. */
 499                break;
 500             case AV_ADD_STRING:
 501                {
 502                   /* add single string. */
 503
 504                   if ((value == NULL) || (*value == '\0'))
 505                   {
 506                      return 1;
 507                   }
 508                   /* FIXME: should validate option string here */
 509                   freez (cur_action->string[action->index]);
 510                   cur_action->string[action->index] = strdup(value);
 511                   break;
 512                }
 513             case AV_REM_STRING:
 514                {
 515                   /* remove single string. */
 516
 517                   freez (cur_action->string[action->index]);
 518                   break;
 519                }
 520             case AV_ADD_MULTI:
 521                {
 522                   /* append multi string. */
 523
 524                   struct list * remove = cur_action->multi_remove[action->index];
 525                   struct list * add    = cur_action->multi_add[action->index];
 526
 527                   if ((value == NULL) || (*value == '\0'))
 528                   {
 529                      return 1;
 530                   }
 531
 532                   list_remove_item(remove, value);
 533                   enlist_unique(add, value, 0);
 534                   break;
 535                }
 536             case AV_REM_MULTI:
 537                {
 538                   /* remove multi string. */
 539
 540                   struct list * remove = cur_action->multi_remove[action->index];
 541                   struct list * add    = cur_action->multi_add[action->index];
 542
 543                   if ( (value == NULL) || (*value == '\0')
 544                      || ((*value == '*') && (value[1] == '\0')) )
 545                   {
 546                      /*
 547                       * no option, or option == "*".
 548                       *
 549                       * Remove *ALL*.
 550                       */
 551                      destroy_list(remove);
 552                      destroy_list(add);
 553                      cur_action->multi_remove_all[action->index] = 1;
 554                   }
 555                   else
 556                   {
 557                      /* Valid option - remove only 1 option */
 558
 559                      if ( !cur_action->multi_remove_all[action->index] )
 560                      {
 561                         /* there isn't a catch-all in the remove list already */
 562                         enlist_unique(remove, value, 0);
 563                      }
 564                      list_remove_item(add, value);
 565                   }
 566                   break;
 567                }
 568             default:
 569                /* Shouldn't get here unless there's memory corruption. */
 570                return 1;
 571             }
 572          }
 573          else
 574          {
 575             /* try user aliases. */
 576             const struct action_alias * alias = alias_list;
 577
 578             while ( (alias != NULL) && (0 != strcmpic(alias->name, option)) )
 579             {
 580                alias = alias->next;
 581             }
 582             if (alias != NULL)
 583             {
 584                /* Found it */
 585                merge_actions(cur_action, alias->action);
 586             }
 587             else
 588             {
 589                /* Bad action name */
 590                return 1;
 591             }
 592          }
 593       }
 594    }
 595
 596    return 0;
 597 }
 598
 599
 600 /*********************************************************************
 601  *
 602  * Function    :  actions_to_text
 603  *
 604  * Description :  Converts a actionsfile entry from numeric form
 605  *                ("mask" and "add") to text.
 606  *
 607  * Parameters  :
 608  *          1  :  mask = As from struct url_actions
 609  *          2  :  add  = As from struct url_actions
 610  *
 611  * Returns     :  A string.  Caller must free it.
 612  *
 613  *********************************************************************/
 614 char * actions_to_text(struct action_spec *action)
 615 {
 616    unsigned mask = action->mask;
 617    unsigned add  = action->add;
 618    char * result = strdup("");
 619    struct list * lst;
 620
 621    /* sanity - prevents "-feature +feature" */
 622    mask |= add;
 623
 624
 625 #define DEFINE_ACTION_BOOL(__name, __bit)   \
 626    if (!(mask & __bit))                     \
 627    {                                        \
 628       result = strsav(result, " -" __name); \
 629    }                                        \
 630    else if (add & __bit)                    \
 631    {                                        \
 632       result = strsav(result, " +" __name); \
 633    }
 634
 635 #define DEFINE_ACTION_STRING(__name, __bit, __index) \
 636    if (!(mask & __bit))                     \
 637    {                                        \
 638       result = strsav(result, " -" __name); \
 639    }                                        \
 640    else if (add & __bit)                    \
 641    {                                        \
 642       result = strsav(result, " +" __name "{"); \
 643       result = strsav(result, action->string[__index]); \
 644       result = strsav(result, "}"); \
 645    }
 646
 647 #define DEFINE_ACTION_MULTI(__name, __index)         \
 648    if (action->multi_remove_all[__index])            \
 649    {                                                 \
 650       result = strsav(result, " -" __name "{*}");    \
 651    }                                                 \
 652    else                                              \
 653    {                                                 \
 654       lst = action->multi_remove[__index]->next;     \
 655       while (lst)                                    \
 656       {                                              \
 657          result = strsav(result, " -" __name "{");   \
 658          result = strsav(result, lst->str);          \
 659          result = strsav(result, "}");               \
 660          lst = lst->next;                            \
 661       }                                              \
 662    }                                                 \
 663    lst = action->multi_add[__index]->next;           \
 664    while (lst)                                       \
 665    {                                                 \
 666       result = strsav(result, " +" __name "{");      \
 667       result = strsav(result, lst->str);             \
 668       result = strsav(result, "}");                  \
 669       lst = lst->next;                               \
 670    }
 671
 672 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
 673
 674 #include "actionlist.h"
 675
 676 #undef DEFINE_ACTION_MULTI
 677 #undef DEFINE_ACTION_STRING
 678 #undef DEFINE_ACTION_BOOL
 679 #undef DEFINE_ACTION_ALIAS
 680
 681    return result;
 682 }
 683
 684
 685 /*********************************************************************
 686  *
 687  * Function    :  current_actions_to_text
 688  *
 689  * Description :  Converts a actionsfile entry to text.
 690  *
 691  * Parameters  :
 692  *          1  :  action = Action
 693  *
 694  * Returns     :  A string.  Caller must free it.
 695  *
 696  *********************************************************************/
 697 char * current_action_to_text(struct current_action_spec *action)
 698 {
 699    unsigned flags  = action->flags;
 700    char * result = strdup("");
 701    struct list * lst;
 702
 703 #define DEFINE_ACTION_BOOL(__name, __bit)   \
 704    if (flags & __bit)                       \
 705    {                                        \
 706       result = strsav(result, " +" __name); \
 707    }                                        \
 708    else                                     \
 709    {                                        \
 710       result = strsav(result, " -" __name); \
 711    }
 712
 713 #define DEFINE_ACTION_STRING(__name, __bit, __index)    \
 714    if (flags & __bit)                                   \
 715    {                                                    \
 716       result = strsav(result, " +" __name "{");         \
 717       result = strsav(result, action->string[__index]); \
 718       result = strsav(result, "}");                     \
 719    }                                                    \
 720    else                                                 \
 721    {                                                    \
 722       result = strsav(result, " -" __name);             \
 723    }
 724
 725 #define DEFINE_ACTION_MULTI(__name, __index)            \
 726    lst = action->multi[__index]->next;                  \
 727    if (lst == NULL)                                     \
 728    {                                                    \
 729       result = strsav(result, " -" __name);             \
 730    }                                                    \
 731    else                                                 \
 732    {                                                    \
 733       while (lst)                                       \
 734       {                                                 \
 735          result = strsav(result, " +" __name "{");      \
 736          result = strsav(result, lst->str);             \
 737          result = strsav(result, "}");                  \
 738          lst = lst->next;                               \
 739       }                                                 \
 740    }
 741
 742 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
 743
 744 #include "actionlist.h"
 745
 746 #undef DEFINE_ACTION_MULTI
 747 #undef DEFINE_ACTION_STRING
 748 #undef DEFINE_ACTION_BOOL
 749 #undef DEFINE_ACTION_ALIAS
 750
 751    return result;
 752 }
 753
 754
 755 /*********************************************************************
 756  *
 757  * Function    :  init_current_action
 758  *
 759  * Description :  Zero out an action.
 760  *
 761  * Parameters  :
 762  *          1  :  dest = An uninitialized current_action_spec.
 763  *
 764  * Returns     :  N/A
 765  *
 766  *********************************************************************/
 767 void init_current_action (struct current_action_spec *dest)
 768 {
 769    memset(dest, '\0', sizeof(*dest));
 770    dest->flags = ACTION_MOST_COMPATIBLE;
 771 }
 772
 773
 774 /*********************************************************************
 775  *
 776  * Function    :  merge_current_action
 777  *
 778  * Description :  Merge two actions together.
 779  *                Similar to "dest += src".
 780  *                Differences between this and merge_actions()
 781  *                is that this one doesn't allocate memory for
 782  *                strings (so "src" better be in memory for at least
 783  *                as long as "dest" is, and you'd better free
 784  *                "dest" using "current_free_action").
 785  *                Also, there is no  mask or remove lists in dest.
 786  *                (If we're applying it to a URL, we don't need them)
 787  *
 788  * Parameters  :
 789  *          1  :  dest = Current actions, to modify.
 790  *          2  :  src = Action to add.
 791  *
 792  * Returns     :  N/A
 793  *
 794  *********************************************************************/
 795 void merge_current_action (struct current_action_spec *dest,
 796                            const struct action_spec *src)
 797 {
 798    int i;
 799
 800    dest->flags  &= src->mask;
 801    dest->flags  |= src->add;
 802
 803    for (i = 0; i < ACTION_STRING_COUNT; i++)
 804    {
 805       char * str = src->string[i];
 806       if (str)
 807       {
 808          freez(dest->string[i]);
 809          dest->string[i] = strdup(str);
 810       }
 811    }
 812
 813    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 814    {
 815       if (src->multi_remove_all[i])
 816       {
 817          /* Remove everything from dest */
 818          destroy_list(dest->multi[i]);
 819          list_duplicate(dest->multi[i], src->multi_add[i]);
 820       }
 821       else
 822       {
 823          list_remove_list(dest->multi[i], src->multi_remove[i]);
 824          list_append_list_unique(dest->multi[i], src->multi_add[i]);
 825       }
 826    }
 827 }
 828
 829
 830 /*********************************************************************
 831  *
 832  * Function    :  free_current_action
 833  *
 834  * Description :  Free a current_action_spec.
 835  *
 836  * Parameters  :
 837  *          1  :  src = Source to free.
 838  *
 839  * Returns     :  N/A
 840  *
 841  *********************************************************************/
 842 void free_current_action (struct current_action_spec *src)
 843 {
 844    int i;
 845
 846    for (i = 0; i < ACTION_STRING_COUNT; i++)
 847    {
 848       freez(src->string[i]);
 849    }
 850
 851    for (i = 0; i < ACTION_MULTI_COUNT; i++)
 852    {
 853       destroy_list(src->multi[i]);
 854    }
 855
 856    memset(src, '\0', sizeof(*src));
 857 }
 858
 859
 860 /*********************************************************************
 861  *
 862  * Function    :  unload_actions_file
 863  *
 864  * Description :  Unloads an actions module.
 865  *
 866  * Parameters  :
 867  *          1  :  file_data = the data structure associated with the
 868  *                            actions file.
 869  *
 870  * Returns     :  N/A
 871  *
 872  *********************************************************************/
 873 void unload_actions_file(void *file_data)
 874 {
 875    struct url_actions * next;
 876    struct url_actions * cur = (struct url_actions *)file_data;
 877    while (cur != NULL)
 878    {
 879       next = cur->next;
 880       free_url(cur->url);
 881       freez(cur);
 882       cur = next;
 883    }
 884
 885 }
 886
 887
 888 /*********************************************************************
 889  *
 890  * Function    :  load_actions_file
 891  *
 892  * Description :  Read and parse a action file and add to files
 893  *                list.
 894  *
 895  * Parameters  :
 896  *          1  :  csp = Current client state (buffers, headers, etc...)
 897  *
 898  * Returns     :  0 => Ok, everything else is an error.
 899  *
 900  *********************************************************************/
 901 int load_actions_file(struct client_state *csp)
 902 {
 903    static struct file_list *current_actions_file  = NULL;
 904
 905    FILE *fp;
 906
 907    struct url_actions *last_perm;
 908    struct url_actions *perm;
 909    char  buf[BUFSIZ];
 910    struct file_list *fs;
 911 #define MODE_START_OF_FILE 1
 912 #define MODE_ACTIONS       2
 913 #define MODE_ALIAS         3
 914    int mode = MODE_START_OF_FILE;
 915    struct action_spec cur_action[1];
 916    struct action_alias * alias_list = NULL;
 917
 918    memset(cur_action, '\0', sizeof(*cur_action));
 919
 920    if (!check_file_changed(current_actions_file, csp->config->actions_file, &fs))
 921    {
 922       /* No need to load */
 923       if (csp)
 924       {
 925          csp->actions_list = current_actions_file;
 926       }
 927       return 0;
 928    }
 929    if (!fs)
 930    {
 931       log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': error finding file: %E",
 932                 csp->config->actions_file);
 933       return 1; /* never get here */
 934    }
 935
 936    fs->f = last_perm = (struct url_actions *)zalloc(sizeof(*last_perm));
 937    if (last_perm == NULL)
 938    {
 939       log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': out of memory!",
 940                 csp->config->actions_file);
 941       return 1; /* never get here */
 942    }
 943
 944    if ((fp = fopen(csp->config->actions_file, "r")) == NULL)
 945    {
 946       log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': error opening file: %E",
 947                 csp->config->actions_file);
 948       return 1; /* never get here */
 949    }
 950
 951    while (read_config_line(buf, sizeof(buf), fp, fs) != NULL)
 952    {
 953       if (*buf == '{')
 954       {
 955          /* It's a header block */
 956          if (buf[1] == '{')
 957          {
 958             /* It's {{settings}} or {{alias}} */
 959             int len = strlen(buf);
 960             char * start = buf + 2;
 961             char * end = buf + len - 1;
 962             if ((len < 5) || (*end-- != '}') || (*end-- != '}'))
 963             {
 964                /* too short */
 965                fclose(fp);
 966                log_error(LOG_LEVEL_FATAL,
 967                   "can't load actions file '%s': invalid line: %s",
 968                   csp->config->actions_file, buf);
 969                return 1; /* never get here */
 970             }
 971
 972             /* Trim leading and trailing whitespace. */
 973             end[1] = '\0';
 974             chomp(start);
 975
 976             if (*start == '\0')
 977             {
 978                /* too short */
 979                fclose(fp);
 980                log_error(LOG_LEVEL_FATAL,
 981                   "can't load actions file '%s': invalid line: {{ }}",
 982                   csp->config->actions_file);
 983                return 1; /* never get here */
 984             }
 985
 986             if (0 == strcmpic(start, "alias"))
 987             {
 988                /* it's an {{alias}} block */
 989
 990                mode = MODE_ALIAS;
 991             }
 992             else
 993             {
 994                /* invalid {{something}} block */
 995                fclose(fp);
 996                log_error(LOG_LEVEL_FATAL,
 997                   "can't load actions file '%s': invalid line: {{%s}}",
 998                   csp->config->actions_file, start);
 999                return 1; /* never get here */
1000             }
1001          }
1002          else
1003          {
1004             /* It's an actions block */
1005
1006             char  actions_buf[BUFSIZ];
1007             char * end;
1008
1009             /* set mode */
1010             mode    = MODE_ACTIONS;
1011
1012             /* free old action */
1013             free_action(cur_action);
1014
1015             /* trim { */
1016             strcpy(actions_buf, buf + 1);
1017
1018             /* check we have a trailing } and then trim it */
1019             end = actions_buf + strlen(actions_buf) - 1;
1020             if (*end != '}')
1021             {
1022                /* too short */
1023                fclose(fp);
1024                log_error(LOG_LEVEL_FATAL,
1025                   "can't load actions file '%s': invalid line: %s",
1026                   csp->config->actions_file, buf);
1027                return 1; /* never get here */
1028             }
1029             *end = '\0';
1030
1031             /* trim any whitespace immediately inside {} */
1032             chomp(actions_buf);
1033
1034             if (*actions_buf == '\0')
1035             {
1036                /* too short */
1037                fclose(fp);
1038                log_error(LOG_LEVEL_FATAL,
1039                   "can't load actions file '%s': invalid line: %s",
1040                   csp->config->actions_file, buf);
1041                return 1; /* never get here */
1042             }
1043
1044             if (get_actions(actions_buf, alias_list, cur_action))
1045             {
1046                /* error */
1047                fclose(fp);
1048                log_error(LOG_LEVEL_FATAL,
1049                   "can't load actions file '%s': invalid line: %s",
1050                   csp->config->actions_file, buf);
1051                return 1; /* never get here */
1052             }
1053          }
1054       }
1055       else if (mode == MODE_ALIAS)
1056       {
1057          /* define an alias */
1058          char  actions_buf[BUFSIZ];
1059          struct action_alias * new_alias;
1060          int more = 1;
1061
1062          char * start = strchr(buf, '=');
1063          char * end = start;
1064
1065          if ((start == NULL) || (start == buf))
1066          {
1067             log_error(LOG_LEVEL_FATAL,
1068                "can't load actions file '%s': invalid alias line: %s",
1069                csp->config->actions_file, buf);
1070             return 1; /* never get here */
1071          }
1072
1073          if ((new_alias = zalloc(sizeof(*new_alias))) == NULL)
1074          {
1075             fclose(fp);
1076             log_error(LOG_LEVEL_FATAL,
1077                "can't load actions file '%s': out of memory!",
1078                csp->config->actions_file);
1079             return 1; /* never get here */
1080          }
1081
1082          /* Eat any the whitespace before the '=' */
1083          end--;
1084          while ((*end == ' ') || (*end == '\t'))
1085          {
1086             /*
1087              * we already know we must have at least 1 non-ws char
1088              * at start of buf - no need to check
1089              */
1090             end--;
1091          }
1092          end[1] = '\0';
1093
1094          /* Eat any the whitespace after the '=' */
1095          start++;
1096          while ((*start == ' ') || (*start == '\t'))
1097          {
1098             start++;
1099          }
1100          if (*start == '\0')
1101          {
1102             log_error(LOG_LEVEL_FATAL,
1103                "can't load actions file '%s': invalid alias line: %s",
1104                csp->config->actions_file, buf);
1105             return 1; /* never get here */
1106          }
1107
1108          new_alias->name = strdup(buf);
1109
1110          strcpy(actions_buf, start);
1111
1112          if (get_actions(actions_buf, alias_list, new_alias->action))
1113          {
1114             /* error */
1115             fclose(fp);
1116             log_error(LOG_LEVEL_FATAL,
1117                "can't load actions file '%s': invalid alias line: %s = %s",
1118                csp->config->actions_file, buf, start);
1119             return 1; /* never get here */
1120          }
1121
1122          /* add to list */
1123          new_alias->next = alias_list;
1124          alias_list = new_alias;
1125       }
1126       else if (mode == MODE_ACTIONS)
1127       {
1128          /* it's a URL pattern */
1129
1130          /* allocate a new node */
1131          if ((perm = zalloc(sizeof(*perm))) == NULL)
1132          {
1133             fclose(fp);
1134             log_error(LOG_LEVEL_FATAL,
1135                "can't load actions file '%s': out of memory!",
1136                csp->config->actions_file);
1137             return 1; /* never get here */
1138          }
1139
1140          /* Save flags */
1141          copy_action (perm->action, cur_action);
1142
1143          /* Save the URL pattern */
1144          if (create_url_spec(perm->url, buf))
1145          {
1146             fclose(fp);
1147             log_error(LOG_LEVEL_FATAL,
1148                "can't load actions file '%s': cannot create URL pattern from: %s",
1149                csp->config->actions_file, buf);
1150             return 1; /* never get here */
1151          }
1152
1153          /* add it to the list */
1154          last_perm->next = perm;
1155          last_perm = perm;
1156       }
1157       else if (mode == MODE_START_OF_FILE)
1158       {
1159          /* oops - please have a {} line as 1st line in file. */
1160          fclose(fp);
1161          log_error(LOG_LEVEL_FATAL,
1162             "can't load actions file '%s': first line is invalid: %s",
1163             csp->config->actions_file, buf);
1164          return 1; /* never get here */
1165       }
1166       else
1167       {
1168          /* How did we get here? This is impossible! */
1169          fclose(fp);
1170          log_error(LOG_LEVEL_FATAL,
1171             "can't load actions file '%s': INTERNAL ERROR - mode = %d",
1172             csp->config->actions_file, mode);
1173          return 1; /* never get here */
1174       }
1175    }
1176
1177    fclose(fp);
1178
1179    free_action(cur_action);
1180
1181    while (alias_list != NULL)
1182    {
1183       struct action_alias * next = alias_list->next;
1184       freez((char *)alias_list->name);
1185       free_action(alias_list->action);
1186       free(alias_list);
1187       alias_list = next;
1188    }
1189
1190 #ifndef SPLIT_PROXY_ARGS
1191    if (!suppress_blocklists)
1192    {
1193       fs->proxy_args = strsav(fs->proxy_args, "</pre>");
1194    }
1195 #endif /* ndef SPLIT_PROXY_ARGS */
1196
1197    /* the old one is now obsolete */
1198    if (current_actions_file)
1199    {
1200       current_actions_file->unloader = unload_actions_file;
1201    }
1202
1203    fs->next    = files->next;
1204    files->next = fs;
1205    current_actions_file = fs;
1206
1207    if (csp)
1208    {
1209       csp->actions_list = fs;
1210    }
1211
1212    return(0);
1213
1214 }