1 /*********************************************************************
3 * File : $Source: /cvsroot/ijbswa/current/cgisimple.c,v $
5 * Purpose : Simple CGIs to get information about Privoxy's
8 * Copyright : Written by and Copyright (C) 2001-2020 the
9 * Privoxy team. https://www.privoxy.org/
11 * Based on the Internet Junkbuster originally written
12 * by and Copyright (C) 1997 Anonymous Coders and
13 * Junkbusters Corporation. http://www.junkbusters.com
15 * This program is free software; you can redistribute it
16 * and/or modify it under the terms of the GNU General
17 * Public License as published by the Free Software
18 * Foundation; either version 2 of the License, or (at
19 * your option) any later version.
21 * This program is distributed in the hope that it will
22 * be useful, but WITHOUT ANY WARRANTY; without even the
23 * implied warranty of MERCHANTABILITY or FITNESS FOR A
24 * PARTICULAR PURPOSE. See the GNU General Public
25 * License for more details.
27 * The GNU General Public License should be included with
28 * this file. If not, you can view it at
29 * http://www.gnu.org/copyleft/gpl.html
30 * or write to the Free Software Foundation, Inc., 59
31 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
33 **********************************************************************/
39 #include <sys/types.h>
45 #if defined (HAVE_ACCESS) && defined (HAVE_UNISTD_H)
47 #endif /* def HAVE_ACCESS && HAVE_UNISTD_H */
51 #include "cgisimple.h"
62 #ifdef FEATURE_CLIENT_TAGS
63 #include "client-tags.h"
66 static jb_err show_defines(struct map *exports);
67 static jb_err cgi_show_file(struct client_state *csp,
68 struct http_response *rsp,
69 const struct map *parameters);
70 static jb_err load_file(const char *filename, char **buffer, size_t *length);
72 /*********************************************************************
74 * Function : cgi_default
76 * Description : CGI function that is called for the CGI_SITE_1_HOST
77 * and CGI_SITE_2_HOST/CGI_SITE_2_PATH base URLs.
78 * Boring - only exports the default exports.
81 * 1 : csp = Current client state (buffers, headers, etc...)
82 * 2 : rsp = http_response data structure for output
83 * 3 : parameters = map of cgi parameters
85 * CGI Parameters : none
87 * Returns : JB_ERR_OK on success
88 * JB_ERR_MEMORY on out-of-memory
90 *********************************************************************/
91 jb_err cgi_default(struct client_state *csp,
92 struct http_response *rsp,
93 const struct map *parameters)
102 if (NULL == (exports = default_exports(csp, "")))
104 return JB_ERR_MEMORY;
107 return template_fill_for_cgi(csp, "default", exports, rsp);
111 /*********************************************************************
113 * Function : cgi_error_404
115 * Description : CGI function that is called if an unknown action was
119 * 1 : csp = Current client state (buffers, headers, etc...)
120 * 2 : rsp = http_response data structure for output
121 * 3 : parameters = map of cgi parameters
123 * CGI Parameters : none
125 * Returns : JB_ERR_OK on success
126 * JB_ERR_MEMORY on out-of-memory error.
128 *********************************************************************/
129 jb_err cgi_error_404(struct client_state *csp,
130 struct http_response *rsp,
131 const struct map *parameters)
139 if (NULL == (exports = default_exports(csp, NULL)))
141 return JB_ERR_MEMORY;
144 rsp->status = strdup_or_die("404 Privoxy configuration page not found");
146 return template_fill_for_cgi(csp, "cgi-error-404", exports, rsp);
150 #ifdef FEATURE_GRACEFUL_TERMINATION
151 /*********************************************************************
155 * Description : CGI function to shut down Privoxy.
156 * NOTE: Turning this on in a production build
157 * would be a BAD idea. An EXTREMELY BAD idea.
158 * In short, don't do it.
161 * 1 : csp = Current client state (buffers, headers, etc...)
162 * 2 : rsp = http_response data structure for output
163 * 3 : parameters = map of cgi parameters
165 * CGI Parameters : none
167 * Returns : JB_ERR_OK on success
169 *********************************************************************/
170 jb_err cgi_die (struct client_state *csp,
171 struct http_response *rsp,
172 const struct map *parameters)
174 static const char status[] = "200 OK Privoxy shutdown request received";
175 static const char body[] =
178 " <title>Privoxy shutdown request received</title>\n"
179 " <link rel=\"shortcut icon\" href=\"" CGI_PREFIX "error-favicon.ico\" type=\"image/x-icon\">\n"
180 " <link rel=\"stylesheet\" type=\"text/css\" href=\"" CGI_PREFIX "send-stylesheet\">\n"
183 "<h1>Privoxy shutdown request received</h1>\n"
184 "<p>Privoxy is going to shut down after the next request.</p>\n"
195 csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
197 rsp->content_length = 0;
198 rsp->head_length = 0;
201 rsp->body = strdup_or_die(body);
202 rsp->status = strdup_or_die(status);
206 #endif /* def FEATURE_GRACEFUL_TERMINATION */
209 /*********************************************************************
211 * Function : cgi_show_request
213 * Description : Show the client's request and what sed() would have
217 * 1 : csp = Current client state (buffers, headers, etc...)
218 * 2 : rsp = http_response data structure for output
219 * 3 : parameters = map of cgi parameters
221 * CGI Parameters : none
223 * Returns : JB_ERR_OK on success
224 * JB_ERR_MEMORY on out-of-memory error.
226 *********************************************************************/
227 jb_err cgi_show_request(struct client_state *csp,
228 struct http_response *rsp,
229 const struct map *parameters)
238 if (NULL == (exports = default_exports(csp, "show-request")))
240 return JB_ERR_MEMORY;
244 * Repair the damage done to the IOB by get_header()
246 for (p = csp->client_iob->buf; p < csp->client_iob->cur; p++)
248 if (*p == '\0') *p = '\n';
252 * Export the original client's request and the one we would
253 * be sending to the server if this wasn't a CGI call
256 if (map(exports, "client-request", 1, html_encode(csp->client_iob->buf), 0))
259 return JB_ERR_MEMORY;
262 if (map(exports, "processed-request", 1,
263 html_encode_and_free_original(
264 #ifdef FEATURE_HTTPS_INSPECTION
266 list_to_text(csp->https_headers) :
268 list_to_text(csp->headers)
272 return JB_ERR_MEMORY;
275 return template_fill_for_cgi(csp, "show-request", exports, rsp);
279 #ifdef FEATURE_CLIENT_TAGS
280 /*********************************************************************
282 * Function : cgi_create_client_tag_form
284 * Description : Creates a HTML form to enable or disable a given
286 * XXX: Could use a template.
289 * 1 : form = Buffer to fill with the generated form
290 * 2 : size = Size of the form buffer
291 * 3 : tag = Name of the tag this form should affect
292 * 4 : toggle_state = Desired state after the button pressed 0
293 * 5 : expires = Whether or not the tag should be enabled.
294 * Only checked if toggle_state is 1.
298 *********************************************************************/
299 static void cgi_create_client_tag_form(char *form, size_t size,
300 const char *tag, int toggle_state, int expires)
304 if (toggle_state == 1)
306 button_name = (expires == 1) ? "Enable" : "Enable temporarily";
310 assert(toggle_state == 0);
311 button_name = "Disable";
315 "<form method=\"GET\" action=\""CGI_PREFIX"toggle-client-tag\" style=\"display: inline\">\n"
316 " <input type=\"hidden\" name=\"tag\" value=\"%s\">\n"
317 " <input type=\"hidden\" name=\"toggle-state\" value=\"%i\">\n"
318 " <input type=\"hidden\" name=\"expires\" value=\"%u\">\n"
319 " <input type=\"submit\" value=\"%s\">\n"
320 "</form>", tag, toggle_state, !expires, button_name);
323 /*********************************************************************
325 * Function : cgi_show_client_tags
327 * Description : Shows the tags that can be set based on the client
331 * 1 : csp = Current client state (buffers, headers, etc...)
332 * 2 : rsp = http_response data structure for output
333 * 3 : parameters = map of cgi parameters
335 * CGI Parameters : none
337 * Returns : JB_ERR_OK on success
338 * JB_ERR_MEMORY on out-of-memory error.
340 *********************************************************************/
341 jb_err cgi_show_client_tags(struct client_state *csp,
342 struct http_response *rsp,
343 const struct map *parameters)
346 struct client_tag_spec *this_tag;
347 jb_err err = JB_ERR_OK;
348 char *client_tag_status;
350 time_t refresh_delay;
356 if (NULL == (exports = default_exports(csp, "client-tags")))
358 return JB_ERR_MEMORY;
360 assert(csp->client_address != NULL);
362 this_tag = csp->config->client_tags;
363 if (this_tag->name == NULL)
365 client_tag_status = strdup_or_die("<p>No tags have been configured.</p>\n");
369 client_tag_status = strdup_or_die("<table border=\"1\">\n"
370 "<tr><th>Tag name</th>\n"
371 "<th>Current state</th><th>Change state</th><th>Description</th></tr>\n");
372 while ((this_tag != NULL) && (this_tag->name != NULL))
376 privoxy_mutex_lock(&client_tags_mutex);
377 tag_state = client_has_requested_tag(csp->client_address, this_tag->name);
378 privoxy_mutex_unlock(&client_tags_mutex);
379 if (!err) err = string_append(&client_tag_status, "<tr><td>");
380 if (!err) err = string_append(&client_tag_status, this_tag->name);
381 if (!err) err = string_append(&client_tag_status, "</td><td>");
382 if (!err) err = string_append(&client_tag_status, tag_state == 1 ? "Enabled" : "Disabled");
383 if (!err) err = string_append(&client_tag_status, "</td><td>");
384 cgi_create_client_tag_form(buf, sizeof(buf), this_tag->name, !tag_state, 1);
385 if (!err) err = string_append(&client_tag_status, buf);
388 cgi_create_client_tag_form(buf, sizeof(buf), this_tag->name, !tag_state, 0);
389 if (!err) err = string_append(&client_tag_status, buf);
391 if (!err) err = string_append(&client_tag_status, "</td><td>");
392 if (!err) err = string_append(&client_tag_status, this_tag->description);
393 if (!err) err = string_append(&client_tag_status, "</td></tr>\n");
398 this_tag = this_tag->next;
400 if (!err) err = string_append(&client_tag_status, "</table>\n");
404 return JB_ERR_MEMORY;
407 refresh_delay = get_next_tag_timeout_for_client(csp->client_address);
408 if (refresh_delay != 0)
410 snprintf(buf, sizeof(buf), "%u", csp->config->client_tag_lifetime);
411 if (map(exports, "refresh-delay", 1, buf, 1))
413 freez(client_tag_status);
415 return JB_ERR_MEMORY;
420 err = map_block_killer(exports, "tags-expire");
421 if (err != JB_ERR_OK)
423 freez(client_tag_status);
428 if (map(exports, "client-tags", 1, client_tag_status, 0))
431 return JB_ERR_MEMORY;
434 if (map(exports, "client-ip-addr", 1, csp->client_address, 1))
437 return JB_ERR_MEMORY;
440 return template_fill_for_cgi(csp, "client-tags", exports, rsp);
444 /*********************************************************************
446 * Function : cgi_toggle_client_tag
448 * Description : Toggles a client tag and redirects to the show-tags
452 * 1 : csp = Current client state (buffers, headers, etc...)
453 * 2 : rsp = http_response data structure for output
454 * 3 : parameters = map of cgi parameters
456 * CGI Parameters : none
457 * 1 : tag = Name of the tag to enable or disable
458 * 2 : toggle-state = How to toggle the tag (0/1)
459 * 3 : expires = Set to 1 if the tag should be enabled
460 * temporarily, otherwise set to 0
462 * Returns : JB_ERR_OK on success
463 * JB_ERR_MEMORY on out-of-memory error.
465 *********************************************************************/
466 jb_err cgi_toggle_client_tag(struct client_state *csp,
467 struct http_response *rsp,
468 const struct map *parameters)
470 const char *toggled_tag;
471 const char *toggle_state;
472 const char *tag_expires;
479 toggled_tag = lookup(parameters, "tag");
480 if (*toggled_tag == '\0')
482 log_error(LOG_LEVEL_ERROR, "Received tag toggle request without tag");
486 tag_expires = lookup(parameters, "expires");
487 if (*tag_expires == '0')
493 time_to_live = csp->config->client_tag_lifetime;
495 toggle_state = lookup(parameters, "toggle-state");
496 if (*toggle_state == '1')
498 enable_client_specific_tag(csp, toggled_tag, time_to_live);
502 disable_client_specific_tag(csp, toggled_tag);
505 rsp->status = strdup_or_die("302 Done dealing with toggle request");
506 if (enlist_unique_header(rsp->headers,
507 "Location", CGI_PREFIX "client-tags"))
509 return JB_ERR_MEMORY;
514 #endif /* def FEATURE_CLIENT_TAGS */
517 /*********************************************************************
519 * Function : cgi_send_banner
521 * Description : CGI function that returns a banner.
524 * 1 : csp = Current client state (buffers, headers, etc...)
525 * 2 : rsp = http_response data structure for output
526 * 3 : parameters = map of cgi parameters
529 * type : Selects the type of banner between "trans", "pattern",
530 * and "auto". Defaults to "pattern" if absent or invalid.
531 * "auto" means to select as if we were image-blocking.
532 * (Only the first character really counts; b and t are
535 * Returns : JB_ERR_OK on success
536 * JB_ERR_MEMORY on out-of-memory error.
538 *********************************************************************/
539 jb_err cgi_send_banner(struct client_state *csp,
540 struct http_response *rsp,
541 const struct map *parameters)
543 char imagetype = lookup(parameters, "type")[0];
545 if (imagetype != 'a' && imagetype != 'b' &&
546 imagetype != 'p' && imagetype != 't')
548 log_error(LOG_LEVEL_ERROR, "Overruling invalid image type '%c'.",
554 * If type is auto, then determine the right thing
555 * to do from the set-image-blocker action
557 if (imagetype == 'a')
564 #ifdef FEATURE_IMAGE_BLOCKING
565 if ((csp->action->flags & ACTION_IMAGE_BLOCKER) != 0)
567 static const char prefix1[] = CGI_PREFIX "send-banner?type=";
568 static const char prefix2[] = "http://" CGI_SITE_1_HOST "/send-banner?type=";
569 const char *p = csp->action->string[ACTION_STRING_IMAGE_BLOCKER];
573 /* Use default - nothing to do here. */
575 else if (0 == strcmpic(p, "blank"))
579 else if (0 == strcmpic(p, "pattern"))
585 * If the action is to call this CGI, determine
588 else if (0 == strncmpic(p, prefix1, sizeof(prefix1) - 1))
590 imagetype = p[sizeof(prefix1) - 1];
592 else if (0 == strncmpic(p, prefix2, sizeof(prefix2) - 1))
594 imagetype = p[sizeof(prefix2) - 1];
598 * Everything else must (should) be a URL to
606 #endif /* def FEATURE_IMAGE_BLOCKING */
610 * Now imagetype is either the non-auto type we were called with,
611 * or it was auto and has since been determined. In any case, we
612 * can proceed to actually answering the request by sending a redirect
613 * or an image as appropriate:
615 if (imagetype == 'r')
617 rsp->status = strdup_or_die("302 Local Redirect from Privoxy");
618 if (enlist_unique_header(rsp->headers, "Location",
619 csp->action->string[ACTION_STRING_IMAGE_BLOCKER]))
621 return JB_ERR_MEMORY;
626 if ((imagetype == 'b') || (imagetype == 't'))
628 rsp->body = bindup(image_blank_data, image_blank_length);
629 rsp->content_length = image_blank_length;
633 rsp->body = bindup(image_pattern_data, image_pattern_length);
634 rsp->content_length = image_pattern_length;
637 if (rsp->body == NULL)
639 return JB_ERR_MEMORY;
641 if (enlist(rsp->headers, "Content-Type: " BUILTIN_IMAGE_MIMETYPE))
643 return JB_ERR_MEMORY;
654 /*********************************************************************
656 * Function : cgi_transparent_image
658 * Description : CGI function that sends a 1x1 transparent image.
661 * 1 : csp = Current client state (buffers, headers, etc...)
662 * 2 : rsp = http_response data structure for output
663 * 3 : parameters = map of cgi parameters
665 * CGI Parameters : None
667 * Returns : JB_ERR_OK on success
668 * JB_ERR_MEMORY on out-of-memory error.
670 *********************************************************************/
671 jb_err cgi_transparent_image(struct client_state *csp,
672 struct http_response *rsp,
673 const struct map *parameters)
678 rsp->body = bindup(image_blank_data, image_blank_length);
679 rsp->content_length = image_blank_length;
681 if (rsp->body == NULL)
683 return JB_ERR_MEMORY;
686 if (enlist(rsp->headers, "Content-Type: " BUILTIN_IMAGE_MIMETYPE))
688 return JB_ERR_MEMORY;
698 /*********************************************************************
700 * Function : cgi_send_default_favicon
702 * Description : CGI function that sends the standard favicon.
705 * 1 : csp = Current client state (buffers, headers, etc...)
706 * 2 : rsp = http_response data structure for output
707 * 3 : parameters = map of cgi parameters
709 * CGI Parameters : None
711 * Returns : JB_ERR_OK on success
712 * JB_ERR_MEMORY on out-of-memory error.
714 *********************************************************************/
715 jb_err cgi_send_default_favicon(struct client_state *csp,
716 struct http_response *rsp,
717 const struct map *parameters)
719 static const char default_favicon_data[] =
720 "\000\000\001\000\001\000\020\020\002\000\000\000\000\000\260"
721 "\000\000\000\026\000\000\000\050\000\000\000\020\000\000\000"
722 "\040\000\000\000\001\000\001\000\000\000\000\000\100\000\000"
723 "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000"
724 "\000\000\377\377\377\000\377\000\052\000\017\360\000\000\077"
725 "\374\000\000\161\376\000\000\161\376\000\000\361\377\000\000"
726 "\361\377\000\000\360\017\000\000\360\007\000\000\361\307\000"
727 "\000\361\307\000\000\361\307\000\000\360\007\000\000\160\036"
728 "\000\000\177\376\000\000\077\374\000\000\017\360\000\000\360"
729 "\017\000\000\300\003\000\000\200\001\000\000\200\001\000\000"
730 "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
731 "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
732 "\000\000\200\001\000\000\200\001\000\000\300\003\000\000\360"
734 static const size_t favicon_length = sizeof(default_favicon_data) - 1;
739 rsp->body = bindup(default_favicon_data, favicon_length);
740 rsp->content_length = favicon_length;
742 if (rsp->body == NULL)
744 return JB_ERR_MEMORY;
747 if (enlist(rsp->headers, "Content-Type: image/x-icon"))
749 return JB_ERR_MEMORY;
759 /*********************************************************************
761 * Function : cgi_send_error_favicon
763 * Description : CGI function that sends the favicon for error pages.
766 * 1 : csp = Current client state (buffers, headers, etc...)
767 * 2 : rsp = http_response data structure for output
768 * 3 : parameters = map of cgi parameters
770 * CGI Parameters : None
772 * Returns : JB_ERR_OK on success
773 * JB_ERR_MEMORY on out-of-memory error.
775 *********************************************************************/
776 jb_err cgi_send_error_favicon(struct client_state *csp,
777 struct http_response *rsp,
778 const struct map *parameters)
780 static const char error_favicon_data[] =
781 "\000\000\001\000\001\000\020\020\002\000\000\000\000\000\260"
782 "\000\000\000\026\000\000\000\050\000\000\000\020\000\000\000"
783 "\040\000\000\000\001\000\001\000\000\000\000\000\100\000\000"
784 "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000"
785 "\000\000\377\377\377\000\000\000\377\000\017\360\000\000\077"
786 "\374\000\000\161\376\000\000\161\376\000\000\361\377\000\000"
787 "\361\377\000\000\360\017\000\000\360\007\000\000\361\307\000"
788 "\000\361\307\000\000\361\307\000\000\360\007\000\000\160\036"
789 "\000\000\177\376\000\000\077\374\000\000\017\360\000\000\360"
790 "\017\000\000\300\003\000\000\200\001\000\000\200\001\000\000"
791 "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
792 "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
793 "\000\000\200\001\000\000\200\001\000\000\300\003\000\000\360"
795 static const size_t favicon_length = sizeof(error_favicon_data) - 1;
800 rsp->body = bindup(error_favicon_data, favicon_length);
801 rsp->content_length = favicon_length;
803 if (rsp->body == NULL)
805 return JB_ERR_MEMORY;
808 if (enlist(rsp->headers, "Content-Type: image/x-icon"))
810 return JB_ERR_MEMORY;
820 /*********************************************************************
822 * Function : cgi_send_stylesheet
824 * Description : CGI function that sends a css stylesheet found
825 * in the cgi-style.css template
828 * 1 : csp = Current client state (buffers, headers, etc...)
829 * 2 : rsp = http_response data structure for output
830 * 3 : parameters = map of cgi parameters
832 * CGI Parameters : None
834 * Returns : JB_ERR_OK on success
835 * JB_ERR_MEMORY on out-of-memory error.
837 *********************************************************************/
838 jb_err cgi_send_stylesheet(struct client_state *csp,
839 struct http_response *rsp,
840 const struct map *parameters)
849 err = template_load(csp, &rsp->body, "cgi-style.css", 0);
851 if (err == JB_ERR_FILE)
854 * No way to tell user; send empty stylesheet
856 log_error(LOG_LEVEL_ERROR, "Could not find cgi-style.css template");
860 return err; /* JB_ERR_MEMORY */
863 if (enlist(rsp->headers, "Content-Type: text/css"))
865 return JB_ERR_MEMORY;
873 /*********************************************************************
875 * Function : cgi_send_url_info_osd
877 * Description : CGI function that sends the OpenSearch Description
878 * template for the show-url-info page. It allows to
879 * access the page through "search engine plugins".
882 * 1 : csp = Current client state (buffers, headers, etc...)
883 * 2 : rsp = http_response data structure for output
884 * 3 : parameters = map of cgi parameters
886 * CGI Parameters : None
888 * Returns : JB_ERR_OK on success
889 * JB_ERR_MEMORY on out-of-memory error.
891 *********************************************************************/
892 jb_err cgi_send_url_info_osd(struct client_state *csp,
893 struct http_response *rsp,
894 const struct map *parameters)
896 jb_err err = JB_ERR_MEMORY;
897 struct map *exports = default_exports(csp, NULL);
904 err = template_fill_for_cgi(csp, "url-info-osd.xml", exports, rsp);
905 if (JB_ERR_OK == err)
907 err = enlist(rsp->headers,
908 "Content-Type: application/opensearchdescription+xml");
917 /*********************************************************************
919 * Function : get_content_type
921 * Description : Use the file extension to guess the content type
922 * header we should use to serve the file.
925 * 1 : filename = Name of the file whose content type
928 * Returns : The guessed content type.
930 *********************************************************************/
931 static const char *get_content_type(const char *filename)
936 const char extension[6];
937 const char content_type[11];
939 static const struct content_type content_types[] =
941 {".css", "text/css"},
942 {".jpg", "image/jpeg"},
943 {".jpeg", "image/jpeg"},
944 {".png", "image/png"},
947 for (i = 0; i < SZ(content_types); i++)
949 if (strstr(filename, content_types[i].extension))
951 return content_types[i].content_type;
955 /* No match by extension, default to html */
959 /*********************************************************************
961 * Function : cgi_send_user_manual
963 * Description : CGI function that sends a file in the user
967 * 1 : csp = Current client state (buffers, headers, etc...)
968 * 2 : rsp = http_response data structure for output
969 * 3 : parameters = map of cgi parameters
971 * CGI Parameters : file=name.html, the name of the HTML file
972 * (relative to user-manual from config)
974 * Returns : JB_ERR_OK on success
975 * JB_ERR_MEMORY on out-of-memory error.
977 *********************************************************************/
978 jb_err cgi_send_user_manual(struct client_state *csp,
979 struct http_response *rsp,
980 const struct map *parameters)
982 const char *filename;
984 jb_err err = JB_ERR_OK;
985 const char *content_type;
991 if (0 == strncmpic(csp->config->usermanual, "http://", 7) ||
992 0 == strncmpic(csp->config->usermanual, "https://", 8))
994 log_error(LOG_LEVEL_CGI, "Request for local user-manual "
995 "received while user-manual delivery is disabled.");
996 return cgi_error_404(csp, rsp, parameters);
999 if (!parameters->first)
1001 /* requested http://p.p/user-manual (without trailing slash) */
1002 return cgi_redirect(rsp, CGI_PREFIX "user-manual/");
1005 get_string_param(parameters, "file", &filename);
1006 if (filename == NULL)
1008 /* It's '/' so serve the index.html if there is one. */
1009 filename = "index.html";
1011 else if (NULL != strchr(filename, '/') || NULL != strstr(filename, ".."))
1014 * We currently only support a flat file
1015 * hierarchy for the documentation.
1017 log_error(LOG_LEVEL_ERROR,
1018 "Rejecting the request to serve '%s' as it contains '/' or '..'",
1020 return JB_ERR_CGI_PARAMS;
1023 full_path = make_path(csp->config->usermanual, filename);
1024 if (full_path == NULL)
1026 return JB_ERR_MEMORY;
1029 err = load_file(full_path, &rsp->body, &rsp->content_length);
1030 if (JB_ERR_OK != err)
1032 assert((JB_ERR_FILE == err) || (JB_ERR_MEMORY == err));
1033 if (JB_ERR_FILE == err)
1035 err = cgi_error_no_template(csp, rsp, full_path);
1042 content_type = get_content_type(filename);
1043 log_error(LOG_LEVEL_CGI,
1044 "Content-Type guessed for %s: %s", filename, content_type);
1046 return enlist_unique_header(rsp->headers, "Content-Type", content_type);
1051 #ifdef FEATURE_EXTENDED_STATISTICS
1052 /*********************************************************************
1054 * Function : get_block_reason_statistics_table
1056 * Description : Produces the block reason statistic table content.
1059 * 1 : csp = Current client state (buffers, headers, etc...)
1061 * Returns : Pointer to the HTML statistic table content or
1062 * NULL on out of memory
1064 *********************************************************************/
1065 static char *get_block_reason_statistics_table(const struct client_state *csp)
1067 char buf[BUFFER_SIZE];
1070 struct file_list *fl;
1071 jb_err err = JB_ERR_OK;
1073 statistics = strdup_or_die("");
1075 /* Run through all action files. */
1076 for (i = 0; i < MAX_AF_FILES; i++)
1078 struct url_actions *b;
1079 struct action_spec *last_action = NULL;
1081 if (((fl = csp->actions_list[i]) == NULL) || ((b = fl->f) == NULL))
1083 /* Skip empty files */
1087 /* Go through all the actions. */
1088 for (b = b->next; NULL != b; b = b->next)
1090 if (last_action == b->action)
1094 if ((b->action->add & ACTION_BLOCK))
1096 unsigned long long count;
1097 const char *block_reason = b->action->string[ACTION_STRING_BLOCK];
1098 const char *encoded_block_reason = html_encode(block_reason);
1100 if (encoded_block_reason == NULL)
1105 get_block_reason_count(block_reason, &count);
1106 snprintf(buf, sizeof(buf),
1107 "<tr><td>%s</td><td style=\"text-align: right\">%llu</td>\n",
1108 encoded_block_reason, count);
1109 freez(encoded_block_reason);
1111 if (!err) err = string_append(&statistics, buf);
1113 last_action = b->action;
1122 /*********************************************************************
1124 * Function : get_filter_statistics_table
1126 * Description : Produces the filter statistic table content.
1129 * 1 : csp = Current client state (buffers, headers, etc...)
1131 * Returns : Pointer to the HTML statistic table content or
1132 * NULL on out of memory
1134 *********************************************************************/
1135 static char *get_filter_statistics_table(const struct client_state *csp)
1137 char buf[BUFFER_SIZE];
1140 struct file_list *fl;
1141 struct re_filterfile_spec *b;
1142 jb_err err = JB_ERR_OK;
1144 statistics = strdup_or_die("");
1146 for (i = 0; i < MAX_AF_FILES; i++)
1149 if ((NULL == fl) || (NULL == fl->f))
1152 * Either there are no filter files left or this
1153 * filter file just contains no valid filters.
1155 * Continue to be sure we don't miss valid filter
1156 * files that are chained after empty or invalid ones.
1161 for (b = fl->f; b != NULL; b = b->next)
1163 if (b->type == FT_CONTENT_FILTER)
1165 unsigned long long executions;
1166 unsigned long long response_bodies_modified;
1167 unsigned long long hits;
1169 get_filter_statistics(b->name, &executions, &response_bodies_modified, &hits);
1170 snprintf(buf, sizeof(buf),
1171 "<tr><td>%s</td><td style=\"text-align: right\">%llu</td>"
1172 "<td style=\"text-align: right\">%llu</td>"
1173 "<td style=\"text-align: right\">%llu</td><tr>\n",
1174 b->name, executions, response_bodies_modified, hits);
1176 if (!err) err = string_append(&statistics, buf);
1184 #endif /* def FEATURE_EXTENDED_STATISTICS */
1187 /*********************************************************************
1189 * Function : cgi_show_status
1191 * Description : CGI function that returns a web page describing the
1192 * current status of Privoxy.
1195 * 1 : csp = Current client state (buffers, headers, etc...)
1196 * 2 : rsp = http_response data structure for output
1197 * 3 : parameters = map of cgi parameters
1200 * file : Which file to show. Only first letter is checked,
1205 * Default is to show menu and other information.
1207 * Returns : JB_ERR_OK on success
1208 * JB_ERR_MEMORY on out-of-memory error.
1210 *********************************************************************/
1211 jb_err cgi_show_status(struct client_state *csp,
1212 struct http_response *rsp,
1213 const struct map *parameters)
1219 char buf[BUFFER_SIZE];
1220 #ifdef FEATURE_STATISTICS
1221 float perc_rej; /* Percentage of http requests rejected */
1222 int local_urls_read;
1223 int local_urls_rejected;
1224 #endif /* ndef FEATURE_STATISTICS */
1225 jb_err err = JB_ERR_OK;
1227 struct map *exports;
1233 if ('\0' != *(lookup(parameters, "file")))
1235 return cgi_show_file(csp, rsp, parameters);
1238 if (NULL == (exports = default_exports(csp, "show-status")))
1240 return JB_ERR_MEMORY;
1244 for (j = 0; (s != NULL) && (j < Argc); j++)
1246 if (!err) err = string_join (&s, html_encode(Argv[j]));
1247 if (!err) err = string_append(&s, " ");
1249 if (!err) err = map(exports, "invocation", 1, s, 0);
1251 if (!err) err = map(exports, "options", 1, csp->config->proxy_args, 1);
1252 if (!err) err = show_defines(exports);
1257 return JB_ERR_MEMORY;
1260 #ifdef FEATURE_STATISTICS
1261 local_urls_read = urls_read;
1262 local_urls_rejected = urls_rejected;
1265 * Need to alter the stats not to include the fetch of this
1268 * Can't do following thread safely! doh!
1271 * urls_rejected--; * This will be incremented subsequently *
1274 if (local_urls_read == 0)
1276 if (!err) err = map_block_killer(exports, "have-stats");
1280 if (!err) err = map_block_killer(exports, "have-no-stats");
1282 perc_rej = (float)local_urls_rejected * 100.0F /
1283 (float)local_urls_read;
1285 snprintf(buf, sizeof(buf), "%d", local_urls_read);
1286 if (!err) err = map(exports, "requests-received", 1, buf, 1);
1288 snprintf(buf, sizeof(buf), "%d", local_urls_rejected);
1289 if (!err) err = map(exports, "requests-blocked", 1, buf, 1);
1291 snprintf(buf, sizeof(buf), "%6.2f", perc_rej);
1292 if (!err) err = map(exports, "percent-blocked", 1, buf, 1);
1295 #else /* ndef FEATURE_STATISTICS */
1296 if (!err) err = map_block_killer(exports, "statistics");
1297 #endif /* ndef FEATURE_STATISTICS */
1299 #ifdef FEATURE_EXTENDED_STATISTICS
1302 char *block_reason_statistics = get_block_reason_statistics_table(csp);
1303 if (block_reason_statistics != NULL)
1305 err = map(exports, "block-reason-statistics", 1, block_reason_statistics, 0);
1309 err = map_block_killer(exports, "extended-statistics");
1314 char *filter_statistics = get_filter_statistics_table(csp);
1315 if (filter_statistics != NULL)
1317 err = map(exports, "filter-statistics", 1, filter_statistics, 0);
1321 err = map_block_killer(exports, "extended-statistics");
1324 #else /* ndef FEATURE_EXTENDED_STATISTICS */
1325 if (!err) err = map_block_killer(exports, "extended-statistics");
1326 #endif /* def FEATURE_EXTENDED_STATISTICS */
1329 * List all action files in use, together with view and edit links,
1330 * except for standard.action, which should only be viewable. (Not
1331 * enforced in the editor itself)
1332 * FIXME: Shouldn't include hardwired HTML here, use line template instead!
1335 for (i = 0; i < MAX_AF_FILES; i++)
1337 if (csp->actions_list[i] != NULL)
1339 if (!err) err = string_append(&s, "<tr><td>");
1340 if (!err) err = string_join(&s, html_encode(csp->actions_list[i]->filename));
1341 snprintf(buf, sizeof(buf),
1342 "</td><td class=\"buttons\"><a href=\"/show-status?file=actions&index=%u\">View</a>", i);
1343 if (!err) err = string_append(&s, buf);
1345 #ifdef FEATURE_CGI_EDIT_ACTIONS
1346 if ((csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS)
1347 && (NULL != csp->config->actions_file_short[i]))
1350 if (access(csp->config->actions_file[i], W_OK) == 0)
1352 #endif /* def HAVE_ACCESS */
1353 snprintf(buf, sizeof(buf), " <a href=\"/edit-actions-list?f=%u\">Edit</a>", i);
1354 if (!err) err = string_append(&s, buf);
1359 if (!err) err = string_append(&s, " <strong>No write access.</strong>");
1361 #endif /* def HAVE_ACCESS */
1365 if (!err) err = string_append(&s, "</td></tr>\n");
1368 if (!err && *s != '\0')
1370 err = map(exports, "actions-filenames", 1, s, 0);
1374 if (!err) err = map(exports, "actions-filenames", 1, "<tr><td>None specified</td></tr>", 1);
1379 * List all re_filterfiles in use, together with view options.
1380 * FIXME: Shouldn't include hardwired HTML here, use line template instead!
1383 for (i = 0; i < MAX_AF_FILES; i++)
1385 if (csp->rlist[i] != NULL)
1387 if (!err) err = string_append(&s, "<tr><td>");
1388 if (!err) err = string_join(&s, html_encode(csp->rlist[i]->filename));
1389 snprintf(buf, sizeof(buf),
1390 "</td><td class=\"buttons\"><a href=\"/show-status?file=filter&index=%u\">View</a>", i);
1391 if (!err) err = string_append(&s, buf);
1392 if (!err) err = string_append(&s, "</td></tr>\n");
1395 if (!err && *s != '\0')
1397 err = map(exports, "re-filter-filenames", 1, s, 0);
1401 if (!err) err = map(exports, "re-filter-filenames", 1, "<tr><td>None specified</td></tr>", 1);
1402 if (!err) err = map_block_killer(exports, "have-filterfile");
1406 #ifdef FEATURE_TRUST
1409 if (!err) err = map(exports, "trust-filename", 1, html_encode(csp->tlist->filename), 0);
1413 if (!err) err = map(exports, "trust-filename", 1, "None specified", 1);
1414 if (!err) err = map_block_killer(exports, "have-trustfile");
1417 if (!err) err = map_block_killer(exports, "trust-support");
1418 #endif /* ndef FEATURE_TRUST */
1420 #ifdef FEATURE_CGI_EDIT_ACTIONS
1421 if (!err && (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
1423 err = map_block_killer(exports, "cgi-editor-is-disabled");
1425 #endif /* ndef CGI_EDIT_ACTIONS */
1427 if (!err) err = map(exports, "force-prefix", 1, FORCE_PREFIX, 1);
1432 return JB_ERR_MEMORY;
1435 return template_fill_for_cgi(csp, "show-status", exports, rsp);
1439 /*********************************************************************
1441 * Function : cgi_show_url_info
1443 * Description : CGI function that determines and shows which actions
1444 * Privoxy will perform for a given url, and which
1445 * matches starting from the defaults have lead to that.
1448 * 1 : csp = Current client state (buffers, headers, etc...)
1449 * 2 : rsp = http_response data structure for output
1450 * 3 : parameters = map of cgi parameters
1453 * url : The url whose actions are to be determined.
1454 * If url is unset, the url-given conditional will be
1455 * set, so that all but the form can be suppressed in
1458 * Returns : JB_ERR_OK on success
1459 * JB_ERR_MEMORY on out-of-memory error.
1461 *********************************************************************/
1462 jb_err cgi_show_url_info(struct client_state *csp,
1463 struct http_response *rsp,
1464 const struct map *parameters)
1467 struct map *exports;
1474 if (NULL == (exports = default_exports(csp, "show-url-info")))
1476 return JB_ERR_MEMORY;
1480 * Get the url= parameter (if present) and remove any leading/trailing spaces.
1482 url_param = strdup_or_die(lookup(parameters, "url"));
1486 * Handle prefixes. 4 possibilities:
1487 * 1) "http://" or "https://" prefix present and followed by URL - OK
1488 * 2) Only the "http://" or "https://" part is present, no URL - change
1489 * to empty string so it will be detected later as "no URL".
1490 * 3) Parameter specified but doesn't start with "http(s?)://" - add a
1492 * 4) Parameter not specified or is empty string - let this fall through
1493 * for now, next block of code will handle it.
1495 if (0 == strncmp(url_param, "http://", 7))
1497 if (url_param[7] == '\0')
1500 * Empty URL (just prefix).
1501 * Make it totally empty so it's caught by the next if ()
1503 url_param[0] = '\0';
1506 else if (0 == strncmp(url_param, "https://", 8))
1508 if (url_param[8] == '\0')
1511 * Empty URL (just prefix).
1512 * Make it totally empty so it's caught by the next if ()
1514 url_param[0] = '\0';
1517 else if ((url_param[0] != '\0')
1518 && ((NULL == strstr(url_param, "://")
1519 || (strstr(url_param, "://") > strstr(url_param, "/")))))
1522 * No prefix or at least no prefix before
1523 * the first slash - assume http://
1525 char *url_param_prefixed = strdup_or_die("http://");
1527 if (JB_ERR_OK != string_join(&url_param_prefixed, url_param))
1530 return JB_ERR_MEMORY;
1532 url_param = url_param_prefixed;
1536 * Hide "toggle off" warning if Privoxy is toggled on.
1539 #ifdef FEATURE_TOGGLE
1540 (global_toggle_state == 1) &&
1541 #endif /* def FEATURE_TOGGLE */
1542 map_block_killer(exports, "privoxy-is-toggled-off")
1547 return JB_ERR_MEMORY;
1550 if (url_param[0] == '\0')
1552 /* URL parameter not specified, display query form only. */
1554 if (map_block_killer(exports, "url-given")
1555 || map(exports, "url", 1, "", 1))
1558 return JB_ERR_MEMORY;
1563 /* Given a URL, so query it. */
1568 struct file_list *fl;
1569 struct url_actions *b;
1570 struct http_request url_to_query[1];
1571 struct current_action_spec action[1];
1574 if (map(exports, "url", 1, html_encode(url_param), 0))
1578 return JB_ERR_MEMORY;
1581 init_current_action(action);
1583 if (map(exports, "default", 1, current_action_to_html(csp, action), 0))
1585 free_current_action(action);
1588 return JB_ERR_MEMORY;
1591 memset(url_to_query, '\0', sizeof(url_to_query));
1592 err = parse_http_url(url_param, url_to_query, REQUIRE_PROTOCOL);
1593 assert((err != JB_ERR_OK) || (url_to_query->ssl == !strncmpic(url_param, "https://", 8)));
1597 if (err == JB_ERR_MEMORY)
1599 free_http_request(url_to_query);
1600 free_current_action(action);
1602 return JB_ERR_MEMORY;
1608 err = map(exports, "matches", 1, "<b>[Invalid URL specified!]</b>" , 1);
1609 if (!err) err = map(exports, "final", 1, lookup(exports, "default"), 1);
1610 if (!err) err = map_block_killer(exports, "valid-url");
1612 free_current_action(action);
1613 free_http_request(url_to_query);
1618 return JB_ERR_MEMORY;
1621 return template_fill_for_cgi(csp, "show-url-info", exports, rsp);
1625 * We have a warning about SSL paths. Hide it for unencrypted sites
1626 * and unconditionally if https inspection is enabled.
1628 #ifndef FEATURE_HTTPS_INSPECTION
1629 if (!url_to_query->ssl)
1632 if (map_block_killer(exports, "https-and-no-https-inspection"))
1634 free_current_action(action);
1636 free_http_request(url_to_query);
1637 return JB_ERR_MEMORY;
1641 matches = strdup_or_die("<table summary=\"\" class=\"transparent\">");
1643 for (i = 0; i < MAX_AF_FILES; i++)
1645 if (NULL == csp->config->actions_file_short[i]
1646 || !strcmp(csp->config->actions_file_short[i], "standard.action")) continue;
1650 if ((fl = csp->actions_list[i]) != NULL)
1652 if ((b = fl->f) != NULL)
1654 /* FIXME: Hardcoded HTML! */
1655 string_append(&matches, "<tr><th>In file: ");
1656 string_join (&matches, html_encode(csp->config->actions_file_short[i]));
1657 snprintf(buf, sizeof(buf), " <a class=\"cmd\" href=\"/show-status?file=actions&index=%d\">", i);
1658 string_append(&matches, buf);
1659 string_append(&matches, "View</a>");
1660 #ifdef FEATURE_CGI_EDIT_ACTIONS
1661 if (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS)
1664 if (access(csp->config->actions_file[i], W_OK) == 0)
1666 #endif /* def HAVE_ACCESS */
1667 snprintf(buf, sizeof(buf),
1668 " <a class=\"cmd\" href=\"/edit-actions-list?f=%d\">", i);
1669 string_append(&matches, buf);
1670 string_append(&matches, "Edit</a>");
1675 string_append(&matches, " <strong>No write access.</strong>");
1677 #endif /* def HAVE_ACCESS */
1679 #endif /* FEATURE_CGI_EDIT_ACTIONS */
1681 string_append(&matches, "</th></tr>\n");
1688 for (; (b != NULL) && (matches != NULL); b = b->next)
1690 if (url_match(b->url, url_to_query))
1692 string_append(&matches, "<tr><td>{");
1693 string_join (&matches, actions_to_html(csp, b->action));
1694 string_append(&matches, " }<br>\n<code>");
1695 string_join (&matches, html_encode(b->url->spec));
1696 string_append(&matches, "</code></td></tr>\n");
1698 if (merge_current_action(action, b->action))
1701 free_http_request(url_to_query);
1702 free_current_action(action);
1704 return JB_ERR_MEMORY;
1712 string_append(&matches, "<tr><td>(no matches in this file)</td></tr>\n");
1715 string_append(&matches, "</table>\n");
1718 * XXX: Kludge to make sure the "Forward settings" section
1719 * shows what forward-override{} would do with the requested URL.
1720 * No one really cares how the CGI request would be forwarded
1721 * if it wasn't intercepted as CGI request in the first place.
1723 * From here on the action bitmask will no longer reflect
1724 * the real url (http://config.privoxy.org/show-url-info?url=.*),
1725 * but luckily it's no longer required later on anyway.
1727 free_current_action(csp->action);
1728 get_url_actions(csp, url_to_query);
1731 * Fill in forwarding settings.
1733 * The possibilities are:
1735 * - http forwarding only
1736 * - socks4(a) forwarding only
1737 * - socks4(a) and http forwarding.
1739 * XXX: Parts of this code could be reused for the
1740 * "forwarding-failed" template which currently doesn't
1741 * display the proxy port and an eventual second forwarder.
1744 const struct forward_spec *fwd = forward_url(csp, url_to_query);
1746 if ((fwd->gateway_host == NULL) && (fwd->forward_host == NULL))
1748 if (!err) err = map_block_killer(exports, "socks-forwarder");
1749 if (!err) err = map_block_killer(exports, "http-forwarder");
1753 char port[10]; /* We save proxy ports as int but need a string here */
1755 if (!err) err = map_block_killer(exports, "no-forwarder");
1757 if (fwd->gateway_host != NULL)
1759 char *socks_type = NULL;
1764 socks_type = "socks4";
1767 socks_type = "socks4a";
1770 socks_type = "socks5";
1773 socks_type = "socks5t";
1776 log_error(LOG_LEVEL_FATAL, "Unknown socks type: %d.", fwd->type);
1779 if (!err) err = map(exports, "socks-type", 1, socks_type, 1);
1780 if (!err) err = map(exports, "gateway-host", 1, fwd->gateway_host, 1);
1781 snprintf(port, sizeof(port), "%d", fwd->gateway_port);
1782 if (!err) err = map(exports, "gateway-port", 1, port, 1);
1786 if (!err) err = map_block_killer(exports, "socks-forwarder");
1789 if (fwd->forward_host != NULL)
1791 if (!err) err = map(exports, "forward-host", 1, fwd->forward_host, 1);
1792 snprintf(port, sizeof(port), "%d", fwd->forward_port);
1793 if (!err) err = map(exports, "forward-port", 1, port, 1);
1797 if (!err) err = map_block_killer(exports, "http-forwarder");
1802 free_http_request(url_to_query);
1804 if (err || matches == NULL)
1806 free_current_action(action);
1808 return JB_ERR_MEMORY;
1811 #ifdef FEATURE_CGI_EDIT_ACTIONS
1812 if ((csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
1814 err = map_block_killer(exports, "cgi-editor-is-disabled");
1816 #endif /* FEATURE_CGI_EDIT_ACTIONS */
1819 * If zlib support is available, if no content filters
1820 * are enabled or if the prevent-compression action is enabled,
1821 * suppress the "compression could prevent filtering" warning.
1823 #ifndef FEATURE_ZLIB
1824 if (!content_filters_enabled(action) ||
1825 (action->flags & ACTION_NO_COMPRESSION))
1828 if (!err) err = map_block_killer(exports, "filters-might-be-ineffective");
1831 if (err || map(exports, "matches", 1, matches , 0))
1833 free_current_action(action);
1835 return JB_ERR_MEMORY;
1838 s = current_action_to_html(csp, action);
1840 free_current_action(action);
1842 if (map(exports, "final", 1, s, 0))
1845 return JB_ERR_MEMORY;
1849 return template_fill_for_cgi(csp, "show-url-info", exports, rsp);
1853 /*********************************************************************
1855 * Function : cgi_robots_txt
1857 * Description : CGI function to return "/robots.txt".
1860 * 1 : csp = Current client state (buffers, headers, etc...)
1861 * 2 : rsp = http_response data structure for output
1862 * 3 : parameters = map of cgi parameters
1864 * CGI Parameters : None
1866 * Returns : JB_ERR_OK on success
1867 * JB_ERR_MEMORY on out-of-memory error.
1869 *********************************************************************/
1870 jb_err cgi_robots_txt(struct client_state *csp,
1871 struct http_response *rsp,
1872 const struct map *parameters)
1880 rsp->body = strdup_or_die(
1881 "# This is the Privoxy control interface.\n"
1882 "# It isn't very useful to index it, and you're likely to break stuff.\n"
1889 err = enlist_unique(rsp->headers, "Content-Type: text/plain", 13);
1893 get_http_time(7 * 24 * 60 * 60, buf, sizeof(buf)); /* 7 days into future */
1894 if (!err) err = enlist_unique_header(rsp->headers, "Expires", buf);
1896 return (err ? JB_ERR_MEMORY : JB_ERR_OK);
1900 /*********************************************************************
1902 * Function : show_defines
1904 * Description : Add to a map the state of all conditional #defines
1905 * used when building
1908 * 1 : exports = map to extend
1910 * Returns : JB_ERR_OK on success
1911 * JB_ERR_MEMORY on out-of-memory error.
1913 *********************************************************************/
1914 static jb_err show_defines(struct map *exports)
1916 jb_err err = JB_ERR_OK;
1919 const char name[31];
1920 const unsigned char is_available;
1923 static const struct feature features[] = {
1925 "FEATURE_64_BIT_TIME_T",
1926 #if (SIZEOF_TIME_T == 8)
1933 "FEATURE_ACCEPT_FILTER",
1934 #ifdef FEATURE_ACCEPT_FILTER
1950 #ifdef FEATURE_BROTLI
1957 "FEATURE_CGI_EDIT_ACTIONS",
1958 #ifdef FEATURE_CGI_EDIT_ACTIONS
1965 "FEATURE_CLIENT_TAGS",
1966 #ifdef FEATURE_CLIENT_TAGS
1973 "FEATURE_COMPRESSION",
1974 #ifdef FEATURE_COMPRESSION
1981 "FEATURE_CONNECTION_KEEP_ALIVE",
1982 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1989 "FEATURE_CONNECTION_SHARING",
1990 #ifdef FEATURE_CONNECTION_SHARING
1997 "FEATURE_EXTERNAL_FILTERS",
1998 #ifdef FEATURE_EXTERNAL_FILTERS
2005 "FEATURE_FAST_REDIRECTS",
2006 #ifdef FEATURE_FAST_REDIRECTS
2013 "FEATURE_FORCE_LOAD",
2014 #ifdef FEATURE_FORCE_LOAD
2021 "FEATURE_GRACEFUL_TERMINATION",
2022 #ifdef FEATURE_GRACEFUL_TERMINATION
2029 "FEATURE_HTTPS_INSPECTION",
2030 #ifdef FEATURE_HTTPS_INSPECTION
2037 "FEATURE_IMAGE_BLOCKING",
2038 #ifdef FEATURE_IMAGE_BLOCKING
2045 "FEATURE_IPV6_SUPPORT",
2054 #ifdef FEATURE_NO_GIFS
2062 #ifdef FEATURE_PTHREAD
2069 "FEATURE_STATISTICS",
2070 #ifdef FEATURE_STATISTICS
2077 "FEATURE_STRPTIME_SANITY_CHECKS",
2078 #ifdef FEATURE_STRPTIME_SANITY_CHECKS
2086 #ifdef FEATURE_TOGGLE
2094 #ifdef FEATURE_TRUST
2109 "FEATURE_DYNAMIC_PCRE",
2110 #ifdef FEATURE_DYNAMIC_PCRE
2117 "FEATURE_EXTENDED_STATISTICS",
2118 #ifdef FEATURE_EXTENDED_STATISTICS
2125 "FEATURE_PCRE_HOST_PATTERNS",
2126 #ifdef FEATURE_PCRE_HOST_PATTERNS
2134 for (i = 0; i < SZ(features); i++)
2136 err = map_conditional(exports, features[i].name, features[i].is_available);
2148 /*********************************************************************
2150 * Function : cgi_show_file
2152 * Description : CGI function that shows the content of a
2153 * configuration file.
2156 * 1 : csp = Current client state (buffers, headers, etc...)
2157 * 2 : rsp = http_response data structure for output
2158 * 3 : parameters = map of cgi parameters
2161 * file : Which file to show. Only first letter is checked,
2166 * Default is to show menu and other information.
2168 * Returns : JB_ERR_OK on success
2169 * JB_ERR_MEMORY on out-of-memory error.
2171 *********************************************************************/
2172 static jb_err cgi_show_file(struct client_state *csp,
2173 struct http_response *rsp,
2174 const struct map *parameters)
2177 const char * filename = NULL;
2178 char * file_description = NULL;
2184 switch (*(lookup(parameters, "file")))
2187 if (!get_number_param(csp, parameters, "index", &i) && i < MAX_AF_FILES && csp->actions_list[i])
2189 filename = csp->actions_list[i]->filename;
2190 file_description = "Actions File";
2195 if (!get_number_param(csp, parameters, "index", &i) && i < MAX_AF_FILES && csp->rlist[i])
2197 filename = csp->rlist[i]->filename;
2198 file_description = "Filter File";
2202 #ifdef FEATURE_TRUST
2206 filename = csp->tlist->filename;
2207 file_description = "Trust File";
2210 #endif /* def FEATURE_TRUST */
2213 if (NULL != filename)
2215 struct map *exports;
2220 exports = default_exports(csp, "show-status");
2221 if (NULL == exports)
2223 return JB_ERR_MEMORY;
2226 if (map(exports, "file-description", 1, file_description, 1)
2227 || map(exports, "filepath", 1, html_encode(filename), 0))
2230 return JB_ERR_MEMORY;
2233 err = load_file(filename, &s, &length);
2234 if (JB_ERR_OK != err)
2236 if (map(exports, "contents", 1, "<h1>ERROR OPENING FILE!</h1>", 1))
2239 return JB_ERR_MEMORY;
2244 s = html_encode_and_free_original(s);
2248 return JB_ERR_MEMORY;
2251 if (map(exports, "contents", 1, s, 0))
2254 return JB_ERR_MEMORY;
2258 return template_fill_for_cgi(csp, "show-status-file", exports, rsp);
2261 return JB_ERR_CGI_PARAMS;
2265 /*********************************************************************
2267 * Function : load_file
2269 * Description : Loads a file into a buffer.
2272 * 1 : filename = Name of the file to be loaded.
2273 * 2 : buffer = Used to return the file's content.
2274 * 3 : length = Used to return the size of the file.
2276 * Returns : JB_ERR_OK in case of success,
2277 * JB_ERR_FILE in case of ordinary file loading errors
2278 * (fseek() and ftell() errors are fatal)
2279 * JB_ERR_MEMORY in case of out-of-memory.
2281 *********************************************************************/
2282 static jb_err load_file(const char *filename, char **buffer, size_t *length)
2286 jb_err err = JB_ERR_OK;
2288 fp = fopen(filename, "rb");
2291 log_error(LOG_LEVEL_ERROR, "Failed to open %s: %E", filename);
2295 /* Get file length */
2296 if (fseek(fp, 0, SEEK_END))
2298 log_error(LOG_LEVEL_FATAL,
2299 "Unexpected error while fseek()ing to the end of %s: %E",
2305 log_error(LOG_LEVEL_FATAL,
2306 "Unexpected ftell() error while loading %s: %E",
2309 *length = (size_t)ret;
2311 /* Go back to the beginning. */
2312 if (fseek(fp, 0, SEEK_SET))
2314 log_error(LOG_LEVEL_FATAL,
2315 "Unexpected error while fseek()ing to the beginning of %s: %E",
2319 *buffer = zalloc_or_die(*length + 1);
2321 if (1 != fread(*buffer, *length, 1, fp))
2324 * May theoretically happen if the file size changes between
2325 * fseek() and fread() because it's edited in-place. Privoxy
2326 * and common text editors don't do that, thus we just fail.
2328 log_error(LOG_LEVEL_ERROR,
2329 "Couldn't completely read file %s.", filename);