Remove old listproc address and webmaster mailing address.
[ira/wip.git] / source3 / web / cgi.c
1 /* 
2    some simple CGI helper routines
3    Copyright (C) Andrew Tridgell 1997-1998
4    
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 2 of the License, or
8    (at your option) any later version.
9    
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14    
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20
21 #include "includes.h"
22 #include "../web/swat_proto.h"
23
24 #define MAX_VARIABLES 10000
25
26 /* set the expiry on fixed pages */
27 #define EXPIRY_TIME (60*60*24*7)
28
29 #ifdef DEBUG_COMMENTS
30 extern void print_title(char *fmt, ...);
31 #endif
32
33 struct var {
34         char *name;
35         char *value;
36 };
37
38 static struct var variables[MAX_VARIABLES];
39 static int num_variables;
40 static int content_length;
41 static int request_post;
42 static char *query_string;
43 static const char *baseurl;
44 static char *pathinfo;
45 static char *C_user;
46 static BOOL inetd_server;
47 static BOOL got_request;
48
49 static char *grab_line(FILE *f, int *cl)
50 {
51         char *ret = NULL;
52         int i = 0;
53         int len = 0;
54
55         while ((*cl)) {
56                 int c;
57         
58                 if (i == len) {
59                         char *ret2;
60                         if (len == 0) len = 1024;
61                         else len *= 2;
62                         ret2 = (char *)Realloc(ret, len);
63                         if (!ret2) return ret;
64                         ret = ret2;
65                 }
66         
67                 c = fgetc(f);
68                 (*cl)--;
69
70                 if (c == EOF) {
71                         (*cl) = 0;
72                         break;
73                 }
74                 
75                 if (c == '\r') continue;
76
77                 if (strchr_m("\n&", c)) break;
78
79                 ret[i++] = c;
80
81         }
82         
83
84         ret[i] = 0;
85         return ret;
86 }
87
88 /***************************************************************************
89   load all the variables passed to the CGI program. May have multiple variables
90   with the same name and the same or different values. Takes a file parameter
91   for simulating CGI invocation eg loading saved preferences.
92   ***************************************************************************/
93 void cgi_load_variables(void)
94 {
95         static char *line;
96         char *p, *s, *tok;
97         int len, i;
98         FILE *f = stdin;
99
100 #ifdef DEBUG_COMMENTS
101         char dummy[100]="";
102         print_title(dummy);
103         d_printf("<!== Start dump in cgi_load_variables() %s ==>\n",__FILE__);
104 #endif
105
106         if (!content_length) {
107                 p = getenv("CONTENT_LENGTH");
108                 len = p?atoi(p):0;
109         } else {
110                 len = content_length;
111         }
112
113
114         if (len > 0 && 
115             (request_post ||
116              ((s=getenv("REQUEST_METHOD")) && 
117               strcasecmp(s,"POST")==0))) {
118                 while (len && (line=grab_line(f, &len))) {
119                         p = strchr_m(line,'=');
120                         if (!p) continue;
121                         
122                         *p = 0;
123                         
124                         variables[num_variables].name = strdup(line);
125                         variables[num_variables].value = strdup(p+1);
126
127                         SAFE_FREE(line);
128                         
129                         if (!variables[num_variables].name || 
130                             !variables[num_variables].value)
131                                 continue;
132
133                         rfc1738_unescape(variables[num_variables].value);
134                         rfc1738_unescape(variables[num_variables].name);
135
136 #ifdef DEBUG_COMMENTS
137                         printf("<!== POST var %s has value \"%s\"  ==>\n",
138                                variables[num_variables].name,
139                                variables[num_variables].value);
140 #endif
141                         
142                         num_variables++;
143                         if (num_variables == MAX_VARIABLES) break;
144                 }
145         }
146
147         fclose(stdin);
148         open("/dev/null", O_RDWR);
149
150         if ((s=query_string) || (s=getenv("QUERY_STRING"))) {
151                 for (tok=strtok(s,"&;");tok;tok=strtok(NULL,"&;")) {
152                         p = strchr_m(tok,'=');
153                         if (!p) continue;
154                         
155                         *p = 0;
156                         
157                         variables[num_variables].name = strdup(tok);
158                         variables[num_variables].value = strdup(p+1);
159
160                         if (!variables[num_variables].name || 
161                             !variables[num_variables].value)
162                                 continue;
163
164                         rfc1738_unescape(variables[num_variables].value);
165                         rfc1738_unescape(variables[num_variables].name);
166
167 #ifdef DEBUG_COMMENTS
168                         printf("<!== Commandline var %s has value \"%s\"  ==>\n",
169                                variables[num_variables].name,
170                                variables[num_variables].value);
171 #endif                                          
172                         num_variables++;
173                         if (num_variables == MAX_VARIABLES) break;
174                 }
175
176         }
177 #ifdef DEBUG_COMMENTS
178         printf("<!== End dump in cgi_load_variables() ==>\n");   
179 #endif
180
181         /* variables from the client are in display charset - convert them
182            to our internal charset before use */
183         for (i=0;i<num_variables;i++) {
184                 pstring dest;
185
186                 convert_string(CH_DISPLAY, CH_UNIX, 
187                                variables[i].name, -1, 
188                                dest, sizeof(dest));
189                 free(variables[i].name);
190                 variables[i].name = strdup(dest);
191
192                 convert_string(CH_DISPLAY, CH_UNIX, 
193                                variables[i].value, -1,
194                                dest, sizeof(dest));
195                 free(variables[i].value);
196                 variables[i].value = strdup(dest);
197         }
198 }
199
200
201 /***************************************************************************
202   find a variable passed via CGI
203   Doesn't quite do what you think in the case of POST text variables, because
204   if they exist they might have a value of "" or even " ", depending on the 
205   browser. Also doesn't allow for variables[] containing multiple variables
206   with the same name and the same or different values.
207   ***************************************************************************/
208 const char *cgi_variable(const char *name)
209 {
210         int i;
211
212         for (i=0;i<num_variables;i++)
213                 if (strcmp(variables[i].name, name) == 0)
214                         return variables[i].value;
215         return NULL;
216 }
217
218 /***************************************************************************
219 tell a browser about a fatal error in the http processing
220   ***************************************************************************/
221 static void cgi_setup_error(const char *err, const char *header, const char *info)
222 {
223         if (!got_request) {
224                 /* damn browsers don't like getting cut off before they give a request */
225                 char line[1024];
226                 while (fgets(line, sizeof(line)-1, stdin)) {
227                         if (strncasecmp(line,"GET ", 4)==0 || 
228                             strncasecmp(line,"POST ", 5)==0 ||
229                             strncasecmp(line,"PUT ", 4)==0) {
230                                 break;
231                         }
232                 }
233         }
234
235         d_printf("HTTP/1.0 %s\r\n%sConnection: close\r\nContent-Type: text/html\r\n\r\n<HTML><HEAD><TITLE>%s</TITLE></HEAD><BODY><H1>%s</H1>%s<p></BODY></HTML>\r\n\r\n", err, header, err, err, info);
236         fclose(stdin);
237         fclose(stdout);
238         exit(0);
239 }
240
241
242 /***************************************************************************
243 tell a browser about a fatal authentication error
244   ***************************************************************************/
245 static void cgi_auth_error(void)
246 {
247         if (inetd_server) {
248                 cgi_setup_error("401 Authorization Required", 
249                                 "WWW-Authenticate: Basic realm=\"SWAT\"\r\n",
250                                 "You must be authenticated to use this service");
251         } else {
252                 printf("Content-Type: text/html\r\n");
253
254                 printf("\r\n<HTML><HEAD><TITLE>SWAT</TITLE></HEAD>\n");
255                 printf("<BODY><H1>Installation Error</H1>\n");
256                 printf("SWAT must be installed via inetd. It cannot be run as a CGI script<p>\n");
257                 printf("</BODY></HTML>\r\n");
258         }
259         exit(0);
260 }
261
262 /***************************************************************************
263 authenticate when we are running as a CGI
264   ***************************************************************************/
265 static void cgi_web_auth(void)
266 {
267         const char *user = getenv("REMOTE_USER");
268         struct passwd *pwd;
269         const char *head = "Content-Type: text/html\r\n\r\n<HTML><BODY><H1>SWAT installation Error</H1>\n";
270         const char *tail = "</BODY></HTML>\r\n";
271
272         if (!user) {
273                 printf("%sREMOTE_USER not set. Not authenticated by web server.<br>%s\n",
274                        head, tail);
275                 exit(0);
276         }
277
278         pwd = getpwnam_alloc(user);
279         if (!pwd) {
280                 printf("%sCannot find user %s<br>%s\n", head, user, tail);
281                 exit(0);
282         }
283
284         setuid(0);
285         setuid(pwd->pw_uid);
286         if (geteuid() != pwd->pw_uid || getuid() != pwd->pw_uid) {
287                 printf("%sFailed to become user %s - uid=%d/%d<br>%s\n", 
288                        head, user, (int)geteuid(), (int)getuid(), tail);
289                 exit(0);
290         }
291         passwd_free(&pwd);
292 }
293
294
295 /***************************************************************************
296 handle a http authentication line
297   ***************************************************************************/
298 static BOOL cgi_handle_authorization(char *line)
299 {
300         char *p;
301         fstring user, user_pass;
302         struct passwd *pass = NULL;
303
304         if (strncasecmp(line,"Basic ", 6)) {
305                 goto err;
306         }
307         line += 6;
308         while (line[0] == ' ') line++;
309         base64_decode(line);
310         if (!(p=strchr_m(line,':'))) {
311                 /*
312                  * Always give the same error so a cracker
313                  * cannot tell why we fail.
314                  */
315                 goto err;
316         }
317         *p = 0;
318
319         convert_string(CH_DISPLAY, CH_UNIX, 
320                        line, -1, 
321                        user, sizeof(user));
322
323         convert_string(CH_DISPLAY, CH_UNIX, 
324                        p+1, -1, 
325                        user_pass, sizeof(user_pass));
326
327         /*
328          * Try and get the user from the UNIX password file.
329          */
330         
331         pass = getpwnam_alloc(user);
332         
333         /*
334          * Validate the password they have given.
335          */
336         
337         if NT_STATUS_IS_OK(pass_check(pass, user, user_pass, 
338                       strlen(user_pass), NULL, False)) {
339                 
340                 if (pass) {
341                         /*
342                          * Password was ok.
343                          */
344                         
345                         become_user_permanently(pass->pw_uid, pass->pw_gid);
346                         
347                         /* Save the users name */
348                         C_user = strdup(user);
349                         passwd_free(&pass);
350                         return True;
351                 }
352         }
353         
354 err:
355         cgi_setup_error("401 Bad Authorization", "", 
356                         "username or password incorrect");
357
358         passwd_free(&pass);
359         return False;
360 }
361
362 /***************************************************************************
363 is this root?
364   ***************************************************************************/
365 BOOL am_root(void)
366 {
367         if (geteuid() == 0) {
368                 return( True);
369         } else {
370                 return( False);
371         }
372 }
373
374 /***************************************************************************
375 return a ptr to the users name
376   ***************************************************************************/
377 char *cgi_user_name(void)
378 {
379         return(C_user);
380 }
381
382
383 /***************************************************************************
384 handle a file download
385   ***************************************************************************/
386 static void cgi_download(char *file)
387 {
388         SMB_STRUCT_STAT st;
389         char buf[1024];
390         int fd, l, i;
391         char *p;
392         char *lang;
393
394         /* sanitise the filename */
395         for (i=0;file[i];i++) {
396                 if (!isalnum((int)file[i]) && !strchr_m("/.-_", file[i])) {
397                         cgi_setup_error("404 File Not Found","",
398                                         "Illegal character in filename");
399                 }
400         }
401
402         if (!file_exist(file, &st)) {
403                 cgi_setup_error("404 File Not Found","",
404                                 "The requested file was not found");
405         }
406
407         fd = web_open(file,O_RDONLY,0);
408         if (fd == -1) {
409                 cgi_setup_error("404 File Not Found","",
410                                 "The requested file was not found");
411         }
412         printf("HTTP/1.0 200 OK\r\n");
413         if ((p=strrchr_m(file,'.'))) {
414                 if (strcmp(p,".gif")==0) {
415                         printf("Content-Type: image/gif\r\n");
416                 } else if (strcmp(p,".jpg")==0) {
417                         printf("Content-Type: image/jpeg\r\n");
418                 } else if (strcmp(p,".txt")==0) {
419                         printf("Content-Type: text/plain\r\n");
420                 } else {
421                         printf("Content-Type: text/html\r\n");
422                 }
423         }
424         printf("Expires: %s\r\n", http_timestring(time(NULL)+EXPIRY_TIME));
425
426         lang = lang_tdb_current();
427         if (lang) {
428                 printf("Content-Language: %s\r\n", lang);
429         }
430
431         printf("Content-Length: %d\r\n\r\n", (int)st.st_size);
432         while ((l=read(fd,buf,sizeof(buf)))>0) {
433                 fwrite(buf, 1, l, stdout);
434         }
435         close(fd);
436         exit(0);
437 }
438
439
440
441
442 /**
443  * @brief Setup the CGI framework.
444  *
445  * Setup the cgi framework, handling the possibility that this program
446  * is either run as a true CGI program with a gateway to a web server, or
447  * is itself a mini web server.
448  **/
449 void cgi_setup(const char *rootdir, int auth_required)
450 {
451         BOOL authenticated = False;
452         char line[1024];
453         char *url=NULL;
454         char *p;
455         char *lang;
456
457         if (chdir(rootdir)) {
458                 cgi_setup_error("400 Server Error", "",
459                                 "chdir failed - the server is not configured correctly");
460         }
461
462         /* Handle the possability we might be running as non-root */
463         sec_init();
464
465         if ((lang=getenv("HTTP_ACCEPT_LANGUAGE"))) {
466                 /* if running as a cgi program */
467                 web_set_lang(lang);
468         }
469
470         /* maybe we are running under a web server */
471         if (getenv("CONTENT_LENGTH") || getenv("REQUEST_METHOD")) {
472                 if (auth_required) {
473                         cgi_web_auth();
474                 }
475                 return;
476         }
477
478         inetd_server = True;
479
480         if (!check_access(1, lp_hostsallow(-1), lp_hostsdeny(-1))) {
481                 cgi_setup_error("400 Server Error", "",
482                                 "Samba is configured to deny access from this client\n<br>Check your \"hosts allow\" and \"hosts deny\" options in smb.conf ");
483         }
484
485         /* we are a mini-web server. We need to read the request from stdin
486            and handle authentication etc */
487         while (fgets(line, sizeof(line)-1, stdin)) {
488                 if (line[0] == '\r' || line[0] == '\n') break;
489                 if (strncasecmp(line,"GET ", 4)==0) {
490                         got_request = True;
491                         url = strdup(&line[4]);
492                 } else if (strncasecmp(line,"POST ", 5)==0) {
493                         got_request = True;
494                         request_post = 1;
495                         url = strdup(&line[5]);
496                 } else if (strncasecmp(line,"PUT ", 4)==0) {
497                         got_request = True;
498                         cgi_setup_error("400 Bad Request", "",
499                                         "This server does not accept PUT requests");
500                 } else if (strncasecmp(line,"Authorization: ", 15)==0) {
501                         authenticated = cgi_handle_authorization(&line[15]);
502                 } else if (strncasecmp(line,"Content-Length: ", 16)==0) {
503                         content_length = atoi(&line[16]);
504                 } else if (strncasecmp(line,"Accept-Language: ", 17)==0) {
505                         web_set_lang(&line[17]);
506                 }
507                 /* ignore all other requests! */
508         }
509
510         if (auth_required && !authenticated) {
511                 cgi_auth_error();
512         }
513
514         if (!url) {
515                 cgi_setup_error("400 Bad Request", "",
516                                 "You must specify a GET or POST request");
517         }
518
519         /* trim the URL */
520         if ((p = strchr_m(url,' ')) || (p=strchr_m(url,'\t'))) {
521                 *p = 0;
522         }
523         while (*url && strchr_m("\r\n",url[strlen(url)-1])) {
524                 url[strlen(url)-1] = 0;
525         }
526
527         /* anything following a ? in the URL is part of the query string */
528         if ((p=strchr_m(url,'?'))) {
529                 query_string = p+1;
530                 *p = 0;
531         }
532
533         string_sub(url, "/swat/", "", 0);
534
535         if (url[0] != '/' && strstr(url,"..")==0 && file_exist(url, NULL)) {
536                 cgi_download(url);
537         }
538
539         printf("HTTP/1.0 200 OK\r\nConnection: close\r\n");
540         printf("Date: %s\r\n", http_timestring(time(NULL)));
541         baseurl = "";
542         pathinfo = url+1;
543 }
544
545
546 /***************************************************************************
547 return the current pages URL
548   ***************************************************************************/
549 const char *cgi_baseurl(void)
550 {
551         if (inetd_server) {
552                 return baseurl;
553         }
554         return getenv("SCRIPT_NAME");
555 }
556
557 /***************************************************************************
558 return the current pages path info
559   ***************************************************************************/
560 const char *cgi_pathinfo(void)
561 {
562         char *r;
563         if (inetd_server) {
564                 return pathinfo;
565         }
566         r = getenv("PATH_INFO");
567         if (!r) return "";
568         if (*r == '/') r++;
569         return r;
570 }
571
572 /***************************************************************************
573 return the hostname of the client
574   ***************************************************************************/
575 char *cgi_remote_host(void)
576 {
577         if (inetd_server) {
578                 return get_socket_name(1,False);
579         }
580         return getenv("REMOTE_HOST");
581 }
582
583 /***************************************************************************
584 return the hostname of the client
585   ***************************************************************************/
586 char *cgi_remote_addr(void)
587 {
588         if (inetd_server) {
589                 return get_socket_addr(1);
590         }
591         return getenv("REMOTE_ADDR");
592 }
593
594
595 /***************************************************************************
596 return True if the request was a POST
597   ***************************************************************************/
598 BOOL cgi_waspost(void)
599 {
600         if (inetd_server) {
601                 return request_post;
602         }
603         return strequal(getenv("REQUEST_METHOD"), "POST");
604 }