1 |
/* |
2 |
* Boa, an http server |
3 |
* Copyright (C) 1995 Paul Phillips <paulp@go2net.com> |
4 |
* Some changes Copyright (C) 1996,97 Larry Doolittle <ldoolitt@boa.org> |
5 |
* Some changes Copyright (C) 1996 Charles F. Randall <crandall@goldsys.com> |
6 |
* Some changes Copyright (C) 1996-99 Jon Nelson <jnelson@boa.org> |
7 |
* |
8 |
* This program is free software; you can redistribute it and/or modify |
9 |
* it under the terms of the GNU General Public License as published by |
10 |
* the Free Software Foundation; either version 1, or (at your option) |
11 |
* any later version. |
12 |
* |
13 |
* This program is distributed in the hope that it will be useful, |
14 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
16 |
* GNU General Public License for more details. |
17 |
* |
18 |
* You should have received a copy of the GNU General Public License |
19 |
* along with this program; if not, write to the Free Software |
20 |
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
21 |
* |
22 |
*/ |
23 |
|
24 |
/* $Id: util.c,v 1.61.2.3 2002/07/07 23:22:18 jnelson Exp $ */ |
25 |
|
26 |
#include "boa.h" |
27 |
|
28 |
#define HEX_TO_DECIMAL(char1, char2) \ |
29 |
(((char1 >= 'A') ? (((char1 & 0xdf) - 'A') + 10) : (char1 - '0')) * 16) + \ |
30 |
(((char2 >= 'A') ? (((char2 & 0xdf) - 'A') + 10) : (char2 - '0'))) |
31 |
|
32 |
const char month_tab[48] = |
33 |
"Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec "; |
34 |
const char day_tab[] = "Sun,Mon,Tue,Wed,Thu,Fri,Sat,"; |
35 |
|
36 |
/* |
37 |
* Name: clean_pathname |
38 |
* |
39 |
* Description: Replaces unsafe/incorrect instances of: |
40 |
* //[...] with / |
41 |
* /./ with / |
42 |
* /../ with / (technically not what we want, but browsers should deal |
43 |
* with this, not servers) |
44 |
*/ |
45 |
|
46 |
void clean_pathname(char *pathname) |
47 |
{ |
48 |
char *cleanpath, c; |
49 |
|
50 |
cleanpath = pathname; |
51 |
while ((c = *pathname++)) { |
52 |
if (c == '/') { |
53 |
while (1) { |
54 |
if (*pathname == '/') |
55 |
pathname++; |
56 |
else if (*pathname == '.' && *(pathname + 1) == '/') |
57 |
pathname += 2; |
58 |
else if (*pathname == '.' && *(pathname + 1) == '.' && |
59 |
*(pathname + 2) == '/') { |
60 |
pathname += 3; |
61 |
} else |
62 |
break; |
63 |
} |
64 |
c = '/'; |
65 |
} |
66 |
*cleanpath++ = c; |
67 |
} |
68 |
|
69 |
*cleanpath = '\0'; |
70 |
} |
71 |
|
72 |
/* |
73 |
* Name: get_commonlog_time |
74 |
* |
75 |
* Description: Returns the current time in common log format in a static |
76 |
* char buffer. |
77 |
* |
78 |
* commonlog time is exactly 25 characters long |
79 |
* because this is only used in logging, we add " [" before and "] " after |
80 |
* making 29 characters |
81 |
* "[27/Feb/1998:20:20:04 +0000] " |
82 |
* |
83 |
* Constrast with rfc822 time: |
84 |
* "Sun, 06 Nov 1994 08:49:37 GMT" |
85 |
* |
86 |
* Altered 10 Jan 2000 by Jon Nelson ala Drew Streib for non UTC logging |
87 |
* |
88 |
*/ |
89 |
|
90 |
char *get_commonlog_time(void) |
91 |
{ |
92 |
struct tm *t; |
93 |
char *p; |
94 |
unsigned int a; |
95 |
static char buf[30]; |
96 |
int time_offset; |
97 |
|
98 |
if (use_localtime) { |
99 |
t = localtime(¤t_time); |
100 |
time_offset = TIMEZONE_OFFSET(t); |
101 |
} else { |
102 |
t = gmtime(¤t_time); |
103 |
time_offset = 0; |
104 |
} |
105 |
|
106 |
p = buf + 29; |
107 |
*p-- = '\0'; |
108 |
*p-- = ' '; |
109 |
*p-- = ']'; |
110 |
a = abs(time_offset / 60); |
111 |
*p-- = '0' + a % 10; |
112 |
a /= 10; |
113 |
*p-- = '0' + a % 6; |
114 |
a /= 6; |
115 |
*p-- = '0' + a % 10; |
116 |
*p-- = '0' + a / 10; |
117 |
*p-- = (time_offset >= 0) ? '+' : '-'; |
118 |
*p-- = ' '; |
119 |
|
120 |
a = t->tm_sec; |
121 |
*p-- = '0' + a % 10; |
122 |
*p-- = '0' + a / 10; |
123 |
*p-- = ':'; |
124 |
a = t->tm_min; |
125 |
*p-- = '0' + a % 10; |
126 |
*p-- = '0' + a / 10; |
127 |
*p-- = ':'; |
128 |
a = t->tm_hour; |
129 |
*p-- = '0' + a % 10; |
130 |
*p-- = '0' + a / 10; |
131 |
*p-- = ':'; |
132 |
a = 1900 + t->tm_year; |
133 |
while (a) { |
134 |
*p-- = '0' + a % 10; |
135 |
a /= 10; |
136 |
} |
137 |
/* p points to an unused spot */ |
138 |
*p-- = '/'; |
139 |
p -= 2; |
140 |
memcpy(p--, month_tab + 4 * (t->tm_mon), 3); |
141 |
*p-- = '/'; |
142 |
a = t->tm_mday; |
143 |
*p-- = '0' + a % 10; |
144 |
*p-- = '0' + a / 10; |
145 |
*p = '['; |
146 |
return p; /* should be same as returning buf */ |
147 |
} |
148 |
|
149 |
/* |
150 |
* Name: month2int |
151 |
* |
152 |
* Description: Turns a three letter month into a 0-11 int |
153 |
* |
154 |
* Note: This function is from wn-v1.07 -- it's clever and fast |
155 |
*/ |
156 |
|
157 |
int month2int(char *monthname) |
158 |
{ |
159 |
switch (*monthname) { |
160 |
case 'A': |
161 |
return (*++monthname == 'p' ? 3 : 7); |
162 |
case 'D': |
163 |
return (11); |
164 |
case 'F': |
165 |
return (1); |
166 |
case 'J': |
167 |
if (*++monthname == 'a') |
168 |
return (0); |
169 |
return (*++monthname == 'n' ? 5 : 6); |
170 |
case 'M': |
171 |
return (*(monthname + 2) == 'r' ? 2 : 4); |
172 |
case 'N': |
173 |
return (10); |
174 |
case 'O': |
175 |
return (9); |
176 |
case 'S': |
177 |
return (8); |
178 |
default: |
179 |
return (-1); |
180 |
} |
181 |
} |
182 |
|
183 |
/* |
184 |
* Name: modified_since |
185 |
* Description: Decides whether a file's mtime is newer than the |
186 |
* If-Modified-Since header of a request. |
187 |
* |
188 |
|
189 |
Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123 |
190 |
Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036 |
191 |
Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format |
192 |
31 September 2000 23:59:59 GMT ; non-standard |
193 |
|
194 |
* RETURN VALUES: |
195 |
* 0: File has not been modified since specified time. |
196 |
* 1: File has been. |
197 |
* -1: Error! |
198 |
*/ |
199 |
|
200 |
int modified_since(time_t * mtime, char *if_modified_since) |
201 |
{ |
202 |
struct tm *file_gmt; |
203 |
char *ims_info; |
204 |
char monthname[10 + 1]; |
205 |
int day, month, year, hour, minute, second; |
206 |
int comp; |
207 |
|
208 |
ims_info = if_modified_since; |
209 |
while (*ims_info != ' ' && *ims_info != '\0') |
210 |
++ims_info; |
211 |
if (*ims_info != ' ') |
212 |
return -1; |
213 |
|
214 |
/* the pre-space in the third scanf skips whitespace for the string */ |
215 |
if (sscanf(ims_info, "%d %3s %d %d:%d:%d GMT", /* RFC 1123 */ |
216 |
&day, monthname, &year, &hour, &minute, &second) == 6); |
217 |
else if (sscanf(ims_info, "%d-%3s-%d %d:%d:%d GMT", /* RFC 1036 */ |
218 |
&day, monthname, &year, &hour, &minute, &second) == 6) |
219 |
year += 1900; |
220 |
else if (sscanf(ims_info, " %3s %d %d:%d:%d %d", /* asctime() format */ |
221 |
monthname, &day, &hour, &minute, &second, &year) == 6); |
222 |
/* allow this non-standard date format: 31 September 2000 23:59:59 GMT */ |
223 |
/* NOTE: Use if_modified_since here, because the date *starts* |
224 |
* with the day, versus a throwaway item |
225 |
*/ |
226 |
else if (sscanf(if_modified_since, "%d %10s %d %d:%d:%d GMT", |
227 |
&day, monthname, &year, &hour, &minute, &second) == 6); |
228 |
else { |
229 |
log_error_time(); |
230 |
fprintf(stderr, "Error in %s, line %d: Unable to sscanf \"%s\"\n", |
231 |
__FILE__, __LINE__, ims_info); |
232 |
return -1; /* error */ |
233 |
} |
234 |
|
235 |
file_gmt = gmtime(mtime); |
236 |
month = month2int(monthname); |
237 |
|
238 |
/* Go through from years to seconds -- if they are ever unequal, |
239 |
we know which one is newer and can return */ |
240 |
|
241 |
if ((comp = 1900 + file_gmt->tm_year - year)) |
242 |
return (comp > 0); |
243 |
if ((comp = file_gmt->tm_mon - month)) |
244 |
return (comp > 0); |
245 |
if ((comp = file_gmt->tm_mday - day)) |
246 |
return (comp > 0); |
247 |
if ((comp = file_gmt->tm_hour - hour)) |
248 |
return (comp > 0); |
249 |
if ((comp = file_gmt->tm_min - minute)) |
250 |
return (comp > 0); |
251 |
if ((comp = file_gmt->tm_sec - second)) |
252 |
return (comp > 0); |
253 |
|
254 |
return 0; /* this person must really be into the latest/greatest */ |
255 |
} |
256 |
|
257 |
|
258 |
/* |
259 |
* Name: to_upper |
260 |
* |
261 |
* Description: Turns a string into all upper case (for HTTP_ header forming) |
262 |
* AND changes - into _ |
263 |
*/ |
264 |
|
265 |
char *to_upper(char *str) |
266 |
{ |
267 |
char *start = str; |
268 |
|
269 |
while (*str) { |
270 |
if (*str == '-') |
271 |
*str = '_'; |
272 |
else |
273 |
*str = toupper(*str); |
274 |
|
275 |
str++; |
276 |
} |
277 |
|
278 |
return start; |
279 |
} |
280 |
|
281 |
/* |
282 |
* Name: unescape_uri |
283 |
* |
284 |
* Description: Decodes a uri, changing %xx encodings with the actual |
285 |
* character. The query_string should already be gone. |
286 |
* |
287 |
* Return values: |
288 |
* 1: success |
289 |
* 0: illegal string |
290 |
*/ |
291 |
|
292 |
int unescape_uri(char *uri, char ** query_string) |
293 |
{ |
294 |
char c, d; |
295 |
char *uri_old; |
296 |
|
297 |
uri_old = uri; |
298 |
|
299 |
while ((c = *uri_old)) { |
300 |
if (c == '%') { |
301 |
uri_old++; |
302 |
if ((c = *uri_old++) && (d = *uri_old++)) |
303 |
*uri++ = HEX_TO_DECIMAL(c, d); |
304 |
else |
305 |
return 0; /* NULL in chars to be decoded */ |
306 |
} else if (c == '?') { /* query string */ |
307 |
if (query_string) |
308 |
*query_string = ++uri_old; |
309 |
/* stop here */ |
310 |
*uri = '\0'; |
311 |
return(1); |
312 |
break; |
313 |
} else if (c == '#') { /* fragment */ |
314 |
/* legal part of URL, but we do *not* care. |
315 |
* However, we still have to look for the query string */ |
316 |
if (query_string) { |
317 |
++uri_old; |
318 |
while((c = *uri_old)) { |
319 |
if (c == '?') { |
320 |
*query_string = ++uri_old; |
321 |
break; |
322 |
} |
323 |
++uri_old; |
324 |
} |
325 |
} |
326 |
break; |
327 |
} else { |
328 |
*uri++ = c; |
329 |
uri_old++; |
330 |
} |
331 |
} |
332 |
|
333 |
*uri = '\0'; |
334 |
return 1; |
335 |
} |
336 |
|
337 |
/* rfc822 (1123) time is exactly 29 characters long |
338 |
* "Sun, 06 Nov 1994 08:49:37 GMT" |
339 |
*/ |
340 |
|
341 |
void rfc822_time_buf(char *buf, time_t s) |
342 |
{ |
343 |
struct tm *t; |
344 |
char *p; |
345 |
unsigned int a; |
346 |
|
347 |
if (!s) { |
348 |
t = gmtime(¤t_time); |
349 |
} else |
350 |
t = gmtime(&s); |
351 |
|
352 |
p = buf + 28; |
353 |
/* p points to the last char in the buf */ |
354 |
|
355 |
p -= 3; |
356 |
/* p points to where the ' ' will go */ |
357 |
memcpy(p--, " GMT", 4); |
358 |
|
359 |
a = t->tm_sec; |
360 |
*p-- = '0' + a % 10; |
361 |
*p-- = '0' + a / 10; |
362 |
*p-- = ':'; |
363 |
a = t->tm_min; |
364 |
*p-- = '0' + a % 10; |
365 |
*p-- = '0' + a / 10; |
366 |
*p-- = ':'; |
367 |
a = t->tm_hour; |
368 |
*p-- = '0' + a % 10; |
369 |
*p-- = '0' + a / 10; |
370 |
*p-- = ' '; |
371 |
a = 1900 + t->tm_year; |
372 |
while (a) { |
373 |
*p-- = '0' + a % 10; |
374 |
a /= 10; |
375 |
} |
376 |
/* p points to an unused spot to where the space will go */ |
377 |
p -= 3; |
378 |
/* p points to where the first char of the month will go */ |
379 |
memcpy(p--, month_tab + 4 * (t->tm_mon), 4); |
380 |
*p-- = ' '; |
381 |
a = t->tm_mday; |
382 |
*p-- = '0' + a % 10; |
383 |
*p-- = '0' + a / 10; |
384 |
*p-- = ' '; |
385 |
p -= 3; |
386 |
memcpy(p, day_tab + t->tm_wday * 4, 4); |
387 |
} |
388 |
|
389 |
char *simple_itoa(unsigned int i) |
390 |
{ |
391 |
/* 21 digits plus null terminator, good for 64-bit or smaller ints |
392 |
* for bigger ints, use a bigger buffer! |
393 |
* |
394 |
* 4294967295 is, incidentally, MAX_UINT (on 32bit systems at this time) |
395 |
* and is 10 bytes long |
396 |
*/ |
397 |
static char local[22]; |
398 |
char *p = &local[21]; |
399 |
*p-- = '\0'; |
400 |
do { |
401 |
*p-- = '0' + i % 10; |
402 |
i /= 10; |
403 |
} while (i > 0); |
404 |
return p + 1; |
405 |
} |
406 |
|
407 |
/* I don't "do" negative conversions |
408 |
* Therefore, -1 indicates error |
409 |
*/ |
410 |
|
411 |
int boa_atoi(char *s) |
412 |
{ |
413 |
int retval; |
414 |
char *reconv; |
415 |
|
416 |
if (!isdigit(*s)) |
417 |
return -1; |
418 |
|
419 |
retval = atoi(s); |
420 |
if (retval < 0) |
421 |
return -1; |
422 |
|
423 |
reconv = simple_itoa(retval); |
424 |
if (memcmp(s,reconv,strlen(s)) != 0) { |
425 |
return -1; |
426 |
} |
427 |
return retval; |
428 |
} |
429 |
|
430 |
int create_temporary_file(short want_unlink, char *storage, int size) |
431 |
{ |
432 |
static char boa_tempfile[MAX_PATH_LENGTH + 1]; |
433 |
int fd; |
434 |
|
435 |
snprintf(boa_tempfile, MAX_PATH_LENGTH, |
436 |
"%s/boa-temp.XXXXXX", tempdir); |
437 |
|
438 |
/* open temp file */ |
439 |
fd = mkstemp(boa_tempfile); |
440 |
if (fd == -1) { |
441 |
log_error_time(); |
442 |
perror("mkstemp"); |
443 |
return 0; |
444 |
} |
445 |
|
446 |
if (storage != NULL) { |
447 |
int len = strlen(boa_tempfile); |
448 |
|
449 |
if (len < size) { |
450 |
memcpy(storage, boa_tempfile, len + 1); |
451 |
} else { |
452 |
close(fd); |
453 |
fd = 0; |
454 |
log_error_time(); |
455 |
fprintf(stderr, "not enough memory for memcpy in storage\n"); |
456 |
want_unlink = 1; |
457 |
} |
458 |
} |
459 |
|
460 |
if (want_unlink) { |
461 |
if (unlink(boa_tempfile) == -1) { |
462 |
close(fd); |
463 |
fd = 0; |
464 |
log_error_time(); |
465 |
fprintf(stderr, "unlink temp file\n"); |
466 |
} |
467 |
} |
468 |
|
469 |
return (fd); |
470 |
} |
471 |
|
472 |
/* |
473 |
* Name: normalize_path |
474 |
* |
475 |
* Description: Makes sure relative paths are made absolute |
476 |
* |
477 |
*/ |
478 |
|
479 |
#define DIRBUF_SIZE MAX_PATH_LENGTH * 2 + 1 |
480 |
char * normalize_path(char *path) |
481 |
{ |
482 |
char dirbuf[DIRBUF_SIZE]; |
483 |
int len1, len2; |
484 |
char *endpath; |
485 |
|
486 |
if (path[0] == '/') { |
487 |
endpath = strdup(path); |
488 |
} else { |
489 |
|
490 |
#ifndef HAVE_GETCWD |
491 |
perror("boa: getcwd() not defined. Aborting."); |
492 |
exit(1); |
493 |
#endif |
494 |
if (getcwd(dirbuf, DIRBUF_SIZE) == NULL) { |
495 |
if (errno == ERANGE) |
496 |
perror |
497 |
("boa: getcwd() failed - unable to get working directory. " |
498 |
"Aborting."); |
499 |
else if (errno == EACCES) |
500 |
perror("boa: getcwd() failed - No read access in current " |
501 |
"directory. Aborting."); |
502 |
else |
503 |
perror("boa: getcwd() failed - unknown error. Aborting."); |
504 |
exit(1); |
505 |
} |
506 |
|
507 |
/* OK, now the hard part. */ |
508 |
len1 = strlen(dirbuf); |
509 |
len2 = strlen(path); |
510 |
if (len1 + len2 > MAX_PATH_LENGTH * 2) { |
511 |
perror("boa: eek. unable to normalize pathname"); |
512 |
exit(1); |
513 |
} |
514 |
if (strcmp(path,".") != 0) { |
515 |
memcpy(dirbuf + len1, "/", 1); |
516 |
memcpy(dirbuf + len1 + 1, path, len2 + 1); |
517 |
} |
518 |
/* fprintf(stderr, "boa: normalize gets \"%s\"\n", dirbuf); */ |
519 |
|
520 |
endpath = strdup(dirbuf); |
521 |
} |
522 |
|
523 |
if (endpath == NULL) { |
524 |
fprintf(stderr, |
525 |
"boa: Cannot strdup path. Aborting.\n"); |
526 |
exit(1); |
527 |
} |
528 |
return endpath; |
529 |
} |
530 |
|
531 |
int real_set_block_fd(int fd) |
532 |
{ |
533 |
int flags; |
534 |
|
535 |
flags = fcntl(fd, F_GETFL); |
536 |
if (flags == -1) |
537 |
return -1; |
538 |
|
539 |
flags &= ~O_NONBLOCK; |
540 |
flags = fcntl(fd, F_SETFL, flags); |
541 |
return flags; |
542 |
} |
543 |
|
544 |
int real_set_nonblock_fd(int fd) |
545 |
{ |
546 |
int flags; |
547 |
|
548 |
flags = fcntl(fd, F_GETFL); |
549 |
if (flags == -1) |
550 |
return -1; |
551 |
|
552 |
flags |= O_NONBLOCK; |
553 |
flags = fcntl(fd, F_SETFL, flags); |
554 |
return flags; |
555 |
} |