git.sesse.net Git - vlc/blob - src/misc/update.c

   1 /*****************************************************************************
   2  * update.c: VLC update and plugins download
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  * $Id: $
   6  *
   7  * Authors: Antoine Cellerier <dionoea -at- videolan -dot- org>
   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 release 2 of the License, or
  12  * (at your option) any later release.
  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 /* TODO
  25  * --> check release types.
  26  * --> make sure that the version comparision method is ok.
  27  */
  28
  29 /**
  30  *   \file
  31  *   This file contains functions related to VLC and plugins update management
  32  */
  33
  34 /*****************************************************************************
  35  * Preamble
  36  *****************************************************************************/
  37
  38 #include <vlc/vlc.h>
  39
  40 #include <ctype.h>                                              /* tolower() */
  41 #include <assert.h>
  42
  43
  44 #include <vlc_update.h>
  45
  46 #include <vlc_block.h>
  47 #include <vlc_stream.h>
  48 #include <vlc_xml.h>
  49 #include <vlc_interface.h>
  50 #include <vlc_charset.h>
  51
  52 /*****************************************************************************
  53  * Misc defines
  54  *****************************************************************************/
  55
  56 /* All release notes and source packages should match on "*"
  57  * Only binary installers are OS specific ( we only provide these
  58  * for Win32, Mac OS X, WincCE, beos(?) ) */
  59 #if defined( UNDER_CE )
  60 #   define UPDATE_VLC_OS "*"
  61 #   define UPDATE_VLC_ARCH "*"
  62 #elif defined( WIN32 )
  63 #   define UPDATE_VLC_OS "windows"
  64 #   define UPDATE_VLC_ARCH "i386"
  65 #elif defined( __APPLE__ )
  66 #   define UPDATE_VLC_OS "macosx"
  67 #   if defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc64__ )
  68 #       define UPDATE_VLC_ARCH "ppc"
  69 #   else
  70 #       define UPDATE_VLC_ARCH "x86"
  71 #   endif
  72 #elif defined( SYS_BEOS )
  73 #   define UPDATE_VLC_OS "beos"
  74 #   define UPDATE_VLC_ARCH "i386"
  75 #else
  76 #   define UPDATE_VLC_OS "*"
  77 #   define UPDATE_VLC_ARCH "*"
  78 #endif
  79
  80 #define UPDATE_VLC_STATUS_URL "http://update.videolan.org/vlc/status.xml"
  81 #define UPDATE_VLC_MIRRORS_URL "http://update.videolan.org/mirrors.xml"
  82
  83 #define STRDUP( a ) ( a ? strdup( a ) : NULL )
  84
  85 /*****************************************************************************
  86  * Local Prototypes
  87  *****************************************************************************/
  88
  89 static void FreeMirrorsList( update_t * );
  90 static void FreeReleasesList( update_t * );
  91 static void GetMirrorsList( update_t *, vlc_bool_t );
  92 static void GetFilesList( update_t *, vlc_bool_t );
  93
  94 static int CompareReleases( const struct update_release_t *,
  95                             const struct update_release_t * );
  96 static int CompareReleaseToCurrent( const struct update_release_t * );
  97
  98 static unsigned int update_iterator_Reset( update_iterator_t * );
  99 static unsigned int update_iterator_NextFile( update_iterator_t * );
 100 static unsigned int update_iterator_PrevFile( update_iterator_t * );
 101 static unsigned int update_iterator_NextMirror( update_iterator_t * );
 102 static unsigned int update_iterator_PrevMirror( update_iterator_t * );
 103
 104 static void update_iterator_GetData( update_iterator_t * );
 105 static void update_iterator_ClearData( update_iterator_t * );
 106
 107 /*****************************************************************************
 108  * Update_t functions
 109  *****************************************************************************/
 110
 111 /**
 112  * Create a new update VLC struct
 113  *
 114  * \param p_this the calling vlc_object
 115  * \return pointer to new update_t or NULL
 116  */
 117 update_t *__update_New( vlc_object_t *p_this )
 118 {
 119     update_t *p_update;
 120
 121     if( p_this == NULL ) return NULL;
 122
 123     p_update = (update_t *)malloc( sizeof( update_t ) );
 124     if( !p_update ) return NULL;
 125
 126     vlc_mutex_init( p_this, &p_update->lock );
 127
 128     p_update->p_libvlc = p_this->p_libvlc;
 129
 130     p_update->p_releases = NULL;
 131     p_update->i_releases = 0;
 132     p_update->b_releases = VLC_FALSE;
 133
 134     p_update->p_mirrors = NULL;
 135     p_update->i_mirrors = 0;
 136     p_update->b_mirrors = VLC_FALSE;
 137
 138 #if 1
 139     msg_Err( p_this, "Auto-update currently disabled." );
 140     vlc_mutex_destroy( &p_update->lock );
 141     free( p_update );
 142     return NULL;
 143 #else
 144     return p_update
 145 #endif
 146 }
 147
 148 /**
 149  * Delete an update_t struct
 150  *
 151  * \param p_update update_t* pointer
 152  * \return nothing
 153  */
 154 void update_Delete( update_t *p_update )
 155 {
 156     assert( p_update );
 157
 158     vlc_mutex_destroy( &p_update->lock );
 159     FreeMirrorsList( p_update );
 160     FreeReleasesList( p_update );
 161     free( p_update );
 162 }
 163
 164 /**
 165  * Empty the mirrors list
 166  * *p_update should be locked before using this function
 167  *
 168  * \param p_update pointer to the update struct
 169  * \return nothing
 170  */
 171 static void FreeMirrorsList( update_t *p_update )
 172 {
 173     int i;
 174
 175     for( i = 0; i < p_update->i_mirrors; i++ )
 176     {
 177         free( p_update->p_mirrors[i].psz_name );
 178         free( p_update->p_mirrors[i].psz_location );
 179         free( p_update->p_mirrors[i].psz_type );
 180         free( p_update->p_mirrors[i].psz_base_url );
 181     }
 182     FREENULL( p_update->p_mirrors );
 183     p_update->i_mirrors = 0;
 184     p_update->b_mirrors = VLC_FALSE;
 185 }
 186
 187 /**
 188  * Empty the releases list
 189  * *p_update should be locked before calling this function
 190  *
 191  * \param p_update pointer to the update struct
 192  * \return nothing
 193  */
 194 static void FreeReleasesList( update_t *p_update )
 195 {
 196     int i;
 197
 198     for( i = 0; i < p_update->i_releases; i++ )
 199     {
 200         int j;
 201         struct update_release_t *p_release = (p_update->p_releases + i);
 202         for( j = 0; j < p_release->i_files; j++ )
 203         {
 204             free( p_release->p_files[j].psz_md5 );
 205             free( p_release->p_files[j].psz_url );
 206             free( p_release->p_files[j].psz_description );
 207         }
 208         free( p_release->psz_major );
 209         free( p_release->psz_minor );
 210         free( p_release->psz_revision );
 211         free( p_release->psz_extra );
 212         free( p_release->psz_svn_revision );
 213         free( p_release->p_files );
 214     }
 215     FREENULL( p_update->p_releases );
 216     p_update->i_releases = 0;
 217     p_update->b_releases = VLC_FALSE;
 218 }
 219
 220 /**
 221  * Get the mirrors list XML file and parse it
 222  * *p_update has to be unlocked when calling this function
 223  *
 224  * \param p_update pointer to the update struct
 225  * \param b_force set to VLC_TRUE if you want to force the mirrors list update
 226  * \return nothing
 227  */
 228 static void GetMirrorsList( update_t *p_update, vlc_bool_t b_force )
 229 {
 230     stream_t *p_stream = NULL;
 231
 232     xml_t *p_xml = NULL;
 233     xml_reader_t *p_xml_reader = NULL;
 234     char *psz_eltname = NULL;
 235     //char *psz_eltvalue = NULL;
 236     char *psz_name = NULL;
 237     char *psz_value = NULL;
 238     struct update_mirror_t tmp_mirror;
 239
 240     vlc_mutex_lock( &p_update->lock );
 241
 242     memset( &tmp_mirror, 0, sizeof(struct update_mirror_t));
 243
 244     if( p_update->b_mirrors && b_force == VLC_FALSE )
 245     {
 246         vlc_mutex_unlock( &p_update->lock );
 247         return;
 248     }
 249
 250     p_xml = xml_Create( p_update->p_libvlc );
 251     if( !p_xml )
 252     {
 253         msg_Err( p_update->p_libvlc, "Failed to open XML parser" );
 254         goto error;
 255     }
 256
 257     p_stream = stream_UrlNew( p_update->p_libvlc, UPDATE_VLC_MIRRORS_URL );
 258     if( !p_stream )
 259     {
 260         msg_Err( p_update->p_libvlc, "Failed to open %s for reading",
 261                  UPDATE_VLC_MIRRORS_URL );
 262         goto error;
 263     }
 264
 265     p_xml_reader = xml_ReaderCreate( p_xml, p_stream );
 266
 267     if( !p_xml_reader )
 268     {
 269         msg_Err( p_update->p_libvlc, "Failed to open %s for parsing",
 270                  UPDATE_VLC_MIRRORS_URL );
 271         goto error;
 272     }
 273
 274     if( p_update->p_mirrors )
 275     {
 276         FreeMirrorsList( p_update );
 277     }
 278
 279     while( xml_ReaderRead( p_xml_reader ) == 1 )
 280     {
 281         switch( xml_ReaderNodeType( p_xml_reader ) )
 282         {
 283             case -1:
 284                 msg_Err( p_update->p_libvlc, "Error while parsing %s",
 285                          UPDATE_VLC_MIRRORS_URL );
 286                 goto error;
 287
 288             case XML_READER_STARTELEM:
 289                 psz_eltname = xml_ReaderName( p_xml_reader );
 290                 if( !psz_eltname )
 291                 {
 292                     msg_Err( p_update->p_libvlc, "Error while parsing %s",
 293                              UPDATE_VLC_MIRRORS_URL );
 294                     goto error;
 295                 }
 296
 297                 while( xml_ReaderNextAttr( p_xml_reader ) == VLC_SUCCESS )
 298                 {
 299                     psz_name = xml_ReaderName( p_xml_reader );
 300                     psz_value = xml_ReaderValue( p_xml_reader );
 301
 302                     if( !psz_name || !psz_value )
 303                     {
 304                         msg_Err( p_update->p_libvlc, "Error while parsing %s",
 305                                  UPDATE_VLC_MIRRORS_URL );
 306                         goto error;
 307                     }
 308
 309                     if( !strcmp( psz_eltname, "mirror" ) )
 310                     {
 311                         if( !strcmp( psz_name, "name" ) )
 312                             tmp_mirror.psz_name = STRDUP( psz_value );
 313                         else if( !strcmp( psz_name, "location" ) )
 314                             tmp_mirror.psz_location = STRDUP( psz_value );
 315                     }
 316                     else if( !strcmp( psz_eltname, "url" ) )
 317                     {
 318                         if( !strcmp( psz_name, "type" ) )
 319                             tmp_mirror.psz_type = STRDUP( psz_value );
 320                         else if( !strcmp( psz_name, "base" ) )
 321                             tmp_mirror.psz_base_url = STRDUP( psz_value );
 322                     }
 323                     FREENULL( psz_name );
 324                     FREENULL( psz_value );
 325                 }
 326                 if( !strcmp( psz_eltname, "url" ) )
 327                 {
 328                     /* append to mirrors list */
 329                     p_update->p_mirrors =
 330                     (struct update_mirror_t *)realloc( p_update->p_mirrors,
 331                                        (++(p_update->i_mirrors))
 332                                        *sizeof( struct update_mirror_t ) );
 333                     p_update->p_mirrors[ p_update->i_mirrors - 1 ] =
 334                         tmp_mirror;
 335                     tmp_mirror.psz_name = STRDUP( tmp_mirror.psz_name );
 336                     tmp_mirror.psz_location = STRDUP( tmp_mirror.psz_location );
 337                     tmp_mirror.psz_type = NULL;
 338                     tmp_mirror.psz_base_url = NULL;
 339                 }
 340                 FREENULL( psz_eltname );
 341                 break;
 342
 343             case XML_READER_ENDELEM:
 344                 psz_eltname = xml_ReaderName( p_xml_reader );
 345                 if( !psz_eltname )
 346                 {
 347                     msg_Err( p_update->p_libvlc, "Error while parsing %s",
 348                              UPDATE_VLC_MIRRORS_URL );
 349                     goto error;
 350                 }
 351
 352                 if( !strcmp( psz_eltname, "mirror" ) )
 353                 {
 354                     FREENULL( tmp_mirror.psz_name );
 355                     FREENULL( tmp_mirror.psz_location );
 356                 }
 357
 358                 FREENULL( psz_eltname );
 359                 break;
 360
 361             /*case XML_READER_TEXT:
 362                 psz_eltvalue = xml_ReaderValue( p_xml_reader );
 363                 FREENULL( psz_eltvalue );
 364                 break;*/
 365         }
 366     }
 367
 368     p_update->b_mirrors = VLC_TRUE;
 369
 370     error:
 371         vlc_mutex_unlock( &p_update->lock );
 372
 373         free( psz_eltname );
 374         //free( psz_eltvalue );
 375         free( psz_name );
 376         free( psz_value );
 377
 378         free( tmp_mirror.psz_name );
 379         free( tmp_mirror.psz_location );
 380         free( tmp_mirror.psz_type );
 381         free( tmp_mirror.psz_base_url );
 382
 383         if( p_xml_reader && p_xml )
 384             xml_ReaderDelete( p_xml, p_xml_reader );
 385         if( p_stream )
 386             stream_Delete( p_stream );
 387         if( p_xml )
 388             xml_Delete( p_xml );
 389 }
 390
 391 /**
 392  * Get the files list XML file and parse it
 393  * *p_update has to be unlocked when calling this function
 394  *
 395  * \param p_update pointer to update struct
 396  * \param b_force set to VLC_TRUE if you want to force the files list update
 397  * \return nothing
 398  */
 399 static void GetFilesList( update_t *p_update, vlc_bool_t b_force )
 400 {
 401     stream_t *p_stream = NULL;
 402
 403     xml_t *p_xml = NULL;
 404     xml_reader_t *p_xml_reader = NULL;
 405
 406     char *psz_eltname = NULL;
 407     char *psz_eltvalue = NULL;
 408     char *psz_name = NULL;
 409     char *psz_value = NULL;
 410
 411     struct update_release_t *p_release = NULL;
 412     struct update_release_t tmp_release;
 413     struct update_file_t tmp_file;
 414
 415     vlc_bool_t b_os = VLC_FALSE, b_arch = VLC_FALSE;
 416
 417     memset( &tmp_release, 0, sizeof(struct update_release_t) );
 418     memset( &tmp_file, 0, sizeof(struct update_file_t) );
 419
 420     tmp_release.i_type = UPDATE_RELEASE_TYPE_STABLE;
 421
 422     vlc_mutex_lock( &p_update->lock );
 423
 424     if( p_update->b_releases && b_force == VLC_FALSE )
 425     {
 426         vlc_mutex_unlock( &p_update->lock );
 427         return;
 428     }
 429
 430     p_xml = xml_Create( p_update->p_libvlc );
 431     if( !p_xml )
 432     {
 433         msg_Err( p_update->p_libvlc, "Failed to open XML parser" );
 434         goto error;
 435     }
 436
 437     p_stream = stream_UrlNew( p_update->p_libvlc, UPDATE_VLC_STATUS_URL );
 438     if( !p_stream )
 439     {
 440         msg_Err( p_update->p_libvlc, "Failed to open %s for reading",
 441                  UPDATE_VLC_STATUS_URL );
 442         goto error;
 443     }
 444
 445     p_xml_reader = xml_ReaderCreate( p_xml, p_stream );
 446
 447     if( !p_xml_reader )
 448     {
 449         msg_Err( p_update->p_libvlc, "Failed to open %s for parsing",
 450                  UPDATE_VLC_STATUS_URL );
 451         goto error;
 452     }
 453
 454     if( p_update->p_releases )
 455     {
 456         FreeReleasesList( p_update );
 457     }
 458
 459     while( xml_ReaderRead( p_xml_reader ) == 1 )
 460     {
 461         switch( xml_ReaderNodeType( p_xml_reader ) )
 462         {
 463             case -1:
 464                 msg_Err( p_update->p_libvlc, "Error while parsing %s",
 465                          UPDATE_VLC_STATUS_URL );
 466                 goto error;
 467
 468             case XML_READER_STARTELEM:
 469                 psz_eltname = xml_ReaderName( p_xml_reader );
 470                 if( !psz_eltname )
 471                 {
 472                     msg_Err( p_update->p_libvlc, "Error while parsing %s",
 473                              UPDATE_VLC_STATUS_URL );
 474                     goto error;
 475                 }
 476
 477                 while( xml_ReaderNextAttr( p_xml_reader ) == VLC_SUCCESS )
 478                 {
 479                     psz_name = xml_ReaderName( p_xml_reader );
 480                     psz_value = xml_ReaderValue( p_xml_reader );
 481
 482                     if( !psz_name || !psz_value )
 483                     {
 484                         msg_Err( p_update->p_libvlc, "Error while parsing %s",
 485                                  UPDATE_VLC_STATUS_URL );
 486                         goto error;
 487                     }
 488
 489                     if( b_os && b_arch )
 490                     {
 491                         if( strcmp( psz_eltname, "version" ) == 0 )
 492                         {
 493                             if( !strcmp( psz_name, "major" ) )
 494                                 tmp_release.psz_major = STRDUP( psz_value );
 495                             else if( !strcmp( psz_name, "minor" ) )
 496                                 tmp_release.psz_minor = STRDUP( psz_value );
 497                             else if( !strcmp( psz_name, "revision" ) )
 498                                 tmp_release.psz_revision = STRDUP( psz_value );
 499                             else if( !strcmp( psz_name, "extra" ) )
 500                                 tmp_release.psz_extra = STRDUP( psz_value );
 501                             else if( !strcmp( psz_name, "svn" ) )
 502                                 tmp_release.psz_svn_revision =
 503                                                            STRDUP( psz_value );
 504                             else if( !strcmp( psz_name, "version" ) )
 505                             {
 506                                 if( !strcmp( psz_value, "unstable" ) )
 507                                     tmp_release.i_type =
 508                                                   UPDATE_RELEASE_TYPE_UNSTABLE;
 509                                 else if( !strcmp( psz_value, "testing" ) )
 510                                     tmp_release.i_type =
 511                                                   UPDATE_RELEASE_TYPE_TESTING;
 512                                 else
 513                                     tmp_release.i_type =
 514                                                   UPDATE_RELEASE_TYPE_STABLE;
 515                             }
 516                         }
 517                         else if( !strcmp( psz_eltname, "file" ) )
 518                         {
 519                             if( !strcmp( psz_name, "type" ) )
 520                             {
 521                                 if( !strcmp( psz_value, "info" ) )
 522                                     tmp_file.i_type = UPDATE_FILE_TYPE_INFO;
 523                                 else if( !strcmp( psz_value, "source" ) )
 524                                     tmp_file.i_type = UPDATE_FILE_TYPE_SOURCE;
 525                                 else if( !strcmp( psz_value, "binary" ) )
 526                                     tmp_file.i_type = UPDATE_FILE_TYPE_BINARY;
 527                                 else if( !strcmp( psz_value, "plugin" ) )
 528                                     tmp_file.i_type = UPDATE_FILE_TYPE_PLUGIN;
 529                                 else
 530                                     tmp_file.i_type = UPDATE_FILE_TYPE_UNDEF;
 531                             }
 532                             else if( !strcmp( psz_name, "md5" ) )
 533                                 tmp_file.psz_md5 = STRDUP( psz_value );
 534                             else if( !strcmp( psz_name, "size" ) )
 535                                 tmp_file.l_size = atol( psz_value );
 536                             else if( !strcmp( psz_name, "url" ) )
 537                                 tmp_file.psz_url = STRDUP( psz_value );
 538                         }
 539                     }
 540                     if( !strcmp( psz_name, "name" )
 541                         && ( !strcmp( psz_value, UPDATE_VLC_OS )
 542                            || !strcmp( psz_value, "*" ) )
 543                         && !strcmp( psz_eltname, "os" ) )
 544                     {
 545                         b_os = VLC_TRUE;
 546                     }
 547                     if( b_os && !strcmp( psz_name, "name" )
 548                         && ( !strcmp( psz_value, UPDATE_VLC_ARCH )
 549                            || !strcmp( psz_value, "*" ) )
 550                         && !strcmp( psz_eltname, "arch" ) )
 551                     {
 552                         b_arch = VLC_TRUE;
 553                     }
 554                     FREENULL( psz_name );
 555                     FREENULL( psz_value );
 556                 }
 557                 if( ( b_os && b_arch && strcmp( psz_eltname, "arch" ) ) )
 558                 {
 559                     if( !strcmp( psz_eltname, "version" ) )
 560                     {
 561                         int i;
 562                         /* look for a previous occurrence of this release */
 563                         for( i = 0; i < p_update->i_releases; i++ )
 564                         {
 565                             p_release = p_update->p_releases + i;
 566                             if( CompareReleases( p_release, &tmp_release )
 567                                 == UPDATE_RELEASE_STATUS_EQUAL )
 568                             {
 569                                 break;
 570                             }
 571                         }
 572                         /* if this is the first time that we see this release,
 573                          * append it to the list of releases */
 574                         if( i == p_update->i_releases )
 575                         {
 576                             tmp_release.i_status =
 577                                 CompareReleaseToCurrent( &tmp_release );
 578                             p_update->p_releases =
 579                (struct update_release_t *)realloc( p_update->p_releases,
 580                (++(p_update->i_releases))*sizeof( struct update_release_t ) );
 581                             p_update->p_releases[ p_update->i_releases - 1 ] =
 582                                 tmp_release;
 583                             p_release =
 584                                 p_update->p_releases + p_update->i_releases - 1;
 585                             tmp_release.psz_major = NULL;
 586                             tmp_release.psz_minor = NULL;
 587                             tmp_release.psz_revision = NULL;
 588                             tmp_release.psz_extra = NULL;
 589                             tmp_release.psz_svn_revision = NULL;
 590                             tmp_release.i_type = UPDATE_RELEASE_TYPE_STABLE;
 591                             tmp_release.i_status = 0;
 592                             tmp_release.p_files = NULL;
 593                             tmp_release.i_files = 0;
 594                         }
 595                         else
 596                         {
 597                             FREENULL( tmp_release.psz_major );
 598                             FREENULL( tmp_release.psz_minor );
 599                             FREENULL( tmp_release.psz_revision );
 600                             FREENULL( tmp_release.psz_extra );
 601                             FREENULL( tmp_release.psz_svn_revision );
 602                             tmp_release.i_type = UPDATE_RELEASE_TYPE_STABLE;
 603                             FREENULL( tmp_release.p_files );
 604                             tmp_release.i_files = 0;
 605                         }
 606                     }
 607                     else if( !strcmp( psz_eltname, "file" ) )
 608                     {
 609                         /* append file to p_release's file list */
 610                         if( p_release == NULL )
 611                         {
 612                             goto error;
 613                         }
 614                         p_release->p_files =
 615                     (struct update_file_t *)realloc( p_release->p_files,
 616                     (++(p_release->i_files))*sizeof( struct update_file_t ) );
 617                         p_release->p_files[ p_release->i_files - 1 ] = tmp_file;
 618                         tmp_file.i_type = UPDATE_FILE_TYPE_UNDEF;
 619                         tmp_file.psz_md5 = NULL;
 620                         tmp_file.l_size = 0;
 621                         tmp_file.psz_url = NULL;
 622                         tmp_file.psz_description = NULL;
 623                     }
 624                 }
 625                 FREENULL( psz_eltname );
 626                 break;
 627
 628             case XML_READER_ENDELEM:
 629                 psz_eltname = xml_ReaderName( p_xml_reader );
 630                 if( !psz_eltname )
 631                 {
 632                     msg_Err( p_update->p_libvlc, "Error while parsing %s",
 633                              UPDATE_VLC_STATUS_URL );
 634                     goto error;
 635                 }
 636
 637                 if( !strcmp( psz_eltname, "os" ) )
 638                     b_os = VLC_FALSE;
 639                 else if( !strcmp( psz_eltname, "arch" ) )
 640                     b_arch = VLC_FALSE;
 641                 FREENULL( psz_eltname );
 642                 break;
 643
 644             case XML_READER_TEXT:
 645                 psz_eltvalue = xml_ReaderValue( p_xml_reader );
 646                 if( p_release && p_release->i_files )
 647                     p_release->p_files[ p_release->i_files - 1 ]
 648                                .psz_description = STRDUP( psz_eltvalue );
 649                 FREENULL( psz_eltvalue );
 650                 break;
 651         }
 652     }
 653
 654     p_update->b_releases = VLC_TRUE;
 655
 656     error:
 657         vlc_mutex_unlock( &p_update->lock );
 658
 659         free( psz_eltname );
 660         free( psz_eltvalue );
 661         free( psz_name );
 662         free( psz_value );
 663
 664         free( tmp_release.psz_major );
 665         free( tmp_release.psz_minor );
 666         free( tmp_release.psz_revision );
 667         free( tmp_release.psz_extra );
 668         free( tmp_release.psz_svn_revision );
 669
 670         free( tmp_file.psz_md5 );
 671         free( tmp_file.psz_url );
 672         free( tmp_file.psz_description );
 673
 674         if( p_xml_reader && p_xml )
 675             xml_ReaderDelete( p_xml, p_xml_reader );
 676         if( p_stream )
 677             stream_Delete( p_stream );
 678         if( p_xml )
 679             xml_Delete( p_xml );
 680 }
 681
 682 /**
 683  * Check for updates
 684  *
 685  * \param p_update pointer to update struct
 686  * \param b_force set to VLC_TRUE if you want to force the update
 687  * \returns nothing
 688  */
 689 void update_Check( update_t *p_update, vlc_bool_t b_force )
 690 {
 691     assert( p_update );
 692
 693     GetMirrorsList( p_update, b_force );
 694     GetFilesList( p_update, b_force );
 695 }
 696
 697 /**
 698  * Compare two release numbers
 699  * The comparision algorith basically performs an alphabetical order (strcmp)
 700  * comparision of each of the version number elements until it finds two
 701  * different ones. This is the tricky function.
 702  *
 703  * \param p1 first release
 704  * \param p2 second release
 705  * \return like strcmp
 706  */
 707 static int CompareReleases( const struct update_release_t *p1,
 708                             const struct update_release_t *p2 )
 709 {
 710     int d;
 711     if( ( d = strcmp( p1->psz_major, p2->psz_major ) ) ) ;
 712     else if( ( d = strcmp( p1->psz_minor, p2->psz_minor ) ) ) ;
 713     else if( ( d = strcmp( p1->psz_revision, p2->psz_revision ) ) ) ;
 714     else
 715     {
 716         d = strcmp( p1->psz_extra, p2->psz_extra );
 717         if( d<0 )
 718         {
 719         /* FIXME:
 720          * not num < NULL < num
 721          * -test and -svn releases are thus always considered older than
 722          * -'' or -0 releases, which is the best i could come up with */
 723             char *psz_end1;
 724             char *psz_end2;
 725             strtol( p1->psz_extra, &psz_end1, 10 );
 726             strtol( p2->psz_extra, &psz_end2, 10 );
 727             if( psz_end2 == p2->psz_extra
 728              && ( psz_end1 != p1->psz_extra || *p1->psz_extra == '\0' ) )
 729                 d = 1;
 730         }
 731     }
 732     if( d < 0 )
 733         return UPDATE_RELEASE_STATUS_OLDER;
 734     else if( d == 0 )
 735         return UPDATE_RELEASE_STATUS_EQUAL;
 736     else
 737         return UPDATE_RELEASE_STATUS_NEWER;
 738 }
 739
 740 /**
 741  * Compare a given release's version number to the current VLC's one
 742  *
 743  * \param p a release
 744  * \return >0 if newer, 0 if equal and <0 if older
 745  */
 746 static int CompareReleaseToCurrent( const struct update_release_t *p )
 747 {
 748     struct update_release_t c;
 749     int r;
 750
 751     memset( &c, 0, sizeof(struct update_release_t) );
 752     c.psz_major = STRDUP( PACKAGE_VERSION_MAJOR );
 753     c.psz_minor = STRDUP( PACKAGE_VERSION_MINOR );
 754     c.psz_revision = STRDUP( PACKAGE_VERSION_REVISION );
 755     c.psz_extra = STRDUP( PACKAGE_VERSION_EXTRA );
 756     r =  CompareReleases( p, &c );
 757     free( c.psz_major );
 758     free( c.psz_minor );
 759     free( c.psz_revision );
 760     free( c.psz_extra );
 761     return r;
 762 }
 763
 764 /*****************************************************************************
 765  * Updatei_iterator_t functions
 766  *****************************************************************************/
 767
 768 /**
 769  * Create a new update iterator structure. This structure can then be used to
 770  * describe a position and move through the update and mirror trees/lists.
 771  * This will use an existing update struct or create a new one if none is
 772  * found
 773  *
 774  * \param p_u the calling update_t
 775  * \return a pointer to an update iterator
 776  */
 777 update_iterator_t *update_iterator_New( update_t *p_u )
 778 {
 779     update_iterator_t *p_uit = NULL;
 780
 781     assert( p_u );
 782
 783     p_uit = (update_iterator_t *)malloc( sizeof( update_iterator_t ) );
 784     if( p_uit == NULL ) return NULL;
 785
 786     p_uit->p_u = p_u;
 787
 788     p_uit->i_m = -1;
 789     p_uit->i_r = -1;
 790     p_uit->i_f = -1;
 791
 792     p_uit->i_t = UPDATE_FILE_TYPE_ALL;
 793     p_uit->i_rs = UPDATE_RELEASE_STATUS_ALL;
 794     p_uit->i_rt = UPDATE_RELEASE_TYPE_STABLE;
 795
 796     p_uit->file.i_type = UPDATE_FILE_TYPE_NONE;
 797     p_uit->file.psz_md5 = NULL;
 798     p_uit->file.psz_url = NULL;
 799     p_uit->file.l_size = 0;
 800     p_uit->file.psz_description = NULL;
 801
 802     p_uit->release.psz_version = NULL;
 803     p_uit->release.psz_svn_revision = NULL;
 804     p_uit->release.i_type = UPDATE_RELEASE_TYPE_UNSTABLE;
 805     p_uit->release.i_status = UPDATE_RELEASE_STATUS_NONE;
 806
 807     p_uit->mirror.psz_name = NULL;
 808     p_uit->mirror.psz_location = NULL;
 809     p_uit->mirror.psz_type = NULL;
 810
 811     return p_uit;
 812 }
 813
 814 /**
 815  * Delete an update iterator structure (duh!)
 816  *
 817  * \param p_uit pointer to an update iterator
 818  * \return nothing
 819  */
 820 void update_iterator_Delete( update_iterator_t *p_uit )
 821 {
 822     assert( p_uit );
 823
 824     update_iterator_ClearData( p_uit );
 825     free( p_uit );
 826 }
 827
 828 /**
 829  * Reset an update_iterator_t structure
 830  *
 831  * \param p_uit pointer to an update iterator
 832  * \return UPDATE_FAIL upon error, UPDATE_SUCCESS otherwise
 833  */
 834 unsigned int update_iterator_Reset( update_iterator_t *p_uit )
 835 {
 836     assert( p_uit );
 837
 838     p_uit->i_r = -1;
 839     p_uit->i_f = -1;
 840     p_uit->i_m = -1;
 841
 842     update_iterator_ClearData( p_uit );
 843     return UPDATE_SUCCESS;
 844 }
 845
 846 /**
 847  * Finds the next file in the update tree that matches status and type
 848  * requirements set in the update_iterator
 849  *
 850  * \param p_uit update iterator
 851  * \return UPDATE_FAIL if we can't find the next file, UPDATE_SUCCESS|UPDATE_FILE if we stay in the same release, UPDATE_SUCCESS|UPDATE_RELEASE|UPDATE_FILE if we change the release index
 852  */
 853 static unsigned int update_iterator_NextFile( update_iterator_t *p_uit )
 854 {
 855     int r,f=-1,old_r;
 856
 857     assert( p_uit );
 858     old_r=p_uit->i_r;
 859
 860     /* if the update iterator was already in a "no match" state, start over */
 861     if( p_uit->i_r == -1 ) p_uit->i_r = 0;
 862     //if( p_uit->i_f == -1 ) p_uit->i_f = 0;
 863
 864     vlc_mutex_lock( &p_uit->p_u->lock );
 865
 866     for( r = p_uit->i_r; r < p_uit->p_u->i_releases; r++ )
 867     {
 868         if( !( p_uit->p_u->p_releases[r].i_status & p_uit->i_rs ) ) continue;
 869         for( f = ( r == p_uit->i_r ? p_uit->i_f + 1 : 0 );
 870              f < p_uit->p_u->p_releases[r].i_files; f++ )
 871         {
 872             if( p_uit->p_u->p_releases[r].p_files[f].i_type & p_uit->i_t )
 873             {
 874                 goto done;/* "double break" */
 875             }
 876         }
 877     }
 878     done:
 879     p_uit->i_r = r;
 880     p_uit->i_f = f;
 881
 882     r = p_uit->p_u->i_releases;
 883
 884     if( old_r == p_uit->i_r )
 885     {
 886         update_iterator_GetData( p_uit );
 887         vlc_mutex_unlock( &p_uit->p_u->lock );
 888         return UPDATE_SUCCESS|UPDATE_FILE;
 889     }
 890     else if( p_uit->i_r == r )
 891     {
 892         p_uit->i_r = -1;
 893         p_uit->i_f = -1;
 894         update_iterator_GetData( p_uit );
 895         vlc_mutex_unlock( &p_uit->p_u->lock );
 896         return UPDATE_FAIL;
 897     }
 898     else
 899     {
 900         update_iterator_GetData( p_uit );
 901         vlc_mutex_unlock( &p_uit->p_u->lock );
 902         return UPDATE_SUCCESS|UPDATE_RELEASE|UPDATE_FILE;
 903     }
 904 }
 905
 906 /**
 907  * Finds the previous file in the update tree that matches status and type
 908  * requirements set in the update_iterator
 909  *
 910  * \param p_uit update iterator
 911  * \return UPDATE_FAIL if we can't find the previous file, UPDATE_SUCCESS|UPDATE_FILE if we stay in the same release, UPDATE_SUCCESS|UPDATE_RELEASE|UPDATE_FILE if we change the release index
 912  */
 913 //TODO: test
 914 static unsigned int update_iterator_PrevFile( update_iterator_t *p_uit )
 915 {
 916     int r,f=-1,old_r;
 917
 918     if( !p_uit ) return UPDATE_FAIL;
 919
 920     old_r=p_uit->i_r;
 921
 922     /* if the update iterator was already in a "no match" state, start over
 923      * (begin at the end of the list) */
 924     if( p_uit->i_r == -1 ) p_uit->i_r = p_uit->p_u->i_releases - 1;
 925     p_uit->i_f = p_uit->p_u->p_releases[p_uit->i_r].i_files + 1;
 926
 927     vlc_mutex_lock( &p_uit->p_u->lock );
 928
 929     for( r = p_uit->i_r; r >= 0; r-- )
 930     {
 931         if( !( p_uit->p_u->p_releases[r].i_status & p_uit->i_rs ) ) continue;
 932         for( f =( r==p_uit->i_r ? p_uit->i_f - 1 : p_uit->p_u->p_releases[r].i_files );
 933              f >= 0; f-- )
 934         {
 935             if( p_uit->p_u->p_releases[r].p_files[f].i_type & p_uit->i_t )
 936             {
 937                 goto done;/* "double break" */
 938             }
 939         }
 940     }
 941     done:
 942     p_uit->i_r = r;
 943     p_uit->i_f = f;
 944
 945     r = p_uit->p_u->i_releases;
 946
 947     if( old_r == p_uit->i_r )
 948     {
 949         update_iterator_GetData( p_uit );
 950         vlc_mutex_unlock( &p_uit->p_u->lock );
 951         return UPDATE_SUCCESS|UPDATE_FILE;
 952     }
 953     else if( p_uit->i_r == -1 )
 954     {
 955         p_uit->i_r = -1;
 956         p_uit->i_f = -1;
 957         update_iterator_GetData( p_uit );
 958         vlc_mutex_unlock( &p_uit->p_u->lock );
 959         return UPDATE_FAIL;
 960     }
 961     else
 962     {
 963         update_iterator_GetData( p_uit );
 964         vlc_mutex_unlock( &p_uit->p_u->lock );
 965         return UPDATE_SUCCESS|UPDATE_RELEASE|UPDATE_FILE;
 966     }
 967 }
 968
 969 /**
 970  * Finds the next mirror in the update tree
 971  *
 972  * \param update iterator
 973  * \return UPDATE_FAIL if we can't find the next mirror, UPDATE_SUCCESS|UPDATE_MIRROR otherwise
 974  */
 975 static unsigned int update_iterator_NextMirror( update_iterator_t *p_uit )
 976 {
 977     if( !p_uit ) return UPDATE_FAIL;
 978     vlc_mutex_lock( &p_uit->p_u->lock );
 979     p_uit->i_m++;
 980     if( p_uit->i_m >= p_uit->p_u->i_mirrors ) p_uit->i_m = -1;
 981     update_iterator_GetData( p_uit );
 982     vlc_mutex_unlock( &p_uit->p_u->lock );
 983     return p_uit->i_m == -1 ? UPDATE_FAIL : UPDATE_SUCCESS|UPDATE_MIRROR;
 984 }
 985
 986 /**
 987  * Finds the previous mirror in the update tree
 988  *
 989  * \param update iterator
 990  * \return UPDATE_FAIL if we can't find a previous mirror, UPDATE_SUCCESS|UPDATE_MIRROR otherwise
 991  */
 992 static unsigned int update_iterator_PrevMirror( update_iterator_t *p_uit )
 993 {
 994     if( !p_uit ) return UPDATE_FAIL;
 995     vlc_mutex_lock( &p_uit->p_u->lock );
 996     p_uit->i_m--;
 997     update_iterator_GetData( p_uit );
 998     vlc_mutex_unlock( &p_uit->p_u->lock );
 999     return p_uit->i_m == -1 ? UPDATE_FAIL : UPDATE_SUCCESS|UPDATE_MIRROR;
1000 }
1001
1002 /**
1003  * Change the update iterator's position in the file and mirrors tree
1004  * If position is negative, don't change it
1005  *
1006  * \param i_m position in mirrors list
1007  * \param i_r position in releases list
1008  * \param i_f position in release's files list
1009  * \return UPDATE_FAIL when changing position fails or position wasn't changed, a combination of UPDATE_MIRROR, UPDATE_RELEASE and UPDATE_FILE otherwise
1010  */
1011 unsigned int update_iterator_ChooseMirrorAndFile( update_iterator_t *p_uit,
1012                                         int i_m, int i_r, int i_f )
1013 {
1014     unsigned int i_val = 0;
1015
1016     if( !p_uit ) return 0;
1017     vlc_mutex_lock( &p_uit->p_u->lock );
1018
1019     if( i_m >= 0 )
1020     {
1021         if( i_m < p_uit->p_u->i_mirrors )
1022         {
1023             if( i_m != p_uit->i_m )
1024                 i_val |= UPDATE_MIRROR;
1025             p_uit->i_m = i_m;
1026         }
1027         else i_m = -1;
1028     }
1029
1030     if( i_r >= 0 )
1031     {
1032         if( i_r < p_uit->p_u->i_releases )
1033         {
1034             if( i_r != p_uit->i_r )
1035                 i_val |= UPDATE_FILE;
1036             p_uit->i_r = i_r;
1037         }
1038         else i_r = -1;
1039     }
1040
1041     if( i_f >= 0 )
1042     {
1043         if( i_r >= 0 && i_r < p_uit->p_u->i_releases
1044             && i_f < p_uit->p_u->p_releases[p_uit->i_r].i_files )
1045         {
1046             if( i_f != p_uit->i_f )
1047                 i_val |= UPDATE_FILE;
1048             p_uit->i_f = i_f;
1049         }
1050         else i_f = -1;
1051     }
1052
1053     update_iterator_GetData( p_uit );
1054     vlc_mutex_unlock( &p_uit->p_u->lock );
1055
1056     if(    ( i_m < 0 || p_uit->i_m >= 0 )
1057         && ( i_r < 0 || p_uit->i_r >= 0 )
1058         && ( i_f < 0 || p_uit->i_f >= 0 ) )
1059     {
1060         /* Everything worked */
1061         return UPDATE_SUCCESS|i_val;
1062     }
1063     else
1064     {
1065         /* Something failed */
1066         return UPDATE_FAIL;
1067     }
1068 }
1069
1070 /**
1071  * Fills the iterator data (file, release and mirror structs)
1072  * The update struct should be locked before calling this function.
1073  *
1074  * \param p_uit update iterator
1075  * \return nothing
1076  */
1077 static void update_iterator_GetData( update_iterator_t *p_uit )
1078 {
1079     struct update_release_t *p_r = NULL;
1080     struct update_file_t *p_f = NULL;
1081     struct update_mirror_t *p_m = NULL;
1082
1083     update_iterator_ClearData( p_uit );
1084
1085     if( p_uit->i_m >= 0 )
1086     {
1087         p_m = p_uit->p_u->p_mirrors + p_uit->i_m;
1088         p_uit->mirror.psz_name = STRDUP( p_m->psz_name );
1089         p_uit->mirror.psz_location = STRDUP( p_m->psz_location );
1090         p_uit->mirror.psz_type = STRDUP( p_m->psz_type );
1091     }
1092
1093     if( p_uit->i_r >= 0 )
1094     {
1095         p_r = p_uit->p_u->p_releases + p_uit->i_r;
1096         asprintf( &p_uit->release.psz_version, "%s.%s.%s-%s",
1097                                               p_r->psz_major,
1098                                               p_r->psz_minor,
1099                                               p_r->psz_revision,
1100                                               p_r->psz_extra );
1101         p_uit->release.psz_svn_revision = STRDUP( p_r->psz_svn_revision );
1102         p_uit->release.i_type = p_r->i_type;
1103         p_uit->release.i_status = p_r->i_status;
1104         if( p_uit->i_f >= 0 )
1105         {
1106             p_f = p_r->p_files + p_uit->i_f;
1107             p_uit->file.i_type = p_f->i_type;
1108             p_uit->file.psz_md5 = STRDUP( p_f->psz_md5 );
1109             p_uit->file.l_size = p_f->l_size;
1110             p_uit->file.psz_description = STRDUP( p_f->psz_description);
1111             if( p_f->psz_url[0] == '/' )
1112             {
1113                 if( p_m )
1114                 {
1115                     asprintf( &p_uit->file.psz_url, "%s%s",
1116                               p_m->psz_base_url, p_f->psz_url );
1117                 }
1118             }
1119             else
1120             {
1121                 p_uit->file.psz_url = STRDUP( p_f->psz_url );
1122             }
1123         }
1124     }
1125 }
1126
1127 /**
1128  * Clears the iterator data (file, release and mirror structs)
1129  *
1130  * \param p_uit update iterator
1131  * \return nothing
1132  */
1133 static void update_iterator_ClearData( update_iterator_t *p_uit )
1134 {
1135     p_uit->file.i_type = UPDATE_FILE_TYPE_NONE;
1136     FREENULL( p_uit->file.psz_md5 );
1137     p_uit->file.l_size = 0;
1138     FREENULL( p_uit->file.psz_description );
1139     FREENULL( p_uit->file.psz_url );
1140     FREENULL( p_uit->release.psz_version );
1141     FREENULL( p_uit->release.psz_svn_revision );
1142     p_uit->release.i_type = UPDATE_RELEASE_TYPE_UNSTABLE;
1143     p_uit->release.i_status = UPDATE_RELEASE_STATUS_NONE;
1144     FREENULL( p_uit->mirror.psz_name );
1145     FREENULL( p_uit->mirror.psz_location );
1146     FREENULL( p_uit->mirror.psz_type );
1147 }
1148
1149 /**
1150  * Perform an action on the update iterator
1151  * Only the first matching action is performed.
1152  *
1153  * \param p_uit update iterator
1154  * \param i_action update action bitmask. can be a combination of UPDATE_NEXT, UPDATE_PREV, UPDATE_MIRROR, UPDATE_RELEASE, UPDATE_FILE, UPDATE_RESET
1155  * \return UPDATE_FAIL if action fails, UPDATE_SUCCESS|(combination of UPDATE_MIRROR, UPDATE_RELEASE and UPDATE_FILE if these changed) otherwise
1156  */
1157 unsigned int update_iterator_Action( update_iterator_t *p_uit, int i_action )
1158 {
1159     if( i_action & UPDATE_RESET )
1160     {
1161         return update_iterator_Reset( p_uit );
1162     }
1163     else
1164     if( i_action & UPDATE_MIRROR )
1165     {
1166         if( i_action & UPDATE_PREV )
1167         {
1168             return update_iterator_PrevMirror( p_uit );
1169         }
1170         else
1171         {
1172             return update_iterator_NextMirror( p_uit );
1173         }
1174     }
1175     /*else if( i_action & UPDATE_RELEASE )
1176     {
1177         if( i_action & UPDATE_PREV )
1178         {
1179             return update_iterator_PrevRelease( p_uit );
1180         }
1181         else
1182         {
1183             return update_iterator_NextRelease( p_uit );
1184         }
1185     }*/
1186     else if( i_action & UPDATE_FILE )
1187     {
1188         if( i_action & UPDATE_PREV )
1189         {
1190             return update_iterator_PrevFile( p_uit );
1191         }
1192         else
1193         {
1194             return update_iterator_NextFile( p_uit );
1195         }
1196     }
1197     else
1198     {
1199         return UPDATE_SUCCESS;
1200     }
1201 }
1202
1203 /**
1204  * Object to launch download thread in a different object
1205  */
1206 typedef struct {
1207     VLC_COMMON_MEMBERS
1208     char *psz_dest;     //< Download destination
1209     char *psz_src;      //< Download source
1210     char *psz_status;   //< Download status displayed in progress dialog
1211 } download_thread_t;
1212
1213 void update_download_for_real( download_thread_t *p_this );
1214
1215 /**
1216  * Download the file selected by the update iterator. This function will
1217  * launch the download in a new thread (downloads can be long)
1218  *
1219  * \param p_uit update iterator
1220  * \param psz_dest destination file path
1221  * \return nothing
1222  */
1223 void update_download( update_iterator_t *p_uit, const char *psz_dest )
1224 {
1225     download_thread_t *p_dt =
1226         vlc_object_create( p_uit->p_u->p_libvlc, sizeof( download_thread_t ) );
1227
1228     p_dt->psz_dest = strdup( psz_dest );
1229     p_dt->psz_src = strdup( p_uit->file.psz_url );
1230     asprintf( &p_dt->psz_status, "%s - %s (%s)\nSource: %s\nDestination: %s",
1231               p_uit->file.psz_description, p_uit->release.psz_version,
1232               p_uit->release.psz_svn_revision, p_uit->file.psz_url,
1233               psz_dest);
1234
1235     vlc_thread_create( p_dt, "download thread", update_download_for_real,
1236                        VLC_THREAD_PRIORITY_LOW, VLC_FALSE );
1237 }
1238
1239 /**
1240  * Convert a long int size in bytes to a string
1241  *
1242  * \param l_size the size in bytes
1243  * \return the size as a string
1244  */
1245 static char *size_str( long int l_size )
1246 {
1247     char *psz_tmp;
1248     if( l_size>> 30 )
1249         asprintf( &psz_tmp, "%.1f GB", (float)l_size/(1<<30) );
1250     if( l_size >> 20 )
1251         asprintf( &psz_tmp, "%.1f MB", (float)l_size/(1<<20) );
1252     else if( l_size >> 10 )
1253         asprintf( &psz_tmp, "%.1f kB", (float)l_size/(1<<10) );
1254     else
1255         asprintf( &psz_tmp, "%ld B", l_size );
1256     return psz_tmp;
1257 }
1258
1259 /**
1260  * The true download function.
1261  *
1262  * \param p_this the download_thread_t object
1263  * \return nothing
1264  */
1265 void update_download_for_real( download_thread_t *p_this )
1266 {
1267     char *psz_dest = p_this->psz_dest;
1268     char *psz_src = p_this->psz_src;
1269     stream_t *p_stream;
1270     libvlc_int_t *p_libvlc = p_this->p_libvlc;
1271
1272     FILE *p_file = NULL;
1273     void *p_buffer;
1274
1275     char *psz_status;
1276
1277     int i_progress;
1278     long int l_size, l_done = 0;
1279
1280     vlc_thread_ready( p_this );
1281
1282     asprintf( &psz_status, "%s\nDownloading... 0.0/? %.1f%% done",
1283               p_this->psz_status, 0.0 );
1284     i_progress = intf_UserProgress( p_libvlc, "Downloading...",
1285                                     psz_status, 0.0, 0 );
1286
1287     p_stream = stream_UrlNew( p_libvlc, psz_src );
1288     if( !p_stream )
1289     {
1290         msg_Err( p_libvlc, "Failed to open %s for reading", psz_src );
1291         intf_UserFatal( p_libvlc, VLC_TRUE, "Download Error",
1292                         "VLC failed to open %s for reading.", psz_src );
1293         intf_UserHide( p_libvlc, i_progress );
1294     }
1295     else
1296     {
1297         p_file = utf8_fopen( psz_dest, "w" );
1298         if( !p_file )
1299         {
1300             msg_Err( p_libvlc, "Failed to open %s for writing", psz_dest );
1301             intf_UserFatal( p_libvlc, VLC_TRUE, "Download Error",
1302                             "VLC failed to open %s for writing.", psz_dest );
1303             intf_UserHide( p_libvlc, i_progress );
1304         }
1305         else
1306         {
1307             long int l_read;
1308             char *psz_s1; char *psz_s2;
1309
1310             l_size = stream_Size(p_stream);
1311             p_buffer = (void *)malloc( 1<<10 );
1312             if( p_buffer )
1313             {
1314                 while( ( l_read = stream_Read( p_stream, p_buffer, 1<<10 ) ) )
1315                 {
1316                     float f_progress;
1317
1318                     fwrite( p_buffer, l_read, 1, p_file );
1319
1320                     l_done += l_read;
1321                     free( psz_status );
1322                     f_progress = 100.0*(float)l_done/(float)l_size;
1323                     psz_s1 = size_str( l_done );
1324                     psz_s2 = size_str( l_size );
1325                     asprintf( &psz_status, "%s\nDownloading... %s/%s (%.1f%%) done",
1326                             p_this->psz_status, psz_s1, psz_s2, f_progress );
1327                     free( psz_s1 );
1328                     free( psz_s2 );
1329
1330                     intf_ProgressUpdate( p_libvlc, i_progress,
1331                                         psz_status, f_progress, 0 );
1332                 }
1333
1334                 free( p_buffer );
1335             }
1336             fclose( p_file );
1337             stream_Delete( p_stream );
1338
1339             free( psz_status );
1340             psz_s2 = size_str( l_size );
1341             asprintf( &psz_status, "%s\nDone %s (100.00%%)",
1342                        p_this->psz_status, psz_s2 );
1343             free( psz_s2 );
1344             intf_ProgressUpdate( p_libvlc, i_progress, psz_status, 100.0, 0 );
1345             free( psz_status );
1346         }
1347     }
1348
1349     free( p_this->psz_dest );
1350     free( p_this->psz_src );
1351     free( p_this->psz_status );
1352
1353     vlc_object_destroy( p_this );
1354 }