* mms/* : converted to access2. It should be reworked to use pf_block, but
[vlc.git] / modules / access / mms / mmstu.c
1 /*****************************************************************************
2  * mms.c: MMS access plug-in
3  *****************************************************************************
4  * Copyright (C) 2001, 2002 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
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 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <stdlib.h>
29 #include <sys/time.h>
30 #include <sys/types.h>
31 #include <sys/stat.h>
32 #include <string.h>
33 #include <errno.h>
34 #include <fcntl.h>
35
36 #include <vlc/vlc.h>
37 #include <vlc/input.h>
38
39 #ifdef HAVE_UNISTD_H
40 #   include <unistd.h>
41 #endif
42
43 #ifdef WIN32
44 #   include <winsock2.h>
45 #   include <ws2tcpip.h>
46 #   ifndef IN_MULTICAST
47 #       define IN_MULTICAST(a) IN_CLASSD(a)
48 #   endif
49 #else
50 #   include <sys/socket.h>
51 #   include <netinet/in.h>
52 #   if HAVE_ARPA_INET_H
53 #      include <arpa/inet.h>
54 #   elif defined( SYS_BEOS )
55 #      include <net/netdb.h>
56 #   endif
57 #endif
58
59 #include "network.h"
60 #include "asf.h"
61 #include "buffer.h"
62
63 #include "mms.h"
64 #include "mmstu.h"
65
66 #undef MMS_DEBUG
67
68 /****************************************************************************
69  * NOTES:
70  *  MMSProtocole documentation found at http://get.to/sdp
71  ****************************************************************************/
72
73 /*****************************************************************************
74  * Local prototypes
75  *****************************************************************************/
76 int  E_( MMSTUOpen )  ( access_t * );
77 void E_( MMSTUClose ) ( access_t * );
78
79
80 static int Read( access_t *, uint8_t *, int );
81 static int Seek( access_t *, int64_t );
82 static int Control( access_t *, int, va_list );
83
84 static int  MMSOpen ( access_t *, vlc_url_t *, int );
85 static int  MMSStart( access_t *, uint32_t );
86 static int  MMSStop ( access_t * );
87 static void MMSClose( access_t * );
88
89
90 static int  mms_CommandRead( access_t *p_access, int i_command1, int i_command2 );
91 static int  mms_CommandSend( access_t *, int, uint32_t, uint32_t, uint8_t *, int );
92
93 static int  mms_HeaderMediaRead( access_t *, int );
94
95 static int  mms_ReceivePacket( access_t * );
96
97
98 /*
99  * XXX DON'T FREE MY MEMORY !!! XXX
100  * non mais :P
101  */
102 /*
103  * Ok, ok, j'le ferai plus...
104  */
105 /*
106  * Merci :))
107  */
108 /*
109  * Vous pourriez signer vos commentaires (même si on voit bien qui peut
110  * écrire ce genre de trucs :p), et écrire en anglais, bordel de
111  * merde :p.
112  */
113 /*
114  * Alors la ouai ç'est fou les gens qui écrivent des commentaires sans les
115  * signer. Ca mériterait un coup de pied dans le cul ça :)
116  */
117
118 int  E_(MMSTUOpen)( access_t *p_access )
119 {
120     access_sys_t   *p_sys;
121     int             i_proto;
122     int             i_status;
123     vlc_value_t val;
124
125     /* Set up p_access */
126     p_access->pf_read = Read;
127     p_access->pf_block = NULL;
128     p_access->pf_control = Control;
129     p_access->pf_seek = Seek;
130     p_access->info.i_update = 0;
131     p_access->info.i_size = 0;
132     p_access->info.i_pos = 0;
133     p_access->info.b_eof = VLC_FALSE;
134     p_access->info.i_title = 0;
135     p_access->info.i_seekpoint = 0;
136     p_access->p_sys = p_sys = malloc( sizeof( access_sys_t ) );
137     memset( p_sys, 0, sizeof( access_sys_t ) );
138
139     /* *** Parse URL and get server addr/port and path *** */
140     vlc_UrlParse( &p_sys->url, p_access->psz_path, 0 );
141     if( p_sys->url.psz_host == NULL || *p_sys->url.psz_host == '\0' )
142     {
143         msg_Err( p_access, "invalid server name" );
144         vlc_UrlClean( &p_sys->url );
145         return VLC_EGENERIC;
146     }
147     if( p_sys->url.i_port <= 0 )
148     {
149         p_sys->url.i_port = 1755;
150     }
151
152     /* *** connect to this server *** */
153     /* look at  requested protocol (udp/tcp) */
154     i_proto = MMS_PROTO_AUTO;
155     if( *p_access->psz_access )
156     {
157         if( !strncmp( p_access->psz_access, "mmsu", 4 ) )
158         {
159             i_proto = MMS_PROTO_UDP;
160         }
161         else if( !strncmp( p_access->psz_access, "mmst", 4 ) )
162         {
163             i_proto = MMS_PROTO_TCP;
164         }
165     }
166
167     /* connect */
168     if( i_proto == MMS_PROTO_AUTO )
169     {   /* first try with TCP and then UDP*/
170         if( ( i_status = MMSOpen( p_access, &p_sys->url, MMS_PROTO_TCP ) ) )
171         {
172             i_status = MMSOpen( p_access, &p_sys->url, MMS_PROTO_UDP );
173         }
174     }
175     else
176     {
177         i_status = MMSOpen( p_access, &p_sys->url, i_proto );
178     }
179
180     if( i_status )
181     {
182         msg_Err( p_access, "cannot connect to server" );
183         vlc_UrlClean( &p_sys->url );
184         return VLC_EGENERIC;
185     }
186
187     msg_Dbg( p_access, "connected to %s:%d", p_sys->url.psz_host, p_sys->url.i_port );
188     /*
189      * i_flags_broadcast
190      *  yy xx ?? ??
191      *  broadcast    yy=0x02, xx= 0x00
192      *  pre-recorded yy=0x01, xx= 0x80 if video, 0x00 no video
193      */
194     if( p_sys->i_packet_count <= 0 && p_sys->asfh.i_data_packets_count > 0 )
195     {
196         p_sys->i_packet_count = p_sys->asfh.i_data_packets_count;
197     }
198     if( p_sys->i_packet_count <= 0 || ( p_sys->i_flags_broadcast >> 24 ) == 0x02 )
199     {
200         p_sys->b_seekable = VLC_FALSE;
201     }
202     else
203     {
204         p_sys->b_seekable = VLC_TRUE;
205         p_access->info.i_size =
206             (uint64_t)p_sys->i_header +
207             (uint64_t)p_sys->i_packet_count * (uint64_t)p_sys->i_packet_length;
208     }
209
210     /* *** Start stream *** */
211     if( MMSStart( p_access, 0xffffffff ) < 0 )
212     {
213         msg_Err( p_access, "cannot start stream" );
214         MMSClose( p_access );
215         vlc_UrlClean( &p_sys->url );
216         return VLC_EGENERIC;
217     }
218
219     /* Update default_pts to a suitable value for mms access */
220     var_Get( p_access, "mms-caching", &val );
221
222     return VLC_SUCCESS;
223 }
224
225 /*****************************************************************************
226  * Close: free unused data structures
227  *****************************************************************************/
228 void E_(MMSTUClose)( access_t *p_access )
229 {
230     access_sys_t *p_sys = p_access->p_sys;
231
232     /* close connection with server */
233     MMSClose( p_access );
234
235     /* free memory */
236     vlc_UrlClean( &p_sys->url );
237
238     free( p_sys );
239 }
240
241 /*****************************************************************************
242  * Control:
243  *****************************************************************************/
244 static int Control( access_t *p_access, int i_query, va_list args )
245 {
246     access_sys_t *p_sys = p_access->p_sys;
247     vlc_bool_t   *pb_bool;
248     int          *pi_int;
249     int64_t      *pi_64;
250     vlc_value_t  val;
251
252     switch( i_query )
253     {
254         /* */
255         case ACCESS_CAN_SEEK:
256             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
257             *pb_bool = p_sys->b_seekable;
258             break;
259         case ACCESS_CAN_FASTSEEK:
260         case ACCESS_CAN_PAUSE:
261         case ACCESS_CAN_CONTROL_PACE:
262             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
263             *pb_bool = VLC_FALSE;
264             break;
265
266         /* */
267         case ACCESS_GET_MTU:
268             pi_int = (int*)va_arg( args, int * );
269             *pi_int = 3 * p_sys->i_packet_length;
270             break;
271
272         case ACCESS_GET_PTS_DELAY:
273             pi_64 = (int64_t*)va_arg( args, int64_t * );
274             var_Get( p_access, "mms-caching", &val );
275             *pi_64 = val.i_int * 1000;
276             break;
277
278         /* */
279         case ACCESS_SET_PAUSE_STATE:
280         case ACCESS_GET_TITLE_INFO:
281         case ACCESS_SET_TITLE:
282         case ACCESS_SET_SEEKPOINT:
283             return VLC_EGENERIC;
284
285         default:
286             msg_Err( p_access, "unimplemented query in control" );
287             return VLC_EGENERIC;
288
289     }
290     return VLC_SUCCESS;
291 }
292
293 /*****************************************************************************
294  * Seek: try to go at the right place
295  *****************************************************************************/
296 static int Seek( access_t * p_access, int64_t i_pos )
297 {
298     access_sys_t *p_sys = p_access->p_sys;
299     uint32_t    i_packet;
300     uint32_t    i_offset;
301     var_buffer_t buffer;
302
303     if( i_pos < 0 )
304         return VLC_EGENERIC;
305
306     if( i_pos < p_sys->i_header)
307     {
308
309         if( p_access->info.i_pos < p_sys->i_header )
310         {
311             /* no need to restart stream, it was already one
312              * or no stream was yet read */
313             p_access->info.i_pos = i_pos;
314             return VLC_SUCCESS;
315         }
316         else
317         {
318             i_packet = 0xffffffff;
319             i_offset = 0;
320         }
321     }
322     else
323     {
324         i_packet = ( i_pos - p_sys->i_header ) / p_sys->i_packet_length;
325         i_offset = ( i_pos - p_sys->i_header ) % p_sys->i_packet_length;
326     }
327     msg_Dbg( p_access, "seeking to "I64Fd " (packet:%d)", i_pos, i_packet );
328
329     MMSStop( p_access );
330     msg_Dbg( p_access, "stream stopped (seek)" );
331
332     /* *** restart stream *** */
333     var_buffer_initwrite( &buffer, 0 );
334     var_buffer_add64( &buffer, 0 ); /* seek point in second */
335     var_buffer_add32( &buffer, 0xffffffff );
336     var_buffer_add32( &buffer, i_packet ); // begin from start
337     var_buffer_add8( &buffer, 0xff ); // stream time limit
338     var_buffer_add8( &buffer, 0xff ); //  on 3bytes ...
339     var_buffer_add8( &buffer, 0xff ); //
340     var_buffer_add8( &buffer, 0x00 ); // don't use limit
341     var_buffer_add32( &buffer, p_sys->i_media_packet_id_type );
342
343     mms_CommandSend( p_access, 0x07, p_sys->i_command_level, 0x0001ffff,
344                      buffer.p_data, buffer.i_data );
345
346     var_buffer_free( &buffer );
347
348
349     while( !p_access->b_die )
350     {
351         mms_HeaderMediaRead( p_access, MMS_PACKET_CMD );
352         if( p_sys->i_command == 0x1e )
353         {
354             msg_Dbg( p_access, "received 0x1e (seek)" );
355             break;
356         }
357     }
358
359     while( !p_access->b_die )
360     {
361         mms_HeaderMediaRead( p_access, MMS_PACKET_CMD );
362         if( p_sys->i_command == 0x05 )
363         {
364             msg_Dbg( p_access, "received 0x05 (seek)" );
365             break;
366         }
367     }
368
369     /* get a packet */
370     mms_HeaderMediaRead( p_access, MMS_PACKET_MEDIA );
371     msg_Dbg( p_access, "Streaming restarted" );
372
373     p_sys->i_media_used += i_offset;
374     p_access->info.i_pos = i_pos;
375     p_access->info.b_eof = VLC_FALSE;
376
377     return VLC_SUCCESS;
378 }
379
380 /*****************************************************************************
381  * Read:
382  *****************************************************************************/
383 static int Read( access_t *p_access, uint8_t *p_buffer, int i_len )
384 {
385     access_sys_t *p_sys = p_access->p_sys;
386     size_t      i_data;
387     size_t      i_copy;
388
389     i_data = 0;
390
391     /* *** now send data if needed *** */
392     while( i_data < i_len )
393     {
394         if( p_access->info.i_pos < p_sys->i_header )
395         {
396             i_copy = __MIN( i_len, p_sys->i_header - p_access->info.i_pos );
397             memcpy( &p_buffer[i_data], &p_sys->p_header[p_access->info.i_pos], i_copy );
398             i_data += i_copy;
399             p_access->info.i_pos += i_copy;
400         }
401         else if( p_sys->i_media_used < p_sys->i_media )
402         {
403             i_copy = __MIN( i_len - i_data ,
404                             p_sys->i_media - p_sys->i_media_used );
405             memcpy( &p_buffer[i_data], &p_sys->p_media[p_sys->i_media_used], i_copy );
406             i_data += i_copy;
407             p_sys->i_media_used += i_copy;
408             p_access->info.i_pos += i_copy;
409         }
410         else if( p_sys->p_media != NULL &&
411                  p_sys->i_media_used < p_sys->i_packet_length )
412         {
413             i_copy = __MIN( i_len - i_data,
414                             p_sys->i_packet_length - p_sys->i_media_used);
415             memset( &p_buffer[i_data], 0, i_copy );
416
417             i_data += i_copy;
418             p_sys->i_media_used += i_copy;
419             p_access->info.i_pos += i_copy;
420         }
421         else if( p_access->info.b_eof ||
422                  mms_HeaderMediaRead( p_access, MMS_PACKET_MEDIA ) < 0 )
423         {
424             break;
425         }
426     }
427
428     return i_data;
429 }
430
431 /****************************************************************************
432  * MMSOpen : Open a connection with the server over mmst or mmsu
433  ****************************************************************************/
434 static int MMSOpen( access_t  *p_access, vlc_url_t *p_url, int  i_proto )
435 {
436     access_sys_t *p_sys = p_access->p_sys;
437     int           b_udp = ( i_proto == MMS_PROTO_UDP ) ? 1 : 0;
438
439     var_buffer_t buffer;
440     char         tmp[4096];
441     uint16_t     *p;
442     int          i_server_version;
443     int          i_tool_version;
444     int          i_update_player_url;
445     int          i_encryption_type;
446     int          i;
447     int          i_streams;
448     int          i_first;
449
450
451     /* *** Open a TCP connection with server *** */
452     msg_Dbg( p_access, "waiting for connection..." );
453     p_sys->i_handle_tcp = net_OpenTCP( p_access, p_url->psz_host, p_url->i_port );
454     if( p_sys->i_handle_tcp < 0 )
455     {
456         msg_Err( p_access, "failed to open a connection (tcp)" );
457         return VLC_EGENERIC;
458     }
459     msg_Dbg( p_access,
460              "connection(tcp) with \"%s:%d\" successful",
461              p_url->psz_host,
462              p_url->i_port );
463
464     /* *** Bind port if UDP protocol is selected *** */
465     if( b_udp )
466     {
467         struct sockaddr_in name;
468         socklen_t i_namelen = sizeof( struct sockaddr_in );
469
470         if( getsockname( p_sys->i_handle_tcp,
471                          (struct sockaddr*)&name, &i_namelen ) < 0 )
472         {
473             net_Close( p_sys->i_handle_tcp );
474             return VLC_EGENERIC;
475         }
476         p_sys->psz_bind_addr = inet_ntoa( name.sin_addr );
477
478         p_sys->i_handle_udp = net_OpenUDP( p_access, p_sys->psz_bind_addr, 7000, "", 0 );
479         if( p_sys->i_handle_udp < 0 )
480         {
481             msg_Err( p_access, "failed to open a connection (udp)" );
482             net_Close( p_sys->i_handle_tcp );
483             return VLC_EGENERIC;
484         }
485         msg_Dbg( p_access,
486                  "connection(udp) at \"%s:%d\" successful",
487                  p_sys->psz_bind_addr, 7000 );
488     }
489     else
490     {
491         p_sys->psz_bind_addr = NULL;
492     }
493
494     /* *** Init context for mms prototcol *** */
495     E_( GenerateGuid )( &p_sys->guid );    /* used to identify client by server */
496     msg_Dbg( p_access,
497              "generated guid: "GUID_FMT,
498              GUID_PRINT( p_sys->guid ) );
499     p_sys->i_command_level = 1;          /* updated after 0x1A command */
500     p_sys->i_seq_num = 0;
501     p_sys->i_media_packet_id_type  = 0x04;
502     p_sys->i_header_packet_id_type = 0x02;
503     p_sys->i_proto = i_proto;
504     p_sys->i_packet_seq_num = 0;
505     p_sys->p_header = NULL;
506     p_sys->i_header = 0;
507     p_sys->p_media = NULL;
508     p_sys->i_media = 0;
509     p_sys->i_media_used = 0;
510
511     p_access->info.i_pos = 0;
512     p_sys->i_buffer_tcp = 0;
513     p_sys->i_buffer_udp = 0;
514     p_sys->p_cmd = NULL;
515     p_sys->i_cmd = 0;
516     p_access->info.b_eof = 0;
517
518     /* *** send command 1 : connection request *** */
519     var_buffer_initwrite( &buffer, 0 );
520     var_buffer_add16( &buffer, 0x001c );
521     var_buffer_add16( &buffer, 0x0003 );
522     sprintf( tmp,
523              "NSPlayer/7.0.0.1956; {"GUID_FMT"}; Host: %s",
524              GUID_PRINT( p_sys->guid ),
525              p_url->psz_host );
526     var_buffer_addUTF16( &buffer, tmp );
527
528     mms_CommandSend( p_access,
529                      0x01,          /* connexion request */
530                      0x00000000,    /* flags, FIXME */
531                      0x0004000b,    /* ???? */
532                      buffer.p_data,
533                      buffer.i_data );
534
535     if( mms_CommandRead( p_access, 0x01, 0 ) < 0 )
536     {
537         var_buffer_free( &buffer );
538         MMSClose( p_access );
539         return VLC_EGENERIC;
540     }
541
542     i_server_version = GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 32 );
543     i_tool_version = GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 36 );
544     i_update_player_url = GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 40 );
545     i_encryption_type = GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 44 );
546     p = (uint16_t*)( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 48 );
547 #define GETUTF16( psz, size ) \
548     { \
549         int i; \
550         psz = malloc( size + 1); \
551         for( i = 0; i < size; i++ ) \
552         { \
553             psz[i] = p[i]; \
554         } \
555         psz[size] = '\0'; \
556         p += 2 * ( size ); \
557     }
558     GETUTF16( p_sys->psz_server_version, i_server_version );
559     GETUTF16( p_sys->psz_tool_version, i_tool_version );
560     GETUTF16( p_sys->psz_update_player_url, i_update_player_url );
561     GETUTF16( p_sys->psz_encryption_type, i_encryption_type );
562 #undef GETUTF16
563     msg_Dbg( p_access,
564              "0x01 --> server_version:\"%s\" tool_version:\"%s\" update_player_url:\"%s\" encryption_type:\"%s\"",
565              p_sys->psz_server_version,
566              p_sys->psz_tool_version,
567              p_sys->psz_update_player_url,
568              p_sys->psz_encryption_type );
569
570     /* *** should make an 18 command to make data timing *** */
571
572     /* *** send command 2 : transport protocol selection *** */
573     var_buffer_reinitwrite( &buffer, 0 );
574     var_buffer_add32( &buffer, 0x00000000 );
575     var_buffer_add32( &buffer, 0x000a0000 );
576     var_buffer_add32( &buffer, 0x00000002 );
577     if( b_udp )
578     {
579         sprintf( tmp,
580                  "\\\\%s\\UDP\\%d",
581                  p_sys->psz_bind_addr,
582                  7000 ); // FIXME
583     }
584     else
585     {
586         sprintf( tmp, "\\\\192.168.0.1\\TCP\\1242"  );
587     }
588     var_buffer_addUTF16( &buffer, tmp );
589     var_buffer_add16( &buffer, '0' );
590
591     mms_CommandSend( p_access,
592                      0x02,          /* connexion request */
593                      0x00000000,    /* flags, FIXME */
594                      0xffffffff,    /* ???? */
595                      buffer.p_data,
596                      buffer.i_data );
597
598     /* *** response from server, should be 0x02 or 0x03 *** */
599     mms_CommandRead( p_access, 0x02, 0x03 );
600     if( p_sys->i_command == 0x03 )
601     {
602         msg_Err( p_access,
603                  "%s protocol selection failed", b_udp ? "UDP" : "TCP" );
604         var_buffer_free( &buffer );
605         MMSClose( p_access );
606         return VLC_EGENERIC;
607     }
608     else if( p_sys->i_command != 0x02 )
609     {
610         msg_Warn( p_access, "received command isn't 0x02 in reponse to 0x02" );
611     }
612
613     /* *** send command 5 : media file name/path requested *** */
614     var_buffer_reinitwrite( &buffer, 0 );
615     var_buffer_add64( &buffer, 0 );
616     var_buffer_addUTF16( &buffer, p_url->psz_path );
617
618     mms_CommandSend( p_access,
619                      0x05,
620                      p_sys->i_command_level,
621                      0xffffffff,
622                      buffer.p_data,
623                      buffer.i_data );
624
625     /* *** wait for reponse *** */
626     mms_CommandRead( p_access, 0x1a, 0x06 );
627
628     /* test if server send 0x1A answer */
629     if( p_sys->i_command == 0x1A )
630     {
631         msg_Err( p_access, "id/password requested (not yet supported)" );
632         /*  FIXME */
633         var_buffer_free( &buffer );
634         MMSClose( p_access );
635         return VLC_EGENERIC;
636     }
637     if( p_sys->i_command != 0x06 )
638     {
639         msg_Err( p_access,
640                  "unknown answer (0x%x instead of 0x06)",
641                  p_sys->i_command );
642         var_buffer_free( &buffer );
643         MMSClose( p_access );
644         return( -1 );
645     }
646
647     /*  1 for file ok, 2 for authen ok */
648     switch( GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE ) )
649     {
650         case 0x0001:
651             msg_Dbg( p_access, "Media file name/path accepted" );
652             break;
653         case 0x0002:
654             msg_Dbg( p_access, "Authentication accepted" );
655             break;
656         case -1:
657         default:
658         msg_Err( p_access, "error while asking for file %d",
659                  GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE ) );
660         var_buffer_free( &buffer );
661         MMSClose( p_access );
662         return VLC_EGENERIC;
663     }
664
665     p_sys->i_flags_broadcast =
666         GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 12 );
667     p_sys->i_media_length =
668         GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 24 );
669     p_sys->i_packet_length =
670         GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 44 );
671     p_sys->i_packet_count =
672         GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 48 );
673     p_sys->i_max_bit_rate =
674         GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 56 );
675     p_sys->i_header_size =
676         GetDWLE( p_sys->p_cmd + MMS_CMD_HEADERSIZE + 60 );
677
678     msg_Dbg( p_access,
679              "answer 0x06 flags:0x%8.8x media_length:%ds packet_length:%d packet_count:%d max_bit_rate:%d header_size:%d",
680              p_sys->i_flags_broadcast,
681              p_sys->i_media_length,
682              p_sys->i_packet_length,
683              p_sys->i_packet_count,
684              p_sys->i_max_bit_rate,
685              p_sys->i_header_size );
686
687     /* *** send command 15 *** */
688
689     var_buffer_reinitwrite( &buffer, 0 );
690     var_buffer_add32( &buffer, 0 );
691     var_buffer_add32( &buffer, 0x8000 );
692     var_buffer_add32( &buffer, 0xffffffff );
693     var_buffer_add32( &buffer, 0x00 );
694     var_buffer_add32( &buffer, 0x00 );
695     var_buffer_add32( &buffer, 0x00 );
696     var_buffer_add64( &buffer, (((uint64_t)0x40ac2000)<<32) );
697     var_buffer_add32( &buffer, p_sys->i_header_packet_id_type );
698     var_buffer_add32( &buffer, 0x00 );
699     mms_CommandSend( p_access, 0x15, p_sys->i_command_level, 0x00,
700                      buffer.p_data, buffer.i_data );
701
702     /* *** wait for reponse *** */
703     /* Commented out because it fails on some stream (no 0x11 answer) */
704 #if 0
705     mms_CommandRead( p_access, 0x11, 0 );
706
707     if( p_sys->i_command != 0x11 )
708     {
709         msg_Err( p_access,
710                  "unknown answer (0x%x instead of 0x11)",
711                  p_sys->i_command );
712         var_buffer_free( &buffer );
713         MMSClose( p_access );
714         return( -1 );
715     }
716 #endif
717
718     /* *** now read header packet *** */
719     /* XXX could be split over multiples packets */
720     msg_Dbg( p_access, "reading header" );
721     for( ;; )
722     {
723         if( mms_HeaderMediaRead( p_access, MMS_PACKET_HEADER ) < 0 )
724         {
725             msg_Err( p_access, "cannot receive header" );
726             var_buffer_free( &buffer );
727             MMSClose( p_access );
728             return VLC_EGENERIC;
729         }
730         if( p_sys->i_header >= p_sys->i_header_size )
731         {
732             msg_Dbg( p_access,
733                      "header complete(%d)",
734                      p_sys->i_header );
735             break;
736         }
737         msg_Dbg( p_access,
738                  "header incomplete (%d/%d), reading more",
739                  p_sys->i_header,
740                  p_sys->i_header_size );
741     }
742
743     /* *** parse header and get stream and their id *** */
744     /* get all streams properties,
745      *
746      * TODO : stream bitrates properties(optional)
747      *        and bitrate mutual exclusion(optional) */
748     E_( asf_HeaderParse )( &p_sys->asfh,
749                            p_sys->p_header, p_sys->i_header );
750     E_( asf_StreamSelect)( &p_sys->asfh,
751                            config_GetInt( p_access, "mms-maxbitrate" ),
752                            config_GetInt( p_access, "mms-all" ),
753                            config_GetInt( p_access, "audio" ),
754                            config_GetInt( p_access, "video" ) );
755
756     /* *** now select stream we want to receive *** */
757     /* TODO take care of stream bitrate TODO */
758     i_streams = 0;
759     i_first = -1;
760     var_buffer_reinitwrite( &buffer, 0 );
761     /* for now, select first audio and video stream */
762     for( i = 1; i < 128; i++ )
763     {
764
765         if( p_sys->asfh.stream[i].i_cat != ASF_STREAM_UNKNOWN )
766         {
767             i_streams++;
768             if( i_first != -1 )
769             {
770                 var_buffer_add16( &buffer, 0xffff );
771                 var_buffer_add16( &buffer, i );
772             }
773             else
774             {
775                 i_first = i;
776             }
777             if( p_sys->asfh.stream[i].i_selected )
778             {
779                 var_buffer_add16( &buffer, 0x0000 );
780                 msg_Info( p_access,
781                           "selecting stream[0x%x] %s (%d kb/s)",
782                           i,
783                           ( p_sys->asfh.stream[i].i_cat == ASF_STREAM_AUDIO  ) ?
784                                                   "audio" : "video" ,
785                           p_sys->asfh.stream[i].i_bitrate / 1024);
786             }
787             else
788             {
789                 var_buffer_add16( &buffer, 0x0002 );
790                 msg_Info( p_access,
791                           "ignoring stream[0x%x] %s (%d kb/s)",
792                           i,
793                           ( p_sys->asfh.stream[i].i_cat == ASF_STREAM_AUDIO  ) ?
794                                     "audio" : "video" ,
795                           p_sys->asfh.stream[i].i_bitrate / 1024);
796
797             }
798         }
799     }
800
801     if( i_streams == 0 )
802     {
803         msg_Err( p_access, "cannot find any stream" );
804         var_buffer_free( &buffer );
805         MMSClose( p_access );
806         return VLC_EGENERIC;
807     }
808     mms_CommandSend( p_access, 0x33,
809                      i_streams,
810                      0xffff | ( i_first << 16 ),
811                      buffer.p_data, buffer.i_data );
812
813     mms_CommandRead( p_access, 0x21, 0 );
814     if( p_sys->i_command != 0x21 )
815     {
816         msg_Err( p_access,
817                  "unknown answer (0x%x instead of 0x21)",
818                  p_sys->i_command );
819         var_buffer_free( &buffer );
820         MMSClose( p_access );
821         return VLC_EGENERIC;
822     }
823
824
825     var_buffer_free( &buffer );
826
827     msg_Info( p_access, "connection sucessful" );
828
829     return VLC_SUCCESS;
830 }
831
832 /****************************************************************************
833  * MMSStart : Start streaming
834  ****************************************************************************/
835 static int MMSStart( access_t  *p_access, uint32_t i_packet )
836 {
837     access_sys_t        *p_sys = p_access->p_sys;
838     var_buffer_t    buffer;
839
840     /* *** start stream from packet 0 *** */
841     var_buffer_initwrite( &buffer, 0 );
842     var_buffer_add64( &buffer, 0 ); /* seek point in second */
843     var_buffer_add32( &buffer, 0xffffffff );
844     var_buffer_add32( &buffer, i_packet ); // begin from start
845     var_buffer_add8( &buffer, 0xff ); // stream time limit
846     var_buffer_add8( &buffer, 0xff ); //  on 3bytes ...
847     var_buffer_add8( &buffer, 0xff ); //
848     var_buffer_add8( &buffer, 0x00 ); // don't use limit
849     var_buffer_add32( &buffer, p_sys->i_media_packet_id_type );
850
851     mms_CommandSend( p_access, 0x07, p_sys->i_command_level, 0x0001ffff,
852                      buffer.p_data, buffer.i_data );
853
854     var_buffer_free( &buffer );
855
856     mms_CommandRead( p_access, 0x05, 0 );
857
858     if( p_sys->i_command != 0x05 )
859     {
860         msg_Err( p_access,
861                  "unknown answer (0x%x instead of 0x05)",
862                  p_sys->i_command );
863         return( -1 );
864     }
865     else
866     {
867         /* get a packet */
868         mms_HeaderMediaRead( p_access, MMS_PACKET_MEDIA );
869         msg_Dbg( p_access, "Streaming started" );
870         return( 0 );
871     }
872 }
873
874 /****************************************************************************
875  * MMSStop : Stop streaming
876  ****************************************************************************/
877 static int MMSStop( access_t  *p_access )
878 {
879     access_sys_t *p_sys = p_access->p_sys;
880
881     /* *** stop stream but keep connection alive *** */
882     mms_CommandSend( p_access,
883                      0x09,
884                      p_sys->i_command_level,
885                      0x001fffff,
886                      NULL, 0 );
887     return( 0 );
888 }
889
890 /****************************************************************************
891  * MMSClose : Close streaming and connection
892  ****************************************************************************/
893 static void MMSClose( access_t  *p_access )
894 {
895     access_sys_t        *p_sys = p_access->p_sys;
896
897     msg_Dbg( p_access, "Connection closed" );
898
899     /* *** tell server that we will disconnect *** */
900     mms_CommandSend( p_access,
901                      0x0d,
902                      p_sys->i_command_level,
903                      0x00000001,
904                      NULL, 0 );
905
906     /* *** close sockets *** */
907     net_Close( p_sys->i_handle_tcp );
908     if( p_sys->i_proto == MMS_PROTO_UDP )
909     {
910         net_Close( p_sys->i_handle_udp );
911     }
912
913     FREE( p_sys->p_cmd );
914     FREE( p_sys->p_media );
915     FREE( p_sys->p_header );
916
917     FREE( p_sys->psz_server_version );
918     FREE( p_sys->psz_tool_version );
919     FREE( p_sys->psz_update_player_url );
920     FREE( p_sys->psz_encryption_type );
921 }
922
923 /****************************************************************************
924  *
925  * MMS specific functions
926  *
927  ****************************************************************************/
928 static int mms_CommandSend( access_t *p_access,
929                              int i_command,
930                              uint32_t i_prefix1, uint32_t i_prefix2,
931                              uint8_t *p_data, int i_data )
932 {
933     var_buffer_t buffer;
934
935     access_sys_t        *p_sys = p_access->p_sys;
936     int i_data_by8;
937
938     i_data_by8 = ( i_data + 7 ) / 8;
939
940     /* first init uffer */
941     var_buffer_initwrite( &buffer, 0 );
942
943     var_buffer_add32( &buffer, 0x00000001 );    /* start sequence */
944     var_buffer_add32( &buffer, 0xB00BFACE );
945     /* size after protocol type */
946     var_buffer_add32( &buffer, i_data + MMS_CMD_HEADERSIZE - 16 );
947     var_buffer_add32( &buffer, 0x20534d4d );    /* protocol "MMS " */
948     var_buffer_add32( &buffer, i_data_by8 + 4 );
949     var_buffer_add32( &buffer, p_sys->i_seq_num ); p_sys->i_seq_num++;
950     var_buffer_add64( &buffer, 0 );
951     var_buffer_add32( &buffer, i_data_by8 + 2 );
952     var_buffer_add32( &buffer, 0x00030000 | i_command ); /* dir | command */
953     var_buffer_add32( &buffer, i_prefix1 );    /* command specific */
954     var_buffer_add32( &buffer, i_prefix2 );    /* command specific */
955
956     /* specific command data */
957     if( p_data && i_data > 0 )
958     {
959         var_buffer_addmemory( &buffer, p_data, i_data );
960     }
961
962     /* send it */
963     if( send( p_sys->i_handle_tcp,
964               buffer.p_data,
965               buffer.i_data,
966               0 ) == -1 )
967     {
968         msg_Err( p_access, "failed to send command" );
969         return VLC_EGENERIC;
970     }
971
972     var_buffer_free( &buffer );
973     return VLC_SUCCESS;
974 }
975
976 static int NetFillBuffer( access_t *p_access )
977 {
978 #ifdef UNDER_CE
979     return -1;
980
981 #else
982     access_sys_t    *p_sys = p_access->p_sys;
983     struct timeval  timeout;
984     fd_set          fds_r, fds_e;
985     int             i_ret;
986
987     /* FIXME when using udp */
988     ssize_t i_tcp, i_udp;
989     ssize_t i_tcp_read, i_udp_read;
990     int i_handle_max;
991     int i_try = 0;
992
993     i_tcp = MMS_BUFFER_SIZE/2 - p_sys->i_buffer_tcp;
994
995     if( p_sys->i_proto == MMS_PROTO_UDP )
996     {
997         i_udp = MMS_BUFFER_SIZE/2 - p_sys->i_buffer_udp;
998     }
999     else
1000     {
1001         i_udp = 0;  /* there isn't udp socket */
1002     }
1003
1004     i_handle_max = 0;
1005
1006     if( i_tcp > 0 )
1007         i_handle_max = __MAX( i_handle_max, p_sys->i_handle_tcp );
1008     if( i_udp > 0 )
1009         i_handle_max = __MAX( i_handle_max, p_sys->i_handle_udp );
1010
1011     if( i_handle_max == 0 )
1012     {
1013         msg_Warn( p_access, "nothing to read %d:%d", i_tcp, i_udp );
1014         return 0;
1015     }
1016     else
1017     {
1018         /* msg_Warn( p_access, "ask for tcp:%d udp:%d", i_tcp, i_udp ); */
1019     }
1020
1021     /* Find if some data is available */
1022     do
1023     {
1024         i_try++;
1025
1026         /* Initialize file descriptor set */
1027         FD_ZERO( &fds_r );
1028         FD_ZERO( &fds_e );
1029
1030         if( i_tcp > 0 )
1031         {
1032             FD_SET( p_sys->i_handle_tcp, &fds_r );
1033             FD_SET( p_sys->i_handle_tcp, &fds_e );
1034         }
1035         if( i_udp > 0 )
1036         {
1037             FD_SET( p_sys->i_handle_udp, &fds_r );
1038             FD_SET( p_sys->i_handle_udp, &fds_e );
1039         }
1040
1041         /* We'll wait 0.5 second if nothing happens */
1042         timeout.tv_sec = 0;
1043         timeout.tv_usec = 500000;
1044
1045         if( i_try > 3 && (p_sys->i_buffer_tcp > 0 || p_sys->i_buffer_udp > 0) )
1046         {
1047             return -1;
1048         }
1049
1050         if( p_access->b_die || p_access->b_error ) return -1;
1051
1052         //msg_Dbg( p_access, "NetFillBuffer: trying again (select)" );
1053
1054     } while( !(i_ret = select(i_handle_max +1, &fds_r, 0, &fds_e, &timeout)) ||
1055              (i_ret < 0 && errno == EINTR) );
1056
1057     if( i_ret < 0 )
1058     {
1059         msg_Err( p_access, "network select error (%s)", strerror(errno) );
1060         return -1;
1061     }
1062
1063     i_tcp_read = i_udp_read = 0;
1064
1065     if( i_tcp > 0 && FD_ISSET( p_sys->i_handle_tcp, &fds_r ) )
1066     {
1067         i_tcp_read =
1068             recv( p_sys->i_handle_tcp,
1069                   p_sys->buffer_tcp + p_sys->i_buffer_tcp,
1070                   i_tcp + MMS_BUFFER_SIZE/2, 0 );
1071     }
1072
1073     if( i_udp > 0 && FD_ISSET( p_sys->i_handle_udp, &fds_r ) )
1074     {
1075         i_udp_read = recv( p_sys->i_handle_udp,
1076                            p_sys->buffer_udp + p_sys->i_buffer_udp,
1077                            i_udp + MMS_BUFFER_SIZE/2, 0 );
1078     }
1079
1080 #if MMS_DEBUG
1081     if( p_sys->i_proto == MMS_PROTO_UDP )
1082     {
1083         msg_Dbg( p_access, "filling buffer TCP:%d+%d UDP:%d+%d",
1084                  p_sys->i_buffer_tcp, i_tcp_read,
1085                  p_sys->i_buffer_udp, i_udp_read );
1086     }
1087     else
1088     {
1089         msg_Dbg( p_access, "filling buffer TCP:%d+%d",
1090                  p_sys->i_buffer_tcp, i_tcp_read );
1091     }
1092 #endif
1093
1094     if( i_tcp_read > 0 ) p_sys->i_buffer_tcp += i_tcp_read;
1095     if( i_udp_read > 0 ) p_sys->i_buffer_udp += i_udp_read;
1096
1097     return i_tcp_read + i_udp_read;
1098 #endif
1099 }
1100
1101 static int  mms_ParseCommand( access_t *p_access,
1102                               uint8_t *p_data,
1103                               int i_data,
1104                               int *pi_used )
1105 {
1106  #define GET32( i_pos ) \
1107     ( p_sys->p_cmd[i_pos] + ( p_sys->p_cmd[i_pos +1] << 8 ) + \
1108       ( p_sys->p_cmd[i_pos + 2] << 16 ) + \
1109       ( p_sys->p_cmd[i_pos + 3] << 24 ) )
1110
1111     access_sys_t        *p_sys = p_access->p_sys;
1112     int         i_length;
1113     uint32_t    i_id;
1114
1115     if( p_sys->p_cmd )
1116     {
1117         free( p_sys->p_cmd );
1118     }
1119     p_sys->i_cmd = i_data;
1120     p_sys->p_cmd = malloc( i_data );
1121     memcpy( p_sys->p_cmd, p_data, i_data );
1122
1123     *pi_used = i_data; /* by default */
1124
1125     if( i_data < MMS_CMD_HEADERSIZE )
1126     {
1127         msg_Warn( p_access, "truncated command (header incomplete)" );
1128         p_sys->i_command = 0;
1129         return -1;
1130     }
1131     i_id =  GetDWLE( p_data + 4 );
1132     i_length = GetDWLE( p_data + 8 ) + 16;
1133
1134     if( i_id != 0xb00bface )
1135     {
1136         msg_Err( p_access,
1137                  "incorrect command header (0x%x)", i_id );
1138         p_sys->i_command = 0;
1139         return -1;
1140     }
1141
1142     if( i_length > p_sys->i_cmd )
1143     {
1144         msg_Warn( p_access,
1145                   "truncated command (missing %d bytes)",
1146                    i_length - i_data  );
1147         p_sys->i_command = 0;
1148         return -1;
1149     }
1150     else if( i_length < p_sys->i_cmd )
1151     {
1152         p_sys->i_cmd = i_length;
1153         *pi_used = i_length;
1154     }
1155
1156     msg_Dbg( p_access,
1157              "recv command start_sequence:0x%8.8x command_id:0x%8.8x length:%d len8:%d sequence 0x%8.8x len8_II:%d dir_comm:0x%8.8x",
1158              GET32( 0 ),
1159              GET32( 4 ),
1160              GET32( 8 ),
1161              /* 12: protocol type "MMS " */
1162              GET32( 16 ),
1163              GET32( 20 ),
1164              /* 24: unknown (0) */
1165              /* 28: unknown (0) */
1166              GET32( 32 ),
1167              GET32( 36 )
1168              /* 40: switches */
1169              /* 44: extra */ );
1170
1171     p_sys->i_command = GET32( 36 ) & 0xffff;
1172 #undef GET32
1173
1174     return MMS_PACKET_CMD;
1175 }
1176
1177 static int  mms_ParsePacket( access_t *p_access,
1178                              uint8_t *p_data, size_t i_data,
1179                              int *pi_used )
1180 {
1181     access_sys_t        *p_sys = p_access->p_sys;
1182     int i_packet_seq_num;
1183     size_t i_packet_length;
1184     uint32_t i_packet_id;
1185
1186     uint8_t  *p_packet;
1187
1188
1189     *pi_used = i_data; /* default */
1190     if( i_data <= 8 )
1191     {
1192         msg_Warn( p_access, "truncated packet (header incomplete)" );
1193         return -1;
1194     }
1195
1196     i_packet_id = p_data[4];
1197     i_packet_seq_num = GetDWLE( p_data );
1198     i_packet_length = GetWLE( p_data + 6 );
1199
1200     //msg_Warn( p_access, "------->i_packet_length=%d, i_data=%d", i_packet_length, i_data );
1201
1202     if( i_packet_length > i_data || i_packet_length <= 8)
1203     {
1204         msg_Dbg( p_access,
1205                  "truncated packet (missing %d bytes)",
1206                  i_packet_length - i_data  );
1207         *pi_used = 0;
1208         return -1;
1209     }
1210     else if( i_packet_length < i_data )
1211     {
1212         *pi_used = i_packet_length;
1213     }
1214
1215     if( i_packet_id == 0xff )
1216     {
1217         msg_Warn( p_access,
1218                   "receive MMS UDP pair timing" );
1219         return( MMS_PACKET_UDP_TIMING );
1220     }
1221
1222     if( i_packet_id != p_sys->i_header_packet_id_type &&
1223         i_packet_id != p_sys->i_media_packet_id_type )
1224     {
1225         msg_Warn( p_access, "incorrect Packet Id Type (0x%x)", i_packet_id );
1226         return -1;
1227     }
1228
1229     /* we now have a media or a header packet */
1230     p_packet = malloc( i_packet_length - 8 ); // don't bother with preheader
1231     memcpy( p_packet, p_data + 8, i_packet_length - 8 );
1232
1233     if( i_packet_seq_num != p_sys->i_packet_seq_num )
1234     {
1235         /* FIXME for udp could be just wrong order ? */
1236         msg_Warn( p_access,
1237                   "detected packet lost (%d != %d)",
1238                   i_packet_seq_num,
1239                   p_sys->i_packet_seq_num );
1240         p_sys->i_packet_seq_num = i_packet_seq_num;
1241     }
1242     p_sys->i_packet_seq_num++;
1243
1244     if( i_packet_id == p_sys->i_header_packet_id_type )
1245     {
1246         if( p_sys->p_header )
1247         {
1248             p_sys->p_header = realloc( p_sys->p_header,
1249                                           p_sys->i_header + i_packet_length - 8 );
1250             memcpy( &p_sys->p_header[p_sys->i_header],
1251                     p_packet,
1252                     i_packet_length - 8 );
1253             p_sys->i_header += i_packet_length - 8;
1254
1255             free( p_packet );
1256         }
1257         else
1258         {
1259             p_sys->p_header = p_packet;
1260             p_sys->i_header = i_packet_length - 8;
1261         }
1262 /*        msg_Dbg( p_access,
1263                  "receive header packet (%d bytes)",
1264                  i_packet_length - 8 ); */
1265
1266         return MMS_PACKET_HEADER;
1267     }
1268     else
1269     {
1270         FREE( p_sys->p_media );
1271         p_sys->p_media = p_packet;
1272         p_sys->i_media = i_packet_length - 8;
1273         p_sys->i_media_used = 0;
1274 /*        msg_Dbg( p_access,
1275                  "receive media packet (%d bytes)",
1276                  i_packet_length - 8 ); */
1277
1278         return MMS_PACKET_MEDIA;
1279     }
1280 }
1281
1282 static int mms_ReceivePacket( access_t *p_access )
1283 {
1284     access_sys_t *p_sys = p_access->p_sys;
1285     int i_packet_tcp_type;
1286     int i_packet_udp_type;
1287
1288     for( ;; )
1289     {
1290         vlc_bool_t b_refill = VLC_TRUE;
1291
1292         /* first if we need to refill buffer */
1293         if( p_sys->i_buffer_tcp >= MMS_CMD_HEADERSIZE )
1294         {
1295             if( GetDWLE( p_sys->buffer_tcp + 4 ) == 0xb00bface  )
1296             {
1297                 if( GetDWLE( p_sys->buffer_tcp + 8 ) + 16 <=
1298                     p_sys->i_buffer_tcp )
1299                 {
1300                     b_refill = VLC_FALSE;
1301                 }
1302             }
1303             else if( GetWLE( p_sys->buffer_tcp + 6 ) <= p_sys->i_buffer_tcp )
1304             {
1305                 b_refill = VLC_FALSE;
1306             }
1307         }
1308         if( p_sys->i_proto == MMS_PROTO_UDP && p_sys->i_buffer_udp >= 8 &&
1309             GetWLE( p_sys->buffer_udp + 6 ) <= p_sys->i_buffer_udp )
1310         {
1311             b_refill = VLC_FALSE;
1312         }
1313
1314         if( b_refill && NetFillBuffer( p_access ) < 0 )
1315         {
1316             msg_Warn( p_access, "cannot fill buffer" );
1317             return -1;
1318         }
1319
1320         i_packet_tcp_type = -1;
1321         i_packet_udp_type = -1;
1322
1323         if( p_sys->i_buffer_tcp > 0 )
1324         {
1325             int i_used;
1326
1327             if( GetDWLE( p_sys->buffer_tcp + 4 ) == 0xb00bface )
1328             {
1329                 i_packet_tcp_type =
1330                     mms_ParseCommand( p_access, p_sys->buffer_tcp,
1331                                       p_sys->i_buffer_tcp, &i_used );
1332
1333             }
1334             else
1335             {
1336                 i_packet_tcp_type =
1337                     mms_ParsePacket( p_access, p_sys->buffer_tcp,
1338                                      p_sys->i_buffer_tcp, &i_used );
1339             }
1340             if( i_used > 0 && i_used < MMS_BUFFER_SIZE )
1341             {
1342                 memmove( p_sys->buffer_tcp, p_sys->buffer_tcp + i_used,
1343                          MMS_BUFFER_SIZE - i_used );
1344             }
1345             p_sys->i_buffer_tcp -= i_used;
1346         }
1347         else if( p_sys->i_buffer_udp > 0 )
1348         {
1349             int i_used;
1350
1351             i_packet_udp_type =
1352                 mms_ParsePacket( p_access, p_sys->buffer_udp,
1353                                  p_sys->i_buffer_udp, &i_used );
1354
1355             if( i_used > 0 && i_used < MMS_BUFFER_SIZE )
1356             {
1357                 memmove( p_sys->buffer_udp, p_sys->buffer_udp + i_used,
1358                          MMS_BUFFER_SIZE - i_used );
1359             }
1360             p_sys->i_buffer_udp -= i_used;
1361         }
1362
1363         if( i_packet_tcp_type == MMS_PACKET_CMD && p_sys->i_command == 0x1b )
1364         {
1365             mms_CommandSend( p_access, 0x1b, 0, 0, NULL, 0 );
1366             i_packet_tcp_type = -1;
1367         }
1368
1369         if( i_packet_tcp_type != -1 )
1370         {
1371             return i_packet_tcp_type;
1372         }
1373         else if( i_packet_udp_type != -1 )
1374         {
1375             return i_packet_udp_type;
1376         }
1377     }
1378 }
1379
1380 static int mms_ReceiveCommand( access_t *p_access )
1381 {
1382     access_sys_t *p_sys = p_access->p_sys;
1383
1384     for( ;; )
1385     {
1386         int i_used;
1387         int i_status;
1388
1389         if( NetFillBuffer( p_access ) < 0 )
1390         {
1391             msg_Warn( p_access, "cannot fill buffer" );
1392             return VLC_EGENERIC;
1393         }
1394         if( p_sys->i_buffer_tcp > 0 )
1395         {
1396             i_status = mms_ParseCommand( p_access, p_sys->buffer_tcp,
1397                                          p_sys->i_buffer_tcp, &i_used );
1398             if( i_used < MMS_BUFFER_SIZE )
1399             {
1400                 memmove( p_sys->buffer_tcp, p_sys->buffer_tcp + i_used,
1401                          MMS_BUFFER_SIZE - i_used );
1402             }
1403             p_sys->i_buffer_tcp -= i_used;
1404
1405             if( i_status < 0 )
1406             {
1407                 return VLC_EGENERIC;
1408             }
1409
1410             if( p_sys->i_command == 0x1b )
1411             {
1412                 mms_CommandSend( p_access, 0x1b, 0, 0, NULL, 0 );
1413             }
1414             else
1415             {
1416                 break;
1417             }
1418         }
1419         else
1420         {
1421             return VLC_EGENERIC;
1422         }
1423     }
1424
1425     return VLC_SUCCESS;
1426 }
1427
1428 #define MMS_RETRY_MAX       10
1429 #define MMS_RETRY_SLEEP     50000
1430
1431 static int mms_CommandRead( access_t *p_access, int i_command1,
1432                             int i_command2 )
1433 {
1434     access_sys_t *p_sys = p_access->p_sys;
1435     int i_count;
1436     int i_status;
1437
1438     for( i_count = 0; i_count < MMS_RETRY_MAX; )
1439     {
1440         i_status = mms_ReceiveCommand( p_access );
1441         if( i_status < 0 || p_sys->i_command == 0 )
1442         {
1443             i_count++;
1444             msleep( MMS_RETRY_SLEEP );
1445         }
1446         else if( i_command1 == 0 && i_command2 == 0)
1447         {
1448             return VLC_SUCCESS;
1449         }
1450         else if( p_sys->i_command == i_command1 ||
1451                  p_sys->i_command == i_command2 )
1452         {
1453             return VLC_SUCCESS;
1454         }
1455         else
1456         {
1457             switch( p_sys->i_command )
1458             {
1459                 case 0x03:
1460                     msg_Warn( p_access, "socket closed by server" );
1461                     p_access->info.b_eof = 1;
1462                     return VLC_EGENERIC;
1463                 case 0x1e:
1464                     msg_Warn( p_access, "end of media stream" );
1465                     p_access->info.b_eof = 1;
1466                     return VLC_EGENERIC;
1467                 default:
1468                     break;
1469             }
1470         }
1471     }
1472     msg_Warn( p_access, "failed to receive command (aborting)" );
1473
1474     return VLC_EGENERIC;
1475 }
1476
1477
1478 static int mms_HeaderMediaRead( access_t *p_access, int i_type )
1479 {
1480     access_sys_t *p_sys = p_access->p_sys;
1481     int          i_count;
1482
1483     for( i_count = 0; i_count < MMS_RETRY_MAX; )
1484     {
1485         int i_status;
1486
1487         if( p_access->b_die )
1488             return -1;
1489
1490         i_status = mms_ReceivePacket( p_access );
1491         if( i_status < 0 )
1492         {
1493             i_count++;
1494             msg_Warn( p_access, "cannot receive header (%d/%d)",
1495                       i_count, MMS_RETRY_MAX );
1496             msleep( MMS_RETRY_SLEEP );
1497         }
1498         else if( i_status == i_type || i_type == MMS_PACKET_ANY )
1499         {
1500             return i_type;
1501         }
1502         else if( i_status == MMS_PACKET_CMD )
1503         {
1504             switch( p_sys->i_command )
1505             {
1506                 case 0x03:
1507                     msg_Warn( p_access, "socket closed by server" );
1508                     p_access->info.b_eof = 1;
1509                     return -1;
1510                 case 0x1e:
1511                     msg_Warn( p_access, "end of media stream" );
1512                     p_access->info.b_eof = 1;
1513                     return -1;
1514                 case 0x20:
1515                     /* XXX not too dificult to be done EXCEPT that we
1516                      * need to restart demuxer... and I don't see how we
1517                      * could do that :p */
1518                     msg_Err( p_access,
1519                              "reinitialization needed --> unsupported" );
1520                     p_access->info.b_eof = VLC_TRUE;
1521                     return -1;
1522                 default:
1523                     break;
1524             }
1525         }
1526     }
1527
1528     msg_Err( p_access, "cannot receive %s (aborting)",
1529              ( i_type == MMS_PACKET_HEADER ) ? "header" : "media data" );
1530     return -1;
1531 }
1532