Consistency-cosmetic for cgi_show_status()
[privoxy.git] / cgisimple.c
1 const char cgisimple_rcs[] = "$Id: cgisimple.c,v 1.124 2014/05/20 11:55:24 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-2014 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 #if defined (HAVE_ACCESS) && defined (HAVE_UNISTD_H)
47 #include <unistd.h>
48 #endif /* def HAVE_ACCESS && HAVE_UNISTD_H */
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    if (!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                   case SOCKS_5T:
1412                      socks_type = "socks5t";
1413                      break;
1414                   default:
1415                      log_error(LOG_LEVEL_FATAL, "Unknown socks type: %d.", fwd->type);
1416                }
1417
1418                if (!err) err = map(exports, "socks-type", 1, socks_type, 1);
1419                if (!err) err = map(exports, "gateway-host", 1, fwd->gateway_host, 1);
1420                snprintf(port, sizeof(port), "%d", fwd->gateway_port);
1421                if (!err) err = map(exports, "gateway-port", 1, port, 1);
1422             }
1423             else
1424             {
1425                if (!err) err = map_block_killer(exports, "socks-forwarder");
1426             }
1427
1428             if (fwd->forward_host != NULL)
1429             {
1430                if (!err) err = map(exports, "forward-host", 1, fwd->forward_host, 1);
1431                snprintf(port, sizeof(port), "%d", fwd->forward_port);
1432                if (!err) err = map(exports, "forward-port", 1, port, 1);
1433             }
1434             else
1435             {
1436                if (!err) err = map_block_killer(exports, "http-forwarder");
1437             }
1438          }
1439       }
1440
1441       free_http_request(url_to_query);
1442
1443       if (err || matches == NULL)
1444       {
1445          free_current_action(action);
1446          free_map(exports);
1447          return JB_ERR_MEMORY;
1448       }
1449
1450 #ifdef FEATURE_CGI_EDIT_ACTIONS
1451       if ((csp->config->feature_flags & RUNTIME_FEATURE_CGI_EDIT_ACTIONS))
1452       {
1453          err = map_block_killer(exports, "cgi-editor-is-disabled");
1454       }
1455 #endif /* FEATURE_CGI_EDIT_ACTIONS */
1456
1457       /*
1458        * If zlib support is available, if no content filters
1459        * are enabled or if the prevent-compression action is enabled,
1460        * suppress the "compression could prevent filtering" warning.
1461        */
1462 #ifndef FEATURE_ZLIB
1463       if (!content_filters_enabled(action) ||
1464          (action->flags & ACTION_NO_COMPRESSION))
1465 #endif
1466       {
1467          if (!err) err = map_block_killer(exports, "filters-might-be-ineffective");
1468       }
1469
1470       if (err || map(exports, "matches", 1, matches , 0))
1471       {
1472          free_current_action(action);
1473          free_map(exports);
1474          return JB_ERR_MEMORY;
1475       }
1476
1477       s = current_action_to_html(csp, action);
1478
1479       free_current_action(action);
1480
1481       if (map(exports, "final", 1, s, 0))
1482       {
1483          free_map(exports);
1484          return JB_ERR_MEMORY;
1485       }
1486    }
1487
1488    return template_fill_for_cgi(csp, "show-url-info", exports, rsp);
1489 }
1490
1491
1492 /*********************************************************************
1493  *
1494  * Function    :  cgi_robots_txt
1495  *
1496  * Description :  CGI function to return "/robots.txt".
1497  *
1498  * Parameters  :
1499  *          1  :  csp = Current client state (buffers, headers, etc...)
1500  *          2  :  rsp = http_response data structure for output
1501  *          3  :  parameters = map of cgi parameters
1502  *
1503  * CGI Parameters : None
1504  *
1505  * Returns     :  JB_ERR_OK on success
1506  *                JB_ERR_MEMORY on out-of-memory error.
1507  *
1508  *********************************************************************/
1509 jb_err cgi_robots_txt(struct client_state *csp,
1510                       struct http_response *rsp,
1511                       const struct map *parameters)
1512 {
1513    char buf[100];
1514    jb_err err;
1515
1516    (void)csp;
1517    (void)parameters;
1518
1519    rsp->body = strdup(
1520       "# This is the Privoxy control interface.\n"
1521       "# It isn't very useful to index it, and you're likely to break stuff.\n"
1522       "# So go away!\n"
1523       "\n"
1524       "User-agent: *\n"
1525       "Disallow: /\n"
1526       "\n");
1527    if (rsp->body == NULL)
1528    {
1529       return JB_ERR_MEMORY;
1530    }
1531
1532    err = enlist_unique(rsp->headers, "Content-Type: text/plain", 13);
1533
1534    rsp->is_static = 1;
1535
1536    get_http_time(7 * 24 * 60 * 60, buf, sizeof(buf)); /* 7 days into future */
1537    if (!err) err = enlist_unique_header(rsp->headers, "Expires", buf);
1538
1539    return (err ? JB_ERR_MEMORY : JB_ERR_OK);
1540 }
1541
1542
1543 /*********************************************************************
1544  *
1545  * Function    :  show_defines
1546  *
1547  * Description :  Add to a map the state od all conditional #defines
1548  *                used when building
1549  *
1550  * Parameters  :
1551  *          1  :  exports = map to extend
1552  *
1553  * Returns     :  JB_ERR_OK on success
1554  *                JB_ERR_MEMORY on out-of-memory error.
1555  *
1556  *********************************************************************/
1557 static jb_err show_defines(struct map *exports)
1558 {
1559    jb_err err = JB_ERR_OK;
1560    int i;
1561    struct feature {
1562       const char name[31];
1563       const unsigned char is_available;
1564    };
1565
1566    static const struct feature features[] = {
1567       {
1568          "FEATURE_ACCEPT_FILTER",
1569 #ifdef FEATURE_ACCEPT_FILTER
1570          1,
1571 #else
1572          0,
1573 #endif
1574       },
1575       {
1576          "FEATURE_ACL",
1577 #ifdef FEATURE_ACL
1578          1,
1579 #else
1580          0,
1581 #endif
1582       },
1583       {
1584          "FEATURE_CGI_EDIT_ACTIONS",
1585 #ifdef FEATURE_CGI_EDIT_ACTIONS
1586          1,
1587 #else
1588          0,
1589 #endif
1590       },
1591       {
1592          "FEATURE_COMPRESSION",
1593 #ifdef FEATURE_COMPRESSION
1594          1,
1595 #else
1596          0,
1597 #endif
1598       },
1599       {
1600          "FEATURE_CONNECTION_KEEP_ALIVE",
1601 #ifdef FEATURE_CONNECTION_KEEP_ALIVE
1602          1,
1603 #else
1604          0,
1605 #endif
1606       },
1607       {
1608          "FEATURE_CONNECTION_SHARING",
1609 #ifdef FEATURE_CONNECTION_SHARING
1610          1,
1611 #else
1612          0,
1613 #endif
1614       },
1615       {
1616          "FEATURE_FAST_REDIRECTS",
1617 #ifdef FEATURE_FAST_REDIRECTS
1618          1,
1619 #else
1620          0,
1621 #endif
1622       },
1623       {
1624          "FEATURE_FORCE_LOAD",
1625 #ifdef FEATURE_FORCE_LOAD
1626          1,
1627 #else
1628          0,
1629 #endif
1630       },
1631       {
1632          "FEATURE_GRACEFUL_TERMINATION",
1633 #ifdef FEATURE_GRACEFUL_TERMINATION
1634          1,
1635 #else
1636          0,
1637 #endif
1638       },
1639       {
1640          "FEATURE_IMAGE_BLOCKING",
1641 #ifdef FEATURE_IMAGE_BLOCKING
1642          1,
1643 #else
1644          0,
1645 #endif
1646       },
1647       {
1648          "FEATURE_IMAGE_DETECT_MSIE",
1649 #ifdef FEATURE_IMAGE_DETECT_MSIE
1650          1,
1651 #else
1652          0,
1653 #endif
1654       },
1655       {
1656          "FEATURE_IPV6_SUPPORT",
1657 #ifdef HAVE_RFC2553
1658          1,
1659 #else
1660          0,
1661 #endif
1662       },
1663       {
1664          "FEATURE_NO_GIFS",
1665 #ifdef FEATURE_NO_GIFS
1666          1,
1667 #else
1668          0,
1669 #endif
1670       },
1671       {
1672          "FEATURE_PTHREAD",
1673 #ifdef FEATURE_PTHREAD
1674          1,
1675 #else
1676          0,
1677 #endif
1678       },
1679       {
1680          "FEATURE_STATISTICS",
1681 #ifdef FEATURE_STATISTICS
1682          1,
1683 #else
1684          0,
1685 #endif
1686       },
1687       {
1688          "FEATURE_STRPTIME_SANITY_CHECKS",
1689 #ifdef FEATURE_STRPTIME_SANITY_CHECKS
1690          1,
1691 #else
1692          0,
1693 #endif
1694       },
1695       {
1696          "FEATURE_TOGGLE",
1697 #ifdef FEATURE_TOGGLE
1698          1,
1699 #else
1700          0,
1701 #endif
1702       },
1703       {
1704          "FEATURE_TRUST",
1705 #ifdef FEATURE_TRUST
1706          1,
1707 #else
1708          0,
1709 #endif
1710       },
1711       {
1712          "FEATURE_ZLIB",
1713 #ifdef FEATURE_ZLIB
1714          1,
1715 #else
1716          0,
1717 #endif
1718       },
1719       {
1720          "FEATURE_DYNAMIC_PCRE",
1721 #ifdef FEATURE_DYNAMIC_PCRE
1722          1,
1723 #else
1724          0,
1725 #endif
1726       }
1727    };
1728
1729    for (i = 0; i < SZ(features); i++)
1730    {
1731       err = map_conditional(exports, features[i].name, features[i].is_available);
1732       if (err)
1733       {
1734          break;
1735       }
1736    }
1737
1738    return err;
1739
1740 }
1741
1742
1743 /*********************************************************************
1744  *
1745  * Function    :  show_rcs
1746  *
1747  * Description :  Create a string with the rcs info for all sourcefiles
1748  *
1749  * Parameters  :  None
1750  *
1751  * Returns     :  A string, or NULL on out-of-memory.
1752  *
1753  *********************************************************************/
1754 static char *show_rcs(void)
1755 {
1756    char *result = strdup("");
1757    char buf[BUFFER_SIZE];
1758
1759    /* Instead of including *all* dot h's in the project (thus creating a
1760     * tremendous amount of dependencies), I will concede to declaring them
1761     * as extern's.  This forces the developer to add to this list, but oh well.
1762     */
1763
1764 #define SHOW_RCS(__x)              \
1765    {                               \
1766       extern const char __x[];     \
1767       snprintf(buf, sizeof(buf), " %s\n", __x);   \
1768       string_append(&result, buf); \
1769    }
1770
1771    /* In alphabetical order */
1772    SHOW_RCS(actions_h_rcs)
1773    SHOW_RCS(actions_rcs)
1774 #ifdef AMIGA
1775    SHOW_RCS(amiga_h_rcs)
1776    SHOW_RCS(amiga_rcs)
1777 #endif /* def AMIGA */
1778    SHOW_RCS(cgi_h_rcs)
1779    SHOW_RCS(cgi_rcs)
1780 #ifdef FEATURE_CGI_EDIT_ACTIONS
1781    SHOW_RCS(cgiedit_h_rcs)
1782    SHOW_RCS(cgiedit_rcs)
1783 #endif /* def FEATURE_CGI_EDIT_ACTIONS */
1784    SHOW_RCS(cgisimple_h_rcs)
1785    SHOW_RCS(cgisimple_rcs)
1786 #ifdef __MINGW32__
1787    SHOW_RCS(cygwin_h_rcs)
1788 #endif
1789    SHOW_RCS(deanimate_h_rcs)
1790    SHOW_RCS(deanimate_rcs)
1791    SHOW_RCS(encode_h_rcs)
1792    SHOW_RCS(encode_rcs)
1793    SHOW_RCS(errlog_h_rcs)
1794    SHOW_RCS(errlog_rcs)
1795    SHOW_RCS(filters_h_rcs)
1796    SHOW_RCS(filters_rcs)
1797    SHOW_RCS(gateway_h_rcs)
1798    SHOW_RCS(gateway_rcs)
1799    SHOW_RCS(jbsockets_h_rcs)
1800    SHOW_RCS(jbsockets_rcs)
1801    SHOW_RCS(jcc_h_rcs)
1802    SHOW_RCS(jcc_rcs)
1803    SHOW_RCS(list_h_rcs)
1804    SHOW_RCS(list_rcs)
1805    SHOW_RCS(loadcfg_h_rcs)
1806    SHOW_RCS(loadcfg_rcs)
1807    SHOW_RCS(loaders_h_rcs)
1808    SHOW_RCS(loaders_rcs)
1809    SHOW_RCS(miscutil_h_rcs)
1810    SHOW_RCS(miscutil_rcs)
1811    SHOW_RCS(parsers_h_rcs)
1812    SHOW_RCS(parsers_rcs)
1813    SHOW_RCS(pcrs_rcs)
1814    SHOW_RCS(pcrs_h_rcs)
1815    SHOW_RCS(project_h_rcs)
1816    SHOW_RCS(ssplit_h_rcs)
1817    SHOW_RCS(ssplit_rcs)
1818    SHOW_RCS(urlmatch_h_rcs)
1819    SHOW_RCS(urlmatch_rcs)
1820 #ifdef _WIN32
1821 #ifndef _WIN_CONSOLE
1822    SHOW_RCS(w32log_h_rcs)
1823    SHOW_RCS(w32log_rcs)
1824    SHOW_RCS(w32res_h_rcs)
1825    SHOW_RCS(w32taskbar_h_rcs)
1826    SHOW_RCS(w32taskbar_rcs)
1827 #endif /* ndef _WIN_CONSOLE */
1828    SHOW_RCS(win32_h_rcs)
1829    SHOW_RCS(win32_rcs)
1830 #endif /* def _WIN32 */
1831
1832 #undef SHOW_RCS
1833
1834    return result;
1835
1836 }
1837
1838
1839 /*********************************************************************
1840  *
1841  * Function    :  cgi_show_file
1842  *
1843  * Description :  CGI function that shows the content of a
1844  *                configuration file.
1845  *
1846  * Parameters  :
1847  *          1  :  csp = Current client state (buffers, headers, etc...)
1848  *          2  :  rsp = http_response data structure for output
1849  *          3  :  parameters = map of cgi parameters
1850  *
1851  * CGI Parameters :
1852  *        file :  Which file to show.  Only first letter is checked,
1853  *                valid values are:
1854  *                - "a"ction file
1855  *                - "r"egex
1856  *                - "t"rust
1857  *                Default is to show menu and other information.
1858  *
1859  * Returns     :  JB_ERR_OK on success
1860  *                JB_ERR_MEMORY on out-of-memory error.
1861  *
1862  *********************************************************************/
1863 static jb_err cgi_show_file(struct client_state *csp,
1864                             struct http_response *rsp,
1865                             const struct map *parameters)
1866 {
1867    unsigned i;
1868    const char * filename = NULL;
1869    char * file_description = NULL;
1870
1871    assert(csp);
1872    assert(rsp);
1873    assert(parameters);
1874
1875    switch (*(lookup(parameters, "file")))
1876    {
1877    case 'a':
1878       if (!get_number_param(csp, parameters, "index", &i) && i < MAX_AF_FILES && csp->actions_list[i])
1879       {
1880          filename = csp->actions_list[i]->filename;
1881          file_description = "Actions File";
1882       }
1883       break;
1884
1885    case 'f':
1886       if (!get_number_param(csp, parameters, "index", &i) && i < MAX_AF_FILES && csp->rlist[i])
1887       {
1888          filename = csp->rlist[i]->filename;
1889          file_description = "Filter File";
1890       }
1891       break;
1892
1893 #ifdef FEATURE_TRUST
1894    case 't':
1895       if (csp->tlist)
1896       {
1897          filename = csp->tlist->filename;
1898          file_description = "Trust File";
1899       }
1900       break;
1901 #endif /* def FEATURE_TRUST */
1902    }
1903
1904    if (NULL != filename)
1905    {
1906       struct map *exports;
1907       char *s;
1908       jb_err err;
1909       size_t length;
1910
1911       exports = default_exports(csp, "show-status");
1912       if (NULL == exports)
1913       {
1914          return JB_ERR_MEMORY;
1915       }
1916
1917       if (map(exports, "file-description", 1, file_description, 1)
1918         || map(exports, "filepath", 1, html_encode(filename), 0))
1919       {
1920          free_map(exports);
1921          return JB_ERR_MEMORY;
1922       }
1923
1924       err = load_file(filename, &s, &length);
1925       if (JB_ERR_OK != err)
1926       {
1927          if (map(exports, "contents", 1, "<h1>ERROR OPENING FILE!</h1>", 1))
1928          {
1929             free_map(exports);
1930             return JB_ERR_MEMORY;
1931          }
1932       }
1933       else
1934       {
1935          s = html_encode_and_free_original(s);
1936          if (NULL == s)
1937          {
1938             return JB_ERR_MEMORY;
1939          }
1940
1941          if (map(exports, "contents", 1, s, 0))
1942          {
1943             free_map(exports);
1944             return JB_ERR_MEMORY;
1945          }
1946       }
1947
1948       return template_fill_for_cgi(csp, "show-status-file", exports, rsp);
1949    }
1950
1951    return JB_ERR_CGI_PARAMS;
1952 }
1953
1954
1955 /*********************************************************************
1956  *
1957  * Function    :  load_file
1958  *
1959  * Description :  Loads a file into a buffer.
1960  *
1961  * Parameters  :
1962  *          1  :  filename = Name of the file to be loaded.
1963  *          2  :  buffer   = Used to return the file's content.
1964  *          3  :  length   = Used to return the size of the file.
1965  *
1966  * Returns     :  JB_ERR_OK in case of success,
1967  *                JB_ERR_FILE in case of ordinary file loading errors
1968  *                            (fseek() and ftell() errors are fatal)
1969  *                JB_ERR_MEMORY in case of out-of-memory.
1970  *
1971  *********************************************************************/
1972 static jb_err load_file(const char *filename, char **buffer, size_t *length)
1973 {
1974    FILE *fp;
1975    long ret;
1976    jb_err err = JB_ERR_OK;
1977
1978    fp = fopen(filename, "rb");
1979    if (NULL == fp)
1980    {
1981       log_error(LOG_LEVEL_ERROR, "Failed to open %s: %E", filename);
1982       return JB_ERR_FILE;
1983    }
1984
1985    /* Get file length */
1986    if (fseek(fp, 0, SEEK_END))
1987    {
1988       log_error(LOG_LEVEL_FATAL,
1989          "Unexpected error while fseek()ing to the end of %s: %E",
1990          filename);
1991    }
1992    ret = ftell(fp);
1993    if (-1 == ret)
1994    {
1995       log_error(LOG_LEVEL_FATAL,
1996          "Unexpected ftell() error while loading %s: %E",
1997          filename);
1998    }
1999    *length = (size_t)ret;
2000
2001    /* Go back to the beginning. */
2002    if (fseek(fp, 0, SEEK_SET))
2003    {
2004       log_error(LOG_LEVEL_FATAL,
2005          "Unexpected error while fseek()ing to the beginning of %s: %E",
2006          filename);
2007    }
2008
2009    *buffer = (char *)zalloc(*length + 1);
2010    if (NULL == *buffer)
2011    {
2012       err = JB_ERR_MEMORY;
2013    }
2014    else if (!fread(*buffer, *length, 1, fp))
2015    {
2016       /*
2017        * May happen if the file size changes between fseek() and
2018        * fread(). If it does, we just log it and serve what we got.
2019        */
2020       log_error(LOG_LEVEL_ERROR,
2021          "Couldn't completely read file %s.", filename);
2022       err = JB_ERR_FILE;
2023    }
2024
2025    fclose(fp);
2026
2027    return err;
2028
2029 }
2030
2031
2032 /*
2033   Local Variables:
2034   tab-width: 3
2035   end:
2036 */