1 const char actions_rcs[] = "$Id: actions.c,v 1.71 2011/09/04 11:10:56 fabiankeil Exp $";
2 /*********************************************************************
4 * File : $Source: /cvsroot/ijbswa/current/actions.c,v $
6 * Purpose : Declares functions to work with actions files
7 * Functions declared include: FIXME
9 * Copyright : Written by and Copyright (C) 2001-2011 the
10 * Privoxy team. http://www.privoxy.org/
12 * Based on the Internet Junkbuster originally written
13 * by and Copyright (C) 1997 Anonymous Coders and
14 * Junkbusters Corporation. http://www.junkbusters.com
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.
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.
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.
34 *********************************************************************/
44 #ifdef FEATURE_PTHREAD
60 const char actions_h_rcs[] = ACTIONS_H_VERSION;
64 * We need the main list of options.
66 * First, we need a way to tell between boolean, string, and multi-string
67 * options. For string and multistring options, we also need to be
68 * able to tell the difference between a "+" and a "-". (For bools,
69 * the "+"/"-" information is encoded in "add" and "mask"). So we use
70 * an enumerated type (well, the preprocessor equivalent). Here are
73 #define AV_NONE 0 /* +opt -opt */
74 #define AV_ADD_STRING 1 /* +stropt{string} */
75 #define AV_REM_STRING 2 /* -stropt */
76 #define AV_ADD_MULTI 3 /* +multiopt{string} +multiopt{string2} */
77 #define AV_REM_MULTI 4 /* -multiopt{string} -multiopt */
80 * We need a structure to hold the name, flag changes,
81 * type, and string index.
86 unsigned long mask; /* a bit set to "0" = remove action */
87 unsigned long add; /* a bit set to "1" = add action */
88 int takes_value; /* an AV_... constant */
89 int index; /* index into strings[] or multi[] */
93 * And with those building blocks in place, here's the array.
95 static const struct action_name action_names[] =
98 * Well actually there's no data here - it's in actionlist.h
99 * This keeps it together to make it easy to change.
101 * Here's the macros used to format it:
103 #define DEFINE_ACTION_MULTI(name,index) \
104 { "+" name, ACTION_MASK_ALL, 0, AV_ADD_MULTI, index }, \
105 { "-" name, ACTION_MASK_ALL, 0, AV_REM_MULTI, index },
106 #define DEFINE_ACTION_STRING(name,flag,index) \
107 { "+" name, ACTION_MASK_ALL, flag, AV_ADD_STRING, index }, \
108 { "-" name, ~flag, 0, AV_REM_STRING, index },
109 #define DEFINE_ACTION_BOOL(name,flag) \
110 { "+" name, ACTION_MASK_ALL, flag }, \
111 { "-" name, ~flag, 0 },
112 #define DEFINE_ACTION_ALIAS 1 /* Want aliases please */
114 #include "actionlist.h"
116 #undef DEFINE_ACTION_MULTI
117 #undef DEFINE_ACTION_STRING
118 #undef DEFINE_ACTION_BOOL
119 #undef DEFINE_ACTION_ALIAS
121 { NULL, 0, 0 } /* End marker */
125 static int load_one_actions_file(struct client_state *csp, int fileid);
128 /*********************************************************************
130 * Function : merge_actions
132 * Description : Merge two actions together.
133 * Similar to "dest += src".
136 * 1 : dest = Actions to modify.
137 * 2 : src = Action to add.
139 * Returns : JB_ERR_OK or JB_ERR_MEMORY
141 *********************************************************************/
142 jb_err merge_actions (struct action_spec *dest,
143 const struct action_spec *src)
148 dest->mask &= src->mask;
149 dest->add &= src->mask;
150 dest->add |= src->add;
152 for (i = 0; i < ACTION_STRING_COUNT; i++)
154 char * str = src->string[i];
157 freez(dest->string[i]);
158 dest->string[i] = strdup(str);
159 if (NULL == dest->string[i])
161 return JB_ERR_MEMORY;
166 for (i = 0; i < ACTION_MULTI_COUNT; i++)
168 if (src->multi_remove_all[i])
170 /* Remove everything from dest */
171 list_remove_all(dest->multi_remove[i]);
172 dest->multi_remove_all[i] = 1;
174 err = list_duplicate(dest->multi_add[i], src->multi_add[i]);
176 else if (dest->multi_remove_all[i])
179 * dest already removes everything, so we only need to worry
182 list_remove_list(dest->multi_add[i], src->multi_remove[i]);
183 err = list_append_list_unique(dest->multi_add[i], src->multi_add[i]);
187 /* No "remove all"s to worry about. */
188 list_remove_list(dest->multi_add[i], src->multi_remove[i]);
189 err = list_append_list_unique(dest->multi_remove[i], src->multi_remove[i]);
190 if (!err) err = list_append_list_unique(dest->multi_add[i], src->multi_add[i]);
203 /*********************************************************************
205 * Function : copy_action
207 * Description : Copy an action_specs.
208 * Similar to "dest = src".
211 * 1 : dest = Destination of copy.
212 * 2 : src = Source for copy.
216 *********************************************************************/
217 jb_err copy_action (struct action_spec *dest,
218 const struct action_spec *src)
221 jb_err err = JB_ERR_OK;
224 memset(dest, '\0', sizeof(*dest));
226 dest->mask = src->mask;
227 dest->add = src->add;
229 for (i = 0; i < ACTION_STRING_COUNT; i++)
231 char * str = src->string[i];
237 return JB_ERR_MEMORY;
239 dest->string[i] = str;
243 for (i = 0; i < ACTION_MULTI_COUNT; i++)
245 dest->multi_remove_all[i] = src->multi_remove_all[i];
246 err = list_duplicate(dest->multi_remove[i], src->multi_remove[i]);
251 err = list_duplicate(dest->multi_add[i], src->multi_add[i]);
260 /*********************************************************************
262 * Function : free_action_spec
264 * Description : Frees an action_spec and the memory used by it.
267 * 1 : src = Source to free.
271 *********************************************************************/
272 void free_action_spec(struct action_spec *src)
279 /*********************************************************************
281 * Function : free_action
283 * Description : Destroy an action_spec. Frees memory used by it,
284 * except for the memory used by the struct action_spec
288 * 1 : src = Source to free.
292 *********************************************************************/
293 void free_action (struct action_spec *src)
302 for (i = 0; i < ACTION_STRING_COUNT; i++)
304 freez(src->string[i]);
307 for (i = 0; i < ACTION_MULTI_COUNT; i++)
309 destroy_list(src->multi_remove[i]);
310 destroy_list(src->multi_add[i]);
313 memset(src, '\0', sizeof(*src));
317 /*********************************************************************
319 * Function : get_action_token
321 * Description : Parses a line for the first action.
322 * Modifies it's input array, doesn't allocate memory.
324 * *line=" +abc{def} -ghi "
331 * 1 : line = [in] The line containing the action.
332 * [out] Start of next action on line, or
333 * NULL if we reached the end of line before
334 * we found an action.
335 * 2 : name = [out] Start of action name, null
336 * terminated. NULL on EOL
337 * 3 : value = [out] Start of action value, null
338 * terminated. NULL if none or EOL.
340 * Returns : JB_ERR_OK => Ok
341 * JB_ERR_PARSE => Mismatched {} (line was trashed anyway)
343 *********************************************************************/
344 jb_err get_action_token(char **line, char **name, char **value)
349 /* set default returns */
354 /* Eat any leading whitespace */
355 while ((*str == ' ') || (*str == '\t'))
367 /* null name, just value is prohibited */
374 while (((ch = *str) != '\0') &&
375 (ch != ' ') && (ch != '\t') && (ch != '{'))
379 /* error, '}' without '{' */
391 /* EOL - be careful not to run off buffer */
396 /* More to parse next time. */
405 str = strchr(str, '}');
422 /*********************************************************************
424 * Function : action_used_to_be_valid
426 * Description : Checks if unrecognized actions were valid in earlier
430 * 1 : action = The string containing the action to check.
432 * Returns : True if yes, otherwise false.
434 *********************************************************************/
435 static int action_used_to_be_valid(const char *action)
437 static const char * const formerly_valid_actions[] = {
440 "send-vanilla-wafer",
442 "treat-forbidden-connects-like-blocks",
448 for (i = 0; i < SZ(formerly_valid_actions); i++)
450 if (0 == strcmpic(action, formerly_valid_actions[i]))
459 /*********************************************************************
461 * Function : get_actions
463 * Description : Parses a list of actions.
466 * 1 : line = The string containing the actions.
467 * Will be written to by this function.
468 * 2 : alias_list = Custom alias list, or NULL for none.
469 * 3 : cur_action = Where to store the action. Caller
472 * Returns : JB_ERR_OK => Ok
473 * JB_ERR_PARSE => Parse error (line was trashed anyway)
474 * nonzero => Out of memory (line was trashed anyway)
476 *********************************************************************/
477 jb_err get_actions(char *line,
478 struct action_alias * alias_list,
479 struct action_spec *cur_action)
482 init_action(cur_action);
483 cur_action->mask = ACTION_MASK_ALL;
487 char * option = NULL;
490 err = get_action_token(&line, &option, &value);
498 /* handle option in 'option' */
500 /* Check for standard action name */
501 const struct action_name * action = action_names;
503 while ( (action->name != NULL) && (0 != strcmpic(action->name, option)) )
507 if (action->name != NULL)
510 cur_action->mask &= action->mask;
511 cur_action->add &= action->mask;
512 cur_action->add |= action->add;
514 switch (action->takes_value)
517 /* ignore any option. */
521 /* add single string. */
523 if ((value == NULL) || (*value == '\0'))
525 if (0 == strcmpic(action->name, "+block"))
528 * XXX: Temporary backwards compatibility hack.
529 * XXX: should include line number.
531 value = "No reason specified.";
532 log_error(LOG_LEVEL_ERROR,
533 "block action without reason found. This may "
534 "become a fatal error in future versions.");
541 /* FIXME: should validate option string here */
542 freez (cur_action->string[action->index]);
543 cur_action->string[action->index] = strdup(value);
544 if (NULL == cur_action->string[action->index])
546 return JB_ERR_MEMORY;
552 /* remove single string. */
554 freez (cur_action->string[action->index]);
559 /* append multi string. */
561 struct list * remove_p = cur_action->multi_remove[action->index];
562 struct list * add_p = cur_action->multi_add[action->index];
564 if ((value == NULL) || (*value == '\0'))
569 list_remove_item(remove_p, value);
570 err = enlist_unique(add_p, value, 0);
579 /* remove multi string. */
581 struct list * remove_p = cur_action->multi_remove[action->index];
582 struct list * add_p = cur_action->multi_add[action->index];
584 if ( (value == NULL) || (*value == '\0')
585 || ((*value == '*') && (value[1] == '\0')) )
588 * no option, or option == "*".
592 list_remove_all(remove_p);
593 list_remove_all(add_p);
594 cur_action->multi_remove_all[action->index] = 1;
598 /* Valid option - remove only 1 option */
600 if ( !cur_action->multi_remove_all[action->index] )
602 /* there isn't a catch-all in the remove list already */
603 err = enlist_unique(remove_p, value, 0);
609 list_remove_item(add_p, value);
614 /* Shouldn't get here unless there's memory corruption. */
621 /* try user aliases. */
622 const struct action_alias * alias = alias_list;
624 while ( (alias != NULL) && (0 != strcmpic(alias->name, option)) )
631 merge_actions(cur_action, alias->action);
633 else if (((size_t)2 < strlen(option)) && action_used_to_be_valid(option+1))
635 log_error(LOG_LEVEL_ERROR, "Action '%s' is no longer valid "
636 "in this Privoxy release. Ignored.", option+1);
638 else if (((size_t)2 < strlen(option)) && 0 == strcmpic(option+1, "hide-forwarded-for-headers"))
640 log_error(LOG_LEVEL_FATAL, "The action 'hide-forwarded-for-headers' "
641 "is no longer valid in this Privoxy release. "
642 "Use 'change-x-forwarded-for' instead.");
646 /* Bad action name */
648 * XXX: This is a fatal error and Privoxy will later on exit
649 * in load_one_actions_file() because of an "invalid line".
651 * It would be preferable to name the offending option in that
652 * error message, but currently there is no way to do that and
653 * we have to live with two error messages for basically the
656 log_error(LOG_LEVEL_ERROR, "Unknown action or alias: %s", option);
667 /*********************************************************************
669 * Function : init_current_action
671 * Description : Zero out an action.
674 * 1 : dest = An uninitialized current_action_spec.
678 *********************************************************************/
679 void init_current_action (struct current_action_spec *dest)
681 memset(dest, '\0', sizeof(*dest));
683 dest->flags = ACTION_MOST_COMPATIBLE;
687 /*********************************************************************
689 * Function : init_action
691 * Description : Zero out an action.
694 * 1 : dest = An uninitialized action_spec.
698 *********************************************************************/
699 void init_action (struct action_spec *dest)
701 memset(dest, '\0', sizeof(*dest));
705 /*********************************************************************
707 * Function : merge_current_action
709 * Description : Merge two actions together.
710 * Similar to "dest += src".
711 * Differences between this and merge_actions()
712 * is that this one doesn't allocate memory for
713 * strings (so "src" better be in memory for at least
714 * as long as "dest" is, and you'd better free
715 * "dest" using "free_current_action").
716 * Also, there is no mask or remove lists in dest.
717 * (If we're applying it to a URL, we don't need them)
720 * 1 : dest = Current actions, to modify.
721 * 2 : src = Action to add.
723 * Returns 0 : no error
724 * !=0 : error, probably JB_ERR_MEMORY.
726 *********************************************************************/
727 jb_err merge_current_action (struct current_action_spec *dest,
728 const struct action_spec *src)
731 jb_err err = JB_ERR_OK;
733 dest->flags &= src->mask;
734 dest->flags |= src->add;
736 for (i = 0; i < ACTION_STRING_COUNT; i++)
738 char * str = src->string[i];
744 return JB_ERR_MEMORY;
746 freez(dest->string[i]);
747 dest->string[i] = str;
751 for (i = 0; i < ACTION_MULTI_COUNT; i++)
753 if (src->multi_remove_all[i])
755 /* Remove everything from dest, then add src->multi_add */
756 err = list_duplicate(dest->multi[i], src->multi_add[i]);
764 list_remove_list(dest->multi[i], src->multi_remove[i]);
765 err = list_append_list_unique(dest->multi[i], src->multi_add[i]);
776 /*********************************************************************
778 * Function : update_action_bits_for_all_tags
780 * Description : Updates the action bits based on all matching tags.
783 * 1 : csp = Current client state (buffers, headers, etc...)
785 * Returns : 0 if no tag matched, or
788 *********************************************************************/
789 int update_action_bits_for_all_tags(struct client_state *csp)
791 struct list_entry *tag;
794 for (tag = csp->tags->first; tag != NULL; tag = tag->next)
796 if (update_action_bits_for_tag(csp, tag->str))
806 /*********************************************************************
808 * Function : update_action_bits_for_tag
810 * Description : Updates the action bits based on the action sections
811 * whose tag patterns match a provided tag.
814 * 1 : csp = Current client state (buffers, headers, etc...)
815 * 2 : tag = The tag on which the update should be based on
817 * Returns : 0 if no tag matched, or
820 *********************************************************************/
821 int update_action_bits_for_tag(struct client_state *csp, const char *tag)
823 struct file_list *fl;
824 struct url_actions *b;
830 assert(list_contains_item(csp->tags, tag));
832 /* Run through all action files, */
833 for (i = 0; i < MAX_AF_FILES; i++)
835 if (((fl = csp->actions_list[i]) == NULL) || ((b = fl->f) == NULL))
837 /* Skip empty files */
841 /* and through all the action patterns, */
842 for (b = b->next; NULL != b; b = b->next)
844 /* skip the URL patterns, */
845 if (NULL == b->url->tag_regex)
850 /* and check if one of the tag patterns matches the tag, */
851 if (0 == regexec(b->url->tag_regex, tag, 0, NULL, 0))
853 /* if it does, update the action bit map, */
854 if (merge_current_action(csp->action, b->action))
856 log_error(LOG_LEVEL_ERROR,
857 "Out of memory while changing action bits");
859 /* and signal the change. */
869 /*********************************************************************
871 * Function : free_current_action
873 * Description : Free memory used by a current_action_spec.
874 * Does not free the current_action_spec itself.
877 * 1 : src = Source to free.
881 *********************************************************************/
882 void free_current_action(struct current_action_spec *src)
886 for (i = 0; i < ACTION_STRING_COUNT; i++)
888 freez(src->string[i]);
891 for (i = 0; i < ACTION_MULTI_COUNT; i++)
893 destroy_list(src->multi[i]);
896 memset(src, '\0', sizeof(*src));
900 static struct file_list *current_actions_file[MAX_AF_FILES] = {
901 NULL, NULL, NULL, NULL, NULL,
902 NULL, NULL, NULL, NULL, NULL
906 #ifdef FEATURE_GRACEFUL_TERMINATION
907 /*********************************************************************
909 * Function : unload_current_actions_file
911 * Description : Unloads current actions file - reset to state at
912 * beginning of program.
918 *********************************************************************/
919 void unload_current_actions_file(void)
923 for (i = 0; i < MAX_AF_FILES; i++)
925 if (current_actions_file[i])
927 current_actions_file[i]->unloader = unload_actions_file;
928 current_actions_file[i] = NULL;
932 #endif /* FEATURE_GRACEFUL_TERMINATION */
935 /*********************************************************************
937 * Function : unload_actions_file
939 * Description : Unloads an actions module.
942 * 1 : file_data = the data structure associated with the
947 *********************************************************************/
948 void unload_actions_file(void *file_data)
950 struct url_actions * next;
951 struct url_actions * cur = (struct url_actions *)file_data;
955 free_url_spec(cur->url);
956 if ((next == NULL) || (next->action != cur->action))
959 * As the action settings might be shared,
960 * we can only free them if the current
961 * url pattern is the last one, or if the
962 * next one is using different settings.
964 free_action_spec(cur->action);
972 /*********************************************************************
974 * Function : free_alias_list
976 * Description : Free memory used by a list of aliases.
979 * 1 : alias_list = Linked list to free.
983 *********************************************************************/
984 void free_alias_list(struct action_alias *alias_list)
986 while (alias_list != NULL)
988 struct action_alias * next = alias_list->next;
989 alias_list->next = NULL;
990 freez(alias_list->name);
991 free_action(alias_list->action);
998 /*********************************************************************
1000 * Function : load_action_files
1002 * Description : Read and parse all the action files and add to files
1006 * 1 : csp = Current client state (buffers, headers, etc...)
1008 * Returns : 0 => Ok, everything else is an error.
1010 *********************************************************************/
1011 int load_action_files(struct client_state *csp)
1016 for (i = 0; i < MAX_AF_FILES; i++)
1018 if (csp->config->actions_file[i])
1020 result = load_one_actions_file(csp, i);
1026 else if (current_actions_file[i])
1028 current_actions_file[i]->unloader = unload_actions_file;
1029 current_actions_file[i] = NULL;
1037 /*********************************************************************
1039 * Function : referenced_filters_are_missing
1041 * Description : Checks if any filters of a certain type referenced
1042 * in an action spec are missing.
1045 * 1 : csp = Current client state (buffers, headers, etc...)
1046 * 2 : cur_action = The action spec to check.
1047 * 3 : multi_index = The index where to look for the filter.
1048 * 4 : filter_type = The filter type the caller is interested in.
1050 * Returns : 0 => All referenced filters exists, everything else is an error.
1052 *********************************************************************/
1053 static int referenced_filters_are_missing(const struct client_state *csp,
1054 const struct action_spec *cur_action, int multi_index, enum filter_type filter_type)
1057 struct file_list *fl;
1058 struct re_filterfile_spec *b;
1059 struct list_entry *filtername;
1061 for (filtername = cur_action->multi_add[multi_index]->first;
1062 filtername; filtername = filtername->next)
1064 int filter_found = 0;
1065 for (i = 0; i < MAX_AF_FILES; i++)
1068 if ((NULL == fl) || (NULL == fl->f))
1073 for (b = fl->f; b; b = b->next)
1075 if (b->type != filter_type)
1079 if (strcmp(b->name, filtername->str) == 0)
1087 log_error(LOG_LEVEL_ERROR, "Missing filter '%s'", filtername->str);
1097 /*********************************************************************
1099 * Function : action_spec_is_valid
1101 * Description : Should eventually figure out if an action spec
1102 * is valid, but currently only checks that the
1103 * referenced filters are accounted for.
1106 * 1 : csp = Current client state (buffers, headers, etc...)
1107 * 2 : cur_action = The action spec to check.
1109 * Returns : 0 => No problems detected, everything else is an error.
1111 *********************************************************************/
1112 static int action_spec_is_valid(struct client_state *csp, const struct action_spec *cur_action)
1116 enum filter_type filter_type;
1118 {ACTION_MULTI_FILTER, FT_CONTENT_FILTER},
1119 {ACTION_MULTI_CLIENT_HEADER_FILTER, FT_CLIENT_HEADER_FILTER},
1120 {ACTION_MULTI_SERVER_HEADER_FILTER, FT_SERVER_HEADER_FILTER},
1121 {ACTION_MULTI_CLIENT_HEADER_TAGGER, FT_CLIENT_HEADER_TAGGER},
1122 {ACTION_MULTI_SERVER_HEADER_TAGGER, FT_SERVER_HEADER_TAGGER}
1127 for (i = 0; i < SZ(filter_map); i++)
1129 errors += referenced_filters_are_missing(csp, cur_action,
1130 filter_map[i].multi_index, filter_map[i].filter_type);
1138 /*********************************************************************
1140 * Function : load_one_actions_file
1142 * Description : Read and parse a action file and add to files
1146 * 1 : csp = Current client state (buffers, headers, etc...)
1147 * 2 : fileid = File index to load.
1149 * Returns : 0 => Ok, everything else is an error.
1151 *********************************************************************/
1152 static int load_one_actions_file(struct client_state *csp, int fileid)
1157 * Note: Keep these in the order they occur in the file, they are
1158 * sometimes tested with <=
1161 MODE_START_OF_FILE = 1,
1163 MODE_DESCRIPTION = 3,
1169 struct url_actions *last_perm;
1170 struct url_actions *perm;
1172 struct file_list *fs;
1173 struct action_spec * cur_action = NULL;
1174 int cur_action_used = 0;
1175 struct action_alias * alias_list = NULL;
1176 unsigned long linenum = 0;
1177 mode = MODE_START_OF_FILE;
1179 if (!check_file_changed(current_actions_file[fileid], csp->config->actions_file[fileid], &fs))
1181 /* No need to load */
1182 csp->actions_list[fileid] = current_actions_file[fileid];
1187 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': %E. "
1188 "Note that beginning with Privoxy 3.0.7, actions files have to be specified "
1189 "with their complete file names.", csp->config->actions_file[fileid]);
1190 return 1; /* never get here */
1193 fs->f = last_perm = (struct url_actions *)zalloc(sizeof(*last_perm));
1194 if (last_perm == NULL)
1196 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': out of memory!",
1197 csp->config->actions_file[fileid]);
1198 return 1; /* never get here */
1201 if ((fp = fopen(csp->config->actions_file[fileid], "r")) == NULL)
1203 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': error opening file: %E",
1204 csp->config->actions_file[fileid]);
1205 return 1; /* never get here */
1208 log_error(LOG_LEVEL_INFO, "Loading actions file: %s", csp->config->actions_file[fileid]);
1210 while (read_config_line(fp, &linenum, &buf) != NULL)
1214 /* It's a header block */
1217 /* It's {{settings}} or {{alias}} */
1218 size_t len = strlen(buf);
1219 char * start = buf + 2;
1220 char * end = buf + len - 1;
1221 if ((len < (size_t)5) || (*end-- != '}') || (*end-- != '}'))
1225 log_error(LOG_LEVEL_FATAL,
1226 "can't load actions file '%s': invalid line (%lu): %s",
1227 csp->config->actions_file[fileid], linenum, buf);
1228 return 1; /* never get here */
1231 /* Trim leading and trailing whitespace. */
1239 log_error(LOG_LEVEL_FATAL,
1240 "can't load actions file '%s': invalid line (%lu): {{ }}",
1241 csp->config->actions_file[fileid], linenum);
1242 return 1; /* never get here */
1246 * An actionsfile can optionally contain the following blocks.
1247 * They *MUST* be in this order, to simplify processing:
1253 * ...free text, format TBD, but no line may start with a '{'...
1258 * The actual actions must be *after* these special blocks.
1259 * None of these special blocks may be repeated.
1262 if (0 == strcmpic(start, "settings"))
1264 /* it's a {{settings}} block */
1265 if (mode >= MODE_SETTINGS)
1267 /* {{settings}} must be first thing in file and must only
1271 log_error(LOG_LEVEL_FATAL,
1272 "can't load actions file '%s': line %lu: {{settings}} must only appear once, and it must be before anything else.",
1273 csp->config->actions_file[fileid], linenum);
1275 mode = MODE_SETTINGS;
1277 else if (0 == strcmpic(start, "description"))
1279 /* it's a {{description}} block */
1280 if (mode >= MODE_DESCRIPTION)
1282 /* {{description}} is a singleton and only {{settings}} may proceed it
1285 log_error(LOG_LEVEL_FATAL,
1286 "can't load actions file '%s': line %lu: {{description}} must only appear once, and only a {{settings}} block may be above it.",
1287 csp->config->actions_file[fileid], linenum);
1289 mode = MODE_DESCRIPTION;
1291 else if (0 == strcmpic(start, "alias"))
1293 /* it's an {{alias}} block */
1294 if (mode >= MODE_ALIAS)
1296 /* {{alias}} must be first thing in file, possibly after
1297 * {{settings}} and {{description}}
1299 * {{alias}} must only appear once.
1301 * Note that these are new restrictions introduced in
1302 * v2.9.10 in order to make actionsfile editing simpler.
1303 * (Otherwise, reordering actionsfile entries without
1304 * completely rewriting the file becomes non-trivial)
1307 log_error(LOG_LEVEL_FATAL,
1308 "can't load actions file '%s': line %lu: {{alias}} must only appear once, and it must be before all actions.",
1309 csp->config->actions_file[fileid], linenum);
1315 /* invalid {{something}} block */
1317 log_error(LOG_LEVEL_FATAL,
1318 "can't load actions file '%s': invalid line (%lu): {{%s}}",
1319 csp->config->actions_file[fileid], linenum, start);
1320 return 1; /* never get here */
1325 /* It's an actions block */
1331 mode = MODE_ACTIONS;
1333 /* free old action */
1336 if (!cur_action_used)
1338 free_action_spec(cur_action);
1342 cur_action_used = 0;
1343 cur_action = (struct action_spec *)zalloc(sizeof(*cur_action));
1344 if (cur_action == NULL)
1347 log_error(LOG_LEVEL_FATAL,
1348 "can't load actions file '%s': out of memory",
1349 csp->config->actions_file[fileid]);
1350 return 1; /* never get here */
1352 init_action(cur_action);
1355 * Copy the buffer before messing with it as we may need the
1356 * unmodified version in for the fatal error messages. Given
1357 * that this is not a common event, we could instead simply
1358 * read the line again.
1360 * buf + 1 to skip the leading '{'
1362 actions_buf = strdup(buf + 1);
1363 if (actions_buf == NULL)
1366 log_error(LOG_LEVEL_FATAL,
1367 "can't load actions file '%s': out of memory",
1368 csp->config->actions_file[fileid]);
1369 return 1; /* never get here */
1372 /* check we have a trailing } and then trim it */
1373 end = actions_buf + strlen(actions_buf) - 1;
1379 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': "
1380 "Missing trailing '}' in action section starting at line (%lu): %s",
1381 csp->config->actions_file[fileid], linenum, buf);
1382 return 1; /* never get here */
1386 /* trim any whitespace immediately inside {} */
1389 if (get_actions(actions_buf, alias_list, cur_action))
1394 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': "
1395 "can't completely parse the action section starting at line (%lu): %s",
1396 csp->config->actions_file[fileid], linenum, buf);
1397 return 1; /* never get here */
1400 if (action_spec_is_valid(csp, cur_action))
1402 log_error(LOG_LEVEL_ERROR, "Invalid action section in file '%s', "
1403 "starting at line %lu: %s",
1404 csp->config->actions_file[fileid], linenum, buf);
1410 else if (mode == MODE_SETTINGS)
1413 * Part of the {{settings}} block.
1414 * For now only serves to check if the file's minimum Privoxy
1415 * version requirement is met, but we may want to read & check
1416 * permissions when we go multi-user.
1418 if (!strncmp(buf, "for-privoxy-version=", 20))
1420 char *version_string, *fields[3];
1423 if ((version_string = strdup(buf + 20)) == NULL)
1426 log_error(LOG_LEVEL_FATAL,
1427 "can't load actions file '%s': out of memory!",
1428 csp->config->actions_file[fileid]);
1429 return 1; /* never get here */
1432 num_fields = ssplit(version_string, ".", fields, SZ(fields), TRUE, FALSE);
1434 if (num_fields < 1 || atoi(fields[0]) == 0)
1436 log_error(LOG_LEVEL_ERROR,
1437 "While loading actions file '%s': invalid line (%lu): %s",
1438 csp->config->actions_file[fileid], linenum, buf);
1440 else if ( atoi(fields[0]) > VERSION_MAJOR
1441 || (num_fields > 1 && atoi(fields[1]) > VERSION_MINOR)
1442 || (num_fields > 2 && atoi(fields[2]) > VERSION_POINT))
1445 log_error(LOG_LEVEL_FATAL,
1446 "Actions file '%s', line %lu requires newer Privoxy version: %s",
1447 csp->config->actions_file[fileid], linenum, buf );
1448 return 1; /* never get here */
1450 free(version_string);
1453 else if (mode == MODE_DESCRIPTION)
1456 * Part of the {{description}} block.
1460 else if (mode == MODE_ALIAS)
1465 char actions_buf[BUFFER_SIZE];
1466 struct action_alias * new_alias;
1468 char * start = strchr(buf, '=');
1471 if ((start == NULL) || (start == buf))
1473 log_error(LOG_LEVEL_FATAL,
1474 "can't load actions file '%s': invalid alias line (%lu): %s",
1475 csp->config->actions_file[fileid], linenum, buf);
1476 return 1; /* never get here */
1479 if ((new_alias = zalloc(sizeof(*new_alias))) == NULL)
1482 log_error(LOG_LEVEL_FATAL,
1483 "can't load actions file '%s': out of memory!",
1484 csp->config->actions_file[fileid]);
1485 return 1; /* never get here */
1488 /* Eat any the whitespace before the '=' */
1490 while ((*end == ' ') || (*end == '\t'))
1493 * we already know we must have at least 1 non-ws char
1494 * at start of buf - no need to check
1500 /* Eat any the whitespace after the '=' */
1502 while ((*start == ' ') || (*start == '\t'))
1508 log_error(LOG_LEVEL_FATAL,
1509 "can't load actions file '%s': invalid alias line (%lu): %s",
1510 csp->config->actions_file[fileid], linenum, buf);
1511 return 1; /* never get here */
1514 if ((new_alias->name = strdup(buf)) == NULL)
1517 log_error(LOG_LEVEL_FATAL,
1518 "can't load actions file '%s': out of memory!",
1519 csp->config->actions_file[fileid]);
1520 return 1; /* never get here */
1523 strlcpy(actions_buf, start, sizeof(actions_buf));
1525 if (get_actions(actions_buf, alias_list, new_alias->action))
1529 log_error(LOG_LEVEL_FATAL,
1530 "can't load actions file '%s': invalid alias line (%lu): %s = %s",
1531 csp->config->actions_file[fileid], linenum, buf, start);
1532 return 1; /* never get here */
1536 new_alias->next = alias_list;
1537 alias_list = new_alias;
1539 else if (mode == MODE_ACTIONS)
1541 /* it's an URL pattern */
1543 /* allocate a new node */
1544 if ((perm = zalloc(sizeof(*perm))) == NULL)
1547 log_error(LOG_LEVEL_FATAL,
1548 "can't load actions file '%s': out of memory!",
1549 csp->config->actions_file[fileid]);
1550 return 1; /* never get here */
1553 perm->action = cur_action;
1554 cur_action_used = 1;
1556 /* Save the URL pattern */
1557 if (create_url_spec(perm->url, buf))
1560 log_error(LOG_LEVEL_FATAL,
1561 "can't load actions file '%s': line %lu: cannot create URL or TAG pattern from: %s",
1562 csp->config->actions_file[fileid], linenum, buf);
1563 return 1; /* never get here */
1566 /* add it to the list */
1567 last_perm->next = perm;
1570 else if (mode == MODE_START_OF_FILE)
1572 /* oops - please have a {} line as 1st line in file. */
1574 log_error(LOG_LEVEL_FATAL,
1575 "can't load actions file '%s': first needed line (%lu) is invalid: %s",
1576 csp->config->actions_file[fileid], linenum, buf);
1577 return 1; /* never get here */
1581 /* How did we get here? This is impossible! */
1583 log_error(LOG_LEVEL_FATAL,
1584 "can't load actions file '%s': INTERNAL ERROR - mode = %d",
1585 csp->config->actions_file[fileid], mode);
1586 return 1; /* never get here */
1593 if (!cur_action_used)
1595 free_action_spec(cur_action);
1597 free_alias_list(alias_list);
1599 /* the old one is now obsolete */
1600 if (current_actions_file[fileid])
1602 current_actions_file[fileid]->unloader = unload_actions_file;
1605 fs->next = files->next;
1607 current_actions_file[fileid] = fs;
1609 csp->actions_list[fileid] = fs;
1616 /*********************************************************************
1618 * Function : actions_to_text
1620 * Description : Converts a actionsfile entry from the internal
1621 * structure into a text line. The output is split
1622 * into one line for each action with line continuation.
1625 * 1 : action = The action to format.
1627 * Returns : A string. Caller must free it.
1628 * NULL on out-of-memory error.
1630 *********************************************************************/
1631 char * actions_to_text(const struct action_spec *action)
1633 unsigned long mask = action->mask;
1634 unsigned long add = action->add;
1635 char *result = strdup("");
1636 struct list_entry * lst;
1638 /* sanity - prevents "-feature +feature" */
1642 #define DEFINE_ACTION_BOOL(__name, __bit) \
1643 if (!(mask & __bit)) \
1645 string_append(&result, " -" __name " \\\n"); \
1647 else if (add & __bit) \
1649 string_append(&result, " +" __name " \\\n"); \
1652 #define DEFINE_ACTION_STRING(__name, __bit, __index) \
1653 if (!(mask & __bit)) \
1655 string_append(&result, " -" __name " \\\n"); \
1657 else if (add & __bit) \
1659 string_append(&result, " +" __name "{"); \
1660 string_append(&result, action->string[__index]); \
1661 string_append(&result, "} \\\n"); \
1664 #define DEFINE_ACTION_MULTI(__name, __index) \
1665 if (action->multi_remove_all[__index]) \
1667 string_append(&result, " -" __name " \\\n"); \
1671 lst = action->multi_remove[__index]->first; \
1674 string_append(&result, " -" __name "{"); \
1675 string_append(&result, lst->str); \
1676 string_append(&result, "} \\\n"); \
1680 lst = action->multi_add[__index]->first; \
1683 string_append(&result, " +" __name "{"); \
1684 string_append(&result, lst->str); \
1685 string_append(&result, "} \\\n"); \
1689 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
1691 #include "actionlist.h"
1693 #undef DEFINE_ACTION_MULTI
1694 #undef DEFINE_ACTION_STRING
1695 #undef DEFINE_ACTION_BOOL
1696 #undef DEFINE_ACTION_ALIAS
1702 /*********************************************************************
1704 * Function : actions_to_html
1706 * Description : Converts a actionsfile entry from numeric form
1707 * ("mask" and "add") to a <br>-separated HTML string
1708 * in which each action is linked to its chapter in
1712 * 1 : csp = Client state (for config)
1713 * 2 : action = Action spec to be converted
1715 * Returns : A string. Caller must free it.
1716 * NULL on out-of-memory error.
1718 *********************************************************************/
1719 char * actions_to_html(const struct client_state *csp,
1720 const struct action_spec *action)
1722 unsigned long mask = action->mask;
1723 unsigned long add = action->add;
1724 char *result = strdup("");
1725 struct list_entry * lst;
1727 /* sanity - prevents "-feature +feature" */
1731 #define DEFINE_ACTION_BOOL(__name, __bit) \
1732 if (!(mask & __bit)) \
1734 string_append(&result, "\n<br>-"); \
1735 string_join(&result, add_help_link(__name, csp->config)); \
1737 else if (add & __bit) \
1739 string_append(&result, "\n<br>+"); \
1740 string_join(&result, add_help_link(__name, csp->config)); \
1743 #define DEFINE_ACTION_STRING(__name, __bit, __index) \
1744 if (!(mask & __bit)) \
1746 string_append(&result, "\n<br>-"); \
1747 string_join(&result, add_help_link(__name, csp->config)); \
1749 else if (add & __bit) \
1751 string_append(&result, "\n<br>+"); \
1752 string_join(&result, add_help_link(__name, csp->config)); \
1753 string_append(&result, "{"); \
1754 string_join(&result, html_encode(action->string[__index])); \
1755 string_append(&result, "}"); \
1758 #define DEFINE_ACTION_MULTI(__name, __index) \
1759 if (action->multi_remove_all[__index]) \
1761 string_append(&result, "\n<br>-"); \
1762 string_join(&result, add_help_link(__name, csp->config)); \
1766 lst = action->multi_remove[__index]->first; \
1769 string_append(&result, "\n<br>-"); \
1770 string_join(&result, add_help_link(__name, csp->config)); \
1771 string_append(&result, "{"); \
1772 string_join(&result, html_encode(lst->str)); \
1773 string_append(&result, "}"); \
1777 lst = action->multi_add[__index]->first; \
1780 string_append(&result, "\n<br>+"); \
1781 string_join(&result, add_help_link(__name, csp->config)); \
1782 string_append(&result, "{"); \
1783 string_join(&result, html_encode(lst->str)); \
1784 string_append(&result, "}"); \
1788 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
1790 #include "actionlist.h"
1792 #undef DEFINE_ACTION_MULTI
1793 #undef DEFINE_ACTION_STRING
1794 #undef DEFINE_ACTION_BOOL
1795 #undef DEFINE_ACTION_ALIAS
1797 /* trim leading <br> */
1798 if (result && *result)
1801 result = strdup(result + 5);
1809 /*********************************************************************
1811 * Function : current_actions_to_html
1813 * Description : Converts a curren action spec to a <br> separated HTML
1814 * text in which each action is linked to its chapter in
1818 * 1 : csp = Client state (for config)
1819 * 2 : action = Current action spec to be converted
1821 * Returns : A string. Caller must free it.
1822 * NULL on out-of-memory error.
1824 *********************************************************************/
1825 char *current_action_to_html(const struct client_state *csp,
1826 const struct current_action_spec *action)
1828 unsigned long flags = action->flags;
1829 struct list_entry * lst;
1830 char *result = strdup("");
1831 char *active = strdup("");
1832 char *inactive = strdup("");
1834 #define DEFINE_ACTION_BOOL(__name, __bit) \
1835 if (flags & __bit) \
1837 string_append(&active, "\n<br>+"); \
1838 string_join(&active, add_help_link(__name, csp->config)); \
1842 string_append(&inactive, "\n<br>-"); \
1843 string_join(&inactive, add_help_link(__name, csp->config)); \
1846 #define DEFINE_ACTION_STRING(__name, __bit, __index) \
1847 if (flags & __bit) \
1849 string_append(&active, "\n<br>+"); \
1850 string_join(&active, add_help_link(__name, csp->config)); \
1851 string_append(&active, "{"); \
1852 string_join(&active, html_encode(action->string[__index])); \
1853 string_append(&active, "}"); \
1857 string_append(&inactive, "\n<br>-"); \
1858 string_join(&inactive, add_help_link(__name, csp->config)); \
1861 #define DEFINE_ACTION_MULTI(__name, __index) \
1862 lst = action->multi[__index]->first; \
1865 string_append(&inactive, "\n<br>-"); \
1866 string_join(&inactive, add_help_link(__name, csp->config)); \
1872 string_append(&active, "\n<br>+"); \
1873 string_join(&active, add_help_link(__name, csp->config)); \
1874 string_append(&active, "{"); \
1875 string_join(&active, html_encode(lst->str)); \
1876 string_append(&active, "}"); \
1881 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
1883 #include "actionlist.h"
1885 #undef DEFINE_ACTION_MULTI
1886 #undef DEFINE_ACTION_STRING
1887 #undef DEFINE_ACTION_BOOL
1888 #undef DEFINE_ACTION_ALIAS
1892 string_append(&result, active);
1895 string_append(&result, "\n<br>");
1896 if (inactive != NULL)
1898 string_append(&result, inactive);