414dfd4151d492d69d36f3b0d625ba9f5a8113f5
[vlc.git] / modules / access / mms / mmsh.c
1 /*****************************************************************************
2  * mmsh.c:
3  *****************************************************************************
4  * Copyright (C) 2001, 2002 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <vlc_common.h>
33 #include <vlc_access.h>
34 #include <vlc_strings.h>
35 #include <vlc_input.h>
36
37 #include <vlc_network.h>
38 #include <vlc_url.h>
39 #include "asf.h"
40 #include "buffer.h"
41
42 #include "mms.h"
43 #include "mmsh.h"
44
45 /* TODO:
46  *  - authentication
47  */
48
49 /*****************************************************************************
50  * Local prototypes
51  *****************************************************************************/
52 int  MMSHOpen  ( access_t * );
53 void MMSHClose ( access_t * );
54
55 static block_t *Block( access_t *p_access );
56 static ssize_t ReadRedirect( access_t *, uint8_t *, size_t );
57 static int  Seek( access_t *, uint64_t );
58 static int  Control( access_t *, int, va_list );
59
60 static int  Describe( access_t  *, char **ppsz_location );
61 static int  Start( access_t *, uint64_t );
62 static void Stop( access_t * );
63
64 static int  GetPacket( access_t *, chunk_t * );
65 static void GetHeader( access_t *p_access, int i_content_length );
66
67 static int Restart( access_t * );
68 static int Reset( access_t * );
69
70 //#define MMSH_USER_AGENT "NSPlayer/4.1.0.3856"
71 #define MMSH_USER_AGENT "NSPlayer/7.10.0.3059"
72
73 /****************************************************************************
74  * Open: connect to ftp server and ask for file
75  ****************************************************************************/
76 int MMSHOpen( access_t *p_access )
77 {
78     access_sys_t    *p_sys;
79     char            *psz_location = NULL;
80     char            *psz_proxy;
81
82     STANDARD_BLOCK_ACCESS_INIT
83
84     p_sys->i_proto= MMS_PROTO_HTTP;
85     p_sys->fd     = -1;
86
87     /* Handle proxy */
88     p_sys->b_proxy = false;
89     memset( &p_sys->proxy, 0, sizeof(p_sys->proxy) );
90
91     /* Check proxy */
92     /* TODO reuse instead http-proxy from http access ? */
93     psz_proxy = var_CreateGetNonEmptyString( p_access, "mmsh-proxy" );
94     if( !psz_proxy )
95     {
96         char *psz_http_proxy = var_InheritString( p_access, "http-proxy" );
97         if( psz_http_proxy )
98         {
99             psz_proxy = psz_http_proxy;
100             var_SetString( p_access, "mmsh-proxy", psz_proxy );
101         }
102     }
103
104     if( psz_proxy )
105     {
106         p_sys->b_proxy = true;
107         vlc_UrlParse( &p_sys->proxy, psz_proxy, 0 );
108         free( psz_proxy );
109     }
110     else
111     {
112         const char *http_proxy = getenv( "http_proxy" );
113         if( http_proxy )
114         {
115             p_sys->b_proxy = true;
116             vlc_UrlParse( &p_sys->proxy, http_proxy, 0 );
117         }
118     }
119
120     if( p_sys->b_proxy )
121     {
122         if( ( p_sys->proxy.psz_host == NULL ) ||
123             ( *p_sys->proxy.psz_host == '\0' ) )
124         {
125             msg_Warn( p_access, "invalid proxy host" );
126             vlc_UrlClean( &p_sys->proxy );
127             free( p_sys );
128             return VLC_EGENERIC;
129         }
130
131         if( p_sys->proxy.i_port <= 0 )
132             p_sys->proxy.i_port = 80;
133         msg_Dbg( p_access, "Using http proxy %s:%d",
134                  p_sys->proxy.psz_host, p_sys->proxy.i_port );
135     }
136
137     /* open a tcp connection */
138     vlc_UrlParse( &p_sys->url, p_access->psz_location, 0 );
139     if( ( p_sys->url.psz_host == NULL ) ||
140         ( *p_sys->url.psz_host == '\0' ) )
141     {
142         msg_Err( p_access, "invalid host" );
143         goto error;
144     }
145     if( p_sys->url.i_port <= 0 )
146         p_sys->url.i_port = 80;
147
148     if( Describe( p_access, &psz_location ) )
149         goto error;
150
151     /* Handle redirection */
152     if( psz_location && *psz_location )
153     {
154         msg_Dbg( p_access, "redirection to %s", psz_location );
155
156         input_thread_t * p_input = access_GetParentInput( p_access );
157         input_item_t * p_new_loc;
158
159         if( !p_input )
160         {
161             free( psz_location );
162             goto error;
163         }
164         /** \bug we do not autodelete here */
165         p_new_loc = input_item_New( psz_location, psz_location );
166         input_item_t *p_item = input_GetItem( p_input );
167         input_item_PostSubItem( p_item, p_new_loc );
168
169         vlc_gc_decref( p_new_loc );
170         vlc_object_release( p_input );
171
172         free( psz_location );
173
174         p_access->pf_block = NULL;
175         p_access->pf_read = ReadRedirect;
176         return VLC_SUCCESS;
177     }
178     free( psz_location );
179
180     /* Start playing */
181     if( Start( p_access, 0 ) )
182     {
183         msg_Err( p_access, "cannot start stream" );
184         free( p_sys->p_header );
185         goto error;
186     }
187
188     return VLC_SUCCESS;
189
190 error:
191     vlc_UrlClean( &p_sys->proxy );
192     vlc_UrlClean( &p_sys->url );
193     free( p_sys );
194     return VLC_EGENERIC;
195 }
196
197 /*****************************************************************************
198  * Close: free unused data structures
199  *****************************************************************************/
200 void  MMSHClose ( access_t *p_access )
201 {
202     access_sys_t *p_sys = p_access->p_sys;
203
204     Stop( p_access );
205
206     free( p_sys->p_header );
207
208     vlc_UrlClean( &p_sys->proxy );
209     vlc_UrlClean( &p_sys->url );
210     free( p_sys );
211 }
212
213 /*****************************************************************************
214  * Control:
215  *****************************************************************************/
216 static int Control( access_t *p_access, int i_query, va_list args )
217 {
218     access_sys_t *p_sys = p_access->p_sys;
219     bool   *pb_bool;
220     bool    b_bool;
221     int64_t      *pi_64;
222     int          i_int;
223
224     switch( i_query )
225     {
226         case ACCESS_CAN_SEEK:
227             pb_bool = (bool*)va_arg( args, bool* );
228             *pb_bool = !p_sys->b_broadcast;
229             break;
230
231         case ACCESS_CAN_FASTSEEK:
232             pb_bool = (bool*)va_arg( args, bool* );
233             *pb_bool = false;
234             break;
235
236         case ACCESS_CAN_PAUSE:
237         case ACCESS_CAN_CONTROL_PACE:
238             pb_bool = (bool*)va_arg( args, bool* );
239             *pb_bool = true;
240             break;
241
242         case ACCESS_GET_SIZE:
243         {
244             uint64_t *s = va_arg( args, uint64_t * );
245             *s = p_sys->b_broadcast ? 0 : p_sys->asfh.i_file_size;
246             return VLC_SUCCESS;
247         }
248
249         case ACCESS_GET_PTS_DELAY:
250             pi_64 = (int64_t*)va_arg( args, int64_t * );
251             *pi_64 = INT64_C(1000)
252                    * var_InheritInteger( p_access, "network-caching" );
253             break;
254
255         case ACCESS_GET_PRIVATE_ID_STATE:
256             i_int = (int)va_arg( args, int );
257             pb_bool = (bool *)va_arg( args, bool * );
258
259             if( (i_int < 0) || (i_int > 127) )
260                 return VLC_EGENERIC;
261             *pb_bool =  p_sys->asfh.stream[i_int].i_selected ? true : false;
262             break;
263
264         case ACCESS_SET_PRIVATE_ID_STATE:
265             i_int = (int)va_arg( args, int );
266             b_bool = (bool)va_arg( args, int );
267             if( (i_int < 0) || (i_int > 127) )
268                 return VLC_EGENERIC;
269             else
270             {
271                 int i_cat = p_sys->asfh.stream[i_int].i_cat;
272                 for ( int i=0; i< 128; i++ )
273                 {
274                     /* First unselect all streams from the same cat */
275                     if ( i_cat == p_sys->asfh.stream[i].i_cat )
276                         p_sys->asfh.stream[i].i_selected = false;
277                 }
278                 p_sys->asfh.stream[i_int].i_selected = true;
279                 Stop( p_access );
280                 Seek( p_access, p_access->info.i_pos );
281                 return VLC_SUCCESS;
282             }
283
284         case ACCESS_SET_PAUSE_STATE:
285             b_bool = (bool)va_arg( args, int );
286             if( b_bool )
287                 Stop( p_access );
288             else
289                 Seek( p_access, p_access->info.i_pos );
290             break;
291
292         default:
293             return VLC_EGENERIC;
294     }
295     return VLC_SUCCESS;
296 }
297
298 /*****************************************************************************
299  * Seek: try to go at the right place
300  *****************************************************************************/
301 static int Seek( access_t *p_access, uint64_t i_pos )
302 {
303     access_sys_t *p_sys = p_access->p_sys;
304     chunk_t      ck;
305     uint64_t     i_offset;
306     uint64_t     i_packet;
307
308     msg_Dbg( p_access, "seeking to %"PRId64, i_pos );
309
310     i_packet = ( i_pos - p_sys->i_header ) / p_sys->asfh.i_min_data_packet_size;
311     i_offset = ( i_pos - p_sys->i_header ) % p_sys->asfh.i_min_data_packet_size;
312
313     Stop( p_access );
314     Start( p_access, i_packet * p_sys->asfh.i_min_data_packet_size );
315
316     while( vlc_object_alive (p_access) )
317     {
318         if( GetPacket( p_access, &ck ) )
319             break;
320
321         /* skip headers */
322         if( ck.i_type != 0x4824 )
323             break;
324
325         msg_Warn( p_access, "skipping header" );
326     }
327
328     p_access->info.i_pos = i_pos;
329     p_access->info.b_eof = false;
330     p_sys->i_packet_used += i_offset;
331
332     return VLC_SUCCESS;
333 }
334
335 /*****************************************************************************
336  * ReadRedirect:
337  *****************************************************************************/
338 static ssize_t ReadRedirect( access_t *p_access, uint8_t *p, size_t i_len )
339 {
340     VLC_UNUSED(p_access); VLC_UNUSED(p); VLC_UNUSED(i_len);
341     return 0;
342 }
343
344 /*****************************************************************************
345  * Block:
346  *****************************************************************************/
347 static block_t *Block( access_t *p_access )
348 {
349     access_sys_t *p_sys = p_access->p_sys;
350     const unsigned i_packet_min = p_sys->asfh.i_min_data_packet_size;
351
352     if( p_access->info.i_pos < p_sys->i_start + p_sys->i_header )
353     {
354         const size_t i_offset = p_access->info.i_pos - p_sys->i_start;
355         const size_t i_copy = p_sys->i_header - i_offset;
356
357         block_t *p_block = block_Alloc( i_copy );
358         if( !p_block )
359             return NULL;
360
361         memcpy( p_block->p_buffer, &p_sys->p_header[i_offset], i_copy );
362         p_access->info.i_pos += i_copy;
363         return p_block;
364     }
365     else if( p_sys->i_packet_length > 0 &&
366              p_sys->i_packet_used < __MAX( p_sys->i_packet_length, i_packet_min ) )
367     {
368         size_t i_copy = 0;
369         size_t i_padding = 0;
370
371         if( p_sys->i_packet_used < p_sys->i_packet_length )
372             i_copy = p_sys->i_packet_length - p_sys->i_packet_used;
373         if( __MAX( p_sys->i_packet_used, p_sys->i_packet_length ) < i_packet_min )
374             i_padding = i_packet_min - __MAX( p_sys->i_packet_used, p_sys->i_packet_length );
375
376         block_t *p_block = block_Alloc( i_copy + i_padding );
377         if( !p_block )
378             return NULL;
379
380         if( i_copy > 0 )
381             memcpy( &p_block->p_buffer[0], &p_sys->p_packet[p_sys->i_packet_used], i_copy );
382         if( i_padding > 0 )
383             memset( &p_block->p_buffer[i_copy], 0, i_padding );
384
385         p_sys->i_packet_used += i_copy + i_padding;
386         p_access->info.i_pos += i_copy + i_padding;
387         return p_block;
388
389     }
390
391     chunk_t ck;
392     if( GetPacket( p_access, &ck ) )
393     {
394         int i_ret = -1;
395         if( p_sys->b_broadcast )
396         {
397             if( (ck.i_type == 0x4524) && (ck.i_sequence != 0) )
398                 i_ret = Restart( p_access );
399             else if( ck.i_type == 0x4324 )
400                 i_ret = Reset( p_access );
401         }
402         if( i_ret )
403         {
404             p_access->info.b_eof = true;
405             return 0;
406         }
407     }
408     if( ck.i_type != 0x4424 )
409     {
410         p_sys->i_packet_used = 0;
411         p_sys->i_packet_length = 0;
412     }
413
414     return NULL;
415 }
416
417 /* */
418 static int Restart( access_t *p_access )
419 {
420     access_sys_t *p_sys = p_access->p_sys;
421     char *psz_location = NULL;
422
423     msg_Dbg( p_access, "Restart the stream" );
424     p_sys->i_start = p_access->info.i_pos;
425
426     /* */
427     msg_Dbg( p_access, "stoping the stream" );
428     Stop( p_access );
429
430     /* */
431     msg_Dbg( p_access, "describe the stream" );
432     if( Describe( p_access, &psz_location ) )
433     {
434         msg_Err( p_access, "describe failed" );
435         return VLC_EGENERIC;
436     }
437     free( psz_location );
438
439     /* */
440     if( Start( p_access, 0 ) )
441     {
442         msg_Err( p_access, "Start failed" );
443         return VLC_EGENERIC;
444     }
445     return VLC_SUCCESS;
446 }
447 static int Reset( access_t *p_access )
448 {
449     access_sys_t *p_sys = p_access->p_sys;
450     asf_header_t old_asfh = p_sys->asfh;
451     int i;
452
453     msg_Dbg( p_access, "Reset the stream" );
454     p_sys->i_start = p_access->info.i_pos;
455
456     /* */
457     p_sys->i_packet_sequence = 0;
458     p_sys->i_packet_used = 0;
459     p_sys->i_packet_length = 0;
460     p_sys->p_packet = NULL;
461
462     /* Get the next header FIXME memory loss ? */
463     GetHeader( p_access, -1 );
464     if( p_sys->i_header <= 0 )
465         return VLC_EGENERIC;
466
467     asf_HeaderParse ( &p_sys->asfh,
468                        p_sys->p_header, p_sys->i_header );
469     msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
470              p_sys->asfh.i_data_packets_count,
471              p_sys->asfh.i_min_data_packet_size );
472
473     asf_StreamSelect( &p_sys->asfh,
474                        var_InheritInteger( p_access, "mms-maxbitrate" ),
475                        var_InheritBool( p_access, "mms-all" ),
476                        var_InheritBool( p_access, "audio" ),
477                        var_InheritBool( p_access, "video" ) );
478
479     /* Check we have comptible asfh */
480     for( i = 1; i < 128; i++ )
481     {
482         asf_stream_t *p_old = &old_asfh.stream[i];
483         asf_stream_t *p_new = &p_sys->asfh.stream[i];
484
485         if( p_old->i_cat != p_new->i_cat || p_old->i_selected != p_new->i_selected )
486             break;
487     }
488     if( i < 128 )
489     {
490         msg_Warn( p_access, "incompatible asf header, restart" );
491         return Restart( p_access );
492     }
493
494     /* */
495     p_sys->i_packet_used = 0;
496     p_sys->i_packet_length = 0;
497     return VLC_SUCCESS;
498 }
499
500 static int OpenConnection( access_t *p_access )
501 {
502     access_sys_t *p_sys = p_access->p_sys;
503     vlc_url_t    srv = p_sys->b_proxy ? p_sys->proxy : p_sys->url;
504
505     if( ( p_sys->fd = net_ConnectTCP( p_access,
506                                       srv.psz_host, srv.i_port ) ) < 0 )
507     {
508         msg_Err( p_access, "cannot connect to %s:%d",
509                  srv.psz_host, srv.i_port );
510         return VLC_EGENERIC;
511     }
512
513     if( p_sys->b_proxy )
514     {
515         net_Printf( p_access, p_sys->fd, NULL,
516                     "GET http://%s:%d%s HTTP/1.0\r\n",
517                     p_sys->url.psz_host, p_sys->url.i_port,
518                     ( (p_sys->url.psz_path == NULL) ||
519                       (*p_sys->url.psz_path == '\0') ) ?
520                          "/" : p_sys->url.psz_path );
521
522         /* Proxy Authentication */
523         if( p_sys->proxy.psz_username && *p_sys->proxy.psz_username )
524         {
525             char *buf;
526             char *b64;
527
528             if( asprintf( &buf, "%s:%s", p_sys->proxy.psz_username,
529                        p_sys->proxy.psz_password ? p_sys->proxy.psz_password : "" ) == -1 )
530                 return VLC_ENOMEM;
531
532             b64 = vlc_b64_encode( buf );
533             free( buf );
534
535             net_Printf( p_access, p_sys->fd, NULL,
536                         "Proxy-Authorization: Basic %s\r\n", b64 );
537             free( b64 );
538         }
539     }
540     else
541     {
542         net_Printf( p_access, p_sys->fd, NULL,
543                     "GET %s HTTP/1.0\r\n"
544                     "Host: %s:%d\r\n",
545                     ( (p_sys->url.psz_path == NULL) ||
546                       (*p_sys->url.psz_path == '\0') ) ?
547                             "/" : p_sys->url.psz_path,
548                     p_sys->url.psz_host, p_sys->url.i_port );
549     }
550     return VLC_SUCCESS;
551 }
552
553 /*****************************************************************************
554  * Describe:
555  *****************************************************************************/
556 static int Describe( access_t  *p_access, char **ppsz_location )
557 {
558     access_sys_t *p_sys = p_access->p_sys;
559     char         *psz_location = NULL;
560     int          i_content_length = -1;
561     bool         b_keepalive = false;
562     char         *psz;
563     int          i_code;
564
565     /* Reinit context */
566     p_sys->b_broadcast = true;
567     p_sys->i_request_context = 1;
568     p_sys->i_packet_sequence = 0;
569     p_sys->i_packet_used = 0;
570     p_sys->i_packet_length = 0;
571     p_sys->p_packet = NULL;
572
573     GenerateGuid ( &p_sys->guid );
574
575     if( OpenConnection( p_access ) )
576         return VLC_EGENERIC;
577
578     net_Printf( p_access, p_sys->fd, NULL,
579                 "Accept: */*\r\n"
580                 "User-Agent: "MMSH_USER_AGENT"\r\n"
581                 "Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=0:0,request-context=%d,max-duration=0\r\n"
582                 "Pragma: xClientGUID={"GUID_FMT"}\r\n"
583                 "Connection: Close\r\n",
584                 p_sys->i_request_context++,
585                 GUID_PRINT( p_sys->guid ) );
586
587     if( net_Printf( p_access, p_sys->fd, NULL, "\r\n" ) < 0 )
588     {
589         msg_Err( p_access, "failed to send request" );
590         goto error;
591     }
592
593     /* Receive the http header */
594     if( ( psz = net_Gets( p_access, p_sys->fd, NULL ) ) == NULL )
595     {
596         msg_Err( p_access, "failed to read answer" );
597         goto error;
598     }
599
600     if( strncmp( psz, "HTTP/1.", 7 ) )
601     {
602         msg_Err( p_access, "invalid HTTP reply '%s'", psz );
603         free( psz );
604         goto error;
605     }
606     i_code = atoi( &psz[9] );
607     if( i_code >= 400 )
608     {
609         msg_Err( p_access, "error: %s", psz );
610         free( psz );
611         goto error;
612     }
613
614     msg_Dbg( p_access, "HTTP reply '%s'", psz );
615     free( psz );
616     for( ;; )
617     {
618         char *psz = net_Gets( p_access, p_sys->fd, NULL );
619         char *p;
620
621         if( psz == NULL )
622         {
623             msg_Err( p_access, "failed to read answer" );
624             goto error;
625         }
626
627         if( *psz == '\0' )
628         {
629             free( psz );
630             break;
631         }
632
633         if( ( p = strchr( psz, ':' ) ) == NULL )
634         {
635             msg_Err( p_access, "malformed header line: %s", psz );
636             free( psz );
637             goto error;
638         }
639         *p++ = '\0';
640         while( *p == ' ' ) p++;
641
642         /* FIXME FIXME test Content-Type to see if it's a plain stream or an
643          * asx FIXME */
644         if( !strcasecmp( psz, "Pragma" ) )
645         {
646             if( strstr( p, "features" ) )
647             {
648                 /* FIXME, it is a bit badly done here ..... */
649                 if( strstr( p, "broadcast" ) )
650                 {
651                     msg_Dbg( p_access, "stream type = broadcast" );
652                     p_sys->b_broadcast = true;
653                 }
654                 else if( strstr( p, "seekable" ) )
655                 {
656                     msg_Dbg( p_access, "stream type = seekable" );
657                     p_sys->b_broadcast = false;
658                 }
659                 else
660                 {
661                     msg_Warn( p_access, "unknow stream types (%s)", p );
662                     p_sys->b_broadcast = false;
663                 }
664             }
665         }
666         else if( !strcasecmp( psz, "Location" ) )
667         {
668             psz_location = strdup( p );
669         }
670         else if( !strcasecmp( psz, "Content-Length" ) )
671         {
672             i_content_length = atoi( p );
673             msg_Dbg( p_access, "content-length = %d", i_content_length );
674         }
675         else if( !strcasecmp( psz, "Connection" ) )
676         {
677             if( strcasestr( p, "Keep-Alive" ) )
678             {
679                 msg_Dbg( p_access, "Keep-Alive header found" );
680                 b_keepalive = true;
681             }
682         }
683
684
685         free( psz );
686     }
687
688     /* Handle the redirection */
689     if( ( (i_code == 301) || (i_code == 302) ||
690           (i_code == 303) || (i_code == 307) ) &&
691         psz_location && *psz_location )
692     {
693         msg_Dbg( p_access, "redirection to %s", psz_location );
694         net_Close( p_sys->fd ); p_sys->fd = -1;
695
696         *ppsz_location = psz_location;
697         return VLC_SUCCESS;
698     }
699     free( psz_location );
700
701     /* Read the asf header */
702     GetHeader( p_access, b_keepalive ? i_content_length : -1);
703     if( p_sys->i_header <= 0 )
704     {
705         msg_Err( p_access, "header size == 0" );
706         goto error;
707     }
708     /* close this connection */
709     net_Close( p_sys->fd );
710     p_sys->fd = -1;
711
712     /* *** parse header and get stream and their id *** */
713     /* get all streams properties,
714      *
715      * TODO : stream bitrates properties(optional)
716      *        and bitrate mutual exclusion(optional) */
717     asf_HeaderParse ( &p_sys->asfh,
718                        p_sys->p_header, p_sys->i_header );
719     msg_Dbg( p_access, "packet count=%"PRId64" packet size=%d",
720              p_sys->asfh.i_data_packets_count,
721              p_sys->asfh.i_min_data_packet_size );
722
723     if( p_sys->asfh.i_min_data_packet_size <= 0 )
724         goto error;
725
726     asf_StreamSelect( &p_sys->asfh,
727                        var_InheritInteger( p_access, "mms-maxbitrate" ),
728                        var_InheritBool( p_access, "mms-all" ),
729                        var_InheritBool( p_access, "audio" ),
730                        var_InheritBool( p_access, "video" ) );
731     return VLC_SUCCESS;
732
733 error:
734     if( p_sys->fd > 0 )
735     {
736         net_Close( p_sys->fd  );
737         p_sys->fd = -1;
738     }
739     return VLC_EGENERIC;
740 }
741
742 static void GetHeader( access_t *p_access, int i_content_length )
743 {
744     access_sys_t *p_sys = p_access->p_sys;
745     int i_read_content = 0;
746
747     /* Read the asf header */
748     p_sys->i_header = 0;
749     free( p_sys->p_header  );
750     p_sys->p_header = NULL;
751     for( ;; )
752     {
753         chunk_t ck;
754         if( (i_content_length >= 0 && i_read_content >= i_content_length) || GetPacket( p_access, &ck ) || ck.i_type != 0x4824 )
755             break;
756
757         i_read_content += (4+ck.i_size);
758
759         if( ck.i_data > 0 )
760         {
761             p_sys->i_header += ck.i_data;
762             p_sys->p_header = xrealloc( p_sys->p_header, p_sys->i_header );
763             memcpy( &p_sys->p_header[p_sys->i_header - ck.i_data],
764                     ck.p_data, ck.i_data );
765         }
766     }
767     msg_Dbg( p_access, "complete header size=%d", p_sys->i_header );
768 }
769
770
771 /*****************************************************************************
772  * Start stream
773  ****************************************************************************/
774 static int Start( access_t *p_access, uint64_t i_pos )
775 {
776     access_sys_t *p_sys = p_access->p_sys;
777     int  i_streams = 0;
778     int  i_streams_selected = 0;
779     int  i;
780     char *psz = NULL;
781
782     msg_Dbg( p_access, "starting stream" );
783
784     for( i = 1; i < 128; i++ )
785     {
786         if( p_sys->asfh.stream[i].i_cat == ASF_CODEC_TYPE_UNKNOWN )
787             continue;
788         i_streams++;
789         if( p_sys->asfh.stream[i].i_selected )
790             i_streams_selected++;
791     }
792     if( i_streams_selected <= 0 )
793     {
794         msg_Err( p_access, "no stream selected" );
795         return VLC_EGENERIC;
796     }
797
798     if( OpenConnection( p_access ) )
799         return VLC_EGENERIC;
800
801     net_Printf( p_access, p_sys->fd, NULL,
802                 "Accept: */*\r\n"
803                 "User-Agent: "MMSH_USER_AGENT"\r\n" );
804     if( p_sys->b_broadcast )
805     {
806         net_Printf( p_access, p_sys->fd, NULL,
807                     "Pragma: no-cache,rate=1.000000,request-context=%d\r\n",
808                     p_sys->i_request_context++ );
809     }
810     else
811     {
812         net_Printf( p_access, p_sys->fd, NULL,
813                     "Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=%u:%u,request-context=%d,max-duration=0\r\n",
814                     (uint32_t)((i_pos >> 32)&0xffffffff),
815                     (uint32_t)(i_pos&0xffffffff),
816                     p_sys->i_request_context++ );
817     }
818     net_Printf( p_access, p_sys->fd, NULL,
819                 "Pragma: xPlayStrm=1\r\n"
820                 "Pragma: xClientGUID={"GUID_FMT"}\r\n"
821                 "Pragma: stream-switch-count=%d\r\n"
822                 "Pragma: stream-switch-entry=",
823                 GUID_PRINT( p_sys->guid ),
824                 i_streams);
825
826     for( i = 1; i < 128; i++ )
827     {
828         if( p_sys->asfh.stream[i].i_cat != ASF_CODEC_TYPE_UNKNOWN )
829         {
830             int i_select = 2;
831             if( p_sys->asfh.stream[i].i_selected )
832             {
833                 i_select = 0;
834             }
835             net_Printf( p_access, p_sys->fd, NULL,
836                         "ffff:%x:%d ", i, i_select );
837         }
838     }
839     net_Printf( p_access, p_sys->fd, NULL, "\r\n" );
840     net_Printf( p_access, p_sys->fd, NULL,
841                 "Connection: Close\r\n" );
842
843     if( net_Printf( p_access, p_sys->fd, NULL, "\r\n" ) < 0 )
844     {
845         msg_Err( p_access, "failed to send request" );
846         return VLC_EGENERIC;
847     }
848
849     psz = net_Gets( p_access, p_sys->fd, NULL );
850     if( psz == NULL )
851     {
852         msg_Err( p_access, "cannot read data 0" );
853         return VLC_EGENERIC;
854     }
855
856     if( atoi( &psz[9] ) >= 400 )
857     {
858         msg_Err( p_access, "error: %s", psz );
859         free( psz );
860         return VLC_EGENERIC;
861     }
862     msg_Dbg( p_access, "HTTP reply '%s'", psz );
863     free( psz );
864
865     /* FIXME check HTTP code */
866     for( ;; )
867     {
868         char *psz = net_Gets( p_access, p_sys->fd, NULL );
869         if( psz == NULL )
870         {
871             msg_Err( p_access, "cannot read data 1" );
872             return VLC_EGENERIC;
873         }
874         if( *psz == '\0' )
875         {
876             free( psz );
877             break;
878         }
879         msg_Dbg( p_access, "%s", psz );
880         free( psz );
881     }
882
883     p_sys->i_packet_used   = 0;
884     p_sys->i_packet_length = 0;
885
886     return VLC_SUCCESS;
887 }
888
889 /*****************************************************************************
890  * closing stream
891  *****************************************************************************/
892 static void Stop( access_t *p_access )
893 {
894     access_sys_t *p_sys = p_access->p_sys;
895
896     msg_Dbg( p_access, "closing stream" );
897     if( p_sys->fd > 0 )
898     {
899         net_Close( p_sys->fd );
900         p_sys->fd = -1;
901     }
902 }
903
904 /*****************************************************************************
905  * get packet
906  *****************************************************************************/
907 static int GetPacket( access_t * p_access, chunk_t *p_ck )
908 {
909     access_sys_t *p_sys = p_access->p_sys;
910     int restsize;
911
912     /* chunk_t */
913     memset( p_ck, 0, sizeof( chunk_t ) );
914
915     /* Read the chunk header */
916     /* Some headers are short, like 0x4324. Reading 12 bytes will cause us
917      * to lose synchronization with the stream. Just read to the length
918      * (4 bytes), decode and then read up to 8 additional bytes to get the
919      * entire header.
920      */
921     if( net_Read( p_access, p_sys->fd, NULL, p_sys->buffer, 4, true ) < 4 )
922     {
923        msg_Err( p_access, "cannot read data 2" );
924        return VLC_EGENERIC;
925     }
926
927     p_ck->i_type = GetWLE( p_sys->buffer);
928     p_ck->i_size = GetWLE( p_sys->buffer + 2);
929
930     restsize = p_ck->i_size;
931     if( restsize > 8 )
932         restsize = 8;
933
934     if( net_Read( p_access, p_sys->fd, NULL, p_sys->buffer + 4, restsize, true ) < restsize )
935     {
936         msg_Err( p_access, "cannot read data 3" );
937         return VLC_EGENERIC;
938     }
939     p_ck->i_sequence  = GetDWLE( p_sys->buffer + 4);
940     p_ck->i_unknown   = GetWLE( p_sys->buffer + 8);
941
942     /* Set i_size2 to 8 if this header was short, since a real value won't be
943      * present in the buffer. Using 8 avoid reading additional data for the
944      * packet.
945      */
946     if( restsize < 8 )
947         p_ck->i_size2 = 8;
948     else
949         p_ck->i_size2 = GetWLE( p_sys->buffer + 10);
950
951     p_ck->p_data      = p_sys->buffer + 12;
952     p_ck->i_data      = p_ck->i_size2 - 8;
953
954     if( p_ck->i_type == 0x4524 )   // $E (End-of-Stream Notification) Packet
955     {
956         if( p_ck->i_sequence == 0 )
957         {
958             msg_Warn( p_access, "EOF" );
959             return VLC_EGENERIC;
960         }
961         else
962         {
963             msg_Warn( p_access, "next stream following" );
964             return VLC_EGENERIC;
965         }
966     }
967     else if( p_ck->i_type == 0x4324 ) // $C (Stream Change Notification) Packet
968     {
969         /* 0x4324 is CHUNK_TYPE_RESET: a new stream will follow with a sequence of 0 */
970         msg_Warn( p_access, "next stream following (reset) seq=%d", p_ck->i_sequence  );
971         return VLC_EGENERIC;
972     }
973     else if( (p_ck->i_type != 0x4824) && (p_ck->i_type != 0x4424) )
974     {
975         /* Unsupported so far:
976          * $M (Metadata) Packet               0x4D24
977          * $P (Packet-Pair) Packet            0x5024
978          * $T (Test Data Notification) Packet 0x5424
979          */
980         msg_Err( p_access, "unrecognized chunk FATAL (0x%x)", p_ck->i_type );
981         return VLC_EGENERIC;
982     }
983
984     if( (p_ck->i_data > 0) &&
985         (net_Read( p_access, p_sys->fd, NULL, &p_sys->buffer[12],
986                    p_ck->i_data, true ) < p_ck->i_data) )
987     {
988         msg_Err( p_access, "cannot read data 4" );
989         return VLC_EGENERIC;
990     }
991
992 #if 0
993     if( (p_sys->i_packet_sequence != 0) &&
994         (p_ck->i_sequence != p_sys->i_packet_sequence) )
995     {
996         msg_Warn( p_access, "packet lost ? (%d != %d)", p_ck->i_sequence, p_sys->i_packet_sequence );
997     }
998 #endif
999
1000     p_sys->i_packet_sequence = p_ck->i_sequence + 1;
1001     p_sys->i_packet_used   = 0;
1002     p_sys->i_packet_length = p_ck->i_data;
1003     p_sys->p_packet        = p_ck->p_data;
1004
1005     return VLC_SUCCESS;
1006 }