In cgi_show_request() only restore the client request up to client_iob->cur
[privoxy.git] / cgisimple.c
1 const char cgisimple_rcs[] = "$Id: cgisimple.c,v 1.116 2012/10/21 12:39:27 fabiankeil Exp $";
2 /*********************************************************************
3  *
4  * File        :  $Source: /cvsroot/ijbswa/current/cgisimple.c,v $
5  *
6  * Purpose     :  Simple CGIs to get information about Privoxy's
7  *                status.
8  *
9  * Copyright   :  Written by and Copyright (C) 2001-2011 the
10  *                Privoxy team. http://www.privoxy.org/
11  *
12  *                Based on the Internet Junkbuster originally written
13  *                by and Copyright (C) 1997 Anonymous Coders and
14  *                Junkbusters Corporation.  http://www.junkbusters.com
15  *
16  *                This program is free software; you can redistribute it
17  *                and/or modify it under the terms of the GNU General
18  *                Public License as published by the Free Software
19  *                Foundation; either version 2 of the License, or (at
20  *                your option) any later version.
21  *
22  *                This program is distributed in the hope that it will
23  *                be useful, but WITHOUT ANY WARRANTY; without even the
24  *                implied warranty of MERCHANTABILITY or FITNESS FOR A
25  *                PARTICULAR PURPOSE.  See the GNU General Public
26  *                License for more details.
27  *
28  *                The GNU General Public License should be included with
29  *                this file.  If not, you can view it at
30  *                http://www.gnu.org/copyleft/gpl.html
31  *                or write to the Free Software Foundation, Inc., 59
32  *                Temple Place - Suite 330, Boston, MA  02111-1307, USA.
33  *
34  **********************************************************************/
35
36
37 #include "config.h"
38
39 #include <stdio.h>
40 #include <sys/types.h>
41 #include <stdlib.h>
42 #include <ctype.h>
43 #include <string.h>
44 #include <assert.h>
45
46 #ifdef HAVE_ACCESS
47 #include <unistd.h>
48 #endif /* def HAVE_ACCESS */
49
50 #include "project.h"
51 #include "cgi.h"
52 #include "cgisimple.h"
53 #include "list.h"
54 #include "encode.h"
55 #include "jcc.h"
56 #include "filters.h"
57 #include "actions.h"
58 #include "miscutil.h"
59 #include "loadcfg.h"
60 #include "parsers.h"
61 #include "urlmatch.h"
62 #include "errlog.h"
63
64 const char cgisimple_h_rcs[] = CGISIMPLE_H_VERSION;
65
66 static char *show_rcs(void);
67 static jb_err show_defines(struct map *exports);
68 static jb_err cgi_show_file(struct client_state *csp,
69                             struct http_response *rsp,
70                             const struct map *parameters);
71 static jb_err load_file(const char *filename, char **buffer, size_t *length);
72
73 /*********************************************************************
74  *
75  * Function    :  cgi_default
76  *
77  * Description :  CGI function that is called for the CGI_SITE_1_HOST
78  *                and CGI_SITE_2_HOST/CGI_SITE_2_PATH base URLs.
79  *                Boring - only exports the default exports.
80  *
81  * Parameters  :
82  *          1  :  csp = Current client state (buffers, headers, etc...)
83  *          2  :  rsp = http_response data structure for output
84  *          3  :  parameters = map of cgi parameters
85  *
86  * CGI Parameters : none
87  *
88  * Returns     :  JB_ERR_OK on success
89  *                JB_ERR_MEMORY on out-of-memory
90  *
91  *********************************************************************/
92 jb_err cgi_default(struct client_state *csp,
93                    struct http_response *rsp,
94                    const struct map *parameters)
95 {
96    struct map *exports;
97
98    (void)parameters;
99
100    assert(csp);
101    assert(rsp);
102
103    if (NULL == (exports = default_exports(csp, "")))
104    {
105       return JB_ERR_MEMORY;
106    }
107
108    return template_fill_for_cgi(csp, "default", exports, rsp);
109 }
110
111
112 /*********************************************************************
113  *
114  * Function    :  cgi_error_404
115  *
116  * Description :  CGI function that is called if an unknown action was
117  *                given.
118  *
119  * Parameters  :
120  *          1  :  csp = Current client state (buffers, headers, etc...)
121  *          2  :  rsp = http_response data structure for output
122  *          3  :  parameters = map of cgi parameters
123  *
124  * CGI Parameters : none
125  *
126  * Returns     :  JB_ERR_OK on success
127  *                JB_ERR_MEMORY on out-of-memory error.
128  *
129  *********************************************************************/
130 jb_err cgi_error_404(struct client_state *csp,
131                      struct http_response *rsp,
132                      const struct map *parameters)
133 {
134    struct map *exports;
135
136    assert(csp);
137    assert(rsp);
138    assert(parameters);
139
140    if (NULL == (exports = default_exports(csp, NULL)))
141    {
142       return JB_ERR_MEMORY;
143    }
144
145    rsp->status = strdup("404 Privoxy configuration page not found");
146    if (rsp->status == NULL)
147    {
148       free_map(exports);
149       return JB_ERR_MEMORY;
150    }
151
152    return template_fill_for_cgi(csp, "cgi-error-404", exports, rsp);
153 }
154
155
156 #ifdef FEATURE_GRACEFUL_TERMINATION
157 /*********************************************************************
158  *
159  * Function    :  cgi_die
160  *
161  * Description :  CGI function to shut down Privoxy.
162  *                NOTE: Turning this on in a production build
163  *                would be a BAD idea.  An EXTREMELY BAD idea.
164  *                In short, don't do it.
165  *
166  * Parameters  :
167  *          1  :  csp = Current client state (buffers, headers, etc...)
168  *          2  :  rsp = http_response data structure for output
169  *          3  :  parameters = map of cgi parameters
170  *
171  * CGI Parameters : none
172  *
173  * Returns     :  JB_ERR_OK on success
174  *                JB_ERR_MEMORY on out-of-memory error.
175  *
176  *********************************************************************/
177 jb_err cgi_die (struct client_state *csp,
178                 struct http_response *rsp,
179                 const struct map *parameters)
180 {
181    static const char status[] = "200 OK Privoxy shutdown request received";
182    static const char body[] =
183       "<html>\n"
184       "<head>\n"
185       " <title>Privoxy shutdown request received</title>\n"
186       " <link rel=\"shortcut icon\" href=\"" CGI_PREFIX "error-favicon.ico\" type=\"image/x-icon\">\n"
187       " <link rel=\"stylesheet\" type=\"text/css\" href=\"http://config.privoxy.org/send-stylesheet\">\n"
188       "</head>\n"
189       "<body>\n"
190       "<h1>Privoxy shutdown request received</h1>\n"
191       "<p>Privoxy is going to shut down after the next request.</p>\n"
192       "</body>\n"
193       "</html>\n";
194
195    assert(csp);
196    assert(rsp);
197    assert(parameters);
198
199    /* quit */
200    g_terminate = 1;
201
202    csp->flags &= ~CSP_FLAG_CLIENT_CONNECTION_KEEP_ALIVE;
203
204    rsp->content_length = 0;
205    rsp->head_length = 0;
206    rsp->is_static = 0;
207
208    rsp->body = strdup(body);
209    rsp->status = strdup(status);
210
211    if ((rsp->body == NULL) || (rsp->status == NULL))
212    {
213       return JB_ERR_MEMORY;
214    }
215
216    return JB_ERR_OK;
217 }
218 #endif /* def FEATURE_GRACEFUL_TERMINATION */
219
220
221 /*********************************************************************
222  *
223  * Function    :  cgi_show_request
224  *
225  * Description :  Show the client's request and what sed() would have
226  *                made of it.
227  *
228  * Parameters  :
229  *          1  :  csp = Current client state (buffers, headers, etc...)
230  *          2  :  rsp = http_response data structure for output
231  *          3  :  parameters = map of cgi parameters
232  *
233  * CGI Parameters : none
234  *
235  * Returns     :  JB_ERR_OK on success
236  *                JB_ERR_MEMORY on out-of-memory error.
237  *
238  *********************************************************************/
239 jb_err cgi_show_request(struct client_state *csp,
240                         struct http_response *rsp,
241                         const struct map *parameters)
242 {
243    char *p;
244    struct map *exports;
245
246    assert(csp);
247    assert(rsp);
248    assert(parameters);
249
250    if (NULL == (exports = default_exports(csp, "show-request")))
251    {
252       return JB_ERR_MEMORY;
253    }
254
255    /*
256     * Repair the damage done to the IOB by get_header()
257     */
258    for (p = csp->client_iob->buf; p < csp->client_iob->cur; p++)
259    {
260       if (*p == '\0') *p = '\n';
261    }
262
263    /*
264     * Export the original client's request and the one we would
265     * be sending to the server if this wasn't a CGI call
266     */
267
268    if (map(exports, "client-request", 1, html_encode(csp->client_iob->buf), 0))
269    {
270       free_map(exports);
271       return JB_ERR_MEMORY;
272    }
273
274    if (map(exports, "processed-request", 1,
275          html_encode_and_free_original(list_to_text(csp->headers)), 0))
276    {
277       free_map(exports);
278       return JB_ERR_MEMORY;
279    }
280
281    return template_fill_for_cgi(csp, "show-request", exports, rsp);
282 }
283
284
285 /*********************************************************************
286  *
287  * Function    :  cgi_send_banner
288  *
289  * Description :  CGI function that returns a banner.
290  *
291  * Parameters  :
292  *          1  :  csp = Current client state (buffers, headers, etc...)
293  *          2  :  rsp = http_response data structure for output
294  *          3  :  parameters = map of cgi parameters
295  *
296  * CGI Parameters :
297  *           type : Selects the type of banner between "trans", "logo",
298  *                  and "auto". Defaults to "logo" if absent or invalid.
299  *                  "auto" means to select as if we were image-blocking.
300  *                  (Only the first character really counts; b and t are
301  *                  equivalent).
302  *
303  * Returns     :  JB_ERR_OK on success
304  *                JB_ERR_MEMORY on out-of-memory error.
305  *
306  *********************************************************************/
307 jb_err cgi_send_banner(struct client_state *csp,
308                        struct http_response *rsp,
309                        const struct map *parameters)
310 {
311    char imagetype = lookup(parameters, "type")[0];
312
313    /*
314     * If type is auto, then determine the right thing
315     * to do from the set-image-blocker action
316     */
317    if (imagetype == 'a')
318    {
319       /*
320        * Default to pattern
321        */
322       imagetype = 'p';
323
324 #ifdef FEATURE_IMAGE_BLOCKING
325       if ((csp->action->flags & ACTION_IMAGE_BLOCKER) != 0)
326       {
327          static const char prefix1[] = CGI_PREFIX "send-banner?type=";
328          static const char prefix2[] = "http://" CGI_SITE_1_HOST "/send-banner?type=";
329          const char *p = csp->action->string[ACTION_STRING_IMAGE_BLOCKER];
330
331          if (p == NULL)
332          {
333             /* Use default - nothing to do here. */
334          }
335          else if (0 == strcmpic(p, "blank"))
336          {
337             imagetype = 'b';
338          }
339          else if (0 == strcmpic(p, "pattern"))
340          {
341             imagetype = 'p';
342          }
343
344          /*
345           * If the action is to call this CGI, determine
346           * the argument:
347           */
348          else if (0 == strncmpic(p, prefix1, sizeof(prefix1) - 1))
349          {
350             imagetype = p[sizeof(prefix1) - 1];
351          }
352          else if (0 == strncmpic(p, prefix2, sizeof(prefix2) - 1))
353          {
354             imagetype = p[sizeof(prefix2) - 1];
355          }
356
357          /*
358           * Everything else must (should) be a URL to
359           * redirect to.
360           */
361          else
362          {
363             imagetype = 'r';
364          }
365       }
366 #endif /* def FEATURE_IMAGE_BLOCKING */
367    }
368
369    /*
370     * Now imagetype is either the non-auto type we were called with,
371     * or it was auto and has since been determined. In any case, we
372     * can proceed to actually answering the request by sending a redirect
373     * or an image as appropriate:
374     */
375    if (imagetype == 'r')
376    {
377       rsp->status = strdup("302 Local Redirect from Privoxy");
378       if (rsp->status == NULL)
379       {
380          return JB_ERR_MEMORY;
381       }
382       if (enlist_unique_header(rsp->headers, "Location",
383                                csp->action->string[ACTION_STRING_IMAGE_BLOCKER]))
384       {
385          return JB_ERR_MEMORY;
386       }
387    }
388    else
389    {
390       if ((imagetype == 'b') || (imagetype == 't'))
391       {
392          rsp->body = bindup(image_blank_data, image_blank_length);
393          rsp->content_length = image_blank_length;
394       }
395       else
396       {
397          rsp->body = bindup(image_pattern_data, image_pattern_length);
398          rsp->content_length = image_pattern_length;
399       }
400
401       if (rsp->body == NULL)
402       {
403          return JB_ERR_MEMORY;
404       }
405       if (enlist(rsp->headers, "Content-Type: " BUILTIN_IMAGE_MIMETYPE))
406       {
407          return JB_ERR_MEMORY;
408       }
409
410       rsp->is_static = 1;
411    }
412
413    return JB_ERR_OK;
414
415 }
416
417
418 /*********************************************************************
419  *
420  * Function    :  cgi_transparent_image
421  *
422  * Description :  CGI function that sends a 1x1 transparent image.
423  *
424  * Parameters  :
425  *          1  :  csp = Current client state (buffers, headers, etc...)
426  *          2  :  rsp = http_response data structure for output
427  *          3  :  parameters = map of cgi parameters
428  *
429  * CGI Parameters : None
430  *
431  * Returns     :  JB_ERR_OK on success
432  *                JB_ERR_MEMORY on out-of-memory error.
433  *
434  *********************************************************************/
435 jb_err cgi_transparent_image(struct client_state *csp,
436                              struct http_response *rsp,
437                              const struct map *parameters)
438 {
439    (void)csp;
440    (void)parameters;
441
442    rsp->body = bindup(image_blank_data, image_blank_length);
443    rsp->content_length = image_blank_length;
444
445    if (rsp->body == NULL)
446    {
447       return JB_ERR_MEMORY;
448    }
449
450    if (enlist(rsp->headers, "Content-Type: " BUILTIN_IMAGE_MIMETYPE))
451    {
452       return JB_ERR_MEMORY;
453    }
454
455    rsp->is_static = 1;
456
457    return JB_ERR_OK;
458
459 }
460
461
462 /*********************************************************************
463  *
464  * Function    :  cgi_send_default_favicon
465  *
466  * Description :  CGI function that sends the standard favicon.
467  *
468  * Parameters  :
469  *          1  :  csp = Current client state (buffers, headers, etc...)
470  *          2  :  rsp = http_response data structure for output
471  *          3  :  parameters = map of cgi parameters
472  *
473  * CGI Parameters : None
474  *
475  * Returns     :  JB_ERR_OK on success
476  *                JB_ERR_MEMORY on out-of-memory error.
477  *
478  *********************************************************************/
479 jb_err cgi_send_default_favicon(struct client_state *csp,
480                                 struct http_response *rsp,
481                                 const struct map *parameters)
482 {
483    static const char default_favicon_data[] =
484       "\000\000\001\000\001\000\020\020\002\000\000\000\000\000\260"
485       "\000\000\000\026\000\000\000\050\000\000\000\020\000\000\000"
486       "\040\000\000\000\001\000\001\000\000\000\000\000\100\000\000"
487       "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000"
488       "\000\000\377\377\377\000\377\000\052\000\017\360\000\000\077"
489       "\374\000\000\161\376\000\000\161\376\000\000\361\377\000\000"
490       "\361\377\000\000\360\017\000\000\360\007\000\000\361\307\000"
491       "\000\361\307\000\000\361\307\000\000\360\007\000\000\160\036"
492       "\000\000\177\376\000\000\077\374\000\000\017\360\000\000\360"
493       "\017\000\000\300\003\000\000\200\001\000\000\200\001\000\000"
494       "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
495       "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
496       "\000\000\200\001\000\000\200\001\000\000\300\003\000\000\360"
497       "\017\000\000";
498    static const size_t favicon_length = sizeof(default_favicon_data) - 1;
499
500    (void)csp;
501    (void)parameters;
502
503    rsp->body = bindup(default_favicon_data, favicon_length);
504    rsp->content_length = favicon_length;
505
506    if (rsp->body == NULL)
507    {
508       return JB_ERR_MEMORY;
509    }
510
511    if (enlist(rsp->headers, "Content-Type: image/x-icon"))
512    {
513       return JB_ERR_MEMORY;
514    }
515
516    rsp->is_static = 1;
517
518    return JB_ERR_OK;
519
520 }
521
522
523 /*********************************************************************
524  *
525  * Function    :  cgi_send_error_favicon
526  *
527  * Description :  CGI function that sends the favicon for error pages.
528  *
529  * Parameters  :
530  *          1  :  csp = Current client state (buffers, headers, etc...)
531  *          2  :  rsp = http_response data structure for output
532  *          3  :  parameters = map of cgi parameters
533  *
534  * CGI Parameters : None
535  *
536  * Returns     :  JB_ERR_OK on success
537  *                JB_ERR_MEMORY on out-of-memory error.
538  *
539  *********************************************************************/
540 jb_err cgi_send_error_favicon(struct client_state *csp,
541                               struct http_response *rsp,
542                               const struct map *parameters)
543 {
544    static const char error_favicon_data[] =
545       "\000\000\001\000\001\000\020\020\002\000\000\000\000\000\260"
546       "\000\000\000\026\000\000\000\050\000\000\000\020\000\000\000"
547       "\040\000\000\000\001\000\001\000\000\000\000\000\100\000\000"
548       "\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000"
549       "\000\000\377\377\377\000\000\000\377\000\017\360\000\000\077"
550       "\374\000\000\161\376\000\000\161\376\000\000\361\377\000\000"
551       "\361\377\000\000\360\017\000\000\360\007\000\000\361\307\000"
552       "\000\361\307\000\000\361\307\000\000\360\007\000\000\160\036"
553       "\000\000\177\376\000\000\077\374\000\000\017\360\000\000\360"
554       "\017\000\000\300\003\000\000\200\001\000\000\200\001\000\000"
555       "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
556       "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"
557       "\000\000\200\001\000\000\200\001\000\000\300\003\000\000\360"
558       "\017\000\000";
559    static const size_t favicon_length = sizeof(error_favicon_data) - 1;
560
561    (void)csp;
562    (void)parameters;
563
564    rsp->body = bindup(error_favicon_data, favicon_length);
565    rsp->content_length = favicon_length;
566
567    if (rsp->body == NULL)
568    {
569       return JB_ERR_MEMORY;
570    }
571
572    if (enlist(rsp->headers, "Content-Type: image/x-icon"))
573    {
574       return JB_ERR_MEMORY;
575    }
576
577    rsp->is_static = 1;
578
579    return JB_ERR_OK;
580
581 }
582
583
584 /*********************************************************************
585  *
586  * Function    :  cgi_send_stylesheet
587  *
588  * Description :  CGI function that sends a css stylesheet found
589  *                in the cgi-style.css template
590  *
591  * Parameters  :
592  *          1  :  csp = Current client state (buffers, headers, etc...)
593  *          2  :  rsp = http_response data structure for output
594  *          3  :  parameters = map of cgi parameters
595  *
596  * CGI Parameters : None
597  *
598  * Returns     :  JB_ERR_OK on success
599  *                JB_ERR_MEMORY on out-of-memory error.
600  *
601  *********************************************************************/
602 jb_err cgi_send_stylesheet(struct client_state *csp,
603                            struct http_response *rsp,
604                            const struct map *parameters)
605 {
606    jb_err err;
607
608    assert(csp);
609    assert(rsp);
610
611    (void)parameters;
612
613    err = template_load(csp, &rsp->body, "cgi-style.css", 0);
614
615    if (err == JB_ERR_FILE)
616    {
617       /*
618        * No way to tell user; send empty stylesheet
619        */
620       log_error(LOG_LEVEL_ERROR, "Could not find cgi-style.css template");
621    }
622    else if (err)
623    {
624       return err; /* JB_ERR_MEMORY */
625    }
626
627    if (enlist(rsp->headers, "Content-Type: text/css"))
628    {
629       return JB_ERR_MEMORY;
630    }
631
632    return JB_ERR_OK;
633
634 }
635
636
637 /*********************************************************************
638  *
639  * Function    :  cgi_send_url_info_osd
640  *
641  * Description :  CGI function that sends the OpenSearch Description
642  *                template for the show-url-info page. It allows to
643  *                access the page through "search engine plugins".
644  *
645  * Parameters  :
646  *          1  :  csp = Current client state (buffers, headers, etc...)
647  *          2  :  rsp = http_response data structure for output
648  *          3  :  parameters = map of cgi parameters
649  *
650  * CGI Parameters : None
651  *
652  * Returns     :  JB_ERR_OK on success
653  *                JB_ERR_MEMORY on out-of-memory error.
654  *
655  *********************************************************************/
656 jb_err cgi_send_url_info_osd(struct client_state *csp,
657                                struct http_response *rsp,
658                                const struct map *parameters)
659 {
660    jb_err err = JB_ERR_MEMORY;
661    struct map *exports = default_exports(csp, NULL);
662
663    (void)csp;
664    (void)parameters;
665
666    if (NULL != exports)
667    {
668       err = template_fill_for_cgi(csp, "url-info-osd.xml", exports, rsp);
669       if (JB_ERR_OK == err)
670       {
671          err = enlist(rsp->headers,
672             "Content-Type: application/opensearchdescription+xml");
673       }
674    }
675
676    return err;
677
678 }
679
680
681 /*********************************************************************
682  *
683  * Function    :  get_content_type
684  *
685  * Description :  Use the file extension to guess the content type
686  *                header we should use to serve the file.
687  *
688  * Parameters  :
689  *          1  :  filename = Name of the file whose content type
690  *                           we care about
691  *
692  * Returns     :  The guessed content type.
693  *
694  *********************************************************************/
695 static const char *get_content_type(const char *filename)
696 {
697    int i;
698    struct content_type
699    {
700       const char *extension;
701       const char *content_type;
702    };
703    static const struct content_type content_types[] =
704    {
705       {".css",  "text/css"},
706       {".jpg",  "image/jpeg"},
707       {".jpeg", "image/jpeg"},
708       {".png",  "image/png"},
709    };
710
711    for (i = 0; i < SZ(content_types); i++)
712    {
713       if (strstr(filename, content_types[i].extension))
714       {
715          return content_types[i].content_type;
716       }
717    }
718
719    /* No match by extension, default to html */
720    return "text/html";
721 }
722
723 /*********************************************************************
724  *
725  * Function    :  cgi_send_user_manual
726  *
727  * Description :  CGI function that sends a file in the user
728  *                manual directory.
729  *
730  * Parameters  :
731  *          1  :  csp = Current client state (buffers, headers, etc...)
732  *          2  :  rsp = http_response data structure for output
733  *          3  :  parameters = map of cgi parameters
734  *
735  * CGI Parameters : file=name.html, the name of the HTML file
736  *                  (relative to user-manual from config)
737  *
738  * Returns     :  JB_ERR_OK on success
739  *                JB_ERR_MEMORY on out-of-memory error.
740  *
741  *********************************************************************/
742 jb_err cgi_send_user_manual(struct client_state *csp,
743                             struct http_response *rsp,
744                             const struct map *parameters)
745 {
746    const char *filename;
747    char *full_path;
748    jb_err err = JB_ERR_OK;
749    const char *content_type;
750
751    assert(csp);
752    assert(rsp);
753    assert(parameters);
754
755    if (0 == strncmpic(csp->config->usermanual, "http://", 7))
756    {
757       log_error(LOG_LEVEL_CGI, "Request for local user-manual "
758          "received while user-manual delivery is disabled.");
759       return cgi_error_404(csp, rsp, parameters);
760    }
761
762    if (!parameters->first)
763    {
764       /* requested http://p.p/user-manual (without trailing slash) */
765       return cgi_redirect(rsp, CGI_PREFIX "user-manual/");
766    }
767
768    get_string_param(parameters, "file", &filename);
769    if (filename == NULL)
770    {
771       /* It's '/' so serve the index.html if there is one.  */
772       filename = "index.html";
773    }
774    else if (NULL != strchr(filename, '/') || NULL != strstr(filename, ".."))
775    {
776       /*
777        * We currently only support a flat file
778        * hierarchy for the documentation.
779        */
780       log_error(LOG_LEVEL_ERROR,
781          "Rejecting the request to serve '%s' as it contains '/' or '..'",
782          filename);
783       return JB_ERR_CGI_PARAMS;
784    }
785
786    full_path = make_path(csp->config->usermanual, filename);
787    if (full_path == NULL)
788    {
789       return JB_ERR_MEMORY;
790    }
791
792    err = load_file(full_path, &rsp->body, &rsp->content_length);
793    if (JB_ERR_OK != err)
794    {
795       assert((JB_ERR_FILE == err) || (JB_ERR_MEMORY == err));
796       if (JB_ERR_FILE == err)
797       {
798          err = cgi_error_no_template(csp, rsp, full_path);
799       }
800       freez(full_path);
801       return err;
802    }
803    freez(full_path);
804
805    content_type = get_content_type(filename);
806    log_error(LOG_LEVEL_CGI,
807       "Content-Type guessed for %s: %s", filename, content_type);
808
809    return enlist_unique_header(rsp->headers, "Content-Type", content_type);
810
811 }
812
813
814 /*********************************************************************
815  *
816  * Function    :  cgi_show_version
817  *
818  * Description :  CGI function that returns a a web page describing the
819  *                file versions of Privoxy.
820  *
821  * Parameters  :
822  *          1  :  csp = Current client state (buffers, headers, etc...)
823  *          2  :  rsp = http_response data structure for output
824  *          3  :  parameters = map of cgi parameters
825  *
826  * CGI Parameters : none
827  *
828  * Returns     :  JB_ERR_OK on success
829  *                JB_ERR_MEMORY on out-of-memory error.
830  *
831  *********************************************************************/
832 jb_err cgi_show_version(struct client_state *csp,
833                         struct http_response *rsp,
834                         const struct map *parameters)
835 {
836    struct map *exports;
837
838    assert(csp);
839    assert(rsp);
840    assert(parameters);
841
842    if (NULL == (exports = default_exports(csp, "show-version")))
843    {
844       return JB_ERR_MEMORY;
845    }
846
847    if (map(exports, "sourceversions", 1, show_rcs(), 0))
848    {
849       free_map(exports);
850       return JB_ERR_MEMORY;
851    }
852
853    return template_fill_for_cgi(csp, "show-version", exports, rsp);
854 }
855
856
857 /*********************************************************************
858  *
859  * Function    :  cgi_show_status
860  *
861  * Description :  CGI function that returns a web page describing the
862  *                current status of Privoxy.
863  *
864  * Parameters  :
865  *          1  :  csp = Current client state (buffers, headers, etc...)
866  *          2  :  rsp = http_response data structure for output
867  *          3  :  parameters = map of cgi parameters
868  *
869  * CGI Parameters :
870  *        file :  Which file to show.  Only first letter is checked,
871  *                valid values are:
872  *                - "a"ction file
873  *                - "r"egex
874  *                - "t"rust
875  *                Default is to show menu and other information.
876  *
877  * Returns     :  JB_ERR_OK on success
878  *                JB_ERR_MEMORY on out-of-memory error.
879  *
880  *********************************************************************/
881 jb_err cgi_show_status(struct client_state *csp,
882                        struct http_response *rsp,
883                        const struct map *parameters)
884 {
885    char *s = NULL;
886    unsigned i;
887    int j;
888
889    char buf[BUFFER_SIZE];
890 #ifdef FEATURE_STATISTICS
891    float perc_rej;   /* Percentage of http requests rejected */
892    int local_urls_read;
893    int local_urls_rejected;
894 #endif /* ndef FEATURE_STATISTICS */
895    jb_err err = JB_ERR_OK;
896
897    struct map *exports;
898
899    assert(csp);
900    assert(rsp);
901    assert(parameters);
902
903    if ('\0' != *(lookup(parameters, "file")))
904    {
905       return cgi_show_file(csp, rsp, parameters);
906    }
907
908    if (NULL == (exports = default_exports(csp, "show-status")))
909    {
910       return JB_ERR_MEMORY;
911    }
912
913    s = strdup("");
914    for (j = 0; (s != NULL) && (j < Argc); j++)
915    {
916       if (!err) err = string_join  (&s, html_encode(Argv[j]));
917       if (!err) err = string_append(&s, " ");
918    }
919    if (!err) err = map(exports, "invocation", 1, s, 0);
920
921    if (!err) err = map(exports, "options", 1, csp->config->proxy_args, 1);
922    if (!err) err = show_defines(exports);
923
924    if (err)
925    {
926       free_map(exports);
927       return JB_ERR_MEMORY;
928    }
929
930 #ifdef FEATURE_STATISTICS
931    local_urls_read     = urls_read;
932    local_urls_rejected = urls_rejected;
933
934    /*
935     * Need to alter the stats not to include the fetch of this
936     * page.
937     *
938     * Can't do following thread safely! doh!
939     *
940     * urls_read--;
941     * urls_rejected--; * This will be incremented subsequently *
942     */
943
944    if (local_urls_read == 0)
945    {
946       if (!err) err = map_block_killer(exports, "have-stats");
947    }
948    else
949    {
950       if (!err) err = map_block_killer(exports, "have-no-stats");
951
952       perc_rej = (float)local_urls_rejected * 100.0F /
953             (float)local_urls_read;
954
955       snprintf(buf, sizeof(buf), "%d", local_urls_read);
956       if (!err) err = map(exports, "requests-received", 1, buf, 1);
957
958       snprintf(buf, sizeof(buf), "%d", local_urls_rejected);
959       if (!err) err = map(exports, "requests-blocked", 1, buf, 1);
960
961       snprintf(buf, sizeof(buf), "%6.2f", perc_rej);
962       if (!err) err = map(exports, "percent-blocked", 1, buf, 1);
963    }
964
965 #else /* ndef FEATURE_STATISTICS */
966    err = err || map_block_killer(exports, "statistics");
967 #endif /* ndef FEATURE_STATISTICS */
968
969    /*
970     * List all action files in use, together with view and edit links,
971     * except for standard.action, which should only be viewable. (Not
972     * enforced in the editor itself)
973     * FIXME: Shouldn't include hardwired HTML here, use line template instead!
974     */
975    s = strdup("");
976    for (i = 0; i < MAX_AF_FILES; i++)
977    {
978       if (csp->actions_list[i] != NULL)
979       {
980          if (!err) err = string_append(&s, "<tr><td>");
981          if (!err) err = string_join(&s, html_encode(csp->actions_list[i]->filename));
982          snprintf(buf, sizeof(buf),
983             "</td><td class=\"buttons\"><a href=\"/show-status?file=actions&amp;index=%u\">View</a>", i);
984          if (!err) err = string_append(&s, buf);
985
986 #ifdef FEATURE_CGI_EDIT_ACTIONS
987          if ((csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS)
988             && (NULL == strstr(csp->actions_list[i]->filename, "standard.action"))
989             && (NULL != csp->config->actions_file_short[i]))
990          {
991 #ifdef HAVE_ACCESS
992             if (access(csp->config->actions_file[i], W_OK) == 0)
993             {
994 #endif /* def HAVE_ACCESS */
995                snprintf(buf, sizeof(buf), "&nbsp;&nbsp;<a href=\"/edit-actions-list?f=%u\">Edit</a>", i);
996                if (!err) err = string_append(&s, buf);
997 #ifdef HAVE_ACCESS
998             }
999             else
1000             {
1001                if (!err) err = string_append(&s, "&nbsp;&nbsp;<strong>No write access.</strong>");
1002             }
1003 #endif /* def HAVE_ACCESS */
1004          }
1005 #endif
1006
1007          if (!err) err = string_append(&s, "</td></tr>\n");
1008       }
1009    }
1010    if (*s != '\0')
1011    {
1012       if (!err) err = map(exports, "actions-filenames", 1, s, 0);
1013    }
1014    else
1015    {
1016       if (!err) err = map(exports, "actions-filenames", 1, "<tr><td>None specified</td></tr>", 1);
1017    }
1018
1019    /*
1020     * List all re_filterfiles in use, together with view options.
1021     * FIXME: Shouldn't include hardwired HTML here, use line template instead!
1022     */
1023    s = strdup("");
1024    for (i = 0; i < MAX_AF_FILES; i++)
1025    {
1026       if (csp->rlist[i] != NULL)
1027       {
1028          if (!err) err = string_append(&s, "<tr><td>");
1029          if (!err) err = string_join(&s, html_encode(csp->rlist[i]->filename));
1030          snprintf(buf, sizeof(buf),
1031             "</td><td class=\"buttons\"><a href=\"/show-status?file=filter&amp;index=%u\">View</a>", i);
1032          if (!err) err = string_append(&s, buf);
1033          if (!err) err = string_append(&s, "</td></tr>\n");
1034       }
1035    }
1036    if (*s != '\0')
1037    {
1038       if (!err) err = map(exports, "re-filter-filenames", 1, s, 0);
1039    }
1040    else
1041    {
1042       if (!err) err = map(exports, "re-filter-filenames", 1, "<tr><td>None specified</td></tr>", 1);
1043       if (!err) err = map_block_killer(exports, "have-filterfile");
1044    }
1045
1046 #ifdef FEATURE_TRUST
1047    if (csp->tlist)
1048    {
1049       if (!err) err = map(exports, "trust-filename", 1, html_encode(csp->tlist->filename), 0);
1050    }
1051    else
1052    {
1053       if (!err) err = map(exports, "trust-filename", 1, "None specified", 1);
1054       if (!err) err = map_block_killer(exports, "have-trustfile");
1055    }
1056 #else
1057    if (!err) err = map_block_killer(exports, "trust-support");
1058 #endif /* ndef FEATURE_TRUST */
1059
1060 #ifdef FEATURE_CGI_EDIT_ACTIONS
1061    if (!err && (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
1062    {
1063       err = map_block_killer(exports, "cgi-editor-is-disabled");
1064    }
1065 #endif /* ndef CGI_EDIT_ACTIONS */
1066
1067    if (err)
1068    {
1069       free_map(exports);
1070       return JB_ERR_MEMORY;
1071    }
1072
1073    return template_fill_for_cgi(csp, "show-status", exports, rsp);
1074 }
1075
1076
1077 /*********************************************************************
1078  *
1079  * Function    :  cgi_show_url_info
1080  *
1081  * Description :  CGI function that determines and shows which actions
1082  *                Privoxy will perform for a given url, and which
1083  *                matches starting from the defaults have lead to that.
1084  *
1085  * Parameters  :
1086  *          1  :  csp = Current client state (buffers, headers, etc...)
1087  *          2  :  rsp = http_response data structure for output
1088  *          3  :  parameters = map of cgi parameters
1089  *
1090  * CGI Parameters :
1091  *            url : The url whose actions are to be determined.
1092  *                  If url is unset, the url-given conditional will be
1093  *                  set, so that all but the form can be suppressed in
1094  *                  the template.
1095  *
1096  * Returns     :  JB_ERR_OK on success
1097  *                JB_ERR_MEMORY on out-of-memory error.
1098  *
1099  *********************************************************************/
1100 jb_err cgi_show_url_info(struct client_state *csp,
1101                          struct http_response *rsp,
1102                          const struct map *parameters)
1103 {
1104    char *url_param;
1105    struct map *exports;
1106    char buf[150];
1107
1108    assert(csp);
1109    assert(rsp);
1110    assert(parameters);
1111
1112    if (NULL == (exports = default_exports(csp, "show-url-info")))
1113    {
1114       return JB_ERR_MEMORY;
1115    }
1116
1117    /*
1118     * Get the url= parameter (if present) and remove any leading/trailing spaces.
1119     */
1120    url_param = strdup(lookup(parameters, "url"));
1121    if (url_param == NULL)
1122    {
1123       free_map(exports);
1124       return JB_ERR_MEMORY;
1125    }
1126    chomp(url_param);
1127
1128    /*
1129     * Handle prefixes.  4 possibilities:
1130     * 1) "http://" or "https://" prefix present and followed by URL - OK
1131     * 2) Only the "http://" or "https://" part is present, no URL - change
1132     *    to empty string so it will be detected later as "no URL".
1133     * 3) Parameter specified but doesn't start with "http(s?)://" - add a
1134     *    "http://" prefix.
1135     * 4) Parameter not specified or is empty string - let this fall through
1136     *    for now, next block of code will handle it.
1137     */
1138    if (0 == strncmp(url_param, "http://", 7))
1139    {
1140       if (url_param[7] == '\0')
1141       {
1142          /*
1143           * Empty URL (just prefix).
1144           * Make it totally empty so it's caught by the next if ()
1145           */
1146          url_param[0] = '\0';
1147       }
1148    }
1149    else if (0 == strncmp(url_param, "https://", 8))
1150    {
1151       if (url_param[8] == '\0')
1152       {
1153          /*
1154           * Empty URL (just prefix).
1155           * Make it totally empty so it's caught by the next if ()
1156           */
1157          url_param[0] = '\0';
1158       }
1159    }
1160    else if ((url_param[0] != '\0')
1161       && ((NULL == strstr(url_param, "://")
1162             || (strstr(url_param, "://") > strstr(url_param, "/")))))
1163    {
1164       /*
1165        * No prefix or at least no prefix before
1166        * the first slash - assume http://
1167        */
1168       char *url_param_prefixed = strdup("http://");
1169
1170       if (JB_ERR_OK != string_join(&url_param_prefixed, url_param))
1171       {
1172          free_map(exports);
1173          return JB_ERR_MEMORY;
1174       }
1175       url_param = url_param_prefixed;
1176    }
1177
1178    /*
1179     * Hide "toggle off" warning if Privoxy is toggled on.
1180     */
1181    if (
1182 #ifdef FEATURE_TOGGLE
1183        (global_toggle_state == 1) &&
1184 #endif /* def FEATURE_TOGGLE */
1185        map_block_killer(exports, "privoxy-is-toggled-off")
1186       )
1187    {
1188       free_map(exports);
1189       return JB_ERR_MEMORY;
1190    }
1191
1192    if (url_param[0] == '\0')
1193    {
1194       /* URL paramater not specified, display query form only. */
1195       free(url_param);
1196       if (map_block_killer(exports, "url-given")
1197         || map(exports, "url", 1, "", 1))
1198       {
1199          free_map(exports);
1200          return JB_ERR_MEMORY;
1201       }
1202    }
1203    else
1204    {
1205       /* Given a URL, so query it. */
1206       jb_err err;
1207       char *matches;
1208       char *s;
1209       int hits = 0;
1210       struct file_list *fl;
1211       struct url_actions *b;
1212       struct http_request url_to_query[1];
1213       struct current_action_spec action[1];
1214       int i;
1215
1216       if (map(exports, "url", 1, html_encode(url_param), 0))
1217       {
1218          free(url_param);
1219          free_map(exports);
1220          return JB_ERR_MEMORY;
1221       }
1222
1223       init_current_action(action);
1224
1225       if (map(exports, "default", 1, current_action_to_html(csp, action), 0))
1226       {
1227          free_current_action(action);
1228          free(url_param);
1229          free_map(exports);
1230          return JB_ERR_MEMORY;
1231       }
1232
1233       memset(url_to_query, '\0', sizeof(url_to_query));
1234       err = parse_http_url(url_param, url_to_query, REQUIRE_PROTOCOL);
1235       assert((err != JB_ERR_OK) || (url_to_query->ssl == !strncmpic(url_param, "https://", 8)));
1236
1237       free(url_param);
1238
1239       if (err == JB_ERR_MEMORY)
1240       {
1241          free_http_request(url_to_query);
1242          free_current_action(action);
1243          free_map(exports);
1244          return JB_ERR_MEMORY;
1245       }
1246       else if (err)
1247       {
1248          /* Invalid URL */
1249
1250          err = map(exports, "matches", 1, "<b>[Invalid URL specified!]</b>" , 1);
1251          if (!err) err = map(exports, "final", 1, lookup(exports, "default"), 1);
1252          if (!err) err = map_block_killer(exports, "valid-url");
1253
1254          free_current_action(action);
1255          free_http_request(url_to_query);
1256
1257          if (err)
1258          {
1259             free_map(exports);
1260             return JB_ERR_MEMORY;
1261          }
1262
1263          return template_fill_for_cgi(csp, "show-url-info", exports, rsp);
1264       }
1265
1266       /*
1267        * We have a warning about SSL paths.  Hide it for unencrypted sites.
1268        */
1269       if (!url_to_query->ssl)
1270       {
1271          if (map_block_killer(exports, "https"))
1272          {
1273             free_current_action(action);
1274             free_map(exports);
1275             free_http_request(url_to_query);
1276             return JB_ERR_MEMORY;
1277          }
1278       }
1279
1280       matches = strdup("<table summary=\"\" class=\"transparent\">");
1281
1282       for (i = 0; i < MAX_AF_FILES; i++)
1283       {
1284          if (NULL == csp->config->actions_file_short[i]
1285              || !strcmp(csp->config->actions_file_short[i], "standard.action")) continue;
1286
1287          b = NULL;
1288          hits = 1;
1289          if ((fl = csp->actions_list[i]) != NULL)
1290          {
1291             if ((b = fl->f) != NULL)
1292             {
1293                /* FIXME: Hardcoded HTML! */
1294                string_append(&matches, "<tr><th>In file: ");
1295                string_join  (&matches, html_encode(csp->config->actions_file_short[i]));
1296                snprintf(buf, sizeof(buf), " <a class=\"cmd\" href=\"/show-status?file=actions&amp;index=%d\">", i);
1297                string_append(&matches, buf);
1298                string_append(&matches, "View</a>");
1299 #ifdef FEATURE_CGI_EDIT_ACTIONS
1300                if (csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS)
1301                {
1302 #ifdef HAVE_ACCESS
1303                   if (access(csp->config->actions_file[i], W_OK) == 0)
1304                   {
1305 #endif /* def HAVE_ACCESS */
1306                      snprintf(buf, sizeof(buf),
1307                         " <a class=\"cmd\" href=\"/edit-actions-list?f=%d\">", i);
1308                      string_append(&matches, buf);
1309                      string_append(&matches, "Edit</a>");
1310 #ifdef HAVE_ACCESS
1311                   }
1312                   else
1313                   {
1314                      string_append(&matches, " <strong>No write access.</strong>");
1315                   }
1316 #endif /* def HAVE_ACCESS */
1317                }
1318 #endif /* FEATURE_CGI_EDIT_ACTIONS */
1319
1320                string_append(&matches, "</th></tr>\n");
1321
1322                hits = 0;
1323                b = b->next;
1324             }
1325          }
1326
1327          for (; (b != NULL) && (matches != NULL); b = b->next)
1328          {
1329             if (url_match(b->url, url_to_query))
1330             {
1331                string_append(&matches, "<tr><td>{");
1332                string_join  (&matches, actions_to_html(csp, b->action));
1333                string_append(&matches, " }<br>\n<code>");
1334                string_join  (&matches, html_encode(b->url->spec));
1335                string_append(&matches, "</code></td></tr>\n");
1336
1337                if (merge_current_action(action, b->action))
1338                {
1339                   freez(matches);
1340                   free_http_request(url_to_query);
1341                   free_current_action(action);
1342                   free_map(exports);
1343                   return JB_ERR_MEMORY;
1344                }
1345                hits++;
1346             }
1347          }
1348
1349          if (!hits)
1350          {
1351             string_append(&matches, "<tr><td>(no matches in this file)</td></tr>\n");
1352          }
1353       }
1354       string_append(&matches, "</table>\n");
1355
1356       /*
1357        * XXX: Kludge to make sure the "Forward settings" section
1358        * shows what forward-override{} would do with the requested URL.
1359        * No one really cares how the CGI request would be forwarded
1360        * if it wasn't intercepted as CGI request in the first place.
1361        *
1362        * From here on the action bitmask will no longer reflect
1363        * the real url (http://config.privoxy.org/show-url-info?url=.*),
1364        * but luckily it's no longer required later on anyway.
1365        */
1366       free_current_action(csp->action);
1367       get_url_actions(csp, url_to_query);
1368
1369       /*
1370        * Fill in forwarding settings.
1371        *
1372        * The possibilities are:
1373        *  - no forwarding
1374        *  - http forwarding only
1375        *  - socks4(a) forwarding only
1376        *  - socks4(a) and http forwarding.
1377        *
1378        * XXX: Parts of this code could be reused for the
1379        * "forwarding-failed" template which currently doesn't
1380        * display the proxy port and an eventual second forwarder.
1381        */
1382       {
1383          const struct forward_spec *fwd = forward_url(csp, url_to_query);
1384
1385          if ((fwd->gateway_host == NULL) && (fwd->forward_host == NULL))
1386          {
1387             if (!err) err = map_block_killer(exports, "socks-forwarder");
1388             if (!err) err = map_block_killer(exports, "http-forwarder");
1389          }
1390          else
1391          {
1392             char port[10]; /* We save proxy ports as int but need a string here */
1393
1394             if (!err) err = map_block_killer(exports, "no-forwarder");
1395
1396             if (fwd->gateway_host != NULL)
1397             {
1398                char *socks_type = NULL;
1399
1400                switch (fwd->type)
1401                {
1402                   case SOCKS_4:
1403                      socks_type = "socks4";
1404                      break;
1405                   case SOCKS_4A:
1406                      socks_type = "socks4a";
1407                      break;
1408                   case SOCKS_5:
1409                      socks_type = "socks5";
1410                      break;
1411                   default:
1412                      log_error(LOG_LEVEL_FATAL, "Unknown socks type: %d.", fwd->type);
1413                }
1414
1415                if (!err) err = map(exports, "socks-type", 1, socks_type, 1);
1416                if (!err) err = map(exports, "gateway-host", 1, fwd->gateway_host, 1);
1417                snprintf(port, sizeof(port), "%d", fwd->gateway_port);
1418                if (!err) err = map(exports, "gateway-port", 1, port, 1);
1419             }
1420             else
1421             {
1422                if (!err) err = map_block_killer(exports, "socks-forwarder");
1423             }
1424
1425             if (fwd->forward_host != NULL)
1426             {
1427                if (!err) err = map(exports, "forward-host", 1, fwd->forward_host, 1);
1428                snprintf(port, sizeof(port), "%d", fwd->forward_port);
1429                if (!err) err = map(exports, "forward-port", 1, port, 1);
1430             }
1431             else
1432             {
1433                if (!err) err = map_block_killer(exports, "http-forwarder");
1434             }
1435          }
1436       }
1437
1438       free_http_request(url_to_query);
1439
1440       if (err || matches == NULL)
1441       {
1442          free_current_action(action);
1443          free_map(exports);
1444          return JB_ERR_MEMORY;
1445       }
1446
1447 #ifdef FEATURE_CGI_EDIT_ACTIONS
1448       if ((csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
1449       {
1450          err = map_block_killer(exports, "cgi-editor-is-disabled");
1451       }
1452 #endif /* FEATURE_CGI_EDIT_ACTIONS */
1453
1454       /*
1455        * If zlib support is available, if no content filters
1456        * are enabled or if the prevent-compression action is enabled,
1457        * suppress the "compression could prevent filtering" warning.
1458        */
1459 #ifndef FEATURE_ZLIB
1460       if (!content_filters_enabled(action) ||
1461          (action->flags & ACTION_NO_COMPRESSION))
1462 #endif
1463       {
1464          if (!err) err = map_block_killer(exports, "filters-might-be-ineffective");
1465       }
1466
1467       if (err || map(exports, "matches", 1, matches , 0))
1468       {
1469          free_current_action(action);
1470          free_map(exports);
1471          return JB_ERR_MEMORY;
1472       }
1473
1474       s = current_action_to_html(csp, action);
1475
1476       free_current_action(action);
1477
1478       if (map(exports, "final", 1, s, 0))
1479       {
1480          free_map(exports);
1481          return JB_ERR_MEMORY;
1482       }
1483    }
1484
1485    return template_fill_for_cgi(csp, "show-url-info", exports, rsp);
1486 }
1487
1488
1489 /*********************************************************************
1490  *
1491  * Function    :  cgi_robots_txt
1492  *
1493  * Description :  CGI function to return "/robots.txt".
1494  *
1495  * Parameters  :
1496  *          1  :  csp = Current client state (buffers, headers, etc...)
1497  *          2  :  rsp = http_response data structure for output
1498  *          3  :  parameters = map of cgi parameters
1499  *
1500  * CGI Parameters : None
1501  *
1502  * Returns     :  JB_ERR_OK on success
1503  *                JB_ERR_MEMORY on out-of-memory error.
1504  *
1505  *********************************************************************/
1506 jb_err cgi_robots_txt(struct client_state *csp,
1507                       struct http_response *rsp,
1508                       const struct map *parameters)
1509 {
1510    char buf[100];
1511    jb_err err;
1512
1513    (void)csp;
1514    (void)parameters;
1515
1516    rsp->body = strdup(
1517       "# This is the Privoxy control interface.\n"
1518       "# It isn't very useful to index it, and you're likely to break stuff.\n"
1519       "# So go away!\n"
1520       "\n"
1521       "User-agent: *\n"
1522       "Disallow: /\n"
1523       "\n");
1524    if (rsp->body == NULL)
1525    {
1526       return JB_ERR_MEMORY;
1527    }
1528
1529    err = enlist_unique(rsp->headers, "Content-Type: text/plain", 13);
1530
1531    rsp->is_static = 1;
1532
1533    get_http_time(7 * 24 * 60 * 60, buf, sizeof(buf)); /* 7 days into future */
1534    if (!err) err = enlist_unique_header(rsp->headers, "Expires", buf);
1535
1536    return (err ? JB_ERR_MEMORY : JB_ERR_OK);
1537 }
1538
1539
1540 /*********************************************************************
1541  *
1542  * Function    :  show_defines
1543  *
1544  * Description :  Add to a map the state od all conditional #defines
1545  *                used when building
1546  *
1547  * Parameters  :
1548  *          1  :  exports = map to extend
1549  *
1550  * Returns     :  JB_ERR_OK on success
1551  *                JB_ERR_MEMORY on out-of-memory error.
1552  *
1553  *********************************************************************/
1554 static jb_err show_defines(struct map *exports)
1555 {
1556    jb_err err = JB_ERR_OK;
1557
1558 #ifdef FEATURE_ACCEPT_FILTER
1559    if (!err) err = map_conditional(exports, "FEATURE_ACCEPT_FILTER", 1);
1560 #else /* ifndef FEATURE_ACCEPT_FILTER */
1561    if (!err) err = map_conditional(exports, "FEATURE_ACCEPT_FILTER", 0);
1562 #endif /* ndef FEATURE_ACCEPT_FILTER */
1563
1564 #ifdef FEATURE_ACL
1565    if (!err) err = map_conditional(exports, "FEATURE_ACL", 1);
1566 #else /* ifndef FEATURE_ACL */
1567    if (!err) err = map_conditional(exports, "FEATURE_ACL", 0);
1568 #endif /* ndef FEATURE_ACL */
1569
1570 #ifdef FEATURE_CGI_EDIT_ACTIONS
1571    if (!err) err = map_conditional(exports, "FEATURE_CGI_EDIT_ACTIONS", 1);
1572 #else /* ifndef FEATURE_CGI_EDIT_ACTIONS */
1573    if (!err) err = map_conditional(exports, "FEATURE_CGI_EDIT_ACTIONS", 0);
1574 #endif /* ndef FEATURE_CGI_EDIT_ACTIONS */
1575
1576 #ifdef FEATURE_COMPRESSION
1577    if (!err) err = map_conditional(exports, "FEATURE_COMPRESSION", 1);
1578 #else /* ifndef FEATURE_COMPRESSION */
1579    if (!err) err = map_conditional(exports, "FEATURE_COMPRESSION", 0);
1580 #endif /* ndef FEATURE_COMPRESSION */
1581
1582 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1583    if (!err) err = map_conditional(exports, "FEATURE_CONNECTION_KEEP_ALIVE", 1);
1584 #else /* ifndef FEATURE_CONNECTION_KEEP_ALIVE */
1585    if (!err) err = map_conditional(exports, "FEATURE_CONNECTION_KEEP_ALIVE", 0);
1586 #endif /* ndef FEATURE_CONNECTION_KEEP_ALIVE */
1587
1588 #ifdef FEATURE_CONNECTION_SHARING
1589    if (!err) err = map_conditional(exports, "FEATURE_CONNECTION_SHARING", 1);
1590 #else /* ifndef FEATURE_CONNECTION_SHARING */
1591    if (!err) err = map_conditional(exports, "FEATURE_CONNECTION_SHARING", 0);
1592 #endif /* ndef FEATURE_CONNECTION_SHARING */
1593
1594 #ifdef FEATURE_FAST_REDIRECTS
1595    if (!err) err = map_conditional(exports, "FEATURE_FAST_REDIRECTS", 1);
1596 #else /* ifndef FEATURE_FAST_REDIRECTS */
1597    if (!err) err = map_conditional(exports, "FEATURE_FAST_REDIRECTS", 0);
1598 #endif /* ndef FEATURE_FAST_REDIRECTS */
1599
1600 #ifdef FEATURE_FORCE_LOAD
1601    if (!err) err = map_conditional(exports, "FEATURE_FORCE_LOAD", 1);
1602    if (!err) err = map(exports, "FORCE_PREFIX", 1, FORCE_PREFIX, 1);
1603 #else /* ifndef FEATURE_FORCE_LOAD */
1604    if (!err) err = map_conditional(exports, "FEATURE_FORCE_LOAD", 0);
1605    if (!err) err = map(exports, "FORCE_PREFIX", 1, "(none - disabled)", 1);
1606 #endif /* ndef FEATURE_FORCE_LOAD */
1607
1608 #ifdef FEATURE_GRACEFUL_TERMINATION
1609    if (!err) err = map_conditional(exports, "FEATURE_GRACEFUL_TERMINATION", 1);
1610 #else /* ifndef FEATURE_GRACEFUL_TERMINATION */
1611    if (!err) err = map_conditional(exports, "FEATURE_GRACEFUL_TERMINATION", 0);
1612 #endif /* ndef FEATURE_GRACEFUL_TERMINATION */
1613
1614 #ifdef FEATURE_IMAGE_BLOCKING
1615    if (!err) err = map_conditional(exports, "FEATURE_IMAGE_BLOCKING", 1);
1616 #else /* ifndef FEATURE_IMAGE_BLOCKING */
1617    if (!err) err = map_conditional(exports, "FEATURE_IMAGE_BLOCKING", 0);
1618 #endif /* ndef FEATURE_IMAGE_BLOCKING */
1619
1620 #ifdef FEATURE_IMAGE_DETECT_MSIE
1621    if (!err) err = map_conditional(exports, "FEATURE_IMAGE_DETECT_MSIE", 1);
1622 #else /* ifndef FEATURE_IMAGE_DETECT_MSIE */
1623    if (!err) err = map_conditional(exports, "FEATURE_IMAGE_DETECT_MSIE", 0);
1624 #endif /* ndef FEATURE_IMAGE_DETECT_MSIE */
1625
1626 #ifdef HAVE_RFC2553
1627    if (!err) err = map_conditional(exports, "FEATURE_IPV6_SUPPORT", 1);
1628 #else /* ifndef HAVE_RFC2553 */
1629    if (!err) err = map_conditional(exports, "FEATURE_IPV6_SUPPORT", 0);
1630 #endif /* ndef HAVE_RFC2553 */
1631
1632 #ifdef FEATURE_NO_GIFS
1633    if (!err) err = map_conditional(exports, "FEATURE_NO_GIFS", 1);
1634 #else /* ifndef FEATURE_NO_GIFS */
1635    if (!err) err = map_conditional(exports, "FEATURE_NO_GIFS", 0);
1636 #endif /* ndef FEATURE_NO_GIFS */
1637
1638 #ifdef FEATURE_PTHREAD
1639    if (!err) err = map_conditional(exports, "FEATURE_PTHREAD", 1);
1640 #else /* ifndef FEATURE_PTHREAD */
1641    if (!err) err = map_conditional(exports, "FEATURE_PTHREAD", 0);
1642 #endif /* ndef FEATURE_PTHREAD */
1643
1644 #ifdef FEATURE_STATISTICS
1645    if (!err) err = map_conditional(exports, "FEATURE_STATISTICS", 1);
1646 #else /* ifndef FEATURE_STATISTICS */
1647    if (!err) err = map_conditional(exports, "FEATURE_STATISTICS", 0);
1648 #endif /* ndef FEATURE_STATISTICS */
1649
1650 #ifdef FEATURE_TOGGLE
1651    if (!err) err = map_conditional(exports, "FEATURE_TOGGLE", 1);
1652 #else /* ifndef FEATURE_TOGGLE */
1653    if (!err) err = map_conditional(exports, "FEATURE_TOGGLE", 0);
1654 #endif /* ndef FEATURE_TOGGLE */
1655
1656 #ifdef FEATURE_TRUST
1657    if (!err) err = map_conditional(exports, "FEATURE_TRUST", 1);
1658 #else /* ifndef FEATURE_TRUST */
1659    if (!err) err = map_conditional(exports, "FEATURE_TRUST", 0);
1660 #endif /* ndef FEATURE_TRUST */
1661
1662 #ifdef FEATURE_ZLIB
1663    if (!err) err = map_conditional(exports, "FEATURE_ZLIB", 1);
1664 #else /* ifndef FEATURE_ZLIB */
1665    if (!err) err = map_conditional(exports, "FEATURE_ZLIB", 0);
1666 #endif /* ndef FEATURE_ZLIB */
1667
1668 #ifdef STATIC_PCRE
1669    if (!err) err = map_conditional(exports, "STATIC_PCRE", 1);
1670 #else /* ifndef STATIC_PCRE */
1671    if (!err) err = map_conditional(exports, "STATIC_PCRE", 0);
1672 #endif /* ndef STATIC_PCRE */
1673
1674 #ifdef STATIC_PCRS
1675    if (!err) err = map_conditional(exports, "STATIC_PCRS", 1);
1676 #else /* ifndef STATIC_PCRS */
1677    if (!err) err = map_conditional(exports, "STATIC_PCRS", 0);
1678 #endif /* ndef STATIC_PCRS */
1679
1680    return err;
1681 }
1682
1683
1684 /*********************************************************************
1685  *
1686  * Function    :  show_rcs
1687  *
1688  * Description :  Create a string with the rcs info for all sourcefiles
1689  *
1690  * Parameters  :  None
1691  *
1692  * Returns     :  A string, or NULL on out-of-memory.
1693  *
1694  *********************************************************************/
1695 static char *show_rcs(void)
1696 {
1697    char *result = strdup("");
1698    char buf[BUFFER_SIZE];
1699
1700    /* Instead of including *all* dot h's in the project (thus creating a
1701     * tremendous amount of dependencies), I will concede to declaring them
1702     * as extern's.  This forces the developer to add to this list, but oh well.
1703     */
1704
1705 #define SHOW_RCS(__x)              \
1706    {                               \
1707       extern const char __x[];     \
1708       snprintf(buf, sizeof(buf), " %s\n", __x);   \
1709       string_append(&result, buf); \
1710    }
1711
1712    /* In alphabetical order */
1713    SHOW_RCS(actions_h_rcs)
1714    SHOW_RCS(actions_rcs)
1715 #ifdef AMIGA
1716    SHOW_RCS(amiga_h_rcs)
1717    SHOW_RCS(amiga_rcs)
1718 #endif /* def AMIGA */
1719    SHOW_RCS(cgi_h_rcs)
1720    SHOW_RCS(cgi_rcs)
1721 #ifdef FEATURE_CGI_EDIT_ACTIONS
1722    SHOW_RCS(cgiedit_h_rcs)
1723    SHOW_RCS(cgiedit_rcs)
1724 #endif /* def FEATURE_CGI_EDIT_ACTIONS */
1725    SHOW_RCS(cgisimple_h_rcs)
1726    SHOW_RCS(cgisimple_rcs)
1727 #ifdef __MINGW32__
1728    SHOW_RCS(cygwin_h_rcs)
1729 #endif
1730    SHOW_RCS(deanimate_h_rcs)
1731    SHOW_RCS(deanimate_rcs)
1732    SHOW_RCS(encode_h_rcs)
1733    SHOW_RCS(encode_rcs)
1734    SHOW_RCS(errlog_h_rcs)
1735    SHOW_RCS(errlog_rcs)
1736    SHOW_RCS(filters_h_rcs)
1737    SHOW_RCS(filters_rcs)
1738    SHOW_RCS(gateway_h_rcs)
1739    SHOW_RCS(gateway_rcs)
1740    SHOW_RCS(jbsockets_h_rcs)
1741    SHOW_RCS(jbsockets_rcs)
1742    SHOW_RCS(jcc_h_rcs)
1743    SHOW_RCS(jcc_rcs)
1744    SHOW_RCS(list_h_rcs)
1745    SHOW_RCS(list_rcs)
1746    SHOW_RCS(loadcfg_h_rcs)
1747    SHOW_RCS(loadcfg_rcs)
1748    SHOW_RCS(loaders_h_rcs)
1749    SHOW_RCS(loaders_rcs)
1750    SHOW_RCS(miscutil_h_rcs)
1751    SHOW_RCS(miscutil_rcs)
1752    SHOW_RCS(parsers_h_rcs)
1753    SHOW_RCS(parsers_rcs)
1754    SHOW_RCS(pcrs_rcs)
1755    SHOW_RCS(pcrs_h_rcs)
1756    SHOW_RCS(project_h_rcs)
1757    SHOW_RCS(ssplit_h_rcs)
1758    SHOW_RCS(ssplit_rcs)
1759    SHOW_RCS(urlmatch_h_rcs)
1760    SHOW_RCS(urlmatch_rcs)
1761 #ifdef _WIN32
1762 #ifndef _WIN_CONSOLE
1763    SHOW_RCS(w32log_h_rcs)
1764    SHOW_RCS(w32log_rcs)
1765    SHOW_RCS(w32res_h_rcs)
1766    SHOW_RCS(w32taskbar_h_rcs)
1767    SHOW_RCS(w32taskbar_rcs)
1768 #endif /* ndef _WIN_CONSOLE */
1769    SHOW_RCS(win32_h_rcs)
1770    SHOW_RCS(win32_rcs)
1771 #endif /* def _WIN32 */
1772
1773 #undef SHOW_RCS
1774
1775    return result;
1776
1777 }
1778
1779
1780 /*********************************************************************
1781  *
1782  * Function    :  cgi_show_file
1783  *
1784  * Description :  CGI function that shows the content of a
1785  *                configuration file.
1786  *
1787  * Parameters  :
1788  *          1  :  csp = Current client state (buffers, headers, etc...)
1789  *          2  :  rsp = http_response data structure for output
1790  *          3  :  parameters = map of cgi parameters
1791  *
1792  * CGI Parameters :
1793  *        file :  Which file to show.  Only first letter is checked,
1794  *                valid values are:
1795  *                - "a"ction file
1796  *                - "r"egex
1797  *                - "t"rust
1798  *                Default is to show menu and other information.
1799  *
1800  * Returns     :  JB_ERR_OK on success
1801  *                JB_ERR_MEMORY on out-of-memory error.
1802  *
1803  *********************************************************************/
1804 static jb_err cgi_show_file(struct client_state *csp,
1805                             struct http_response *rsp,
1806                             const struct map *parameters)
1807 {
1808    unsigned i;
1809    const char * filename = NULL;
1810    char * file_description = NULL;
1811
1812    assert(csp);
1813    assert(rsp);
1814    assert(parameters);
1815
1816    switch (*(lookup(parameters, "file")))
1817    {
1818    case 'a':
1819       if (!get_number_param(csp, parameters, "index", &i) && i < MAX_AF_FILES && csp->actions_list[i])
1820       {
1821          filename = csp->actions_list[i]->filename;
1822          file_description = "Actions File";
1823       }
1824       break;
1825
1826    case 'f':
1827       if (!get_number_param(csp, parameters, "index", &i) && i < MAX_AF_FILES && csp->rlist[i])
1828       {
1829          filename = csp->rlist[i]->filename;
1830          file_description = "Filter File";
1831       }
1832       break;
1833
1834 #ifdef FEATURE_TRUST
1835    case 't':
1836       if (csp->tlist)
1837       {
1838          filename = csp->tlist->filename;
1839          file_description = "Trust File";
1840       }
1841       break;
1842 #endif /* def FEATURE_TRUST */
1843    }
1844
1845    if (NULL != filename)
1846    {
1847       struct map *exports;
1848       char *s;
1849       jb_err err;
1850       size_t length;
1851
1852       exports = default_exports(csp, "show-status");
1853       if (NULL == exports)
1854       {
1855          return JB_ERR_MEMORY;
1856       }
1857
1858       if (map(exports, "file-description", 1, file_description, 1)
1859         || map(exports, "filepath", 1, html_encode(filename), 0))
1860       {
1861          free_map(exports);
1862          return JB_ERR_MEMORY;
1863       }
1864
1865       err = load_file(filename, &s, &length);
1866       if (JB_ERR_OK != err)
1867       {
1868          if (map(exports, "contents", 1, "<h1>ERROR OPENING FILE!</h1>", 1))
1869          {
1870             free_map(exports);
1871             return JB_ERR_MEMORY;
1872          }
1873       }
1874       else
1875       {
1876          s = html_encode_and_free_original(s);
1877          if (NULL == s)
1878          {
1879             return JB_ERR_MEMORY;
1880          }
1881
1882          if (map(exports, "contents", 1, s, 0))
1883          {
1884             free_map(exports);
1885             return JB_ERR_MEMORY;
1886          }
1887       }
1888
1889       return template_fill_for_cgi(csp, "show-status-file", exports, rsp);
1890    }
1891
1892    return JB_ERR_CGI_PARAMS;
1893 }
1894
1895
1896 /*********************************************************************
1897  *
1898  * Function    :  load_file
1899  *
1900  * Description :  Loads a file into a buffer.
1901  *
1902  * Parameters  :
1903  *          1  :  filename = Name of the file to be loaded.
1904  *          2  :  buffer   = Used to return the file's content.
1905  *          3  :  length   = Used to return the size of the file.
1906  *
1907  * Returns     :  JB_ERR_OK in case of success,
1908  *                JB_ERR_FILE in case of ordinary file loading errors
1909  *                            (fseek() and ftell() errors are fatal)
1910  *                JB_ERR_MEMORY in case of out-of-memory.
1911  *
1912  *********************************************************************/
1913 static jb_err load_file(const char *filename, char **buffer, size_t *length)
1914 {
1915    FILE *fp;
1916    long ret;
1917    jb_err err = JB_ERR_OK;
1918
1919    fp = fopen(filename, "rb");
1920    if (NULL == fp)
1921    {
1922       log_error(LOG_LEVEL_ERROR, "Failed to open %s: %E", filename);
1923       return JB_ERR_FILE;
1924    }
1925
1926    /* Get file length */
1927    if (fseek(fp, 0, SEEK_END))
1928    {
1929       log_error(LOG_LEVEL_FATAL,
1930          "Unexpected error while fseek()ing to the end of %s: %E",
1931          filename);
1932    }
1933    ret = ftell(fp);
1934    if (-1 == ret)
1935    {
1936       log_error(LOG_LEVEL_FATAL,
1937          "Unexpected ftell() error while loading %s: %E",
1938          filename);
1939    }
1940    *length = (size_t)ret;
1941
1942    /* Go back to the beginning. */
1943    if (fseek(fp, 0, SEEK_SET))
1944    {
1945       log_error(LOG_LEVEL_FATAL,
1946          "Unexpected error while fseek()ing to the beginning of %s: %E",
1947          filename);
1948    }
1949
1950    *buffer = (char *)zalloc(*length + 1);
1951    if (NULL == *buffer)
1952    {
1953       err = JB_ERR_MEMORY;
1954    }
1955    else if (!fread(*buffer, *length, 1, fp))
1956    {
1957       /*
1958        * May happen if the file size changes between fseek() and
1959        * fread(). If it does, we just log it and serve what we got.
1960        */
1961       log_error(LOG_LEVEL_ERROR,
1962          "Couldn't completely read file %s.", filename);
1963       err = JB_ERR_FILE;
1964    }
1965
1966    fclose(fp);
1967
1968    return err;
1969
1970 }
1971
1972
1973 /*
1974   Local Variables:
1975   tab-width: 3
1976   end:
1977 */