Mercurial > mplayer.hg
annotate libmpdemux/http.c @ 15246:849a6f39964f
use the documented default video device /dev/video0 instead of /dev/video that is missing on most systems
author | iive |
---|---|
date | Sat, 23 Apr 2005 21:23:58 +0000 |
parents | 475c551d9890 |
children | 281d155fb37f |
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" | |
4816
f1dea39a50bb
Fixed the http response parser when the http header only has the HTTP
bertrand
parents:
4311
diff
changeset
|
12 #include "url.h" |
5915 | 13 #include "mp_msg.h" |
870 | 14 |
15 HTTP_header_t * | |
16 http_new_header() { | |
17 HTTP_header_t *http_hdr; | |
18 | |
19 http_hdr = (HTTP_header_t*)malloc(sizeof(HTTP_header_t)); | |
20 if( http_hdr==NULL ) return NULL; | |
21 memset( http_hdr, 0, sizeof(HTTP_header_t) ); | |
22 | |
23 return http_hdr; | |
24 } | |
25 | |
26 void | |
27 http_free( HTTP_header_t *http_hdr ) { | |
3039 | 28 HTTP_field_t *field, *field2free; |
870 | 29 if( http_hdr==NULL ) return; |
30 if( http_hdr->protocol!=NULL ) free( http_hdr->protocol ); | |
31 if( http_hdr->uri!=NULL ) free( http_hdr->uri ); | |
32 if( http_hdr->reason_phrase!=NULL ) free( http_hdr->reason_phrase ); | |
33 if( http_hdr->field_search!=NULL ) free( http_hdr->field_search ); | |
902 | 34 if( http_hdr->method!=NULL ) free( http_hdr->method ); |
35 if( http_hdr->buffer!=NULL ) free( http_hdr->buffer ); | |
3039 | 36 field = http_hdr->first_field; |
37 while( field!=NULL ) { | |
38 field2free = field; | |
14460 | 39 if (field->field_name) |
40 free(field->field_name); | |
3039 | 41 field = field->next; |
42 free( field2free ); | |
43 } | |
870 | 44 free( http_hdr ); |
3039 | 45 http_hdr = NULL; |
870 | 46 } |
47 | |
902 | 48 int |
49 http_response_append( HTTP_header_t *http_hdr, char *response, int length ) { | |
1027 | 50 if( http_hdr==NULL || response==NULL || length<0 ) return -1; |
7304
7da2c2a68547
Check if realloc failed on http_hdr->buffer instead of ptr in http_response_append,
bertrand
parents:
7293
diff
changeset
|
51 |
7293 | 52 http_hdr->buffer = (char*)realloc( http_hdr->buffer, http_hdr->buffer_size+length+1 ); |
7304
7da2c2a68547
Check if realloc failed on http_hdr->buffer instead of ptr in http_response_append,
bertrand
parents:
7293
diff
changeset
|
53 if( http_hdr->buffer==NULL ) { |
7293 | 54 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory (re)allocation failed\n"); |
902 | 55 return -1; |
56 } | |
7293 | 57 memcpy( http_hdr->buffer+http_hdr->buffer_size, response, length ); |
58 http_hdr->buffer_size += length; | |
59 http_hdr->buffer[http_hdr->buffer_size]=0; // close the string! | |
902 | 60 return http_hdr->buffer_size; |
61 } | |
62 | |
63 int | |
2489
0ecc1b4f7cf8
Added ASF http server streaming (Not mms streaming).
bertrand
parents:
2310
diff
changeset
|
64 http_is_header_entire( HTTP_header_t *http_hdr ) { |
902 | 65 if( http_hdr==NULL ) return -1; |
7293 | 66 if( http_hdr->buffer==NULL ) return 0; // empty |
67 | |
3784 | 68 if( strstr(http_hdr->buffer, "\r\n\r\n")==NULL && |
69 strstr(http_hdr->buffer, "\n\n")==NULL ) return 0; | |
70 return 1; | |
902 | 71 } |
72 | |
73 int | |
74 http_response_parse( HTTP_header_t *http_hdr ) { | |
870 | 75 char *hdr_ptr, *ptr; |
76 char *field=NULL; | |
8179
63a5e03f4346
Removed hard coded value for the length of the header separator.
bertrand
parents:
7304
diff
changeset
|
77 int pos_hdr_sep, hdr_sep_len, len; |
902 | 78 if( http_hdr==NULL ) return -1; |
79 if( http_hdr->is_parsed ) return 0; | |
870 | 80 |
81 // Get the protocol | |
902 | 82 hdr_ptr = strstr( http_hdr->buffer, " " ); |
870 | 83 if( hdr_ptr==NULL ) { |
5915 | 84 mp_msg(MSGT_NETWORK,MSGL_ERR,"Malformed answer. No space separator found.\n"); |
902 | 85 return -1; |
870 | 86 } |
902 | 87 len = hdr_ptr-http_hdr->buffer; |
870 | 88 http_hdr->protocol = (char*)malloc(len+1); |
89 if( http_hdr->protocol==NULL ) { | |
5915 | 90 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); |
902 | 91 return -1; |
870 | 92 } |
902 | 93 strncpy( http_hdr->protocol, http_hdr->buffer, len ); |
94 http_hdr->protocol[len]='\0'; | |
870 | 95 if( !strncasecmp( http_hdr->protocol, "HTTP", 4) ) { |
96 if( sscanf( http_hdr->protocol+5,"1.%d", &(http_hdr->http_minor_version) )!=1 ) { | |
5915 | 97 mp_msg(MSGT_NETWORK,MSGL_ERR,"Malformed answer. Unable to get HTTP minor version.\n"); |
902 | 98 return -1; |
870 | 99 } |
100 } | |
101 | |
102 // Get the status code | |
103 if( sscanf( ++hdr_ptr, "%d", &(http_hdr->status_code) )!=1 ) { | |
5915 | 104 mp_msg(MSGT_NETWORK,MSGL_ERR,"Malformed answer. Unable to get status code.\n"); |
902 | 105 return -1; |
870 | 106 } |
107 hdr_ptr += 4; | |
108 | |
109 // Get the reason phrase | |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
110 ptr = strstr( hdr_ptr, "\n" ); |
870 | 111 if( hdr_ptr==NULL ) { |
5915 | 112 mp_msg(MSGT_NETWORK,MSGL_ERR,"Malformed answer. Unable to get the reason phrase.\n"); |
902 | 113 return -1; |
870 | 114 } |
115 len = ptr-hdr_ptr; | |
116 http_hdr->reason_phrase = (char*)malloc(len+1); | |
117 if( http_hdr->reason_phrase==NULL ) { | |
5915 | 118 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); |
902 | 119 return -1; |
870 | 120 } |
121 strncpy( http_hdr->reason_phrase, hdr_ptr, len ); | |
4311 | 122 if( http_hdr->reason_phrase[len-1]=='\r' ) { |
123 len--; | |
124 } | |
870 | 125 http_hdr->reason_phrase[len]='\0'; |
126 | |
127 // Set the position of the header separator: \r\n\r\n | |
8179
63a5e03f4346
Removed hard coded value for the length of the header separator.
bertrand
parents:
7304
diff
changeset
|
128 hdr_sep_len = 4; |
902 | 129 ptr = strstr( http_hdr->buffer, "\r\n\r\n" ); |
870 | 130 if( ptr==NULL ) { |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
131 ptr = strstr( http_hdr->buffer, "\n\n" ); |
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
132 if( ptr==NULL ) { |
5915 | 133 mp_msg(MSGT_NETWORK,MSGL_ERR,"Header may be incomplete. No CRLF CRLF found.\n"); |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
134 return -1; |
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
135 } |
8179
63a5e03f4346
Removed hard coded value for the length of the header separator.
bertrand
parents:
7304
diff
changeset
|
136 hdr_sep_len = 2; |
870 | 137 } |
902 | 138 pos_hdr_sep = ptr-http_hdr->buffer; |
870 | 139 |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
140 // 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
|
141 hdr_ptr = strstr( http_hdr->buffer, "\n" )+1; |
870 | 142 do { |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
143 ptr = hdr_ptr; |
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
144 while( *ptr!='\r' && *ptr!='\n' ) ptr++; |
870 | 145 len = ptr-hdr_ptr; |
4816
f1dea39a50bb
Fixed the http response parser when the http header only has the HTTP
bertrand
parents:
4311
diff
changeset
|
146 if( len==0 ) break; |
870 | 147 field = (char*)realloc(field, len+1); |
148 if( field==NULL ) { | |
5915 | 149 mp_msg(MSGT_NETWORK,MSGL_ERR,"Memory allocation failed\n"); |
902 | 150 return -1; |
870 | 151 } |
152 strncpy( field, hdr_ptr, len ); | |
153 field[len]='\0'; | |
154 http_set_field( http_hdr, field ); | |
3514
43518985def8
Handle broken server that doesn't send CRLF but jusr LF.
bertrand
parents:
3497
diff
changeset
|
155 hdr_ptr = ptr+((*ptr=='\r')?2:1); |
902 | 156 } while( hdr_ptr<(http_hdr->buffer+pos_hdr_sep) ); |
870 | 157 |
158 if( field!=NULL ) free( field ); | |
159 | |
8179
63a5e03f4346
Removed hard coded value for the length of the header separator.
bertrand
parents:
7304
diff
changeset
|
160 if( pos_hdr_sep+hdr_sep_len<http_hdr->buffer_size ) { |
870 | 161 // Response has data! |
8179
63a5e03f4346
Removed hard coded value for the length of the header separator.
bertrand
parents:
7304
diff
changeset
|
162 http_hdr->body = http_hdr->buffer+pos_hdr_sep+hdr_sep_len; |
63a5e03f4346
Removed hard coded value for the length of the header separator.
bertrand
parents:
7304
diff
changeset
|
163 http_hdr->body_size = http_hdr->buffer_size-(pos_hdr_sep+hdr_sep_len); |
870 | 164 } |
165 | |
902 | 166 http_hdr->is_parsed = 1; |
167 return 0; | |
870 | 168 } |
169 | |
170 char * | |
902 | 171 http_build_request( HTTP_header_t *http_hdr ) { |
3497 | 172 char *ptr, *uri=NULL; |
902 | 173 int len; |
3039 | 174 HTTP_field_t *field; |
870 | 175 if( http_hdr==NULL ) return NULL; |
176 | |
177 if( http_hdr->method==NULL ) http_set_method( http_hdr, "GET"); | |
178 if( http_hdr->uri==NULL ) http_set_uri( http_hdr, "/"); | |
3497 | 179 else { |
12391 | 180 uri = (char*)malloc(strlen(http_hdr->uri) + 1); |
3497 | 181 if( uri==NULL ) { |
5915 | 182 mp_msg(MSGT_NETWORK,MSGL_ERR,"Memory allocation failed\n"); |
3497 | 183 return NULL; |
184 } | |
12391 | 185 strcpy(uri,http_hdr->uri); |
3497 | 186 } |
870 | 187 |
3497 | 188 //**** Compute the request length |
189 // Add the Method line | |
190 len = strlen(http_hdr->method)+strlen(uri)+12; | |
191 // Add the fields | |
192 field = http_hdr->first_field; | |
3039 | 193 while( field!=NULL ) { |
194 len += strlen(field->field_name)+2; | |
195 field = field->next; | |
196 } | |
3497 | 197 // Add the CRLF |
198 len += 2; | |
199 // Add the body | |
902 | 200 if( http_hdr->body!=NULL ) { |
201 len += http_hdr->body_size; | |
202 } | |
3497 | 203 // Free the buffer if it was previously used |
902 | 204 if( http_hdr->buffer!=NULL ) { |
205 free( http_hdr->buffer ); | |
206 http_hdr->buffer = NULL; | |
207 } | |
3497 | 208 http_hdr->buffer = (char*)malloc(len+1); |
902 | 209 if( http_hdr->buffer==NULL ) { |
5915 | 210 mp_msg(MSGT_NETWORK,MSGL_ERR,"Memory allocation failed\n"); |
902 | 211 return NULL; |
212 } | |
213 http_hdr->buffer_size = len; | |
214 | |
3497 | 215 //*** Building the request |
902 | 216 ptr = http_hdr->buffer; |
3497 | 217 // Add the method line |
218 ptr += sprintf( ptr, "%s %s HTTP/1.%d\r\n", http_hdr->method, uri, http_hdr->http_minor_version ); | |
3039 | 219 field = http_hdr->first_field; |
3497 | 220 // Add the field |
3039 | 221 while( field!=NULL ) { |
222 ptr += sprintf( ptr, "%s\r\n", field->field_name ); | |
223 field = field->next; | |
224 } | |
870 | 225 ptr += sprintf( ptr, "\r\n" ); |
3497 | 226 // Add the body |
870 | 227 if( http_hdr->body!=NULL ) { |
228 memcpy( ptr, http_hdr->body, http_hdr->body_size ); | |
229 } | |
3497 | 230 |
231 if( uri ) free( uri ); | |
902 | 232 return http_hdr->buffer; |
870 | 233 } |
234 | |
235 char * | |
236 http_get_field( HTTP_header_t *http_hdr, const char *field_name ) { | |
237 if( http_hdr==NULL || field_name==NULL ) return NULL; | |
3039 | 238 http_hdr->field_search_pos = http_hdr->first_field; |
239 http_hdr->field_search = (char*)realloc( http_hdr->field_search, strlen(field_name)+1 ); | |
870 | 240 if( http_hdr->field_search==NULL ) { |
5915 | 241 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); |
870 | 242 return NULL; |
243 } | |
244 strcpy( http_hdr->field_search, field_name ); | |
245 return http_get_next_field( http_hdr ); | |
246 } | |
247 | |
248 char * | |
249 http_get_next_field( HTTP_header_t *http_hdr ) { | |
250 char *ptr; | |
3039 | 251 HTTP_field_t *field; |
870 | 252 if( http_hdr==NULL ) return NULL; |
253 | |
3039 | 254 field = http_hdr->field_search_pos; |
255 while( field!=NULL ) { | |
256 ptr = strstr( field->field_name, ":" ); | |
870 | 257 if( ptr==NULL ) return NULL; |
3039 | 258 if( !strncasecmp( field->field_name, http_hdr->field_search, ptr-(field->field_name) ) ) { |
870 | 259 ptr++; // Skip the column |
260 while( ptr[0]==' ' ) ptr++; // Skip the spaces if there is some | |
3039 | 261 http_hdr->field_search_pos = field->next; |
870 | 262 return ptr; // return the value without the field name |
263 } | |
3039 | 264 field = field->next; |
870 | 265 } |
266 return NULL; | |
267 } | |
268 | |
269 void | |
3039 | 270 http_set_field( HTTP_header_t *http_hdr, const char *field_name ) { |
271 HTTP_field_t *new_field; | |
272 if( http_hdr==NULL || field_name==NULL ) return; | |
870 | 273 |
3039 | 274 new_field = (HTTP_field_t*)malloc(sizeof(HTTP_field_t)); |
275 if( new_field==NULL ) { | |
5915 | 276 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); |
870 | 277 return; |
278 } | |
3039 | 279 new_field->next = NULL; |
280 new_field->field_name = (char*)malloc(strlen(field_name)+1); | |
281 if( new_field->field_name==NULL ) { | |
5915 | 282 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); |
3039 | 283 return; |
284 } | |
285 strcpy( new_field->field_name, field_name ); | |
286 | |
287 if( http_hdr->last_field==NULL ) { | |
288 http_hdr->first_field = new_field; | |
289 } else { | |
290 http_hdr->last_field->next = new_field; | |
291 } | |
292 http_hdr->last_field = new_field; | |
870 | 293 http_hdr->field_nb++; |
294 } | |
295 | |
296 void | |
297 http_set_method( HTTP_header_t *http_hdr, const char *method ) { | |
298 if( http_hdr==NULL || method==NULL ) return; | |
299 | |
300 http_hdr->method = (char*)malloc(strlen(method)+1); | |
301 if( http_hdr->method==NULL ) { | |
5915 | 302 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); |
870 | 303 return; |
304 } | |
305 strcpy( http_hdr->method, method ); | |
306 } | |
307 | |
308 void | |
309 http_set_uri( HTTP_header_t *http_hdr, const char *uri ) { | |
310 if( http_hdr==NULL || uri==NULL ) return; | |
311 | |
312 http_hdr->uri = (char*)malloc(strlen(uri)+1); | |
313 if( http_hdr->uri==NULL ) { | |
5915 | 314 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); |
870 | 315 return; |
316 } | |
317 strcpy( http_hdr->uri, uri ); | |
318 } | |
319 | |
6514 | 320 int |
321 http_add_basic_authentication( HTTP_header_t *http_hdr, const char *username, const char *password ) { | |
322 char *auth, *usr_pass, *b64_usr_pass; | |
323 int encoded_len, pass_len=0, out_len; | |
324 if( http_hdr==NULL || username==NULL ) return -1; | |
325 | |
326 if( password!=NULL ) { | |
327 pass_len = strlen(password); | |
328 } | |
329 | |
330 usr_pass = (char*)malloc(strlen(username)+pass_len+2); | |
331 if( usr_pass==NULL ) { | |
332 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); | |
333 return -1; | |
334 } | |
335 | |
336 sprintf( usr_pass, "%s:%s", username, (password==NULL)?"":password ); | |
337 | |
338 // Base 64 encode with at least 33% more data than the original size | |
339 encoded_len = strlen(usr_pass)*2; | |
340 b64_usr_pass = (char*)malloc(encoded_len); | |
341 if( b64_usr_pass==NULL ) { | |
342 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); | |
343 return -1; | |
344 } | |
345 | |
346 out_len = base64_encode( usr_pass, strlen(usr_pass), b64_usr_pass, encoded_len); | |
347 if( out_len<0 ) { | |
348 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Base64 out overflow\n"); | |
349 return -1; | |
350 } | |
351 | |
352 b64_usr_pass[out_len]='\0'; | |
353 | |
354 auth = (char*)malloc(encoded_len+22); | |
355 if( auth==NULL ) { | |
356 mp_msg(MSGT_NETWORK,MSGL_FATAL,"Memory allocation failed\n"); | |
357 return -1; | |
358 } | |
359 | |
360 sprintf( auth, "Authorization: Basic %s", b64_usr_pass); | |
361 http_set_field( http_hdr, auth ); | |
362 | |
363 free( usr_pass ); | |
364 free( b64_usr_pass ); | |
365 free( auth ); | |
366 | |
367 return 0; | |
368 } | |
369 | |
870 | 370 void |
371 http_debug_hdr( HTTP_header_t *http_hdr ) { | |
3039 | 372 HTTP_field_t *field; |
373 int i = 0; | |
902 | 374 if( http_hdr==NULL ) return; |
870 | 375 |
5915 | 376 mp_msg(MSGT_NETWORK,MSGL_V,"--- HTTP DEBUG HEADER --- START ---\n"); |
377 mp_msg(MSGT_NETWORK,MSGL_V,"protocol: [%s]\n", http_hdr->protocol ); | |
378 mp_msg(MSGT_NETWORK,MSGL_V,"http minor version: [%d]\n", http_hdr->http_minor_version ); | |
379 mp_msg(MSGT_NETWORK,MSGL_V,"uri: [%s]\n", http_hdr->uri ); | |
380 mp_msg(MSGT_NETWORK,MSGL_V,"method: [%s]\n", http_hdr->method ); | |
381 mp_msg(MSGT_NETWORK,MSGL_V,"status code: [%d]\n", http_hdr->status_code ); | |
382 mp_msg(MSGT_NETWORK,MSGL_V,"reason phrase: [%s]\n", http_hdr->reason_phrase ); | |
383 mp_msg(MSGT_NETWORK,MSGL_V,"body size: [%d]\n", http_hdr->body_size ); | |
870 | 384 |
5915 | 385 mp_msg(MSGT_NETWORK,MSGL_V,"Fields:\n"); |
3039 | 386 field = http_hdr->first_field; |
387 while( field!=NULL ) { | |
5915 | 388 mp_msg(MSGT_NETWORK,MSGL_V," %d - %s\n", i++, field->field_name ); |
3039 | 389 field = field->next; |
390 } | |
5915 | 391 mp_msg(MSGT_NETWORK,MSGL_V,"--- HTTP DEBUG HEADER --- END ---\n"); |
870 | 392 } |
6514 | 393 |
394 int | |
395 base64_encode(const void *enc, int encLen, char *out, int outMax) { | |
396 static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; | |
397 | |
398 unsigned char *encBuf; | |
399 int outLen; | |
400 unsigned int bits; | |
401 unsigned int shift; | |
402 | |
403 encBuf = (unsigned char*)enc; | |
404 outLen = 0; | |
405 bits = 0; | |
406 shift = 0; | |
407 | |
408 while( outLen<outMax ) { | |
409 if( encLen>0 ) { | |
410 // Shift in byte | |
411 bits <<= 8; | |
412 bits |= *encBuf; | |
413 shift += 8; | |
414 // Next byte | |
415 encBuf++; | |
416 encLen--; | |
417 } else if( shift>0 ) { | |
418 // Pad last bits to 6 bits - will end next loop | |
419 bits <<= 6 - shift; | |
420 shift = 6; | |
421 } else { | |
422 // Terminate with Mime style '=' | |
423 *out = '='; | |
424 outLen++; | |
425 | |
426 return outLen; | |
427 } | |
428 | |
429 // Encode 6 bit segments | |
430 while( shift>=6 ) { | |
431 shift -= 6; | |
432 *out = b64[ (bits >> shift) & 0x3F ]; | |
433 out++; | |
434 outLen++; | |
435 } | |
436 } | |
437 | |
438 // Output overflow | |
439 return -1; | |
440 } | |
441 | |
442 |