hydra/src/util.c

/*
 *  Hydra, an http server
 *  Copyright (C) 1995 Paul Phillips <paulp@go2net.com>
 *  Some changes Copyright (C) 1996,97 Larry Doolittle <ldoolitt@boa.org>
 *  Some changes Copyright (C) 1996 Charles F. Randall <crandall@goldsys.com>
 *  Some changes Copyright (C) 1996-99 Jon Nelson <jnelson@boa.org>
 *  Portions Copyright (C) 2002 Nikos Mavroyanopoulos <nmav@gnutls.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 1, or (at your option)
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/* $Id: util.c,v 1.19 2002/10/29 12:13:54 nmav Exp $ */

#include "boa.h"

#define HEX_TO_DECIMAL(char1, char2)    \
    (((char1 >= 'A') ? (((char1 & 0xdf) - 'A') + 10) : (char1 - '0')) * 16) + \
    (((char2 >= 'A') ? (((char2 & 0xdf) - 'A') + 10) : (char2 - '0')))

const char month_tab[48] =
    "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec ";
const char day_tab[] = "Sun,Mon,Tue,Wed,Thu,Fri,Sat,";

/*
 * Name: clean_pathname
 *
 * Description: Replaces unsafe/incorrect instances of:
 *  //[...] with /
 *  /./ with /
 *  /../ with / (technically not what we want, but browsers should deal
 *   with this, not servers)
 */

void clean_pathname(char *pathname)
{
    char *cleanpath, c;

    cleanpath = pathname;
    while ((c = *pathname++)) {
        if (c == '/') {
            while (1) {
                if (*pathname == '/')
                    pathname++;
                else if (*pathname == '.' && *(pathname + 1) == '/')
                    pathname += 2;
                else if (*pathname == '.' && *(pathname + 1) == '.' &&
                         *(pathname + 2) == '/') {
                    pathname += 3;
                } else
                    break;
            }
            c = '/';
        }
        *cleanpath++ = c;
    }

    *cleanpath = '\0';
}

/*
 * Name: get_commonlog_time
 *
 * Description: Returns the current time in common log format in a static
 * char buffer.
 *
 * commonlog time is exactly 25 characters long
 * because this is only used in logging, we add " [" before and "] " after
 * making 29 characters
 * "[27/Feb/1998:20:20:04 +0000] "
 *
 * Constrast with rfc822 time:
 * "Sun, 06 Nov 1994 08:49:37 GMT"
 *
 * Altered 10 Jan 2000 by Jon Nelson ala Drew Streib for non UTC logging
 *
 */

void get_commonlog_time(char buf[30])
{
    struct tm *t;
    char *p;
    unsigned int a;
    int time_offset;

    if (use_localtime) {
        t = localtime(&current_time);
        time_offset = TIMEZONE_OFFSET(t);
    } else {
        t = gmtime(&current_time);
        time_offset = 0;
    }

    p = buf + 29;
    *p-- = '\0';
    *p-- = ' ';
    *p-- = ']';
    a = abs(time_offset / 60);
    *p-- = '0' + a % 10;
    a /= 10;
    *p-- = '0' + a % 6;
    a /= 6;
    *p-- = '0' + a % 10;
    *p-- = '0' + a / 10;
    *p-- = (time_offset >= 0) ? '+' : '-';
    *p-- = ' ';

    a = t->tm_sec;
    *p-- = '0' + a % 10;
    *p-- = '0' + a / 10;
    *p-- = ':';
    a = t->tm_min;
    *p-- = '0' + a % 10;
    *p-- = '0' + a / 10;
    *p-- = ':';
    a = t->tm_hour;
    *p-- = '0' + a % 10;
    *p-- = '0' + a / 10;
    *p-- = ':';
    a = 1900 + t->tm_year;
    while (a) {
        *p-- = '0' + a % 10;
        a /= 10;
    }
    /* p points to an unused spot */
    *p-- = '/';
    p -= 2;
    memcpy(p--, month_tab + 4 * (t->tm_mon), 3);
    *p-- = '/';
    a = t->tm_mday;
    *p-- = '0' + a % 10;
    *p-- = '0' + a / 10;
    *p = '[';
    return;                   /* should be same as returning buf */
}

/*
 * Name: month2int
 *
 * Description: Turns a three letter month into a 0-11 int
 *
 * Note: This function is from wn-v1.07 -- it's clever and fast
 */

int month2int(char *monthname)
{
    switch (*monthname) {
    case 'A':
        return (*++monthname == 'p' ? 3 : 7);
    case 'D':
        return (11);
    case 'F':
        return (1);
    case 'J':
        if (*++monthname == 'a')
            return (0);
        return (*++monthname == 'n' ? 5 : 6);
    case 'M':
        return (*(monthname + 2) == 'r' ? 2 : 4);
    case 'N':
        return (10);
    case 'O':
        return (9);
    case 'S':
        return (8);
    default:
        return (-1);
    }
}

/*
 * Name: modified_since
 * Description: Decides whether a file's mtime is newer than the
 * If-Modified-Since header of a request.
 *

 Sun, 06 Nov 1994 08:49:37 GMT    ; RFC 822, updated by RFC 1123
 Sunday, 06-Nov-94 08:49:37 GMT   ; RFC 850, obsoleted by RFC 1036
 Sun Nov  6 08:49:37 1994         ; ANSI C's asctime() format
 31 September 2000 23:59:59 GMT   ; non-standard

 * RETURN VALUES:
 *  0: File has not been modified since specified time.
 *  1: File has been.
 * -1: Error!
 */

int modified_since(time_t mtime, char *if_modified_since)
{
    struct tm *file_gmt;
    char *ims_info;
    char monthname[10 + 1];
    int day, month, year, hour, minute, second;
    int comp;

    ims_info = if_modified_since;
    while (*ims_info != ' ' && *ims_info != '\0')
        ++ims_info;
    if (*ims_info != ' ')
        return -1;

    /* the pre-space in the third scanf skips whitespace for the string */
    if (sscanf(ims_info, "%d %3s %d %d:%d:%d GMT", /* RFC 1123 */
               &day, monthname, &year, &hour, &minute, &second) == 6);
    else if (sscanf(ims_info, "%d-%3s-%d %d:%d:%d GMT", /* RFC 1036 */
                    &day, monthname, &year, &hour, &minute, &second) == 6)
        year += 1900;
    else if (sscanf(ims_info, " %3s %d %d:%d:%d %d", /* asctime() format */
                    monthname, &day, &hour, &minute, &second, &year) == 6);
    /*  allow this non-standard date format: 31 September 2000 23:59:59 GMT */
    /* NOTE: Use if_modified_since here, because the date *starts*
     *       with the day, versus a throwaway item
     */
    else if (sscanf(if_modified_since, "%d %10s %d %d:%d:%d GMT",
                    &day, monthname, &year, &hour, &minute, &second) == 6);
    else {
        log_error_time();
        fprintf(stderr, "Error in %s, line %d: Unable to sscanf \"%s\"\n",
                __FILE__, __LINE__, ims_info);
        return -1;              /* error */
    }

    file_gmt = gmtime(&mtime);
    month = month2int(monthname);

    /* Go through from years to seconds -- if they are ever unequal,
     we know which one is newer and can return */

    if ((comp = 1900 + file_gmt->tm_year - year))
        return (comp > 0);
    if ((comp = file_gmt->tm_mon - month))
        return (comp > 0);
    if ((comp = file_gmt->tm_mday - day))
        return (comp > 0);
    if ((comp = file_gmt->tm_hour - hour))
        return (comp > 0);
    if ((comp = file_gmt->tm_min - minute))
        return (comp > 0);
    if ((comp = file_gmt->tm_sec - second))
        return (comp > 0);

    return 0;                   /* this person must really be into the latest/greatest */
}


/*
 * Name: to_upper
 *
 * Description: Turns a string into all upper case (for HTTP_ header forming)
 * AND changes - into _
 */

char *to_upper(char *str)
{
    char *start = str;

    while (*str) {
        if (*str == '-')
            *str = '_';
        else
            *str = toupper(*str);

        str++;
    }

    return start;
}

/*
 * Name: unescape_uri
 *
 * Description: Decodes a uri, changing %xx encodings with the actual
 * character.  The query_string should already be gone.
 *
 * Return values:
 *  1: success
 *  0: illegal string
 */

int unescape_uri(char *uri, char ** query_string)
{
    char c, d;
    char *uri_old;

    uri_old = uri;

    while ((c = *uri_old)) {
        if (c == '%') {
            uri_old++;
            if ((c = *uri_old++) && (d = *uri_old++))
                *uri++ = HEX_TO_DECIMAL(c, d);
            else
                return 0;       /* NULL in chars to be decoded */
        } else if (c == '?') { /* query string */
            if (query_string)
                *query_string = ++uri_old;
            /* stop here */
            *uri = '\0';
            return(1);
            break;
        } else if (c == '#') { /* fragment */
            /* legal part of URL, but we do *not* care.
             * However, we still have to look for the query string */
            if (query_string) {
                ++uri_old;
                while((c = *uri_old)) {
                    if (c == '?') {
                        *query_string = ++uri_old;
                        break;
                    }
                    ++uri_old;
                }
            }
            break;
        } else {
            *uri++ = c;
            uri_old++;
        }
    }

    *uri = '\0';
    return 1;
}

/* rfc822 (1123) time is exactly 29 characters long
 * "Sun, 06 Nov 1994 08:49:37 GMT"
 */

void rfc822_time_buf(char *buf, time_t s)
{
    struct tm *t;
    char *p;
    unsigned int a;

    if (!s) {
        t = gmtime(&current_time);
    } else
        t = gmtime(&s);

    p = buf + 28;
    /* p points to the last char in the buf */

    p -= 3;
    /* p points to where the ' ' will go */
    memcpy(p--, " GMT", 4);

    a = t->tm_sec;
    *p-- = '0' + a % 10;
    *p-- = '0' + a / 10;
    *p-- = ':';
    a = t->tm_min;
    *p-- = '0' + a % 10;
    *p-- = '0' + a / 10;
    *p-- = ':';
    a = t->tm_hour;
    *p-- = '0' + a % 10;
    *p-- = '0' + a / 10;
    *p-- = ' ';
    a = 1900 + t->tm_year;
    while (a) {
        *p-- = '0' + a % 10;
        a /= 10;
    }
    /* p points to an unused spot to where the space will go */
    p -= 3;
    /* p points to where the first char of the month will go */
    memcpy(p--, month_tab + 4 * (t->tm_mon), 4);
    *p-- = ' ';
    a = t->tm_mday;
    *p-- = '0' + a % 10;
    *p-- = '0' + a / 10;
    *p-- = ' ';
    p -= 3;
    memcpy(p, day_tab + t->tm_wday * 4, 4);
}

/* Converts an integer to a string and
 * returns the number of digits. Does not accept negative
 * values.
 */
int simple_itoa(large_int i, char buf[22])
{
    /* 21 digits plus null terminator, good for 64-bit or smaller ints
     * for bigger ints, use a bigger buffer!
     *
     * 4294967295 is, incidentally, MAX_UINT (on 32bit systems at this time)
     * and is 10 bytes long
     */
    char *p = &buf[21];
    int digits = 1; /* include null char */
    
    if ( i < 0) {
        buf[0] = 0;
        return 0;
    }

    *p-- = '\0';
    do {
        digits++;
        *p-- = '0' + i % 10;
        i /= 10;
    } while (i > 0);

    p++;
    if (p!=buf) memmove( buf, p, digits);

    return digits - 1;
}

/* Generates an Etag, by using the file size, and the modification time
 */
int create_etag(unsigned long int size, unsigned long int mod_time, 
   char etag[MAX_ETAG_LENGTH])
{
char buf[22];
int len, len2;

    etag[0] = '\"'; 
    len = 1;

    len2 = simple_itoa( size % 100000, buf); /* up to 5 digits */
    memcpy( &etag[len], buf, len2);
    len += len2;

    etag[len++] = '-';
    len2 = simple_itoa( mod_time % 100000, buf); /* also 5 digits */
    memcpy( &etag[len], buf, len2);
    len += len2;

    etag[len++] = '\"';
    etag[len] = 0; /* etag is null terminated */

    return len;
}


/* I don't "do" negative conversions
 * Therefore, -1 indicates error
 */

int boa_atoi(const char *s)
{
    int retval;
    char reconv[22];

    if (!isdigit(*s))
        return -1;

    retval = atoi( s);
    if (retval < 0)
        return -1;

    simple_itoa(retval, reconv);
    if (memcmp(s,reconv,strlen(s)) != 0) {
        return -1;
    }
    return retval;
}

large_int boa_atoll(const char *s)
{
    long int retval;
    char reconv[22];

    if (!isdigit(*s))
        return -1;

#ifdef HAVE_ATOLL
    retval = atoll( s);
#else
    retval = atol( s);
#endif
    if (retval < 0)
        return -1;

    simple_itoa(retval, reconv);
    if (memcmp(s,reconv,strlen(s)) != 0) {
        return -1;
    }
    return retval;
}

#define TEMP_FILE_TEMPLATE "/hydra.temp.XXXXXX"
#define TEMP_FILE_TEMPLATE_LEN sizeof(TEMP_FILE_TEMPLATE)-1

void close_tmp_fd( tmp_fd* fds) 
{
   if (fds->pipe) {
      if (fds->fds[1]!=-1)
         close( fds->fds[1]);
   }

   if (fds->fds[0]!=-1)
      close( fds->fds[0]);
   
   fds->fds[0] = fds->fds[1] = -1;
   
}

const static tmp_fd EMPTY_FDS = { {-1, -1}, 0};

/* returns -1 on error */
/* size holds the number of data that will be written to
 * the temporary file.
 */
tmp_fd create_temporary_file(short want_unlink, int size)
{
    char boa_tempfile[MAX_PATH_LENGTH + 1];
    tmp_fd fd;
    int total_len;

    fd.pipe = 0;

    if (size > 0 && size < PIPE_BUF)
        if (pipe( fd.fds) != -1) {
           fd.pipe = 1;
           return fd;
        }

    total_len = tempdir_len + TEMP_FILE_TEMPLATE_LEN;
    if (total_len > MAX_PATH_LENGTH) {
        log_error_time();
        fprintf(stderr, "Temporary file length (%d) is too long\n", total_len);
        return EMPTY_FDS;
    }

    memcpy( boa_tempfile, tempdir, tempdir_len);
    memcpy( &boa_tempfile[tempdir_len], TEMP_FILE_TEMPLATE, TEMP_FILE_TEMPLATE_LEN);
    boa_tempfile[total_len] = 0; /* null terminated */

    fd.fds[0] = fd.fds[1] = -1;
    /* open temp file 
     */
    fd.fds[0] = mkstemp(boa_tempfile);
    if (fd.fds[0] == -1) {
        log_error_time();
        perror("mkstemp");
        return EMPTY_FDS;
    }

    if (want_unlink) {
        if (unlink(boa_tempfile) == -1) {
            close(fd.fds[0]);
            fd.fds[0] = -1;
            log_error_time();
            fprintf(stderr, "unlink temp file\n");
        }
    }

    fd.fds[1] = fd.fds[0];
    return (fd);
}

int set_block_fd(int fd)
{
    int flags;

    flags = fcntl(fd, F_GETFL);
    if (flags == -1)
        return -1;

    flags &= ~O_NONBLOCK;
    flags = fcntl(fd, F_SETFL, flags);
    return flags;
}

int set_nonblock_fd(int fd)
{
    int flags;

    flags = fcntl(fd, F_GETFL);
    if (flags == -1)
        return -1;

    flags |= O_NONBLOCK;
    flags = fcntl(fd, F_SETFL, flags);
    return flags;
}

int set_cloexec_fd(int fd)
{
    int flags;

    flags = fcntl(fd, F_GETFL);
    if (flags == -1)
        return -1;

    flags |= FD_CLOEXEC;
    flags = fcntl(fd, F_SETFL, flags);
    return flags;
}

void create_url( char * buffer, int buffer_size, int secure, 
   const char* hostname, int port, const char* request_uri)
{
char * proto;
char str_port[23];
int do_port = 0;

   buffer[0] = 0; /* in case we fail */
   if (hostname == NULL)
        hostname = "";

   if (request_uri == NULL)
        request_uri = "";

   if (secure) {
      proto = "https";
      if (port != 443)
         do_port = 1;
   } else {
      proto = "http";
      if (port != 80)
         do_port = 1;
   }

   if (do_port) {
      str_port[0] = ':';
      simple_itoa( port, &str_port[1]);
   }

   if ((strlen(proto) + strlen(str_port) + strlen(hostname) +
       strlen(request_uri) + 5) > buffer_size) {
       /* This is more than impossible. The buffer is long enough */
       log_error_time();
       fprintf(stderr, "Could not create URL. Buffer was not enough.\n");
       return;
   }

   sprintf( buffer, "%s://%s%s%s/", proto, hostname, str_port, request_uri);

   return;
}

/* Breaks a list of "xxx", "yyy", to a character array, of
 * MAX_COMMA_SEP_ELEMENTS size; Note that the given string is modified.
 */
void break_comma_list(char *etag,
                 char *broken_etag[MAX_COMMA_SEP_ELEMENTS],
                         int *elements)
{
   char *p = etag;

   *elements = 0;

   do {
      broken_etag[*elements] = p;

      (*elements)++;

      p = strchr(p, ',');
      if (p) {
         *p = 0;
         p++;                   /* move to next entry and skip white
                                 * space.
                                 */
         while (*p == ' ')
            p++;
      }
   } while (p != NULL && *elements < MAX_COMMA_SEP_ELEMENTS);
}

/* Quoting from rfc1034:

<domain> ::= <subdomain> | " "

<subdomain> ::= <label> | <subdomain> "." <label>

<label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]

<ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>

<let-dig-hyp> ::= <let-dig> | "-"

<let-dig> ::= <letter> | <digit>

<letter> ::= any one of the 52 alphabetic characters A through Z in
upper case and a through z in lower case

<digit> ::= any one of the ten digits 0 through 9

and

The labels must follow the rules for ARPANET host names.  They must
start with a letter, end with a letter or digit, and have as interior
characters only letters, digits, and hyphen.  There are also some
restrictions on the length.  Labels must be 63 characters or less.

*/

int check_host(char *r)
{
    /* a hostname can only consist of
     * chars and numbers, and sep. by only
     * one period.
     * It may not end with a period, and must
     * not start with a number.
     *
     * >0: correct
     * -1: error
     *  0: not returned
     *
     */
    char *c;
    short period_ok = 0;
    short len = 0;

    c = r;
    if (c == NULL) {
        return -1;
    }

    /* must start with a letter */
    if (!isalpha(*c))
        return -1;

    len = 1;
    while (*(++c) != '\0') {
        /* interior letters may be alphanumeric, '-', or '.' */
        /* '.' may not follow '.' */
        if (isalnum(*c) || *c == '-')
            period_ok = 1;
        else if (*c == '.' && period_ok)
            period_ok = 0;
        else
            return -1;
        ++len;
    }
    /* c points to '\0' */
    --c;
    /* must end with a letter or digit */
    if (!isalnum(*c))
        return -1;
    return len;
}


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.19 2002/10/29 12:13:54 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	/* Converts an integer to a string and
390	* returns the number of digits. Does not accept negative
391	* values.
392	*/
393	int simple_itoa(large_int i, char buf[22])
394	{
395	/* 21 digits plus null terminator, good for 64-bit or smaller ints
396	* for bigger ints, use a bigger buffer!
397	*
398	* 4294967295 is, incidentally, MAX_UINT (on 32bit systems at this time)
399	* and is 10 bytes long
400	*/
401	char *p = &buf[21];
402	int digits = 1; /* include null char */
403
404	if ( i < 0) {
405	buf[0] = 0;
406	return 0;
407	}
408
409	*p-- = '\0';
410	do {
411	digits++;
412	*p-- = '0' + i % 10;
413	i /= 10;
414	} while (i > 0);
415
416	p++;
417	if (p!=buf) memmove( buf, p, digits);
418
419	return digits - 1;
420	}
421
422	/* Generates an Etag, by using the file size, and the modification time
423	*/
424	int create_etag(unsigned long int size, unsigned long int mod_time,
425	char etag[MAX_ETAG_LENGTH])
426	{
427	char buf[22];
428	int len, len2;
429
430	etag[0] = '\"';
431	len = 1;
432
433	len2 = simple_itoa( size % 100000, buf); /* up to 5 digits */
434	memcpy( &etag[len], buf, len2);
435	len += len2;
436
437	etag[len++] = '-';
438	len2 = simple_itoa( mod_time % 100000, buf); /* also 5 digits */
439	memcpy( &etag[len], buf, len2);
440	len += len2;
441
442	etag[len++] = '\"';
443	etag[len] = 0; /* etag is null terminated */
444
445	return len;
446	}
447
448
449	/* I don't "do" negative conversions
450	* Therefore, -1 indicates error
451	*/
452
453	int boa_atoi(const char *s)
454	{
455	int retval;
456	char reconv[22];
457
458	if (!isdigit(*s))
459	return -1;
460
461	retval = atoi( s);
462	if (retval < 0)
463	return -1;
464
465	simple_itoa(retval, reconv);
466	if (memcmp(s,reconv,strlen(s)) != 0) {
467	return -1;
468	}
469	return retval;
470	}
471
472	large_int boa_atoll(const char *s)
473	{
474	long int retval;
475	char reconv[22];
476
477	if (!isdigit(*s))
478	return -1;
479
480	#ifdef HAVE_ATOLL
481	retval = atoll( s);
482	#else
483	retval = atol( s);
484	#endif
485	if (retval < 0)
486	return -1;
487
488	simple_itoa(retval, reconv);
489	if (memcmp(s,reconv,strlen(s)) != 0) {
490	return -1;
491	}
492	return retval;
493	}
494
495	#define TEMP_FILE_TEMPLATE "/hydra.temp.XXXXXX"
496	#define TEMP_FILE_TEMPLATE_LEN sizeof(TEMP_FILE_TEMPLATE)-1
497
498	void close_tmp_fd( tmp_fd* fds)
499	{
500	if (fds->pipe) {
501	if (fds->fds[1]!=-1)
502	close( fds->fds[1]);
503	}
504
505	if (fds->fds[0]!=-1)
506	close( fds->fds[0]);
507
508	fds->fds[0] = fds->fds[1] = -1;
509
510	}
511
512	const static tmp_fd EMPTY_FDS = { {-1, -1}, 0};
513
514	/* returns -1 on error */
515	/* size holds the number of data that will be written to
516	* the temporary file.
517	*/
518	tmp_fd create_temporary_file(short want_unlink, int size)
519	{
520	char boa_tempfile[MAX_PATH_LENGTH + 1];
521	tmp_fd fd;
522	int total_len;
523
524	fd.pipe = 0;
525
526	if (size > 0 && size < PIPE_BUF)
527	if (pipe( fd.fds) != -1) {
528	fd.pipe = 1;
529	return fd;
530	}
531
532	total_len = tempdir_len + TEMP_FILE_TEMPLATE_LEN;
533	if (total_len > MAX_PATH_LENGTH) {
534	log_error_time();
535	fprintf(stderr, "Temporary file length (%d) is too long\n", total_len);
536	return EMPTY_FDS;
537	}
538
539	memcpy( boa_tempfile, tempdir, tempdir_len);
540	memcpy( &boa_tempfile[tempdir_len], TEMP_FILE_TEMPLATE, TEMP_FILE_TEMPLATE_LEN);
541	boa_tempfile[total_len] = 0; /* null terminated */
542
543	fd.fds[0] = fd.fds[1] = -1;
544	/* open temp file
545	*/
546	fd.fds[0] = mkstemp(boa_tempfile);
547	if (fd.fds[0] == -1) {
548	log_error_time();
549	perror("mkstemp");
550	return EMPTY_FDS;
551	}
552
553	if (want_unlink) {
554	if (unlink(boa_tempfile) == -1) {
555	close(fd.fds[0]);
556	fd.fds[0] = -1;
557	log_error_time();
558	fprintf(stderr, "unlink temp file\n");
559	}
560	}
561
562	fd.fds[1] = fd.fds[0];
563	return (fd);
564	}
565
566	int set_block_fd(int fd)
567	{
568	int flags;
569
570	flags = fcntl(fd, F_GETFL);
571	if (flags == -1)
572	return -1;
573
574	flags &= ~O_NONBLOCK;
575	flags = fcntl(fd, F_SETFL, flags);
576	return flags;
577	}
578
579	int set_nonblock_fd(int fd)
580	{
581	int flags;
582
583	flags = fcntl(fd, F_GETFL);
584	if (flags == -1)
585	return -1;
586
587	flags \|= O_NONBLOCK;
588	flags = fcntl(fd, F_SETFL, flags);
589	return flags;
590	}
591
592	int set_cloexec_fd(int fd)
593	{
594	int flags;
595
596	flags = fcntl(fd, F_GETFL);
597	if (flags == -1)
598	return -1;
599
600	flags \|= FD_CLOEXEC;
601	flags = fcntl(fd, F_SETFL, flags);
602	return flags;
603	}
604
605	void create_url( char * buffer, int buffer_size, int secure,
606	const char* hostname, int port, const char* request_uri)
607	{
608	char * proto;
609	char str_port[23];
610	int do_port = 0;
611
612	buffer[0] = 0; /* in case we fail */
613	if (hostname == NULL)
614	hostname = "";
615
616	if (request_uri == NULL)
617	request_uri = "";
618
619	if (secure) {
620	proto = "https";
621	if (port != 443)
622	do_port = 1;
623	} else {
624	proto = "http";
625	if (port != 80)
626	do_port = 1;
627	}
628
629	if (do_port) {
630	str_port[0] = ':';
631	simple_itoa( port, &str_port[1]);
632	}
633
634	if ((strlen(proto) + strlen(str_port) + strlen(hostname) +
635	strlen(request_uri) + 5) > buffer_size) {
636	/* This is more than impossible. The buffer is long enough */
637	log_error_time();
638	fprintf(stderr, "Could not create URL. Buffer was not enough.\n");
639	return;
640	}
641
642	sprintf( buffer, "%s://%s%s%s/", proto, hostname, str_port, request_uri);
643
644	return;
645	}
646
647	/* Breaks a list of "xxx", "yyy", to a character array, of
648	* MAX_COMMA_SEP_ELEMENTS size; Note that the given string is modified.
649	*/
650	void break_comma_list(char *etag,
651	char *broken_etag[MAX_COMMA_SEP_ELEMENTS],
652	int *elements)
653	{
654	char *p = etag;
655
656	*elements = 0;
657
658	do {
659	broken_etag[*elements] = p;
660
661	(*elements)++;
662
663	p = strchr(p, ',');
664	if (p) {
665	*p = 0;
666	p++; /* move to next entry and skip white
667	* space.
668	*/
669	while (*p == ' ')
670	p++;
671	}
672	} while (p != NULL && *elements < MAX_COMMA_SEP_ELEMENTS);
673	}
674
675	/* Quoting from rfc1034:
676
677	<domain> ::= <subdomain> \| " "
678
679	<subdomain> ::= <label> \| <subdomain> "." <label>
680
681	<label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
682
683	<ldh-str> ::= <let-dig-hyp> \| <let-dig-hyp> <ldh-str>
684
685	<let-dig-hyp> ::= <let-dig> \| "-"
686
687	<let-dig> ::= <letter> \| <digit>
688
689	<letter> ::= any one of the 52 alphabetic characters A through Z in
690	upper case and a through z in lower case
691
692	<digit> ::= any one of the ten digits 0 through 9
693
694	and
695
696	The labels must follow the rules for ARPANET host names. They must
697	start with a letter, end with a letter or digit, and have as interior
698	characters only letters, digits, and hyphen. There are also some
699	restrictions on the length. Labels must be 63 characters or less.
700
701	*/
702
703	int check_host(char *r)
704	{
705	/* a hostname can only consist of
706	* chars and numbers, and sep. by only
707	* one period.
708	* It may not end with a period, and must
709	* not start with a number.
710	*
711	* >0: correct
712	* -1: error
713	* 0: not returned
714	*
715	*/
716	char *c;
717	short period_ok = 0;
718	short len = 0;
719
720	c = r;
721	if (c == NULL) {
722	return -1;
723	}
724
725	/* must start with a letter */
726	if (!isalpha(*c))
727	return -1;
728
729	len = 1;
730	while (*(++c) != '\0') {
731	/* interior letters may be alphanumeric, '-', or '.' */
732	/* '.' may not follow '.' */
733	if (isalnum(c) \|\| c == '-')
734	period_ok = 1;
735	else if (*c == '.' && period_ok)
736	period_ok = 0;
737	else
738	return -1;
739	++len;
740	}
741	/* c points to '\0' */
742	--c;
743	/* must end with a letter or digit */
744	if (!isalnum(*c))
745	return -1;
746	return len;
747	}
748
749