Mercurial > mplayer.hg
annotate libmpdemux/http.c @ 4564:5e1221d4655e
completely reworked FILM demuxer to support both audio and video...neither
of which work yet (CVID video and uncompressed audio)...but the demuxer is
working well now
author | melanson |
---|---|
date | Thu, 07 Feb 2002 05:55:29 +0000 |
parents | c9f861653fe2 |
children | f1dea39a50bb |
rev | line source |
---|---|
902 | 1 /* |
2 * HTTP Helper | |
3 * by Bertrand Baudet <bertrand_baudet@yahoo.com> | |
4 * (C) 2001, MPlayer team. | |
5 */ | |
6 | |
870 | 7 #include <stdio.h> |
8 #include <stdlib.h> | |
9 #include <string.h> | |
10 | |
11 #include "http.h" | |
12 | |
13 HTTP_header_t * | |
14 http_new_header() { | |
15 HTTP_header_t *http_hdr; | |
16 | |
17 http_hdr = (HTTP_header_t*)malloc(sizeof(HTTP_header_t)); | |
18 if( http_hdr==NULL ) return NULL; | |
19 memset( http_hdr, 0, sizeof(HTTP_header_t) ); | |
20 | |
21 return http_hdr; | |
22 } | |
23 | |
24 void | |
25 http_free( HTTP_header_t *http_hdr ) { | |
3039 | 26 HTTP_field_t *field, *field2free; |
870 | 27 if( http_hdr==NULL ) return; |
28 if( http_hdr->protocol!=NULL ) free( http_hdr->protocol ); | |
29 if( http_hdr->uri!=NULL ) free( http_hdr->uri ); | |
30 if( http_hdr->reason_phrase!=NULL ) free( http_hdr->reason_phrase ); | |
31 if( http_hdr->body!=NULL ) free( http_hdr->body ); | |
32 if( http_hdr->field_search!=NULL ) free( http_hdr->field_search ); | |
902 | 33 if( http_hdr->method!=NULL ) free( http_hdr->method ); |
34 if( http_hdr->buffer!=NULL ) free( http_hdr->buffer ); | |
3039 | 35 field = http_hdr->first_field; |
36 while( field!=NULL ) { | |
37 field2free = field; | |
38 field = field->next; | |
39 free( field2free ); | |
40 } | |
870 | 41 free( http_hdr ); |
3039 | 42 http_hdr = NULL; |
870 | 43 } |
44 | |
902 | 45 int |
46 http_response_append( HTTP_header_t *http_hdr, char *response, int length ) { | |
47 char *ptr = NULL; | |
1027 | 48 if( http_hdr==NULL || response==NULL || length<0 ) return -1; |
902 | 49 ptr = (char*)malloc( http_hdr->buffer_size+length ); |
50 if( ptr==NULL ) { | |
51 printf("Memory allocation failed\n"); | |
52 return -1; | |
53 } | |
54 if( http_hdr->buffer_size==0 ) { | |
55 // Buffer empty, copy response into it. | |
56 memcpy( ptr, response, length ); | |
57 http_hdr->buffer_size = length; | |
58 } else { | |
59 // Buffer not empty, grow buffer, copy and append the response. | |
60 memcpy( ptr, http_hdr->buffer, http_hdr->buffer_size ); | |
61 free( http_hdr->buffer ); | |
62 memcpy( ptr+http_hdr->buffer_size, response, length ); | |
63 http_hdr->buffer_size += length; | |
64 } | |
65 http_hdr->buffer = ptr; | |
66 return http_hdr->buffer_size; | |
67 } | |
68 | |
69 int | |
2489
0ecc1b4f7cf8
Added ASF http server streaming (Not mms streaming).
bertrand
parents:
2310
diff
changeset
|
70 http_is_header_entire( HTTP_header_t *http_hdr ) { |
902 | 71 if( http_hdr==NULL ) return -1; |
72 | |
3784 | 73 if( strstr(http_hdr->buffer, "\r\n\r\n")==NULL && |
74 strstr(http_hdr->buffer, "\n\n")==NULL ) return 0; | |
75 return 1; | |
902 | 76 } |
77 | |
78 int | |
79 http_response_parse( HTTP_header_t *http_hdr ) { | |
870 | 80 char *hdr_ptr, *ptr; |
81 char *field=NULL; | |
82 int pos_hdr_sep, len; | |
902 | 83 if( http_hdr==NULL ) return -1; |
84 if( http_hdr->is_parsed ) return 0; | |
870 | 85 |
86 // Get the protocol | |
902 | 87 hdr_ptr = strstr( http_hdr->buffer, " " ); |
870 | 88 if( hdr_ptr==NULL ) { |
902 | 89 printf("Malformed answer. No space separator found.\n"); |
90 return -1; | |
870 | 91 } |
902 | 92 len = hdr_ptr-http_hdr->buffer; |
870 | 93 http_hdr->protocol = (char*)malloc(len+1); |
94 if( http_hdr->protocol==NULL ) { | |
95 printf("Memory allocation failed\n"); | |
902 | 96 return -1; |
870 | 97 } |
902 | 98 strncpy( http_hdr->protocol, http_hdr->buffer, len ); |
99 http_hdr->protocol[len]='\0'; | |
870 | 100 if( !strncasecmp( http_hdr->protocol, "HTTP", 4) ) { |
101 if( sscanf( http_hdr->protocol+5,"1.%d", &(http_hdr->http_minor_version) )!=1 ) { | |
902 | 102 printf("Malformed answer. Unable to get HTTP minor version.\n"); |
103 return -1; | |
870 | 104 } |
105 } | |
106 | |
107 // Get the status code | |
108 if( sscanf( ++hdr_ptr, "%d", &(http_hdr->status_code) )!=1 ) { | |
902 | 109 printf("Malformed answer. Unable to get status code.\n"); |
110 return -1; | |
870 | 111 } |
112 hdr_ptr += 4; | |
113 | |
114 // Get the reason phrase | |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
115 ptr = strstr( hdr_ptr, "\n" ); |
870 | 116 if( hdr_ptr==NULL ) { |
902 | 117 printf("Malformed answer. Unable to get the reason phrase.\n"); |
118 return -1; | |
870 | 119 } |
120 len = ptr-hdr_ptr; | |
121 http_hdr->reason_phrase = (char*)malloc(len+1); | |
122 if( http_hdr->reason_phrase==NULL ) { | |
123 printf("Memory allocation failed\n"); | |
902 | 124 return -1; |
870 | 125 } |
126 strncpy( http_hdr->reason_phrase, hdr_ptr, len ); | |
4311 | 127 if( http_hdr->reason_phrase[len-1]=='\r' ) { |
128 len--; | |
129 } | |
870 | 130 http_hdr->reason_phrase[len]='\0'; |
131 | |
132 // Set the position of the header separator: \r\n\r\n | |
902 | 133 ptr = strstr( http_hdr->buffer, "\r\n\r\n" ); |
870 | 134 if( ptr==NULL ) { |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
135 ptr = strstr( http_hdr->buffer, "\n\n" ); |
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
136 if( ptr==NULL ) { |
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
137 printf("Header may be incomplete. No CRLF CRLF found.\n"); |
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
138 return -1; |
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
139 } |
870 | 140 } |
902 | 141 pos_hdr_sep = ptr-http_hdr->buffer; |
870 | 142 |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
143 // Point to the first line after the method line. |
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
144 hdr_ptr = strstr( http_hdr->buffer, "\n" )+1; |
870 | 145 do { |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
146 ptr = hdr_ptr; |
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
147 while( *ptr!='\r' && *ptr!='\n' ) ptr++; |
870 | 148 len = ptr-hdr_ptr; |
149 field = (char*)realloc(field, len+1); | |
150 if( field==NULL ) { | |
151 printf("Memory allocation failed\n"); | |
902 | 152 return -1; |
870 | 153 } |
154 strncpy( field, hdr_ptr, len ); | |
155 field[len]='\0'; | |
156 http_set_field( http_hdr, field ); | |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
157 hdr_ptr = ptr+((*ptr=='\r')?2:1); |
902 | 158 } while( hdr_ptr<(http_hdr->buffer+pos_hdr_sep) ); |
870 | 159 |
160 if( field!=NULL ) free( field ); | |
161 | |
902 | 162 if( pos_hdr_sep+4<http_hdr->buffer_size ) { |
870 | 163 // Response has data! |
902 | 164 int data_length = http_hdr->buffer_size-(pos_hdr_sep+4); |
870 | 165 http_hdr->body = (char*)malloc( data_length ); |
166 if( http_hdr->body==NULL ) { | |
902 | 167 printf("Memory allocation failed\n"); |
168 return -1; | |
870 | 169 } |
902 | 170 memcpy( http_hdr->body, http_hdr->buffer+pos_hdr_sep+4, data_length ); |
870 | 171 http_hdr->body_size = data_length; |
172 } | |
173 | |
902 | 174 http_hdr->is_parsed = 1; |
175 return 0; | |
870 | 176 } |
177 | |
178 char * | |
902 | 179 http_build_request( HTTP_header_t *http_hdr ) { |
3497 | 180 char *ptr, *uri=NULL; |
902 | 181 int len; |
3039 | 182 HTTP_field_t *field; |
870 | 183 if( http_hdr==NULL ) return NULL; |
184 | |
185 if( http_hdr->method==NULL ) http_set_method( http_hdr, "GET"); | |
186 if( http_hdr->uri==NULL ) http_set_uri( http_hdr, "/"); | |
3497 | 187 else { |
188 uri = (char*)malloc(strlen(http_hdr->uri)*2); | |
189 if( uri==NULL ) { | |
190 printf("Memory allocation failed\n"); | |
191 return NULL; | |
192 } | |
193 url_escape_string( uri, http_hdr->uri ); | |
194 } | |
870 | 195 |
3497 | 196 //**** Compute the request length |
197 // Add the Method line | |
198 len = strlen(http_hdr->method)+strlen(uri)+12; | |
199 // Add the fields | |
200 field = http_hdr->first_field; | |
3039 | 201 while( field!=NULL ) { |
202 len += strlen(field->field_name)+2; | |
203 field = field->next; | |
204 } | |
3497 | 205 // Add the CRLF |
206 len += 2; | |
207 // Add the body | |
902 | 208 if( http_hdr->body!=NULL ) { |
209 len += http_hdr->body_size; | |
210 } | |
3497 | 211 // Free the buffer if it was previously used |
902 | 212 if( http_hdr->buffer!=NULL ) { |
213 free( http_hdr->buffer ); | |
214 http_hdr->buffer = NULL; | |
215 } | |
3497 | 216 http_hdr->buffer = (char*)malloc(len+1); |
902 | 217 if( http_hdr->buffer==NULL ) { |
218 printf("Memory allocation failed\n"); | |
219 return NULL; | |
220 } | |
221 http_hdr->buffer_size = len; | |
222 | |
3497 | 223 //*** Building the request |
902 | 224 ptr = http_hdr->buffer; |
3497 | 225 // Add the method line |
226 ptr += sprintf( ptr, "%s %s HTTP/1.%d\r\n", http_hdr->method, uri, http_hdr->http_minor_version ); | |
3039 | 227 field = http_hdr->first_field; |
3497 | 228 // Add the field |
3039 | 229 while( field!=NULL ) { |
230 ptr += sprintf( ptr, "%s\r\n", field->field_name ); | |
231 field = field->next; | |
232 } | |
870 | 233 ptr += sprintf( ptr, "\r\n" ); |
3497 | 234 // Add the body |
870 | 235 if( http_hdr->body!=NULL ) { |
236 memcpy( ptr, http_hdr->body, http_hdr->body_size ); | |
237 } | |
3497 | 238 |
239 if( uri ) free( uri ); | |
902 | 240 return http_hdr->buffer; |
870 | 241 } |
242 | |
243 char * | |
244 http_get_field( HTTP_header_t *http_hdr, const char *field_name ) { | |
245 if( http_hdr==NULL || field_name==NULL ) return NULL; | |
3039 | 246 http_hdr->field_search_pos = http_hdr->first_field; |
247 http_hdr->field_search = (char*)realloc( http_hdr->field_search, strlen(field_name)+1 ); | |
870 | 248 if( http_hdr->field_search==NULL ) { |
249 printf("Memory allocation failed\n"); | |
250 return NULL; | |
251 } | |
252 strcpy( http_hdr->field_search, field_name ); | |
253 return http_get_next_field( http_hdr ); | |
254 } | |
255 | |
256 char * | |
257 http_get_next_field( HTTP_header_t *http_hdr ) { | |
258 char *ptr; | |
259 int i; | |
3039 | 260 HTTP_field_t *field; |
870 | 261 if( http_hdr==NULL ) return NULL; |
262 | |
3039 | 263 field = http_hdr->field_search_pos; |
264 while( field!=NULL ) { | |
265 ptr = strstr( field->field_name, ":" ); | |
870 | 266 if( ptr==NULL ) return NULL; |
3039 | 267 if( !strncasecmp( field->field_name, http_hdr->field_search, ptr-(field->field_name) ) ) { |
870 | 268 ptr++; // Skip the column |
269 while( ptr[0]==' ' ) ptr++; // Skip the spaces if there is some | |
3039 | 270 http_hdr->field_search_pos = field->next; |
870 | 271 return ptr; // return the value without the field name |
272 } | |
3039 | 273 field = field->next; |
870 | 274 } |
275 return NULL; | |
276 } | |
277 | |
278 void | |
3039 | 279 http_set_field( HTTP_header_t *http_hdr, const char *field_name ) { |
280 HTTP_field_t *new_field; | |
281 if( http_hdr==NULL || field_name==NULL ) return; | |
870 | 282 |
3039 | 283 new_field = (HTTP_field_t*)malloc(sizeof(HTTP_field_t)); |
284 if( new_field==NULL ) { | |
870 | 285 printf("Memory allocation failed\n"); |
286 return; | |
287 } | |
3039 | 288 new_field->next = NULL; |
289 new_field->field_name = (char*)malloc(strlen(field_name)+1); | |
290 if( new_field->field_name==NULL ) { | |
291 printf("Memory allocation failed\n"); | |
292 return; | |
293 } | |
294 strcpy( new_field->field_name, field_name ); | |
295 | |
296 if( http_hdr->last_field==NULL ) { | |
297 http_hdr->first_field = new_field; | |
298 } else { | |
299 http_hdr->last_field->next = new_field; | |
300 } | |
301 http_hdr->last_field = new_field; | |
870 | 302 http_hdr->field_nb++; |
303 } | |
304 | |
305 void | |
306 http_set_method( HTTP_header_t *http_hdr, const char *method ) { | |
307 if( http_hdr==NULL || method==NULL ) return; | |
308 | |
309 http_hdr->method = (char*)malloc(strlen(method)+1); | |
310 if( http_hdr->method==NULL ) { | |
311 printf("Memory allocation failed\n"); | |
312 return; | |
313 } | |
314 strcpy( http_hdr->method, method ); | |
315 } | |
316 | |
317 void | |
318 http_set_uri( HTTP_header_t *http_hdr, const char *uri ) { | |
319 if( http_hdr==NULL || uri==NULL ) return; | |
320 | |
321 http_hdr->uri = (char*)malloc(strlen(uri)+1); | |
322 if( http_hdr->uri==NULL ) { | |
323 printf("Memory allocation failed\n"); | |
324 return; | |
325 } | |
326 strcpy( http_hdr->uri, uri ); | |
327 } | |
328 | |
329 void | |
330 http_debug_hdr( HTTP_header_t *http_hdr ) { | |
3039 | 331 HTTP_field_t *field; |
332 int i = 0; | |
902 | 333 if( http_hdr==NULL ) return; |
870 | 334 |
4311 | 335 printf("--- HTTP DEBUG HEADER --- START ---\n"); |
336 printf("protocol: [%s]\n", http_hdr->protocol ); | |
337 printf("http minor version: [%d]\n", http_hdr->http_minor_version ); | |
338 printf("uri: [%s]\n", http_hdr->uri ); | |
339 printf("method: [%s]\n", http_hdr->method ); | |
340 printf("status code: [%d]\n", http_hdr->status_code ); | |
341 printf("reason phrase: [%s]\n", http_hdr->reason_phrase ); | |
342 printf("body size: [%d]\n", http_hdr->body_size ); | |
870 | 343 |
344 printf("Fields:\n"); | |
3039 | 345 field = http_hdr->first_field; |
346 while( field!=NULL ) { | |
347 printf(" %d - %s\n", i++, field->field_name ); | |
348 field = field->next; | |
349 } | |
4311 | 350 printf("--- HTTP DEBUG HEADER --- END ---\n"); |
870 | 351 } |