/[hydra]/hydra/src/util.c
ViewVC logotype

Contents of /hydra/src/util.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.19 - (show annotations)
Tue Oct 29 12:13:54 2002 UTC (21 years, 5 months ago) by nmav
Branch: MAIN
CVS Tags: hydra_0_0_10, hydra_0_1_2, hydra_0_1_1, hydra_0_1_0
Branch point for: hydra_0_1_0_patches
Changes since 1.18: +6 -8 lines
File MIME type: text/plain
*** empty log message ***

1 /*
2 * Hydra, 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 * Portions Copyright (C) 2002 Nikos Mavroyanopoulos <nmav@gnutls.org>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 1, or (at your option)
12 * any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 */
24
25 /* $Id: util.c,v 1.18 2002/10/26 21:05:35 nmav Exp $ */
26
27 #include "boa.h"
28
29 #define HEX_TO_DECIMAL(char1, char2) \
30 (((char1 >= 'A') ? (((char1 & 0xdf) - 'A') + 10) : (char1 - '0')) * 16) + \
31 (((char2 >= 'A') ? (((char2 & 0xdf) - 'A') + 10) : (char2 - '0')))
32
33 const char month_tab[48] =
34 "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec ";
35 const char day_tab[] = "Sun,Mon,Tue,Wed,Thu,Fri,Sat,";
36
37 /*
38 * Name: clean_pathname
39 *
40 * Description: Replaces unsafe/incorrect instances of:
41 * //[...] with /
42 * /./ with /
43 * /../ with / (technically not what we want, but browsers should deal
44 * with this, not servers)
45 */
46
47 void clean_pathname(char *pathname)
48 {
49 char *cleanpath, c;
50
51 cleanpath = pathname;
52 while ((c = *pathname++)) {
53 if (c == '/') {
54 while (1) {
55 if (*pathname == '/')
56 pathname++;
57 else if (*pathname == '.' && *(pathname + 1) == '/')
58 pathname += 2;
59 else if (*pathname == '.' && *(pathname + 1) == '.' &&
60 *(pathname + 2) == '/') {
61 pathname += 3;
62 } else
63 break;
64 }
65 c = '/';
66 }
67 *cleanpath++ = c;
68 }
69
70 *cleanpath = '\0';
71 }
72
73 /*
74 * Name: get_commonlog_time
75 *
76 * Description: Returns the current time in common log format in a static
77 * char buffer.
78 *
79 * commonlog time is exactly 25 characters long
80 * because this is only used in logging, we add " [" before and "] " after
81 * making 29 characters
82 * "[27/Feb/1998:20:20:04 +0000] "
83 *
84 * Constrast with rfc822 time:
85 * "Sun, 06 Nov 1994 08:49:37 GMT"
86 *
87 * Altered 10 Jan 2000 by Jon Nelson ala Drew Streib for non UTC logging
88 *
89 */
90
91 void get_commonlog_time(char buf[30])
92 {
93 struct tm *t;
94 char *p;
95 unsigned int a;
96 int time_offset;
97
98 if (use_localtime) {
99 t = localtime(&current_time);
100 time_offset = TIMEZONE_OFFSET(t);
101 } else {
102 t = gmtime(&current_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; /* 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(&current_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 /* Returns the number of digits */
390 int simple_itoa(large_int i, char buf[22])
391 {
392 /* 21 digits plus null terminator, good for 64-bit or smaller ints
393 * for bigger ints, use a bigger buffer!
394 *
395 * 4294967295 is, incidentally, MAX_UINT (on 32bit systems at this time)
396 * and is 10 bytes long
397 */
398 char *p = &buf[21];
399 int digits = 1; /* include null char */
400
401 *p-- = '\0';
402 do {
403 digits++;
404 *p-- = '0' + i % 10;
405 i /= 10;
406 } while (i > 0);
407
408 p++;
409 if (p!=buf) memmove( buf, p, digits);
410
411 return digits - 1;
412 }
413
414 /* Generates an Etag, by using the file size, and the modification time
415 */
416 int create_etag(unsigned long int size, unsigned long int mod_time,
417 char etag[MAX_ETAG_LENGTH])
418 {
419 char buf[22];
420 int len, len2;
421
422 etag[0] = '\"';
423 len = 1;
424
425 len2 = simple_itoa( size % 100000, buf); /* up to 5 digits */
426 memcpy( &etag[len], buf, len2);
427 len += len2;
428
429 etag[len++] = '-';
430 len2 = simple_itoa( mod_time % 100000, buf); /* also 5 digits */
431 memcpy( &etag[len], buf, len2);
432 len += len2;
433
434 etag[len++] = '\"';
435 etag[len] = 0; /* etag is null terminated */
436
437 return len;
438 }
439
440
441 /* I don't "do" negative conversions
442 * Therefore, -1 indicates error
443 */
444
445 int boa_atoi(const char *s)
446 {
447 int retval;
448 char reconv[22];
449
450 if (!isdigit(*s))
451 return -1;
452
453 retval = atoi( s);
454 if (retval < 0)
455 return -1;
456
457 simple_itoa(retval, reconv);
458 if (memcmp(s,reconv,strlen(s)) != 0) {
459 return -1;
460 }
461 return retval;
462 }
463
464 large_int boa_atoll(const char *s)
465 {
466 long int retval;
467 char reconv[22];
468
469 if (!isdigit(*s))
470 return -1;
471
472 #ifdef HAVE_ATOLL
473 retval = atoll( s);
474 #else
475 retval = atol( s);
476 #endif
477 if (retval < 0)
478 return -1;
479
480 simple_itoa(retval, reconv);
481 if (memcmp(s,reconv,strlen(s)) != 0) {
482 return -1;
483 }
484 return retval;
485 }
486
487 #define TEMP_FILE_TEMPLATE "/hydra.temp.XXXXXX"
488 #define TEMP_FILE_TEMPLATE_LEN sizeof(TEMP_FILE_TEMPLATE)-1
489
490 void close_tmp_fd( tmp_fd* fds)
491 {
492 if (fds->pipe) {
493 if (fds->fds[1]!=-1)
494 close( fds->fds[1]);
495 }
496
497 if (fds->fds[0]!=-1)
498 close( fds->fds[0]);
499
500 fds->fds[0] = fds->fds[1] = -1;
501
502 }
503
504 const static tmp_fd EMPTY_FDS = { {-1, -1}, 0};
505
506 /* returns -1 on error */
507 /* size holds the number of data that will be written to
508 * the temporary file.
509 */
510 tmp_fd create_temporary_file(short want_unlink, int size)
511 {
512 char boa_tempfile[MAX_PATH_LENGTH + 1];
513 tmp_fd fd;
514 int total_len;
515
516 fd.pipe = 0;
517
518 if (size > 0 && size < PIPE_BUF)
519 if (pipe( fd.fds) != -1) {
520 fd.pipe = 1;
521 return fd;
522 }
523
524 total_len = tempdir_len + TEMP_FILE_TEMPLATE_LEN;
525 if (total_len > MAX_PATH_LENGTH) {
526 log_error_time();
527 fprintf(stderr, "Temporary file length (%d) is too long\n", total_len);
528 return EMPTY_FDS;
529 }
530
531 memcpy( boa_tempfile, tempdir, tempdir_len);
532 memcpy( &boa_tempfile[tempdir_len], TEMP_FILE_TEMPLATE, TEMP_FILE_TEMPLATE_LEN);
533 boa_tempfile[total_len] = 0; /* null terminated */
534
535 fd.fds[0] = fd.fds[1] = -1;
536 /* open temp file
537 */
538 fd.fds[0] = mkstemp(boa_tempfile);
539 if (fd.fds[0] == -1) {
540 log_error_time();
541 perror("mkstemp");
542 return EMPTY_FDS;
543 }
544
545 if (want_unlink) {
546 if (unlink(boa_tempfile) == -1) {
547 close(fd.fds[0]);
548 fd.fds[0] = -1;
549 log_error_time();
550 fprintf(stderr, "unlink temp file\n");
551 }
552 }
553
554 fd.fds[1] = fd.fds[0];
555 return (fd);
556 }
557
558 int set_block_fd(int fd)
559 {
560 int flags;
561
562 flags = fcntl(fd, F_GETFL);
563 if (flags == -1)
564 return -1;
565
566 flags &= ~O_NONBLOCK;
567 flags = fcntl(fd, F_SETFL, flags);
568 return flags;
569 }
570
571 int set_nonblock_fd(int fd)
572 {
573 int flags;
574
575 flags = fcntl(fd, F_GETFL);
576 if (flags == -1)
577 return -1;
578
579 flags |= O_NONBLOCK;
580 flags = fcntl(fd, F_SETFL, flags);
581 return flags;
582 }
583
584 int set_cloexec_fd(int fd)
585 {
586 int flags;
587
588 flags = fcntl(fd, F_GETFL);
589 if (flags == -1)
590 return -1;
591
592 flags |= FD_CLOEXEC;
593 flags = fcntl(fd, F_SETFL, flags);
594 return flags;
595 }
596
597 void create_url( char * buffer, int buffer_size, int secure,
598 const char* hostname, int port, const char* request_uri)
599 {
600 char * proto;
601 char str_port[23];
602 int do_port = 0;
603
604 buffer[0] = 0; /* in case we fail */
605 if (hostname == NULL)
606 hostname = "";
607
608 if (request_uri == NULL)
609 request_uri = "";
610
611 if (secure) {
612 proto = "https";
613 if (port != 443)
614 do_port = 1;
615 } else {
616 proto = "http";
617 if (port != 80)
618 do_port = 1;
619 }
620
621 if (do_port) {
622 str_port[0] = ':';
623 simple_itoa( port, &str_port[1]);
624 }
625
626 if ((strlen(proto) + strlen(str_port) + strlen(hostname) +
627 strlen(request_uri) + 5) > buffer_size) {
628 /* This is more than impossible. The buffer is long enough */
629 log_error_time();
630 fprintf(stderr, "Could not create URL. Buffer was not enough.\n");
631 return;
632 }
633
634 sprintf( buffer, "%s://%s%s%s/", proto, hostname, str_port, request_uri);
635
636 return;
637 }
638
639 /* Breaks a list of "xxx", "yyy", to a character array, of
640 * MAX_COMMA_SEP_ELEMENTS size; Note that the given string is modified.
641 */
642 void break_comma_list(char *etag,
643 char *broken_etag[MAX_COMMA_SEP_ELEMENTS],
644 int *elements)
645 {
646 char *p = etag;
647
648 *elements = 0;
649
650 do {
651 broken_etag[*elements] = p;
652
653 (*elements)++;
654
655 p = strchr(p, ',');
656 if (p) {
657 *p = 0;
658 p++; /* move to next entry and skip white
659 * space.
660 */
661 while (*p == ' ')
662 p++;
663 }
664 } while (p != NULL && *elements < MAX_COMMA_SEP_ELEMENTS);
665 }
666
667 /* Quoting from rfc1034:
668
669 <domain> ::= <subdomain> | " "
670
671 <subdomain> ::= <label> | <subdomain> "." <label>
672
673 <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
674
675 <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
676
677 <let-dig-hyp> ::= <let-dig> | "-"
678
679 <let-dig> ::= <letter> | <digit>
680
681 <letter> ::= any one of the 52 alphabetic characters A through Z in
682 upper case and a through z in lower case
683
684 <digit> ::= any one of the ten digits 0 through 9
685
686 and
687
688 The labels must follow the rules for ARPANET host names. They must
689 start with a letter, end with a letter or digit, and have as interior
690 characters only letters, digits, and hyphen. There are also some
691 restrictions on the length. Labels must be 63 characters or less.
692
693 */
694
695 int check_host(char *r)
696 {
697 /* a hostname can only consist of
698 * chars and numbers, and sep. by only
699 * one period.
700 * It may not end with a period, and must
701 * not start with a number.
702 *
703 * >0: correct
704 * -1: error
705 * 0: not returned
706 *
707 */
708 char *c;
709 short period_ok = 0;
710 short len = 0;
711
712 c = r;
713 if (c == NULL) {
714 return -1;
715 }
716
717 /* must start with a letter */
718 if (!isalpha(*c))
719 return -1;
720
721 len = 1;
722 while (*(++c) != '\0') {
723 /* interior letters may be alphanumeric, '-', or '.' */
724 /* '.' may not follow '.' */
725 if (isalnum(*c) || *c == '-')
726 period_ok = 1;
727 else if (*c == '.' && period_ok)
728 period_ok = 0;
729 else
730 return -1;
731 ++len;
732 }
733 /* c points to '\0' */
734 --c;
735 /* must end with a letter or digit */
736 if (!isalnum(*c))
737 return -1;
738 return len;
739 }
740
741

webmaster@linux.gr
ViewVC Help
Powered by ViewVC 1.1.26