Annotation of embedaddon/thttpd/cgi-src/ssi.c, revision 1.1.1.1
1.1 misho 1: /* ssi - server-side-includes CGI program
2: **
3: ** Copyright © 1995 by Jef Poskanzer <jef@mail.acme.com>.
4: ** All rights reserved.
5: **
6: ** Redistribution and use in source and binary forms, with or without
7: ** modification, are permitted provided that the following conditions
8: ** are met:
9: ** 1. Redistributions of source code must retain the above copyright
10: ** notice, this list of conditions and the following disclaimer.
11: ** 2. Redistributions in binary form must reproduce the above copyright
12: ** notice, this list of conditions and the following disclaimer in the
13: ** documentation and/or other materials provided with the distribution.
14: **
15: ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16: ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17: ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18: ** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19: ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20: ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21: ** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22: ** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23: ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24: ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25: ** SUCH DAMAGE.
26: */
27:
28: #include <stdio.h>
29: #include <stdlib.h>
30: #include <string.h>
31: #include <time.h>
32: #include <sys/types.h>
33: #include <sys/stat.h>
34:
35: #include "config.h"
36: #include "match.h"
37:
38:
39: #define ST_GROUND 0
40: #define ST_LESSTHAN 1
41: #define ST_BANG 2
42: #define ST_MINUS1 3
43: #define ST_MINUS2 4
44:
45:
46: static void read_file( char* vfilename, char* filename, FILE* fp );
47:
48:
49: static char* argv0;
50: static char* url;
51:
52: static char timefmt[100];
53: static int sizefmt;
54: #define SF_BYTES 0
55: #define SF_ABBREV 1
56: static struct stat sb;
57:
58:
59: static void
60: internal_error( char* reason )
61: {
62: char* title = "500 Internal Error";
63:
64: (void) printf( "\
65: <HTML><HEAD><TITLE>%s</TITLE></HEAD>\n\
66: <BODY><H2>%s</H2>\n\
67: Something unusual went wrong during a server-side-includes request:\n\
68: <BLOCKQUOTE>\n\
69: %s\n\
70: </BLOCKQUOTE>\n\
71: </BODY></HTML>\n", title, title, reason );
72: }
73:
74:
75: static void
76: not_found( char* filename )
77: {
78: char* title = "404 Not Found";
79:
80: (void) printf( "\
81: <HTML><HEAD><TITLE>%s</TITLE></HEAD>\n\
82: <BODY><H2>%s</H2>\n\
83: The requested server-side-includes filename, %s,\n\
84: does not seem to exist.\n\
85: </BODY></HTML>\n", title, title, filename );
86: }
87:
88:
89: static void
90: not_found2( char* directive, char* tag, char* filename2 )
91: {
92: char* title = "Not Found";
93:
94: (void) printf( "\
95: <HR><H2>%s</H2>\n\
96: The filename requested in a %s %s directive, %s,\n\
97: does not seem to exist.\n\
98: <HR>\n", title, directive, tag, filename2 );
99: }
100:
101:
102: static void
103: not_permitted( char* directive, char* tag, char* val )
104: {
105: char* title = "Not Permitted";
106:
107: (void) printf( "\
108: <HR><H2>%s</H2>\n\
109: The filename requested in the %s %s=%s directive\n\
110: may not be fetched.\n\
111: <HR>\n", title, directive, tag, val );
112: }
113:
114:
115: static void
116: unknown_directive( char* filename, char* directive )
117: {
118: char* title = "Unknown Directive";
119:
120: (void) printf( "\
121: <HR><H2>%s</H2>\n\
122: The requested server-side-includes filename, %s,\n\
123: tried to use an unknown directive, %s.\n\
124: <HR>\n", title, filename, directive );
125: }
126:
127:
128: static void
129: unknown_tag( char* filename, char* directive, char* tag )
130: {
131: char* title = "Unknown Tag";
132:
133: (void) printf( "\
134: <HR><H2>%s</H2>\n\
135: The requested server-side-includes filename, %s,\n\
136: tried to use the directive %s with an unknown tag, %s.\n\
137: <HR>\n", title, filename, directive, tag );
138: }
139:
140:
141: static void
142: unknown_value( char* filename, char* directive, char* tag, char* val )
143: {
144: char* title = "Unknown Value";
145:
146: (void) printf( "\
147: <HR><H2>%s</H2>\n\
148: The requested server-side-includes filename, %s,\n\
149: tried to use the directive %s %s with an unknown value, %s.\n\
150: <HR>\n", title, filename, directive, tag, val );
151: }
152:
153:
154: static int
155: get_filename( char* vfilename, char* filename, char* directive, char* tag, char* val, char* fn, int fnsize )
156: {
157: int vl, fl;
158: char* cp;
159:
160: /* Used for the various commands that accept a file name.
161: ** These commands accept two tags:
162: ** virtual
163: ** Gives a virtual path to a document on the server.
164: ** file
165: ** Gives a pathname relative to the current directory. ../ cannot
166: ** be used in this pathname, nor can absolute paths be used.
167: */
168: vl = strlen( vfilename );
169: fl = strlen( filename );
170: if ( strcmp( tag, "virtual" ) == 0 )
171: {
172: if ( strstr( val, "../" ) != (char*) 0 )
173: {
174: not_permitted( directive, tag, val );
175: return -1;
176: }
177: /* Figure out root using difference between vfilename and filename. */
178: if ( vl > fl ||
179: strcmp( vfilename, &filename[fl - vl] ) != 0 )
180: return -1;
181: if ( fl - vl + strlen( val ) >= fnsize )
182: return -1;
183: (void) strncpy( fn, filename, fl - vl );
184: (void) strcpy( &fn[fl - vl], val );
185: }
186: else if ( strcmp( tag, "file" ) == 0 )
187: {
188: if ( val[0] == '/' || strstr( val, "../" ) != (char*) 0 )
189: {
190: not_permitted( directive, tag, val );
191: return -1;
192: }
193: if ( fl + 1 + strlen( val ) >= fnsize )
194: return -1;
195: (void) strcpy( fn, filename );
196: cp = strrchr( fn, '/' );
197: if ( cp == (char*) 0 )
198: {
199: cp = &fn[strlen( fn )];
200: *cp = '/';
201: }
202: (void) strcpy( ++cp, val );
203: }
204: else
205: {
206: unknown_tag( filename, directive, tag );
207: return -1;
208: }
209: return 0;
210: }
211:
212:
213: static int
214: check_filename( char* filename )
215: {
216: static int inited = 0;
217: static char* cgi_pattern;
218: int fnl;
219: char* cp;
220: char* dirname;
221: char* authname;
222: struct stat sb;
223: int r;
224:
225: if ( ! inited )
226: {
227: /* Get the cgi pattern. */
228: cgi_pattern = getenv( "CGI_PATTERN" );
229: #ifdef CGI_PATTERN
230: if ( cgi_pattern == (char*) 0 )
231: cgi_pattern = CGI_PATTERN;
232: #endif /* CGI_PATTERN */
233: inited = 1;
234: }
235:
236: /* ../ is not permitted. */
237: if ( strstr( filename, "../" ) != (char*) 0 )
238: return 0;
239:
240: #ifdef AUTH_FILE
241: /* Ensure that we are not reading a basic auth password file. */
242: fnl = strlen(filename);
243: if ( strcmp( filename, AUTH_FILE ) == 0 ||
244: ( fnl >= sizeof(AUTH_FILE) &&
245: strcmp( &filename[fnl - sizeof(AUTH_FILE) + 1], AUTH_FILE ) == 0 &&
246: filename[fnl - sizeof(AUTH_FILE)] == '/' ) )
247: return 0;
248:
249: /* Check for an auth file in the same directory. We can't do an actual
250: ** auth password check here because CGI programs are not given the
251: ** authorization header, for security reasons. So instead we just
252: ** prohibit access to all auth-protected files.
253: */
254: dirname = strdup( filename );
255: if ( dirname == (char*) 0 )
256: return 0; /* out of memory */
257: cp = strrchr( dirname, '/' );
258: if ( cp == (char*) 0 )
259: (void) strcpy( dirname, "." );
260: else
261: *cp = '\0';
262: authname = malloc( strlen( dirname ) + 1 + sizeof(AUTH_FILE) );
263: if ( authname == (char*) 0 )
264: return 0; /* out of memory */
265: (void) sprintf( authname, "%s/%s", dirname, AUTH_FILE );
266: r = stat( authname, &sb );
267: free( dirname );
268: free( authname );
269: if ( r == 0 )
270: return 0;
271: #endif /* AUTH_FILE */
272:
273: /* Ensure that we are not reading a CGI file. */
274: if ( cgi_pattern != (char*) 0 && match( cgi_pattern, filename ) )
275: return 0;
276:
277: return 1;
278: }
279:
280:
281: static void
282: show_time( time_t t, int gmt )
283: {
284: struct tm* tmP;
285: char tbuf[500];
286:
287: if ( gmt )
288: tmP = gmtime( &t );
289: else
290: tmP = localtime( &t );
291: if ( strftime( tbuf, sizeof(tbuf), timefmt, tmP ) > 0 )
292: (void) fputs( tbuf, stdout );
293: }
294:
295:
296: static void
297: show_size( off_t size )
298: {
299: switch ( sizefmt )
300: {
301: case SF_BYTES:
302: (void) printf( "%ld", (long) size ); /* spec says should have commas */
303: break;
304: case SF_ABBREV:
305: if ( size < 1024 )
306: (void) printf( "%ld", (long) size );
307: else if ( size < 1024 )
308: (void) printf( "%ldK", (long) size / 1024L );
309: else if ( size < 1024*1024 )
310: (void) printf( "%ldM", (long) size / (1024L*1024L) );
311: else
312: (void) printf( "%ldG", (long) size / (1024L*1024L*1024L) );
313: break;
314: }
315: }
316:
317:
318: static void
319: do_config( char* vfilename, char* filename, FILE* fp, char* directive, char* tag, char* val )
320: {
321: /* The config directive controls various aspects of the file parsing.
322: ** There are two valid tags:
323: ** timefmt
324: ** Gives the server a new format to use when providing dates. This
325: ** is a string compatible with the strftime library call.
326: ** sizefmt
327: ** Determines the formatting to be used when displaying the size of
328: ** a file. Valid choices are bytes, for a formatted byte count
329: ** (formatted as 1,234,567), or abbrev for an abbreviated version
330: ** displaying the number of kilobytes or megabytes the file occupies.
331: */
332:
333: if ( strcmp( tag, "timefmt" ) == 0 )
334: {
335: (void) strncpy( timefmt, val, sizeof(timefmt) - 1 );
336: timefmt[sizeof(timefmt) - 1] = '\0';
337: }
338: else if ( strcmp( tag, "sizefmt" ) == 0 )
339: {
340: if ( strcmp( val, "bytes" ) == 0 )
341: sizefmt = SF_BYTES;
342: else if ( strcmp( val, "abbrev" ) == 0 )
343: sizefmt = SF_ABBREV;
344: else
345: unknown_value( filename, directive, tag, val );
346: }
347: else
348: unknown_tag( filename, directive, tag );
349: }
350:
351:
352: static void
353: do_include( char* vfilename, char* filename, FILE* fp, char* directive, char* tag, char* val )
354: {
355: char vfilename2[1000];
356: char filename2[1000];
357: FILE* fp2;
358:
359: /* Inserts the text of another document into the parsed document. */
360:
361: if ( get_filename(
362: vfilename, filename, directive, tag, val, filename2,
363: sizeof(filename2) ) < 0 )
364: return;
365:
366: if ( ! check_filename( filename2 ) )
367: {
368: not_permitted( directive, tag, filename2 );
369: return;
370: }
371:
372: fp2 = fopen( filename2, "r" );
373: if ( fp2 == (FILE*) 0 )
374: {
375: not_found2( directive, tag, filename2 );
376: return;
377: }
378:
379: if ( strcmp( tag, "virtual" ) == 0 )
380: {
381: if ( strlen( val ) < sizeof( vfilename2 ) )
382: (void) strcpy( vfilename2, val );
383: else
384: (void) strcpy( vfilename2, filename2 ); /* same size, has to fit */
385: }
386: else
387: {
388: if ( strlen( vfilename ) + 1 + strlen( val ) < sizeof(vfilename2) )
389: {
390: char* cp;
391: (void) strcpy( vfilename2, vfilename );
392: cp = strrchr( vfilename2, '/' );
393: if ( cp == (char*) 0 )
394: {
395: cp = &vfilename2[strlen( vfilename2 )];
396: *cp = '/';
397: }
398: (void) strcpy( ++cp, val );
399: }
400: else
401: (void) strcpy( vfilename2, filename2 ); /* same size, has to fit */
402: }
403:
404: read_file( vfilename2, filename2, fp2 );
405: (void) fclose( fp2 );
406: }
407:
408:
409: static void
410: do_echo( char* vfilename, char* filename, FILE* fp, char* directive, char* tag, char* val )
411: {
412: char* cp;
413: time_t t;
414:
415: /* Prints the value of one of the include variables. Any dates are
416: ** printed subject to the currently configured timefmt. The only valid
417: ** tag is var, whose value is the name of the variable you wish to echo.
418: */
419:
420: if ( strcmp( tag, "var" ) != 0 )
421: unknown_tag( filename, directive, tag );
422: else
423: {
424: if ( strcmp( val, "DOCUMENT_NAME" ) == 0 )
425: {
426: /* The current filename. */
427: (void) fputs( filename, stdout );
428: }
429: else if ( strcmp( val, "DOCUMENT_URI" ) == 0 )
430: {
431: /* The virtual path to this file (such as /~robm/foo.shtml). */
432: (void) fputs( vfilename, stdout );
433: }
434: else if ( strcmp( val, "QUERY_STRING_UNESCAPED" ) == 0 )
435: {
436: /* The unescaped version of any search query the client sent. */
437: cp = getenv( "QUERY_STRING" );
438: if ( cp != (char*) 0 )
439: (void) fputs( cp, stdout );
440: }
441: else if ( strcmp( val, "DATE_LOCAL" ) == 0 )
442: {
443: /* The current date, local time zone. */
444: t = time( (time_t*) 0 );
445: show_time( t, 0 );
446: }
447: else if ( strcmp( val, "DATE_GMT" ) == 0 )
448: {
449: /* Same as DATE_LOCAL but in Greenwich mean time. */
450: t = time( (time_t*) 0 );
451: show_time( t, 1 );
452: }
453: else if ( strcmp( val, "LAST_MODIFIED" ) == 0 )
454: {
455: /* The last modification date of the current document. */
456: if ( fstat( fileno( fp ), &sb ) >= 0 )
457: show_time( sb.st_mtime, 0 );
458: }
459: else
460: {
461: /* Try an environment variable. */
462: cp = getenv( val );
463: if ( cp == (char*) 0 )
464: unknown_value( filename, directive, tag, val );
465: else
466: (void) fputs( cp, stdout );
467: }
468: }
469: }
470:
471:
472: static void
473: do_fsize( char* vfilename, char* filename, FILE* fp, char* directive, char* tag, char* val )
474: {
475: char filename2[1000];
476:
477: /* Prints the size of the specified file. */
478:
479: if ( get_filename(
480: vfilename, filename, directive, tag, val, filename2,
481: sizeof(filename2) ) < 0 )
482: return;
483: if ( stat( filename2, &sb ) < 0 )
484: {
485: not_found2( directive, tag, filename2 );
486: return;
487: }
488: show_size( sb.st_size );
489: }
490:
491:
492: static void
493: do_flastmod( char* vfilename, char* filename, FILE* fp, char* directive, char* tag, char* val )
494: {
495: char filename2[1000];
496:
497: /* Prints the last modification date of the specified file. */
498:
499: if ( get_filename(
500: vfilename, filename, directive, tag, val, filename2,
501: sizeof(filename2) ) < 0 )
502: return;
503: if ( stat( filename2, &sb ) < 0 )
504: {
505: not_found2( directive, tag, filename2 );
506: return;
507: }
508: show_time( sb.st_mtime, 0 );
509: }
510:
511:
512: static void
513: parse( char* vfilename, char* filename, FILE* fp, char* str )
514: {
515: char* directive;
516: char* cp;
517: int ntags;
518: char* tags[200];
519: int dirn;
520: #define DI_CONFIG 0
521: #define DI_INCLUDE 1
522: #define DI_ECHO 2
523: #define DI_FSIZE 3
524: #define DI_FLASTMOD 4
525: int i;
526: char* val;
527:
528: directive = str;
529: directive += strspn( directive, " \t\n\r" );
530:
531: ntags = 0;
532: cp = directive;
533: for (;;)
534: {
535: cp = strpbrk( cp, " \t\n\r\"" );
536: if ( cp == (char*) 0 )
537: break;
538: if ( *cp == '"' )
539: {
540: cp = strpbrk( cp + 1, "\"" );
541: ++cp;
542: if ( *cp == '\0' )
543: break;
544: }
545: *cp++ = '\0';
546: cp += strspn( cp, " \t\n\r" );
547: if ( *cp == '\0' )
548: break;
549: if ( ntags < sizeof(tags)/sizeof(*tags) )
550: tags[ntags++] = cp;
551: }
552:
553: if ( strcmp( directive, "config" ) == 0 )
554: dirn = DI_CONFIG;
555: else if ( strcmp( directive, "include" ) == 0 )
556: dirn = DI_INCLUDE;
557: else if ( strcmp( directive, "echo" ) == 0 )
558: dirn = DI_ECHO;
559: else if ( strcmp( directive, "fsize" ) == 0 )
560: dirn = DI_FSIZE;
561: else if ( strcmp( directive, "flastmod" ) == 0 )
562: dirn = DI_FLASTMOD;
563: else
564: {
565: unknown_directive( filename, directive );
566: return;
567: }
568:
569: for ( i = 0; i < ntags; ++i )
570: {
571: if ( i > 0 )
572: putchar( ' ' );
573: val = strchr( tags[i], '=' );
574: if ( val == (char*) 0 )
575: val = "";
576: else
577: *val++ = '\0';
578: if ( *val == '"' && val[strlen( val ) - 1] == '"' )
579: {
580: val[strlen( val ) - 1] = '\0';
581: ++val;
582: }
583: switch( dirn )
584: {
585: case DI_CONFIG:
586: do_config( vfilename, filename, fp, directive, tags[i], val );
587: break;
588: case DI_INCLUDE:
589: do_include( vfilename, filename, fp, directive, tags[i], val );
590: break;
591: case DI_ECHO:
592: do_echo( vfilename, filename, fp, directive, tags[i], val );
593: break;
594: case DI_FSIZE:
595: do_fsize( vfilename, filename, fp, directive, tags[i], val );
596: break;
597: case DI_FLASTMOD:
598: do_flastmod( vfilename, filename, fp, directive, tags[i], val );
599: break;
600: }
601: }
602: }
603:
604:
605: static void
606: slurp( char* vfilename, char* filename, FILE* fp )
607: {
608: char buf[1000];
609: int i;
610: int state;
611: int ich;
612:
613: /* Now slurp in the rest of the comment from the input file. */
614: i = 0;
615: state = ST_GROUND;
616: while ( ( ich = getc( fp ) ) != EOF )
617: {
618: switch ( state )
619: {
620: case ST_GROUND:
621: if ( ich == '-' )
622: state = ST_MINUS1;
623: break;
624: case ST_MINUS1:
625: if ( ich == '-' )
626: state = ST_MINUS2;
627: else
628: state = ST_GROUND;
629: break;
630: case ST_MINUS2:
631: if ( ich == '>' )
632: {
633: buf[i - 2] = '\0';
634: parse( vfilename, filename, fp, buf );
635: return;
636: }
637: else if ( ich != '-' )
638: state = ST_GROUND;
639: break;
640: }
641: if ( i < sizeof(buf) - 1 )
642: buf[i++] = (char) ich;
643: }
644: }
645:
646:
647: static void
648: read_file( char* vfilename, char* filename, FILE* fp )
649: {
650: int ich;
651: int state;
652:
653: /* Copy it to output, while running a state-machine to look for
654: ** SSI directives.
655: */
656: state = ST_GROUND;
657: while ( ( ich = getc( fp ) ) != EOF )
658: {
659: switch ( state )
660: {
661: case ST_GROUND:
662: if ( ich == '<' )
663: { state = ST_LESSTHAN; continue; }
664: break;
665: case ST_LESSTHAN:
666: if ( ich == '!' )
667: { state = ST_BANG; continue; }
668: else
669: { state = ST_GROUND; putchar( '<' ); }
670: break;
671: case ST_BANG:
672: if ( ich == '-' )
673: { state = ST_MINUS1; continue; }
674: else
675: { state = ST_GROUND; (void) fputs ( "<!", stdout ); }
676: break;
677: case ST_MINUS1:
678: if ( ich == '-' )
679: { state = ST_MINUS2; continue; }
680: else
681: { state = ST_GROUND; (void) fputs ( "<!-", stdout ); }
682: break;
683: case ST_MINUS2:
684: if ( ich == '#' )
685: {
686: slurp( vfilename, filename, fp );
687: state = ST_GROUND;
688: continue;
689: }
690: else
691: { state = ST_GROUND; (void) fputs ( "<!--", stdout ); }
692: break;
693: }
694: putchar( (char) ich );
695: }
696: }
697:
698:
699: int
700: main( int argc, char** argv )
701: {
702: char* script_name;
703: char* path_info;
704: char* path_translated;
705: FILE* fp;
706:
707: argv0 = argv[0];
708:
709: /* Default formats. */
710: (void) strcpy( timefmt, "%a %b %e %T %Z %Y" );
711: sizefmt = SF_BYTES;
712:
713: /* The MIME type has to be text/html. */
714: (void) fputs( "Content-type: text/html\n\n", stdout );
715:
716: /* Get the name that we were run as. */
717: script_name = getenv( "SCRIPT_NAME" );
718: if ( script_name == (char*) 0 )
719: {
720: internal_error( "Couldn't get SCRIPT_NAME environment variable." );
721: exit( 1 );
722: }
723:
724: /* Append the PATH_INFO, if any, to get the full URL. */
725: path_info = getenv( "PATH_INFO" );
726: if ( path_info == (char*) 0 )
727: path_info = "";
728: url = (char*) malloc( strlen( script_name ) + strlen( path_info ) + 1 );
729: if ( url == (char*) 0 )
730: {
731: internal_error( "Out of memory." );
732: exit( 1 );
733: }
734: (void) sprintf( url, "%s%s", script_name, path_info );
735:
736: /* Get the name of the file to parse. */
737: path_translated = getenv( "PATH_TRANSLATED" );
738: if ( path_translated == (char*) 0 )
739: {
740: internal_error( "Couldn't get PATH_TRANSLATED environment variable." );
741: exit( 1 );
742: }
743:
744: if ( ! check_filename( path_translated ) )
745: {
746: not_permitted( "initial", "PATH_TRANSLATED", path_translated );
747: exit( 1 );
748: }
749:
750: /* Open it. */
751: fp = fopen( path_translated, "r" );
752: if ( fp == (FILE*) 0 )
753: {
754: not_found( path_translated );
755: exit( 1 );
756: }
757:
758: /* Read and handle the file. */
759: read_file( path_info, path_translated, fp );
760:
761: (void) fclose( fp );
762: exit( 0 );
763: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ssi.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / thttpd / cgi-src