git.sesse.net Git - vlc/blob - modules/access/mms/mmstu.c

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