1 const char actions_rcs[] = "$Id: actions.c,v 1.66 2011/03/03 14:39:57 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 *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;
1036 /*********************************************************************
1038 * Function : load_one_actions_file
1040 * Description : Read and parse a action file and add to files
1044 * 1 : csp = Current client state (buffers, headers, etc...)
1045 * 2 : fileid = File index to load.
1047 * Returns : 0 => Ok, everything else is an error.
1049 *********************************************************************/
1050 static int load_one_actions_file(struct client_state *csp, int fileid)
1055 * Note: Keep these in the order they occur in the file, they are
1056 * sometimes tested with <=
1059 MODE_START_OF_FILE = 1,
1061 MODE_DESCRIPTION = 3,
1067 struct url_actions *last_perm;
1068 struct url_actions *perm;
1070 struct file_list *fs;
1071 struct action_spec * cur_action = NULL;
1072 int cur_action_used = 0;
1073 struct action_alias * alias_list = NULL;
1074 unsigned long linenum = 0;
1075 mode = MODE_START_OF_FILE;
1077 if (!check_file_changed(current_actions_file[fileid], csp->config->actions_file[fileid], &fs))
1079 /* No need to load */
1080 csp->actions_list[fileid] = current_actions_file[fileid];
1085 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': %E. "
1086 "Note that beginning with Privoxy 3.0.7, actions files have to be specified "
1087 "with their complete file names.", csp->config->actions_file[fileid]);
1088 return 1; /* never get here */
1091 fs->f = last_perm = (struct url_actions *)zalloc(sizeof(*last_perm));
1092 if (last_perm == NULL)
1094 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': out of memory!",
1095 csp->config->actions_file[fileid]);
1096 return 1; /* never get here */
1099 if ((fp = fopen(csp->config->actions_file[fileid], "r")) == NULL)
1101 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': error opening file: %E",
1102 csp->config->actions_file[fileid]);
1103 return 1; /* never get here */
1106 log_error(LOG_LEVEL_INFO, "Loading actions file: %s", csp->config->actions_file[fileid]);
1108 while (read_config_line(fp, &linenum, &buf) != NULL)
1112 /* It's a header block */
1115 /* It's {{settings}} or {{alias}} */
1116 size_t len = strlen(buf);
1117 char * start = buf + 2;
1118 char * end = buf + len - 1;
1119 if ((len < (size_t)5) || (*end-- != '}') || (*end-- != '}'))
1123 log_error(LOG_LEVEL_FATAL,
1124 "can't load actions file '%s': invalid line (%lu): %s",
1125 csp->config->actions_file[fileid], linenum, buf);
1126 return 1; /* never get here */
1129 /* Trim leading and trailing whitespace. */
1137 log_error(LOG_LEVEL_FATAL,
1138 "can't load actions file '%s': invalid line (%lu): {{ }}",
1139 csp->config->actions_file[fileid], linenum);
1140 return 1; /* never get here */
1144 * An actionsfile can optionally contain the following blocks.
1145 * They *MUST* be in this order, to simplify processing:
1151 * ...free text, format TBD, but no line may start with a '{'...
1156 * The actual actions must be *after* these special blocks.
1157 * None of these special blocks may be repeated.
1160 if (0 == strcmpic(start, "settings"))
1162 /* it's a {{settings}} block */
1163 if (mode >= MODE_SETTINGS)
1165 /* {{settings}} must be first thing in file and must only
1169 log_error(LOG_LEVEL_FATAL,
1170 "can't load actions file '%s': line %lu: {{settings}} must only appear once, and it must be before anything else.",
1171 csp->config->actions_file[fileid], linenum);
1173 mode = MODE_SETTINGS;
1175 else if (0 == strcmpic(start, "description"))
1177 /* it's a {{description}} block */
1178 if (mode >= MODE_DESCRIPTION)
1180 /* {{description}} is a singleton and only {{settings}} may proceed it
1183 log_error(LOG_LEVEL_FATAL,
1184 "can't load actions file '%s': line %lu: {{description}} must only appear once, and only a {{settings}} block may be above it.",
1185 csp->config->actions_file[fileid], linenum);
1187 mode = MODE_DESCRIPTION;
1189 else if (0 == strcmpic(start, "alias"))
1191 /* it's an {{alias}} block */
1192 if (mode >= MODE_ALIAS)
1194 /* {{alias}} must be first thing in file, possibly after
1195 * {{settings}} and {{description}}
1197 * {{alias}} must only appear once.
1199 * Note that these are new restrictions introduced in
1200 * v2.9.10 in order to make actionsfile editing simpler.
1201 * (Otherwise, reordering actionsfile entries without
1202 * completely rewriting the file becomes non-trivial)
1205 log_error(LOG_LEVEL_FATAL,
1206 "can't load actions file '%s': line %lu: {{alias}} must only appear once, and it must be before all actions.",
1207 csp->config->actions_file[fileid], linenum);
1213 /* invalid {{something}} block */
1215 log_error(LOG_LEVEL_FATAL,
1216 "can't load actions file '%s': invalid line (%lu): {{%s}}",
1217 csp->config->actions_file[fileid], linenum, start);
1218 return 1; /* never get here */
1223 /* It's an actions block */
1229 mode = MODE_ACTIONS;
1231 /* free old action */
1234 if (!cur_action_used)
1236 free_action_spec(cur_action);
1240 cur_action_used = 0;
1241 cur_action = (struct action_spec *)zalloc(sizeof(*cur_action));
1242 if (cur_action == NULL)
1245 log_error(LOG_LEVEL_FATAL,
1246 "can't load actions file '%s': out of memory",
1247 csp->config->actions_file[fileid]);
1248 return 1; /* never get here */
1250 init_action(cur_action);
1253 * Copy the buffer before messing with it as we may need the
1254 * unmodified version in for the fatal error messages. Given
1255 * that this is not a common event, we could instead simply
1256 * read the line again.
1258 * buf + 1 to skip the leading '{'
1260 actions_buf = strdup(buf + 1);
1261 if (actions_buf == NULL)
1264 log_error(LOG_LEVEL_FATAL,
1265 "can't load actions file '%s': out of memory",
1266 csp->config->actions_file[fileid]);
1267 return 1; /* never get here */
1270 /* check we have a trailing } and then trim it */
1271 end = actions_buf + strlen(actions_buf) - 1;
1277 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': "
1278 "Missing trailing '}' in action section starting at line (%lu): %s",
1279 csp->config->actions_file[fileid], linenum, buf);
1280 return 1; /* never get here */
1284 /* trim any whitespace immediately inside {} */
1287 if (get_actions(actions_buf, alias_list, cur_action))
1292 log_error(LOG_LEVEL_FATAL, "can't load actions file '%s': "
1293 "can't completely parse the action section starting at line (%lu): %s",
1294 csp->config->actions_file[fileid], linenum, buf);
1295 return 1; /* never get here */
1300 else if (mode == MODE_SETTINGS)
1303 * Part of the {{settings}} block.
1304 * For now only serves to check if the file's minimum Privoxy
1305 * version requirement is met, but we may want to read & check
1306 * permissions when we go multi-user.
1308 if (!strncmp(buf, "for-privoxy-version=", 20))
1310 char *version_string, *fields[3];
1313 if ((version_string = strdup(buf + 20)) == NULL)
1316 log_error(LOG_LEVEL_FATAL,
1317 "can't load actions file '%s': out of memory!",
1318 csp->config->actions_file[fileid]);
1319 return 1; /* never get here */
1322 num_fields = ssplit(version_string, ".", fields, 3, TRUE, FALSE);
1324 if (num_fields < 1 || atoi(fields[0]) == 0)
1326 log_error(LOG_LEVEL_ERROR,
1327 "While loading actions file '%s': invalid line (%lu): %s",
1328 csp->config->actions_file[fileid], linenum, buf);
1330 else if ( atoi(fields[0]) > VERSION_MAJOR
1331 || (num_fields > 1 && atoi(fields[1]) > VERSION_MINOR)
1332 || (num_fields > 2 && atoi(fields[2]) > VERSION_POINT))
1335 log_error(LOG_LEVEL_FATAL,
1336 "Actions file '%s', line %lu requires newer Privoxy version: %s",
1337 csp->config->actions_file[fileid], linenum, buf );
1338 return 1; /* never get here */
1340 free(version_string);
1343 else if (mode == MODE_DESCRIPTION)
1346 * Part of the {{description}} block.
1350 else if (mode == MODE_ALIAS)
1355 char actions_buf[BUFFER_SIZE];
1356 struct action_alias * new_alias;
1358 char * start = strchr(buf, '=');
1361 if ((start == NULL) || (start == buf))
1363 log_error(LOG_LEVEL_FATAL,
1364 "can't load actions file '%s': invalid alias line (%lu): %s",
1365 csp->config->actions_file[fileid], linenum, buf);
1366 return 1; /* never get here */
1369 if ((new_alias = zalloc(sizeof(*new_alias))) == NULL)
1372 log_error(LOG_LEVEL_FATAL,
1373 "can't load actions file '%s': out of memory!",
1374 csp->config->actions_file[fileid]);
1375 return 1; /* never get here */
1378 /* Eat any the whitespace before the '=' */
1380 while ((*end == ' ') || (*end == '\t'))
1383 * we already know we must have at least 1 non-ws char
1384 * at start of buf - no need to check
1390 /* Eat any the whitespace after the '=' */
1392 while ((*start == ' ') || (*start == '\t'))
1398 log_error(LOG_LEVEL_FATAL,
1399 "can't load actions file '%s': invalid alias line (%lu): %s",
1400 csp->config->actions_file[fileid], linenum, buf);
1401 return 1; /* never get here */
1404 if ((new_alias->name = strdup(buf)) == NULL)
1407 log_error(LOG_LEVEL_FATAL,
1408 "can't load actions file '%s': out of memory!",
1409 csp->config->actions_file[fileid]);
1410 return 1; /* never get here */
1413 strlcpy(actions_buf, start, sizeof(actions_buf));
1415 if (get_actions(actions_buf, alias_list, new_alias->action))
1419 log_error(LOG_LEVEL_FATAL,
1420 "can't load actions file '%s': invalid alias line (%lu): %s = %s",
1421 csp->config->actions_file[fileid], linenum, buf, start);
1422 return 1; /* never get here */
1426 new_alias->next = alias_list;
1427 alias_list = new_alias;
1429 else if (mode == MODE_ACTIONS)
1431 /* it's an URL pattern */
1433 /* allocate a new node */
1434 if ((perm = zalloc(sizeof(*perm))) == NULL)
1437 log_error(LOG_LEVEL_FATAL,
1438 "can't load actions file '%s': out of memory!",
1439 csp->config->actions_file[fileid]);
1440 return 1; /* never get here */
1443 perm->action = cur_action;
1444 cur_action_used = 1;
1446 /* Save the URL pattern */
1447 if (create_url_spec(perm->url, buf))
1450 log_error(LOG_LEVEL_FATAL,
1451 "can't load actions file '%s': line %lu: cannot create URL or TAG pattern from: %s",
1452 csp->config->actions_file[fileid], linenum, buf);
1453 return 1; /* never get here */
1456 /* add it to the list */
1457 last_perm->next = perm;
1460 else if (mode == MODE_START_OF_FILE)
1462 /* oops - please have a {} line as 1st line in file. */
1464 log_error(LOG_LEVEL_FATAL,
1465 "can't load actions file '%s': first needed line (%lu) is invalid: %s",
1466 csp->config->actions_file[fileid], linenum, buf);
1467 return 1; /* never get here */
1471 /* How did we get here? This is impossible! */
1473 log_error(LOG_LEVEL_FATAL,
1474 "can't load actions file '%s': INTERNAL ERROR - mode = %d",
1475 csp->config->actions_file[fileid], mode);
1476 return 1; /* never get here */
1483 if (!cur_action_used)
1485 free_action_spec(cur_action);
1487 free_alias_list(alias_list);
1489 /* the old one is now obsolete */
1490 if (current_actions_file[fileid])
1492 current_actions_file[fileid]->unloader = unload_actions_file;
1495 fs->next = files->next;
1497 current_actions_file[fileid] = fs;
1499 csp->actions_list[fileid] = fs;
1506 /*********************************************************************
1508 * Function : actions_to_text
1510 * Description : Converts a actionsfile entry from the internal
1511 * structure into a text line. The output is split
1512 * into one line for each action with line continuation.
1515 * 1 : action = The action to format.
1517 * Returns : A string. Caller must free it.
1518 * NULL on out-of-memory error.
1520 *********************************************************************/
1521 char * actions_to_text(const struct action_spec *action)
1523 unsigned long mask = action->mask;
1524 unsigned long add = action->add;
1525 char *result = strdup("");
1526 struct list_entry * lst;
1528 /* sanity - prevents "-feature +feature" */
1532 #define DEFINE_ACTION_BOOL(__name, __bit) \
1533 if (!(mask & __bit)) \
1535 string_append(&result, " -" __name " \\\n"); \
1537 else if (add & __bit) \
1539 string_append(&result, " +" __name " \\\n"); \
1542 #define DEFINE_ACTION_STRING(__name, __bit, __index) \
1543 if (!(mask & __bit)) \
1545 string_append(&result, " -" __name " \\\n"); \
1547 else if (add & __bit) \
1549 string_append(&result, " +" __name "{"); \
1550 string_append(&result, action->string[__index]); \
1551 string_append(&result, "} \\\n"); \
1554 #define DEFINE_ACTION_MULTI(__name, __index) \
1555 if (action->multi_remove_all[__index]) \
1557 string_append(&result, " -" __name " \\\n"); \
1561 lst = action->multi_remove[__index]->first; \
1564 string_append(&result, " -" __name "{"); \
1565 string_append(&result, lst->str); \
1566 string_append(&result, "} \\\n"); \
1570 lst = action->multi_add[__index]->first; \
1573 string_append(&result, " +" __name "{"); \
1574 string_append(&result, lst->str); \
1575 string_append(&result, "} \\\n"); \
1579 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
1581 #include "actionlist.h"
1583 #undef DEFINE_ACTION_MULTI
1584 #undef DEFINE_ACTION_STRING
1585 #undef DEFINE_ACTION_BOOL
1586 #undef DEFINE_ACTION_ALIAS
1592 /*********************************************************************
1594 * Function : actions_to_html
1596 * Description : Converts a actionsfile entry from numeric form
1597 * ("mask" and "add") to a <br>-seperated HTML string
1598 * in which each action is linked to its chapter in
1602 * 1 : csp = Client state (for config)
1603 * 2 : action = Action spec to be converted
1605 * Returns : A string. Caller must free it.
1606 * NULL on out-of-memory error.
1608 *********************************************************************/
1609 char * actions_to_html(const struct client_state *csp,
1610 const struct action_spec *action)
1612 unsigned long mask = action->mask;
1613 unsigned long add = action->add;
1614 char *result = strdup("");
1615 struct list_entry * lst;
1617 /* sanity - prevents "-feature +feature" */
1621 #define DEFINE_ACTION_BOOL(__name, __bit) \
1622 if (!(mask & __bit)) \
1624 string_append(&result, "\n<br>-"); \
1625 string_join(&result, add_help_link(__name, csp->config)); \
1627 else if (add & __bit) \
1629 string_append(&result, "\n<br>+"); \
1630 string_join(&result, add_help_link(__name, csp->config)); \
1633 #define DEFINE_ACTION_STRING(__name, __bit, __index) \
1634 if (!(mask & __bit)) \
1636 string_append(&result, "\n<br>-"); \
1637 string_join(&result, add_help_link(__name, csp->config)); \
1639 else if (add & __bit) \
1641 string_append(&result, "\n<br>+"); \
1642 string_join(&result, add_help_link(__name, csp->config)); \
1643 string_append(&result, "{"); \
1644 string_join(&result, html_encode(action->string[__index])); \
1645 string_append(&result, "}"); \
1648 #define DEFINE_ACTION_MULTI(__name, __index) \
1649 if (action->multi_remove_all[__index]) \
1651 string_append(&result, "\n<br>-"); \
1652 string_join(&result, add_help_link(__name, csp->config)); \
1656 lst = action->multi_remove[__index]->first; \
1659 string_append(&result, "\n<br>-"); \
1660 string_join(&result, add_help_link(__name, csp->config)); \
1661 string_append(&result, "{"); \
1662 string_join(&result, html_encode(lst->str)); \
1663 string_append(&result, "}"); \
1667 lst = action->multi_add[__index]->first; \
1670 string_append(&result, "\n<br>+"); \
1671 string_join(&result, add_help_link(__name, csp->config)); \
1672 string_append(&result, "{"); \
1673 string_join(&result, html_encode(lst->str)); \
1674 string_append(&result, "}"); \
1678 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
1680 #include "actionlist.h"
1682 #undef DEFINE_ACTION_MULTI
1683 #undef DEFINE_ACTION_STRING
1684 #undef DEFINE_ACTION_BOOL
1685 #undef DEFINE_ACTION_ALIAS
1687 /* trim leading <br> */
1688 if (result && *result)
1691 result = strdup(result + 5);
1699 /*********************************************************************
1701 * Function : current_actions_to_html
1703 * Description : Converts a curren action spec to a <br> seperated HTML
1704 * text in which each action is linked to its chapter in
1708 * 1 : csp = Client state (for config)
1709 * 2 : action = Current action spec to be converted
1711 * Returns : A string. Caller must free it.
1712 * NULL on out-of-memory error.
1714 *********************************************************************/
1715 char *current_action_to_html(const struct client_state *csp,
1716 const struct current_action_spec *action)
1718 unsigned long flags = action->flags;
1719 struct list_entry * lst;
1720 char *result = strdup("");
1721 char *active = strdup("");
1722 char *inactive = strdup("");
1724 #define DEFINE_ACTION_BOOL(__name, __bit) \
1725 if (flags & __bit) \
1727 string_append(&active, "\n<br>+"); \
1728 string_join(&active, add_help_link(__name, csp->config)); \
1732 string_append(&inactive, "\n<br>-"); \
1733 string_join(&inactive, add_help_link(__name, csp->config)); \
1736 #define DEFINE_ACTION_STRING(__name, __bit, __index) \
1737 if (flags & __bit) \
1739 string_append(&active, "\n<br>+"); \
1740 string_join(&active, add_help_link(__name, csp->config)); \
1741 string_append(&active, "{"); \
1742 string_join(&active, html_encode(action->string[__index])); \
1743 string_append(&active, "}"); \
1747 string_append(&inactive, "\n<br>-"); \
1748 string_join(&inactive, add_help_link(__name, csp->config)); \
1751 #define DEFINE_ACTION_MULTI(__name, __index) \
1752 lst = action->multi[__index]->first; \
1755 string_append(&inactive, "\n<br>-"); \
1756 string_join(&inactive, add_help_link(__name, csp->config)); \
1762 string_append(&active, "\n<br>+"); \
1763 string_join(&active, add_help_link(__name, csp->config)); \
1764 string_append(&active, "{"); \
1765 string_join(&active, html_encode(lst->str)); \
1766 string_append(&active, "}"); \
1771 #define DEFINE_ACTION_ALIAS 0 /* No aliases for output */
1773 #include "actionlist.h"
1775 #undef DEFINE_ACTION_MULTI
1776 #undef DEFINE_ACTION_STRING
1777 #undef DEFINE_ACTION_BOOL
1778 #undef DEFINE_ACTION_ALIAS
1782 string_append(&result, active);
1785 string_append(&result, "\n<br>");
1786 if (inactive != NULL)
1788 string_append(&result, inactive);