Protocol's get() method no longer takes ownership of the URI. HTTP is the
[people/sha0/gpxe.git] / src / net / tcp / http.c
1 /*
2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17  */
18
19 /**
20  * @file
21  *
22  * Hyper Text Transfer Protocol (HTTP)
23  *
24  */
25
26 #include <stddef.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <strings.h>
30 #include <errno.h>
31 #include <assert.h>
32 #include <vsprintf.h>
33 #include <gpxe/async.h>
34 #include <gpxe/uri.h>
35 #include <gpxe/buffer.h>
36 #include <gpxe/http.h>
37
38 static inline struct http_request *
39 tcp_to_http ( struct tcp_application *app ) {
40         return container_of ( app, struct http_request, tcp );
41 }
42
43 /**
44  * Mark HTTP request as complete
45  *
46  * @v http              HTTP request
47  * @v rc                Return status code
48  *
49  */
50 static void http_done ( struct http_request *http, int rc ) {
51
52         /* Close TCP connection */
53         tcp_close ( &http->tcp );
54
55         /* Prevent further processing of any current packet */
56         http->rx_state = HTTP_RX_DEAD;
57
58         /* Free up any dynamically allocated storage */
59         empty_line_buffer ( &http->linebuf );
60
61         /* If we had a Content-Length, and the received content length
62          * isn't correct, flag an error
63          */
64         if ( http->content_length &&
65              ( http->content_length != http->buffer->fill ) ) {
66                 DBGC ( http, "HTTP %p incorrect length %zd, should be %zd\n",
67                        http, http->buffer->fill, http->content_length );
68                 rc = -EIO;
69         }
70
71         /* Mark async operation as complete */
72         async_done ( &http->async, rc );
73 }
74
75 /**
76  * Convert HTTP response code to return status code
77  *
78  * @v response          HTTP response code
79  * @ret rc              Return status code
80  */
81 static int http_response_to_rc ( unsigned int response ) {
82         switch ( response ) {
83         case 200:
84                 return 0;
85         case 404:
86                 return -ENOENT;
87         case 403:
88                 return -EPERM;
89         default:
90                 return -EIO;
91         }
92 }
93
94 /**
95  * Handle HTTP response
96  *
97  * @v http              HTTP request
98  * @v response          HTTP response
99  */
100 static void http_rx_response ( struct http_request *http, char *response ) {
101         char *spc;
102         int rc = -EIO;
103
104         DBGC ( http, "HTTP %p response \"%s\"\n", http, response );
105
106         /* Check response starts with "HTTP/" */
107         if ( strncmp ( response, "HTTP/", 5 ) != 0 )
108                 goto err;
109
110         /* Locate and check response code */
111         spc = strchr ( response, ' ' );
112         if ( ! spc )
113                 goto err;
114         http->response = strtoul ( spc, NULL, 10 );
115         if ( ( rc = http_response_to_rc ( http->response ) ) != 0 )
116                 goto err;
117
118         /* Move to received headers */
119         http->rx_state = HTTP_RX_HEADER;
120         return;
121
122  err:
123         DBGC ( http, "HTTP %p bad response\n", http );
124         http_done ( http, rc );
125         return;
126 }
127
128 /**
129  * Handle HTTP Content-Length header
130  *
131  * @v http              HTTP request
132  * @v value             HTTP header value
133  * @ret rc              Return status code
134  */
135 static int http_rx_content_length ( struct http_request *http,
136                                     const char *value ) {
137         char *endp;
138
139         http->content_length = strtoul ( value, &endp, 10 );
140         if ( *endp != '\0' ) {
141                 DBGC ( http, "HTTP %p invalid Content-Length \"%s\"\n",
142                        http, value );
143                 return -EIO;
144         }
145
146         return 0;
147 }
148
149 /**
150  * An HTTP header handler
151  *
152  */
153 struct http_header_handler {
154         /** Name (e.g. "Content-Length") */
155         const char *header;
156         /** Handle received header
157          *
158          * @v http      HTTP request
159          * @v value     HTTP header value
160          * @ret rc      Return status code
161          */
162         int ( * rx ) ( struct http_request *http, const char *value );
163 };
164
165 /** List of HTTP header handlers */
166 struct http_header_handler http_header_handlers[] = {
167         {
168                 .header = "Content-Length",
169                 .rx = http_rx_content_length,
170         },
171         { NULL, NULL }
172 };
173
174 /**
175  * Handle HTTP header
176  *
177  * @v http              HTTP request
178  * @v header            HTTP header
179  */
180 static void http_rx_header ( struct http_request *http, char *header ) {
181         struct http_header_handler *handler;
182         char *separator;
183         char *value;
184         int rc = -EIO;
185
186         /* An empty header line marks the transition to the data phase */
187         if ( ! header[0] ) {
188                 DBGC ( http, "HTTP %p start of data\n", http );
189                 empty_line_buffer ( &http->linebuf );
190                 http->rx_state = HTTP_RX_DATA;
191                 return;
192         }
193
194         DBGC ( http, "HTTP %p header \"%s\"\n", http, header );
195
196         /* Split header at the ": " */
197         separator = strstr ( header, ": " );
198         if ( ! separator )
199                 goto err;
200         *separator = '\0';
201         value = ( separator + 2 );
202
203         /* Hand off to header handler, if one exists */
204         for ( handler = http_header_handlers ; handler->header ; handler++ ) {
205                 if ( strcasecmp ( header, handler->header ) == 0 ) {
206                         if ( ( rc = handler->rx ( http, value ) ) != 0 )
207                                 goto err;
208                         break;
209                 }
210         }
211         return;
212
213  err:
214         DBGC ( http, "HTTP %p bad header\n", http );
215         http_done ( http, rc );
216         return;
217 }
218
219 /**
220  * Handle new data arriving via HTTP connection in the data phase
221  *
222  * @v http              HTTP request
223  * @v data              New data
224  * @v len               Length of new data
225  */
226 static void http_rx_data ( struct http_request *http,
227                            const char *data, size_t len ) {
228         int rc;
229
230         /* Fill data buffer */
231         if ( ( rc = fill_buffer ( http->buffer, data,
232                                   http->buffer->fill, len ) ) != 0 ) {
233                 DBGC ( http, "HTTP %p failed to fill data buffer: %s\n",
234                        http, strerror ( rc ) );
235                 http_done ( http, rc );
236                 return;
237         }
238
239         /* If we have reached the content-length, stop now */
240         if ( http->content_length &&
241              ( http->buffer->fill >= http->content_length ) ) {
242                 http_done ( http, 0 );
243         }
244 }
245
246 /**
247  * Handle new data arriving via HTTP connection
248  *
249  * @v http              HTTP request
250  * @v data              New data
251  * @v len               Length of new data
252  */
253 static void http_newdata ( struct tcp_application *app,
254                            void *data, size_t len ) {
255         struct http_request *http = tcp_to_http ( app );
256         const char *buf = data;
257         char *line;
258         int rc;
259
260         while ( len ) {
261                 if ( http->rx_state == HTTP_RX_DEAD ) {
262                         /* Do no further processing */
263                         return;
264                 } else if ( http->rx_state == HTTP_RX_DATA ) {
265                         /* Once we're into the data phase, just fill
266                          * the data buffer
267                          */
268                         http_rx_data ( http, buf, len );
269                         return;
270                 } else {
271                         /* In the other phases, buffer and process a
272                          * line at a time
273                          */
274                         if ( ( rc = line_buffer ( &http->linebuf, &buf,
275                                                   &len ) ) != 0 ) {
276                                 DBGC ( http, "HTTP %p could not buffer line: "
277                                        "%s\n", http, strerror ( rc ) );
278                                 http_done ( http, rc );
279                                 return;
280                         }
281                         if ( ( line = buffered_line ( &http->linebuf ) ) ) {
282                                 switch ( http->rx_state ) {
283                                 case HTTP_RX_RESPONSE:
284                                         http_rx_response ( http, line );
285                                         break;
286                                 case HTTP_RX_HEADER:
287                                         http_rx_header ( http, line );
288                                         break;
289                                 default:
290                                         assert ( 0 );
291                                         break;
292                                 }
293                         }
294                 }
295         }
296 }
297
298 /**
299  * Send HTTP data
300  *
301  * @v app               TCP application
302  * @v buf               Temporary data buffer
303  * @v len               Length of temporary data buffer
304  */
305 static void http_senddata ( struct tcp_application *app,
306                             void *buf, size_t len ) {
307         struct http_request *http = tcp_to_http ( app );
308         const char *path = http->uri->path;
309         const char *host = http->uri->host;
310
311         if ( ! path )
312                 path = "/";
313
314         if ( ! host )
315                 host = "";
316
317         len = snprintf ( buf, len,
318                          "GET %s HTTP/1.1\r\n"
319                          "User-Agent: gPXE/" VERSION "\r\n"
320                          "Host: %s\r\n"
321                          "\r\n", path, host );
322
323         tcp_send ( app, ( buf + http->tx_offset ), ( len - http->tx_offset ) );
324 }
325
326 /**
327  * HTTP data acknowledged
328  *
329  * @v app               TCP application
330  * @v len               Length of acknowledged data
331  */
332 static void http_acked ( struct tcp_application *app, size_t len ) {
333         struct http_request *http = tcp_to_http ( app );
334
335         http->tx_offset += len;
336 }
337
338 /**
339  * HTTP connection closed by network stack
340  *
341  * @v app               TCP application
342  */
343 static void http_closed ( struct tcp_application *app, int rc ) {
344         struct http_request *http = tcp_to_http ( app );
345
346         DBGC ( http, "HTTP %p connection closed: %s\n",
347                http, strerror ( rc ) );
348         
349         http_done ( http, rc );
350 }
351
352 /** HTTP TCP operations */
353 static struct tcp_operations http_tcp_operations = {
354         .closed         = http_closed,
355         .acked          = http_acked,
356         .newdata        = http_newdata,
357         .senddata       = http_senddata,
358 };
359
360 /**
361  * Reap asynchronous operation
362  *
363  * @v async             Asynchronous operation
364  */
365 static void http_reap ( struct async *async ) {
366         struct http_request *http =
367                 container_of ( async, struct http_request, async );
368
369         free ( http );
370 }
371
372 /** HTTP asynchronous operations */
373 static struct async_operations http_async_operations = {
374         .reap                   = http_reap,
375 };
376
377 #warning "Quick name resolution hack"
378 #include <byteswap.h>
379
380 /**
381  * Initiate a HTTP connection
382  *
383  * @v uri               Uniform Resource Identifier
384  * @v buffer            Buffer into which to download file
385  * @v parent            Parent asynchronous operation
386  * @ret rc              Return status code
387  */
388 int http_get ( struct uri *uri, struct buffer *buffer, struct async *parent ) {
389         struct http_request *http;
390         int rc;
391
392         /* Allocate and populate HTTP structure */
393         http = malloc ( sizeof ( *http ) );
394         if ( ! http ) {
395                 rc = -ENOMEM;
396                 goto err;
397         }
398         memset ( http, 0, sizeof ( *http ) );
399         http->uri = uri;
400         http->buffer = buffer;
401         http->tcp.tcp_op = &http_tcp_operations;
402
403 #warning "Quick name resolution hack"
404         union {
405                 struct sockaddr_tcpip st;
406                 struct sockaddr_in sin;
407         } server;
408         server.sin.sin_port = htons ( HTTP_PORT );
409         server.sin.sin_family = AF_INET;
410         if ( inet_aton ( uri->host, &server.sin.sin_addr ) == 0 ) {
411                 rc = -EINVAL;
412                 goto err;
413         }
414
415         if ( ( rc = tcp_connect ( &http->tcp, &server.st, 0 ) ) != 0 )
416                 goto err;
417
418         async_init ( &http->async, &http_async_operations, parent );
419         return 0;
420
421  err:
422         DBGC ( http, "HTTP %p could not create request: %s\n", 
423                http, strerror ( rc ) );
424         free ( http );
425         return rc;
426 }