9bec4f536d0ccabbbcecb62866f91d33e9744d3f
[vlc.git] / modules / access / mms / mmsh.c
1 /*****************************************************************************
2  * mmsh.c:
3  *****************************************************************************
4  * Copyright (C) 2001, 2002 VideoLAN
5  * $Id: mmsh.c,v 1.5 2003/08/17 23:02:51 fenrir Exp $
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
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 2 of the License, or
12  * (at your option) 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*
25  * TODO:
26  *  * http_proxy
27  *
28  */
29
30 /*****************************************************************************
31  * Preamble
32  *****************************************************************************/
33 #include <stdlib.h>
34 #include <string.h>
35
36 #include <vlc/vlc.h>
37 #include <vlc/input.h>
38
39 #ifdef HAVE_ERRNO_H
40 #   include <errno.h>
41 #endif
42 #ifdef HAVE_FCNTL_H
43 #   include <fcntl.h>
44 #endif
45 #ifdef HAVE_SYS_TIME_H
46 #    include <sys/time.h>
47 #endif
48
49 #ifdef HAVE_UNISTD_H
50 #   include <unistd.h>
51 #endif
52
53 #if defined( UNDER_CE )
54 #   include <winsock.h>
55 #elif defined( WIN32 )
56 #   include <winsock2.h>
57 #   include <ws2tcpip.h>
58 #   ifndef IN_MULTICAST
59 #       define IN_MULTICAST(a) IN_CLASSD(a)
60 #   endif
61 #else
62 #   include <sys/socket.h>
63 #endif
64
65 #include "network.h"
66 #include "asf.h"
67 #include "buffer.h"
68
69 #include "mms.h"
70 #include "mmsh.h"
71
72 /*****************************************************************************
73  * Local prototypes
74  *****************************************************************************/
75 int  E_( MMSHOpen )  ( input_thread_t * );
76 void E_( MMSHClose ) ( input_thread_t * );
77
78 static ssize_t Read        ( input_thread_t * p_input, byte_t * p_buffer,
79                              size_t i_len );
80 static void    Seek        ( input_thread_t *, off_t );
81
82 /****************************************************************************
83  ****************************************************************************
84  *******************                                      *******************
85  *******************       Main functions                 *******************
86  *******************                                      *******************
87  ****************************************************************************
88  ****************************************************************************/
89
90 /****************************************************************************
91  * Open: connect to ftp server and ask for file
92  ****************************************************************************/
93 int  E_( MMSHOpen )  ( input_thread_t *p_input )
94 {
95     access_sys_t    *p_sys;
96
97     uint8_t         *p;
98     http_answer_t   *p_ans;
99     http_field_t    *p_field;
100     chunk_t         ck;
101
102     /* init p_sys */
103     p_sys = malloc( sizeof( access_sys_t ) );
104     p_sys->i_proto = MMS_PROTO_HTTP;
105
106     p_sys->p_socket = NULL;
107     p_sys->i_request_context = 1;
108     p_sys->i_buffer = 0;
109     p_sys->i_buffer_pos = 0;
110     p_sys->b_broadcast = VLC_TRUE;
111     p_sys->p_packet = NULL;
112     p_sys->i_packet_sequence = 0;
113     p_sys->i_packet_used = 0;
114     p_sys->i_packet_length = 0;
115     p_sys->i_pos = 0;
116     E_( GenerateGuid )( &p_sys->guid );
117
118     /* open a tcp connection */
119     p_sys->p_url = E_( url_new )( p_input->psz_name );
120
121     if( *p_sys->p_url->psz_host == '\0' )
122     {
123         msg_Err( p_input, "invalid server addresse" );
124         goto exit_error;
125     }
126     if( p_sys->p_url->i_port <= 0 )
127     {
128         p_sys->p_url->i_port = 80;
129     }
130
131     p_sys->p_socket = NetOpenTCP( p_input, p_sys->p_url );
132     if( !p_sys->p_socket )
133     {
134         msg_Err( p_input, "cannot connect" );
135         goto exit_error;
136     }
137     p_sys->i_request_context = 1;
138
139     /* *** send first request *** */
140     p = &p_sys->buffer[0];
141     p += sprintf( p, "GET %s HTTP/1.0\r\n", p_sys->p_url->psz_path );
142     p += sprintf( p,"Accept: */*\r\n" );
143     p += sprintf( p, "User-Agent: NSPlayer/4.1.0.3856\r\n" );
144     p += sprintf( p, "Host: %s:%d\r\n", p_sys->p_url->psz_host, p_sys->p_url->i_port );
145     p += sprintf( p, "Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=0:0,request-context=%d,max-duration=0\r\n", p_sys->i_request_context++ );
146     //p += sprintf( p, "Pragma: xClientGUID={c77e7400-738a-11d2-9add-0020af0a3278}\r\n" );
147     p += sprintf( p, "Pragma: xClientGUID={"GUID_FMT"}\r\n", GUID_PRINT( p_sys->guid ) );
148     p += sprintf( p, "Connection: Close\r\n\r\n" );
149     NetWrite( p_input, p_sys->p_socket, p_sys->buffer,  p - p_sys->buffer );
150
151
152     if( NetFill ( p_input, p_sys, BUFFER_SIZE ) <= 0 )
153     {
154         msg_Err( p_input, "cannot read answer" );
155         goto exit_error;
156     }
157     NetClose( p_input, p_sys->p_socket );
158
159     p_ans = http_answer_parse( p_sys->buffer, p_sys->i_buffer );
160     if( !p_ans )
161     {
162         msg_Err( p_input, "cannot parse answer" );
163         goto exit_error;
164     }
165
166     if( p_ans->i_error >= 400 )
167     {
168         msg_Err( p_input, "error %d (server return=`%s')", p_ans->i_error, p_ans->psz_answer );
169         http_answer_free( p_ans );
170         goto exit_error;
171     }
172     else if( p_ans->i_error >= 300 )
173     {
174         msg_Err( p_input, "FIXME redirec unsuported %d (server return=`%s')", p_ans->i_error, p_ans->psz_answer );
175         http_answer_free( p_ans );
176         goto exit_error;
177     }
178     else if( p_ans->i_body <= 0 )
179     {
180         msg_Err( p_input, "empty answer" );
181         http_answer_free( p_ans );
182         goto exit_error;
183     }
184
185     /* now get features */
186     /* FIXME FIXME test Content-Type to see if it's a plain stream or an asx FIXME */
187     for( p_field = p_ans->p_fields; p_field != NULL; p_field = http_field_find( p_field->p_next, "Pragma" ) )
188     {
189         if( !strncasecmp( p_field->psz_value, "features", 8 ) )
190         {
191             if( strstr( p_field->psz_value, "broadcast" ) )
192             {
193                 msg_Dbg( p_input, "stream type = broadcast" );
194                 p_sys->b_broadcast = VLC_TRUE;
195             }
196             else if( strstr( p_field->psz_value, "seekable" ) )
197             {
198                 msg_Dbg( p_input, "stream type = seekable" );
199                 p_sys->b_broadcast = VLC_FALSE;
200             }
201             else
202             {
203                 msg_Warn( p_input, "unknow stream types (%s)", p_field->psz_value );
204                 p_sys->b_broadcast = VLC_FALSE;
205             }
206         }
207     }
208
209     /* gather header */
210     p_sys->i_header = 0;
211     p_sys->p_header = malloc( p_ans->i_body );
212     do
213     {
214         if( chunk_parse( &ck, p_ans->p_body, p_ans->i_body ) )
215         {
216             msg_Err( p_input, "invalid chunk answer" );
217             goto exit_error;
218         }
219         if( ck.i_type != 0x4824 )
220         {
221             msg_Err( p_input, "invalid chunk (0x%x)", ck.i_type );
222             break;
223         }
224         if( ck.i_data > 0 )
225         {
226             memcpy( &p_sys->p_header[p_sys->i_header],
227                     ck.p_data,
228                     ck.i_data );
229
230             p_sys->i_header += ck.i_data;
231         }
232
233         /* BEURK */
234         p_ans->p_body   += 12 + ck.i_data;
235         p_ans->i_body   -= 12 + ck.i_data;
236
237     } while( p_ans->i_body > 12 );
238
239     http_answer_free( p_ans );
240
241     msg_Dbg( p_input, "complete header size=%d", p_sys->i_header );
242     if( p_sys->i_header <= 0 )
243     {
244         msg_Err( p_input, "header size == 0" );
245         goto exit_error;
246     }
247     /* *** parse header and get stream and their id *** */
248     /* get all streams properties,
249      *
250      * TODO : stream bitrates properties(optional)
251      *        and bitrate mutual exclusion(optional) */
252     E_( asf_HeaderParse )( &p_sys->asfh,
253                            p_sys->p_header, p_sys->i_header );
254     msg_Dbg( p_input, "packet count=%lld packet size=%d",p_sys->asfh.i_data_packets_count, p_sys->asfh.i_min_data_packet_size );
255
256     E_( asf_StreamSelect)( &p_sys->asfh,
257                            config_GetInt( p_input, "mms-maxbitrate" ),
258                            config_GetInt( p_input, "mms-all" ),
259                            config_GetInt( p_input, "audio" ),
260                            config_GetInt( p_input, "video" ) );
261
262     if( mmsh_start( p_input, p_sys, 0 ) )
263     {
264         msg_Err( p_input, "cannot start stream" );
265         goto exit_error;
266     }
267
268     /* *** set exported functions *** */
269     p_input->pf_read = Read;
270     p_input->pf_seek = Seek;
271     p_input->pf_set_program = input_SetProgram;
272     p_input->pf_set_area = NULL;
273
274     p_input->p_private = NULL;
275     p_input->i_mtu = 3 * p_sys->asfh.i_min_data_packet_size;
276
277     /* *** finished to set some variable *** */
278     vlc_mutex_lock( &p_input->stream.stream_lock );
279     p_input->stream.b_pace_control = 0;
280     if( p_sys->b_broadcast )
281     {
282         p_input->stream.p_selected_area->i_size = 0;
283         p_input->stream.b_seekable = 0;
284     }
285     else
286     {
287         p_input->stream.p_selected_area->i_size = p_sys->asfh.i_file_size;
288         p_input->stream.b_seekable = 1;
289     }
290     p_input->stream.p_selected_area->i_tell = 0;
291     p_input->stream.i_method = INPUT_METHOD_NETWORK;
292     vlc_mutex_unlock( &p_input->stream.stream_lock );
293
294     /* Update default_pts to a suitable value for ftp access */
295     p_input->i_pts_delay = config_GetInt( p_input, "mms-caching" ) * 1000;
296
297     p_input->p_access_data = p_sys;
298
299     return( VLC_SUCCESS );
300
301 exit_error:
302     E_( url_free )( p_sys->p_url );
303
304     if( p_sys->p_socket )
305     {
306         NetClose( p_input, p_sys->p_socket );
307     }
308     free( p_sys );
309     return( VLC_EGENERIC );
310 }
311
312 /*****************************************************************************
313  * Close: free unused data structures
314  *****************************************************************************/
315 void E_( MMSHClose ) ( input_thread_t *p_input )
316 {
317     access_sys_t    *p_sys   = p_input->p_access_data;
318
319     msg_Dbg( p_input, "stopping stream" );
320
321     mmsh_stop( p_input, p_sys );
322
323     free( p_sys );
324 }
325
326 static int mmsh_get_packet( input_thread_t * p_input, access_sys_t *p_sys, chunk_t *p_ck )
327 {
328     int i_mov = p_sys->i_buffer - p_sys->i_buffer_pos;
329
330     if( p_sys->i_buffer_pos > BUFFER_SIZE / 2 )
331     {
332         if( i_mov > 0 )
333         {
334             memmove( &p_sys->buffer[0], 
335                      &p_sys->buffer[p_sys->i_buffer_pos],
336                      i_mov );
337         }
338
339         p_sys->i_buffer     = i_mov;
340         p_sys->i_buffer_pos = 0;
341     }
342
343     if( NetFill( p_input, p_sys, 12 ) < 12 )
344     {
345         msg_Warn( p_input, "cannot fill buffer" );
346         return VLC_EGENERIC;
347     }
348
349     chunk_parse( p_ck, &p_sys->buffer[p_sys->i_buffer_pos], p_sys->i_buffer - p_sys->i_buffer_pos );
350
351     if( p_ck->i_type == 0x4524 )   // Transfer complete
352     {
353         msg_Warn( p_input, "EOF" );
354         return VLC_EGENERIC;
355     }
356     else if( p_ck->i_type != 0x4824 && p_ck->i_type != 0x4424 )
357     {
358         msg_Err( p_input, "invalid chunk FATAL" );
359         return VLC_EGENERIC;
360     }
361
362     if( p_ck->i_data < p_ck->i_size2 - 8 )
363     {
364         if( NetFill( p_input, p_sys, p_ck->i_size2 - 8 - p_ck->i_data ) <= 0 )
365         {
366             msg_Warn( p_input, "cannot fill buffer" );
367             return VLC_EGENERIC;
368         }
369         chunk_parse( p_ck, &p_sys->buffer[p_sys->i_buffer_pos], p_sys->i_buffer - p_sys->i_buffer_pos );
370     }
371
372     if( p_sys->i_packet_sequence != 0 && p_ck->i_sequence != p_sys->i_packet_sequence )
373     {
374         msg_Warn( p_input, "packet lost ?" );
375     }
376
377     p_sys->i_packet_sequence = p_ck->i_sequence + 1;
378     p_sys->i_packet_used   = 0;
379     p_sys->i_packet_length = p_ck->i_data;
380     p_sys->p_packet        = p_ck->p_data;
381
382     p_sys->i_buffer_pos += 12 + p_ck->i_data;
383
384     return VLC_SUCCESS;
385 }
386
387
388 /*****************************************************************************
389  * Seek: try to go at the right place
390  *****************************************************************************/
391 static void Seek( input_thread_t * p_input, off_t i_pos )
392 {
393     access_sys_t *p_sys = p_input->p_access_data;
394     chunk_t      ck;
395     off_t        i_offset;
396     off_t        i_packet;
397
398     i_packet = ( i_pos - p_sys->i_header ) / p_sys->asfh.i_min_data_packet_size;
399     i_offset = ( i_pos - p_sys->i_header ) % p_sys->asfh.i_min_data_packet_size;
400
401     msg_Err( p_input, "seeking to "I64Fd, i_pos );
402
403     vlc_mutex_lock( &p_input->stream.stream_lock );
404
405     mmsh_stop( p_input, p_sys );
406     mmsh_start( p_input, p_sys, i_packet * p_sys->asfh.i_min_data_packet_size );
407
408     for( ;; )
409     {
410         if( mmsh_get_packet( p_input, p_sys, &ck ) )
411         {
412             break;
413         }
414
415         /* skip headers */
416         if( ck.i_type != 0x4824 )
417         {
418             break;
419         }
420         msg_Warn( p_input, "skipping header" );
421     }
422
423     p_sys->i_pos = i_pos;
424     p_sys->i_packet_used += i_offset;
425
426
427     p_input->stream.p_selected_area->i_tell = i_pos;
428     vlc_mutex_unlock( &p_input->stream.stream_lock );
429
430 }
431
432 /*****************************************************************************
433  * Read:
434  *****************************************************************************/
435 static ssize_t Read        ( input_thread_t * p_input, byte_t * p_buffer,
436                              size_t i_len )
437 {
438     access_sys_t *p_sys = p_input->p_access_data;
439     size_t       i_copy;
440     size_t       i_data = 0;
441
442     while( i_data < i_len )
443     {
444         if( p_sys->i_packet_used < p_sys->i_packet_length )
445         {
446             i_copy = __MIN( p_sys->i_packet_length - p_sys->i_packet_used, i_len - i_data );
447
448             memcpy( &p_buffer[i_data],
449                     &p_sys->p_packet[p_sys->i_packet_used],
450                     i_copy );
451
452             i_data += i_copy;
453             p_sys->i_packet_used += i_copy;
454         }
455         else if( p_sys->i_pos + i_data > p_sys->i_header &&
456                  (int)p_sys->i_packet_used < p_sys->asfh.i_min_data_packet_size )
457         {
458             i_copy = __MIN( p_sys->asfh.i_min_data_packet_size - p_sys->i_packet_used, i_len - i_data );
459
460             memset( &p_buffer[i_data], 0, i_copy );
461
462             i_data += i_copy;
463             p_sys->i_packet_used += i_copy;
464         }
465         else
466         {
467             chunk_t ck;
468             /* get a new packet */
469             /* fill enought data (>12) */
470             msg_Dbg( p_input, "waiting data (buffer = %d bytes", p_sys->i_buffer );
471
472             if( mmsh_get_packet( p_input, p_sys, &ck ) )
473             {
474                 return 0;
475             }
476
477             //fprintf( stderr, "type=0x%x size=%d sequence=%d unknown=%d size2=%d data=%d\n",
478             //         ck.i_type, ck.i_size, ck.i_sequence, ck.i_unknown, ck.i_size2, ck.i_data );
479         }
480     }
481
482     p_sys->i_pos += i_data;
483
484
485     return( i_data );
486 }
487
488
489 /****************************************************************************/
490 /****************************************************************************/
491 /****************************************************************************/
492 /****************************************************************************/
493 /****************************************************************************/
494
495 static int mmsh_start( input_thread_t *p_input, access_sys_t *p_sys, off_t i_pos )
496 {
497     uint8_t *p;
498     int i_streams = 0;
499     int i;
500     http_answer_t *p_ans;
501
502     msg_Dbg( p_input, "starting stream" );
503
504     p_sys->p_socket = NetOpenTCP( p_input, p_sys->p_url );
505
506     for( i = 1; i < 128; i++ )
507     {
508         if( p_sys->asfh.stream[i].i_selected )
509         {
510             i_streams++;
511         }
512     }
513
514     if( i_streams <= 0 )
515     {
516         msg_Err( p_input, "no stream selected" );
517         return VLC_EGENERIC;
518     }
519
520     p = &p_sys->buffer[0];
521     p += sprintf( p, "GET %s HTTP/1.0\r\n", p_sys->p_url->psz_path );
522     p += sprintf( p,"Accept: */*\r\n" );
523     p += sprintf( p, "User-Agent: NSPlayer/4.1.0.3856\r\n" );
524     p += sprintf( p, "Host: %s:%d\r\n", p_sys->p_url->psz_host, p_sys->p_url->i_port );
525     if( p_sys->b_broadcast )
526     {
527         p += sprintf( p, "Pragma: no-cache,rate=1.000000,request-context=%d\r\n", p_sys->i_request_context++ );
528     }
529     else
530     {
531         p += sprintf( p, "Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=%u:%u,request-context=%d,max-duration=0\r\n",
532                          (uint32_t)((i_pos >> 32)&0xffffffff), (uint32_t)(i_pos&0xffffffff), p_sys->i_request_context++ );
533     }
534     p += sprintf( p, "Pragma: xPlayStrm=1\r\n" );
535     //p += sprintf( p, "Pragma: xClientGUID={c77e7400-738a-11d2-9add-0020af0a3278}\r\n" );
536     p += sprintf( p, "Pragma: xClientGUID={"GUID_FMT"}\r\n", GUID_PRINT( p_sys->guid ) );
537     p += sprintf( p, "Pragma: stream-switch-count=%d\r\n", i_streams );
538     p += sprintf( p, "Pragma: stream-switch-entry=" );
539     for( i = 0; i < i_streams; i++ )
540     {
541         if( p_sys->asfh.stream[i].i_selected )
542         {
543             p += sprintf( p, "ffff:%d:0 ", p_sys->asfh.stream[i].i_id );
544         }
545         else
546         {
547             p += sprintf( p, "ffff:%d:2 ", p_sys->asfh.stream[i].i_id );
548         }
549     }
550     p += sprintf( p, "\r\n" );
551     p += sprintf( p, "Connection: Close\r\n\r\n" );
552
553
554     NetWrite( p_input, p_sys->p_socket, p_sys->buffer,  p - p_sys->buffer );
555
556     msg_Dbg( p_input, "filling buffer" );
557     /* we read until we found a \r\n\r\n or \n\n */
558     p_sys->i_buffer = 0;
559     p_sys->i_buffer_pos = 0;
560     for( ;; )
561     {
562         int     i_try = 0;
563         int     i_read;
564         uint8_t *p;
565
566         p = &p_sys->buffer[p_sys->i_buffer];
567         i_read =
568             NetRead( p_input, p_sys->p_socket,
569                      &p_sys->buffer[p_sys->i_buffer],
570                       1024 );
571
572         if( i_read == 0 )
573         {
574             if( i_try++ > 12 )
575             {
576                 break;
577             }
578             msg_Dbg( p_input, "another try (%d/12)", i_try );
579             continue;
580         }
581
582         if( i_read <= 0 || p_input->b_die || p_input->b_error )
583         {
584             break;
585         }
586         p_sys->i_buffer += i_read;
587         p_sys->buffer[p_sys->i_buffer] = '\0';
588
589         if( strstr( p, "\r\n\r\n" ) || strstr( p, "\n\n" ) )
590         {
591             msg_Dbg( p_input, "body found" );
592             break;
593         }
594         if( p_sys->i_buffer >= BUFFER_SIZE - 1024 )
595         {
596             msg_Dbg( p_input, "buffer size exeded" );
597             break;
598         }
599     }
600
601     p_ans = http_answer_parse( p_sys->buffer, p_sys->i_buffer );
602     if( !p_ans )
603     {
604         msg_Err( p_input, "cannot parse answer" );
605         return VLC_EGENERIC;
606     }
607
608     if( p_ans->i_error < 200 || p_ans->i_error >= 300 )
609     {
610         msg_Err( p_input, "error %d (server return=`%s')", p_ans->i_error, p_ans->psz_answer );
611         http_answer_free( p_ans );
612         return VLC_EGENERIC;
613     }
614
615     if( !p_ans->p_body )
616     {
617         p_sys->i_buffer_pos = 0;
618         p_sys->i_buffer = 0;
619     }
620     else
621     {
622         p_sys->i_buffer_pos = p_ans->p_body - p_sys->buffer;
623     }
624     http_answer_free( p_ans );
625
626     return VLC_SUCCESS;
627 }
628
629 static void mmsh_stop( input_thread_t *p_input, access_sys_t *p_sys )
630 {
631     msg_Dbg( p_input, "closing stream" );
632     NetClose( p_input, p_sys->p_socket );
633 }
634
635 static ssize_t NetFill( input_thread_t *p_input,
636                         access_sys_t   *p_sys, int i_size )
637 {
638     int i_try   = 0;
639     int i_total = 0;
640
641     i_size = __MIN( i_size, BUFFER_SIZE - p_sys->i_buffer );
642     if( i_size <= 0 )
643     {
644         return 0;
645     }
646     
647
648     for( ;; )
649     {
650         int i_read;
651
652         i_read =
653             NetRead( p_input, p_sys->p_socket, &p_sys->buffer[p_sys->i_buffer], i_size );
654
655         if( i_read == 0 )
656         {
657             if( i_try++ > 2 )
658             {
659                 break;
660             }
661             msg_Dbg( p_input, "another try %d/2", i_try );
662             continue;
663         }
664
665         if( i_read < 0 || p_input->b_die || p_input->b_error )
666         {
667             break;
668         }
669         i_total += i_read;
670
671         p_sys->i_buffer += i_read;
672         if( i_total >= i_size )
673         {
674             break;
675         }
676     }
677
678     p_sys->buffer[p_sys->i_buffer] = '\0';
679
680     return i_total;
681 }
682
683 /****************************************************************************
684  * NetOpenTCP:
685  ****************************************************************************/
686 static input_socket_t * NetOpenTCP( input_thread_t *p_input, url_t *p_url )
687 {
688     input_socket_t   *p_socket;
689     char             *psz_network;
690     module_t         *p_network;
691     network_socket_t socket_desc;
692
693
694     p_socket = malloc( sizeof( input_socket_t ) );
695     memset( p_socket, 0, sizeof( input_socket_t ) );
696
697     psz_network = "";
698     if( config_GetInt( p_input, "ipv4" ) )
699     {
700         psz_network = "ipv4";
701     }
702     else if( config_GetInt( p_input, "ipv6" ) )
703     {
704         psz_network = "ipv6";
705     }
706
707     msg_Dbg( p_input, "waiting for connection..." );
708
709     socket_desc.i_type = NETWORK_TCP;
710     socket_desc.psz_server_addr = p_url->psz_host;
711     socket_desc.i_server_port   = p_url->i_port;
712     socket_desc.psz_bind_addr   = "";
713     socket_desc.i_bind_port     = 0;
714     socket_desc.i_ttl           = 0;
715     p_input->p_private = (void*)&socket_desc;
716     if( !( p_network = module_Need( p_input, "network", psz_network ) ) )
717     {
718         msg_Err( p_input, "failed to connect with server" );
719         return NULL;
720     }
721     module_Unneed( p_input, p_network );
722     p_socket->i_handle = socket_desc.i_handle;
723     p_input->i_mtu     = socket_desc.i_mtu;
724
725     msg_Dbg( p_input,
726              "connection with \"%s:%d\" successful",
727              p_url->psz_host,
728              p_url->i_port );
729
730     return p_socket;
731 }
732
733 /*****************************************************************************
734  * Read: read on a file descriptor, checking b_die periodically
735  *****************************************************************************/
736 static ssize_t NetRead( input_thread_t *p_input,
737                         input_socket_t *p_socket,
738                         byte_t *p_buffer, size_t i_len )
739 {
740     struct timeval  timeout;
741     fd_set          fds;
742     ssize_t         i_recv;
743     int             i_ret;
744
745     /* Initialize file descriptor set */
746     FD_ZERO( &fds );
747     FD_SET( p_socket->i_handle, &fds );
748
749     /* We'll wait 1 second if nothing happens */
750     timeout.tv_sec  = 1;
751     timeout.tv_usec = 0;
752
753     /* Find if some data is available */
754     while( ( i_ret = select( p_socket->i_handle + 1, &fds,
755                              NULL, NULL, &timeout )) == 0 ||
756 #ifdef HAVE_ERRNO_H
757            ( i_ret < 0 && errno == EINTR )
758 #endif
759          )
760     {
761         FD_ZERO( &fds );
762         FD_SET( p_socket->i_handle, &fds );
763         timeout.tv_sec  = 1;
764         timeout.tv_usec = 0;
765
766         if( p_input->b_die || p_input->b_error )
767         {
768             return 0;
769         }
770     }
771
772     if( i_ret < 0 )
773     {
774         msg_Err( p_input, "network select error (%s)", strerror(errno) );
775         return -1;
776     }
777
778     i_recv = recv( p_socket->i_handle, p_buffer, i_len, 0 );
779
780     if( i_recv < 0 )
781     {
782         msg_Err( p_input, "recv failed (%s)", strerror(errno) );
783     }
784
785     return i_recv;
786 }
787
788 static ssize_t NetWrite( input_thread_t *p_input,
789                          input_socket_t *p_socket,
790                          byte_t *p_buffer, size_t i_len )
791 {
792     struct timeval  timeout;
793     fd_set          fds;
794     ssize_t         i_send;
795     int             i_ret;
796
797     /* Initialize file descriptor set */
798     FD_ZERO( &fds );
799     FD_SET( p_socket->i_handle, &fds );
800
801     /* We'll wait 1 second if nothing happens */
802     timeout.tv_sec  = 1;
803     timeout.tv_usec = 0;
804
805     /* Find if some data is available */
806     while( ( i_ret = select( p_socket->i_handle + 1, NULL, &fds, NULL, &timeout ) ) == 0 ||
807 #ifdef HAVE_ERRNO_H
808            ( i_ret < 0 && errno == EINTR )
809 #endif
810          )
811     {
812         FD_ZERO( &fds );
813         FD_SET( p_socket->i_handle, &fds );
814         timeout.tv_sec  = 1;
815         timeout.tv_usec = 0;
816
817         if( p_input->b_die || p_input->b_error )
818         {
819             return 0;
820         }
821     }
822
823     if( i_ret < 0 )
824     {
825         msg_Err( p_input, "network select error (%s)", strerror(errno) );
826         return -1;
827     }
828
829     i_send = send( p_socket->i_handle, p_buffer, i_len, 0 );
830
831     if( i_send < 0 )
832     {
833         msg_Err( p_input, "send failed (%s)", strerror(errno) );
834     }
835
836     return i_send;
837 }
838
839 static void NetClose( input_thread_t *p_input, input_socket_t *p_socket )
840 {
841 #if defined( WIN32 ) || defined( UNDER_CE )
842     closesocket( p_socket->i_handle );
843 #else
844     close( p_socket->i_handle );
845 #endif
846
847     free( p_socket );
848 }
849
850 static int http_next_line( uint8_t **pp_data, int *pi_data )
851 {
852     char *p, *p_end = *pp_data + *pi_data;
853
854     for( p = *pp_data; p < p_end; p++ )
855     {
856         if( p + 1 < p_end && *p == '\n' )
857         {
858             *pi_data = p_end - p - 1;
859             *pp_data = p + 1;
860             return VLC_SUCCESS;
861         }
862         if( p + 2 < p_end && p[0] == '\r' && p[1] == '\n' )
863         {
864             *pi_data = p_end - p - 2;
865             *pp_data = p + 2;
866             return VLC_SUCCESS;
867         }
868     }
869     *pi_data = 0;
870     *pp_data = p_end;
871     return VLC_EGENERIC;
872 }
873
874 static http_answer_t *http_answer_parse( uint8_t *p_data, int i_data )
875 {
876     http_answer_t *ans = malloc( sizeof( http_answer_t ) );
877     http_field_t  **pp_last;
878     char          buffer[1024];
879
880     if( sscanf( p_data, "HTTP/1.%d %d %s", &ans-> i_version, &ans->i_error, buffer ) < 3 )
881     {
882         free( ans );
883         return NULL;
884     }
885     ans->psz_answer = strdup( buffer );
886     fprintf( stderr, "version=%d error=%d answer=%s\n", ans-> i_version, ans->i_error, ans->psz_answer );
887     ans->p_fields = NULL;
888     ans->i_body   = 0;
889     ans->p_body   = 0;
890
891     pp_last = &ans->p_fields;
892
893     for( ;; )
894     {
895         http_field_t  *p_field;
896         uint8_t       *colon;
897
898         if( http_next_line( &p_data, &i_data ) )
899         {
900             return ans;
901         }
902         if( !strncmp( p_data, "\r\n", 2 ) || !strncmp( p_data, "\n", 1 ) )
903         {
904             break;
905         }
906
907         colon = strstr( p_data, ": " );
908         if( colon )
909         {
910             uint8_t *end;
911
912             end = strstr( colon, "\n" ) - 1;
913             if( *end != '\r' )
914             {
915                 end++;
916             }
917
918             p_field             = malloc( sizeof( http_field_t ) );
919             p_field->psz_name   = strndup( p_data, colon - p_data );
920             p_field->psz_value  = strndup( colon + 2, end - colon - 2 );
921             p_field->p_next     = NULL;
922
923             *pp_last = p_field;
924             pp_last = &p_field->p_next;
925
926             fprintf( stderr, "field name=`%s' value=`%s'\n", p_field->psz_name, p_field->psz_value );
927         }
928     }
929
930     if( http_next_line( &p_data, &i_data ) )
931     {
932         return ans;
933     }
934
935     ans->p_body = p_data;
936     ans->i_body = i_data;
937     fprintf( stderr, "body size=%d\n", i_data );
938
939     return ans;
940 }
941
942 static void http_answer_free( http_answer_t *ans )
943 {
944     http_field_t  *p_field = ans->p_fields;
945
946     while( p_field )
947     {
948         http_field_t *p_next;
949
950         p_next = p_field->p_next;
951         free( p_field->psz_name );
952         free( p_field->psz_value );
953         free( p_field );
954
955         p_field = p_next;
956     }
957
958     free( ans->psz_answer );
959     free( ans );
960 }
961
962 static http_field_t *http_field_find( http_field_t *p_field, char *psz_name )
963 {
964
965     while( p_field )
966     {
967         if( !strcasecmp( p_field->psz_name, psz_name ) )
968         {
969             return p_field;
970         }
971
972         p_field = p_field->p_next;
973     }
974
975     return NULL;
976 }
977 #if 0
978 static char *http_field_get_value( http_answer_t *ans, char *psz_name )
979 {
980     http_field_t  *p_field = ans->p_fields;
981
982     while( p_field )
983     {
984         if( !strcasecmp( p_field->psz_name, psz_name ) )
985         {
986             return p_field->psz_value;
987         }
988
989         p_field = p_field->p_next;
990     }
991
992     return NULL;
993 }
994 #endif
995
996
997 static int chunk_parse( chunk_t *ck, uint8_t *p_data, int i_data )
998 {
999     if( i_data < 12 )
1000     {
1001         return VLC_EGENERIC;
1002     }
1003
1004     ck->i_type      = GetWLE( p_data );
1005     ck->i_size      = GetWLE( p_data + 2);
1006     ck->i_sequence  = GetDWLE( p_data  + 4);
1007     ck->i_unknown   = GetWLE( p_data + 8);
1008     ck->i_size2     = GetWLE( p_data + 10);
1009
1010     ck->p_data      = p_data + 12;
1011     ck->i_data      = __MIN( i_data - 12, ck->i_size2 - 8 );
1012
1013 #if 0
1014     fprintf( stderr, "type=0x%x size=%d sequence=%d unknown=%d size2=%d data=%d\n",
1015              ck->i_type, ck->i_size, ck->i_sequence, ck->i_unknown, ck->i_size2, ck->i_data );
1016 #endif
1017     return VLC_SUCCESS;
1018 }
1019