Home | History | Annotate | Download | only in pxe 
      1 #include <syslinux/sysappend.h>
      2 #include <ctype.h>
      3 #include <lwip/api.h>
      4 #include "pxe.h"
      5 #include "version.h"
      6 #include "url.h"
      7 #include "net.h"
      8 
      9 #define HTTP_PORT	80
     10 
     11 static bool is_tspecial(int ch)
     12 {
     13     bool tspecial = false;
     14     switch(ch) {
     15     case '(':  case ')':  case '<':  case '>':  case '@':
     16     case ',':  case ';':  case ':':  case '\\': case '"':
     17     case '/':  case '[':  case ']':  case '?':  case '=':
     18     case '{':  case '}':  case ' ':  case '\t':
     19 	tspecial = true;
     20 	break;
     21     }
     22     return tspecial;
     23 }
     24 
     25 static bool is_ctl(int ch)
     26 {
     27     return ch < 0x20;
     28 }
     29 
     30 static bool is_token(int ch)
     31 {
     32     /* Can by antying except a ctl character or a tspecial */
     33     return !is_ctl(ch) && !is_tspecial(ch);
     34 }
     35 
     36 static bool append_ch(char *str, size_t size, size_t *pos, int ch)
     37 {
     38     bool success = true;
     39     if ((*pos + 1) >= size) {
     40 	*pos = 0;
     41 	success = false;
     42     } else {
     43 	str[*pos] = ch;
     44 	str[*pos + 1] = '\0';
     45 	*pos += 1;
     46     }
     47     return success;
     48 }
     49 
     50 static size_t cookie_len, header_len;
     51 static char *cookie_buf, *header_buf;
     52 
     53 __export uint32_t SendCookies = -1UL; /* Send all cookies */
     54 
     55 static size_t http_do_bake_cookies(char *q)
     56 {
     57     static const char uchexchar[16] = "0123456789ABCDEF";
     58     int i;
     59     size_t n = 0;
     60     const char *p;
     61     char c;
     62     bool first = true;
     63     uint32_t mask = SendCookies;
     64 
     65     for (i = 0; i < SYSAPPEND_MAX; i++) {
     66 	if ((mask & 1) && (p = sysappend_strings[i])) {
     67 	    if (first) {
     68 		if (q) {
     69 		    strcpy(q, "Cookie: ");
     70 		    q += 8;
     71 		}
     72 		n += 8;
     73 		first = false;
     74 	    }
     75 	    if (q) {
     76 		strcpy(q, "_Syslinux_");
     77 		q += 10;
     78 	    }
     79 	    n += 10;
     80 	    /* Copy string up to and including '=' */
     81 	    do {
     82 		c = *p++;
     83 		if (q)
     84 		    *q++ = c;
     85 		n++;
     86 	    } while (c != '=');
     87 	    while ((c = *p++)) {
     88 		if (c == ' ') {
     89 		    if (q)
     90 			*q++ = '+';
     91 		    n++;
     92 		} else if (is_token(c)) {
     93 		    if (q)
     94 			*q++ = c;
     95 		    n++;
     96 		} else {
     97 		    if (q) {
     98 			*q++ = '%';
     99 			*q++ = uchexchar[c >> 4];
    100 			*q++ = uchexchar[c & 15];
    101 		    }
    102 		    n += 3;
    103 		}
    104 	    }
    105 	    if (q)
    106 		*q++ = ';';
    107 	    n++;
    108 	}
    109 	mask >>= 1;
    110     }
    111     if (!first) {
    112 	if (q) {
    113 	    *q++ = '\r';
    114 	    *q++ = '\n';
    115 	}
    116 	n += 2;
    117     }
    118     if (q)
    119 	*q = '\0';
    120 
    121     return n;
    122 }
    123 
    124 __export void http_bake_cookies(void)
    125 {
    126     if (cookie_buf)
    127 	free(cookie_buf);
    128 
    129     cookie_len = http_do_bake_cookies(NULL);
    130     cookie_buf = malloc(cookie_len+1);
    131     if (!cookie_buf) {
    132 	cookie_len = 0;
    133 	return;
    134     }
    135 
    136     if (header_buf)
    137 	free(header_buf);
    138 
    139     header_len = cookie_len + 6*FILENAME_MAX + 256;
    140     header_buf = malloc(header_len);
    141     if (!header_buf) {
    142 	header_len = 0;
    143 	return;			/* Uh-oh... */
    144     }
    145 
    146     http_do_bake_cookies(cookie_buf);
    147 }
    148 
    149 static const struct pxe_conn_ops http_conn_ops = {
    150     .fill_buffer	= core_tcp_fill_buffer,
    151     .close		= core_tcp_close_file,
    152     .readdir		= http_readdir,
    153 };
    154 
    155 void http_open(struct url_info *url, int flags, struct inode *inode,
    156 	       const char **redir)
    157 {
    158     struct pxe_pvt_inode *socket = PVT(inode);
    159     int header_bytes;
    160     const char *next;
    161     char field_name[20];
    162     char field_value[1024];
    163     size_t field_name_len, field_value_len;
    164     enum state {
    165 	st_httpver,
    166 	st_stcode,
    167 	st_skipline,
    168 	st_fieldfirst,
    169 	st_fieldname,
    170 	st_fieldvalue,
    171 	st_skip_fieldname,
    172 	st_skip_fieldvalue,
    173 	st_eoh,
    174     } state;
    175     static char location[FILENAME_MAX];
    176     uint32_t content_length; /* same as inode->size */
    177     size_t response_size;
    178     int status;
    179     int pos;
    180     int err;
    181 
    182     (void)flags;
    183 
    184     if (!header_buf)
    185 	return;			/* http is broken... */
    186 
    187     /* This is a straightforward TCP connection after headers */
    188     socket->ops = &http_conn_ops;
    189 
    190     /* Reset all of the variables */
    191     inode->size = content_length = -1;
    192 
    193     /* Start the http connection */
    194     err = core_tcp_open(socket);
    195     if (err)
    196         return;
    197 
    198     if (!url->port)
    199 	url->port = HTTP_PORT;
    200 
    201     err = core_tcp_connect(socket, url->ip, url->port);
    202     if (err)
    203 	goto fail;
    204 
    205     strcpy(header_buf, "GET /");
    206     header_bytes = 5;
    207     header_bytes += url_escape_unsafe(header_buf+5, url->path,
    208 				      header_len - 5);
    209     if (header_bytes >= header_len)
    210 	goto fail;		/* Buffer overflow */
    211     header_bytes += snprintf(header_buf + header_bytes,
    212 			     header_len - header_bytes,
    213 			     " HTTP/1.0\r\n"
    214 			     "Host: %s\r\n"
    215 			     "User-Agent: Syslinux/" VERSION_STR "\r\n"
    216 			     "Connection: close\r\n"
    217 			     "%s"
    218 			     "\r\n",
    219 			     url->host, cookie_buf ? cookie_buf : "");
    220     if (header_bytes >= header_len)
    221 	goto fail;		/* Buffer overflow */
    222 
    223     err = core_tcp_write(socket, header_buf, header_bytes, false);
    224     if (err)
    225 	goto fail;
    226 
    227     /* Parse the HTTP header */
    228     state = st_httpver;
    229     pos = 0;
    230     status = 0;
    231     response_size = 0;
    232     field_value_len = 0;
    233     field_name_len = 0;
    234 
    235     while (state != st_eoh) {
    236 	int ch = pxe_getc(inode);
    237 	/* Eof before I finish paring the header */
    238 	if (ch == -1)
    239 	    goto fail;
    240 #if 0
    241         printf("%c", ch);
    242 #endif
    243 	response_size++;
    244 	if (ch == '\r' || ch == '\0')
    245 	    continue;
    246 	switch (state) {
    247 	case st_httpver:
    248 	    if (ch == ' ') {
    249 		state = st_stcode;
    250 		pos = 0;
    251 	    }
    252 	    break;
    253 
    254 	case st_stcode:
    255 	    if (ch < '0' || ch > '9')
    256 	       goto fail;
    257 	    status = (status*10) + (ch - '0');
    258 	    if (++pos == 3)
    259 		state = st_skipline;
    260 	    break;
    261 
    262 	case st_skipline:
    263 	    if (ch == '\n')
    264 		state = st_fieldfirst;
    265 	    break;
    266 
    267 	case st_fieldfirst:
    268 	    if (ch == '\n')
    269 		state = st_eoh;
    270 	    else if (isspace(ch)) {
    271 		/* A continuation line */
    272 		state = st_fieldvalue;
    273 		goto fieldvalue;
    274 	    }
    275 	    else if (is_token(ch)) {
    276 		/* Process the previous field before starting on the next one */
    277 		if (strcasecmp(field_name, "Content-Length") == 0) {
    278 		    next = field_value;
    279 		    /* Skip leading whitespace */
    280 		    while (isspace(*next))
    281 			next++;
    282 		    content_length = 0;
    283 		    for (;(*next >= '0' && *next <= '9'); next++) {
    284 			if ((content_length * 10) < content_length)
    285 			    break;
    286 			content_length = (content_length * 10) + (*next - '0');
    287 		    }
    288 		    /* In the case of overflow or other error ignore
    289 		     * Content-Length.
    290 		     */
    291 		    if (*next)
    292 			content_length = -1;
    293 		}
    294 		else if (strcasecmp(field_name, "Location") == 0) {
    295 		    next = field_value;
    296 		    /* Skip leading whitespace */
    297 		    while (isspace(*next))
    298 			next++;
    299 		    strlcpy(location, next, sizeof location);
    300 		}
    301 		/* Start the field name and field value afress */
    302 		field_name_len = 1;
    303 		field_name[0] = ch;
    304 		field_name[1] = '\0';
    305 		field_value_len = 0;
    306 		field_value[0] = '\0';
    307 		state = st_fieldname;
    308 	    }
    309 	    else /* Bogus try to recover */
    310 		state = st_skipline;
    311 	    break;
    312 
    313 	case st_fieldname:
    314 	    if (ch == ':' ) {
    315 		state = st_fieldvalue;
    316 	    }
    317 	    else if (is_token(ch)) {
    318 		if (!append_ch(field_name, sizeof field_name, &field_name_len, ch))
    319 		    state = st_skip_fieldname;
    320 	    }
    321 	    /* Bogus cases try to recover */
    322 	    else if (ch == '\n')
    323 		state = st_fieldfirst;
    324 	    else
    325 		state = st_skipline;
    326 	    break;
    327 
    328 	 case st_fieldvalue:
    329 	    if (ch == '\n')
    330 		state = st_fieldfirst;
    331 	    else {
    332 	    fieldvalue:
    333 		if (!append_ch(field_value, sizeof field_value, &field_value_len, ch))
    334 		    state = st_skip_fieldvalue;
    335 	    }
    336 	    break;
    337 
    338 	/* For valid fields whose names are longer than I choose to support. */
    339 	case st_skip_fieldname:
    340 	    if (ch == ':')
    341 		state = st_skip_fieldvalue;
    342 	    else if (is_token(ch))
    343 		state = st_skip_fieldname;
    344 	    /* Bogus cases try to recover */
    345 	    else if (ch == '\n')
    346 		state = st_fieldfirst;
    347 	    else
    348 		state = st_skipline;
    349 	    break;
    350 
    351 	/* For valid fields whose bodies are longer than I choose to support. */
    352 	case st_skip_fieldvalue:
    353 	    if (ch == '\n')
    354 		state = st_fieldfirst;
    355 	    break;
    356 
    357 	case st_eoh:
    358 	   break; /* Should never happen */
    359 	}
    360     }
    361 
    362     if (state != st_eoh)
    363 	status = 0;
    364 
    365     switch (status) {
    366     case 200:
    367 	/*
    368 	 * All OK, need to mark header data consumed and set up a file
    369 	 * structure...
    370 	 */
    371 	/* Treat the remainder of the bytes as data */
    372 	socket->tftp_filepos -= response_size;
    373 	break;
    374     case 301:
    375     case 302:
    376     case 303:
    377     case 307:
    378 	/* A redirect */
    379 	if (!location[0])
    380 	    goto fail;
    381 	*redir = location;
    382 	goto fail;
    383     default:
    384 	goto fail;
    385 	break;
    386     }
    387     return;
    388 fail:
    389     inode->size = 0;
    390     core_tcp_close_file(inode);
    391     return;
    392 }
    393