1d7f7656e16f6c0772fb56cc79661036620ede00
[vlc.git] / src / misc / update.c
1 /*****************************************************************************
2  * update.c: VLC update checking and downloading
3  *****************************************************************************
4  * Copyright © 2005-2008 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Antoine Cellerier <dionoea -at- videolan -dot- org>
8  *          Rémi Duraffort <ivoire at via.ecp.fr>
9             Rafaël Carré <funman@videolanorg>
10  *
11  * This program is free software; you can redistribute it and/or modify it
12  * under the terms of the GNU Lesser General Public License as published by
13  * the Free Software Foundation; either release 2 of the License, or
14  * (at your option) any later release.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24  *****************************************************************************/
25
26 /**
27  *   \file
28  *   This file contains functions related to VLC update management
29  */
30
31 /*****************************************************************************
32  * Preamble
33  *****************************************************************************/
34
35 #ifdef HAVE_CONFIG_H
36 # include "config.h"
37 #endif
38
39 #include <vlc_common.h>
40 #include <vlc_update.h>
41
42 #ifdef UPDATE_CHECK
43
44 #include <assert.h>
45
46 #include <vlc_pgpkey.h>
47 #include <vlc_stream.h>
48 #include <vlc_strings.h>
49 #include <vlc_fs.h>
50 #include <vlc_dialog.h>
51 #include <vlc_interface.h>
52
53 #include <gcrypt.h>
54 #include <vlc_gcrypt.h>
55 #ifdef _WIN32
56 #include <shellapi.h>
57 #endif
58 #include "update.h"
59 #include "../libvlc.h"
60
61 /*****************************************************************************
62  * Misc defines
63  *****************************************************************************/
64
65 /*
66  * Here is the format of these "status files" :
67  * First line is the last version: "X.Y.Z.E" where:
68  *      * X is the major number
69  *      * Y is the minor number
70  *      * Z is the revision number
71  *      * .E is an OPTIONAL extra number
72  *      * IE "1.2.0" or "1.1.10.1"
73  * Second line is a url of the binary for this last version
74  * Remaining text is a required description of the update
75  */
76
77 #if defined( _WIN64 )
78 # define UPDATE_OS_SUFFIX "-win-x64"
79 #elif defined( _WIN32 )
80 # define UPDATE_OS_SUFFIX "-win-x86"
81 #else
82 # define UPDATE_OS_SUFFIX ""
83 #endif
84
85 #ifndef NDEBUG
86 # define UPDATE_VLC_STATUS_URL "http://update-test.videolan.org/vlc/status-win-x86"
87 #else
88 # define UPDATE_VLC_STATUS_URL "http://update.videolan.org/vlc/status" UPDATE_OS_SUFFIX
89 #endif
90
91 /*****************************************************************************
92  * Update_t functions
93  *****************************************************************************/
94
95 #undef update_New
96 /**
97  * Create a new update VLC struct
98  *
99  * \param p_this the calling vlc_object
100  * \return pointer to new update_t or NULL
101  */
102 update_t *update_New( vlc_object_t *p_this )
103 {
104     update_t *p_update;
105     assert( p_this );
106
107     p_update = (update_t *)malloc( sizeof( update_t ) );
108     if( !p_update ) return NULL;
109
110     vlc_mutex_init( &p_update->lock );
111
112     p_update->p_libvlc = p_this->p_libvlc;
113
114     p_update->release.psz_url = NULL;
115     p_update->release.psz_desc = NULL;
116
117     p_update->p_download = NULL;
118     p_update->p_check = NULL;
119
120     p_update->p_pkey = NULL;
121     vlc_gcrypt_init();
122
123     return p_update;
124 }
125
126 /**
127  * Delete an update_t struct
128  *
129  * \param p_update update_t* pointer
130  * \return nothing
131  */
132 void update_Delete( update_t *p_update )
133 {
134     assert( p_update );
135
136     if( p_update->p_check )
137     {
138         vlc_join( p_update->p_check->thread, NULL );
139         free( p_update->p_check );
140     }
141
142     if( p_update->p_download )
143     {
144         atomic_store( &p_update->p_download->aborted, true );
145         vlc_join( p_update->p_download->thread, NULL );
146         vlc_object_release( p_update->p_download );
147     }
148
149     vlc_mutex_destroy( &p_update->lock );
150
151     free( p_update->release.psz_url );
152     free( p_update->release.psz_desc );
153     free( p_update->p_pkey );
154
155     free( p_update );
156 }
157
158 /**
159  * Empty the release struct
160  *
161  * \param p_update update_t* pointer
162  * \return nothing
163  */
164 static void EmptyRelease( update_t *p_update )
165 {
166     p_update->release.i_major = 0;
167     p_update->release.i_minor = 0;
168     p_update->release.i_revision = 0;
169
170     FREENULL( p_update->release.psz_url );
171     FREENULL( p_update->release.psz_desc );
172 }
173
174 /**
175  * Get the update file and parse it
176  * p_update has to be locked when calling this function
177  *
178  * \param p_update pointer to update struct
179  * \return true if the update is valid and authenticated
180  */
181 static bool GetUpdateFile( update_t *p_update )
182 {
183     stream_t *p_stream = NULL;
184     char *psz_version_line = NULL;
185     char *psz_update_data = NULL;
186
187     p_stream = stream_UrlNew( p_update->p_libvlc, UPDATE_VLC_STATUS_URL );
188     if( !p_stream )
189     {
190         msg_Err( p_update->p_libvlc, "Failed to open %s for reading",
191                  UPDATE_VLC_STATUS_URL );
192         goto error;
193     }
194
195     uint64_t i_read;
196     if( stream_GetSize( p_stream, &i_read ) || i_read >= UINT16_MAX )
197     {
198         msg_Err(p_update->p_libvlc, "Status file too large");
199         goto error;
200     }
201
202     psz_update_data = malloc( i_read + 1 ); /* terminating '\0' */
203     if( !psz_update_data )
204         goto error;
205
206     if( stream_Read( p_stream, psz_update_data, i_read ) != (ssize_t)i_read )
207     {
208         msg_Err( p_update->p_libvlc, "Couldn't download update file %s",
209                 UPDATE_VLC_STATUS_URL );
210         goto error;
211     }
212     psz_update_data[i_read] = '\0';
213
214     stream_Delete( p_stream );
215     p_stream = NULL;
216
217     /* first line : version number */
218     char *psz_update_data_parser = psz_update_data;
219     size_t i_len = strcspn( psz_update_data, "\r\n" );
220     psz_update_data_parser += i_len;
221     while( *psz_update_data_parser == '\r' || *psz_update_data_parser == '\n' )
222         psz_update_data_parser++;
223
224     if( !(psz_version_line = malloc( i_len + 1)) )
225         goto error;
226     strncpy( psz_version_line, psz_update_data, i_len );
227     psz_version_line[i_len] = '\0';
228
229     p_update->release.i_extra = 0;
230     int ret = sscanf( psz_version_line, "%i.%i.%i.%i",
231                     &p_update->release.i_major, &p_update->release.i_minor,
232                     &p_update->release.i_revision, &p_update->release.i_extra);
233     if( ret != 3 && ret != 4 )
234     {
235             msg_Err( p_update->p_libvlc, "Update version false formated" );
236             goto error;
237     }
238
239     /* second line : URL */
240     i_len = strcspn( psz_update_data_parser, "\r\n" );
241     if( i_len == 0 )
242     {
243         msg_Err( p_update->p_libvlc, "Update file %s is corrupted: URL missing",
244                  UPDATE_VLC_STATUS_URL );
245
246         goto error;
247     }
248
249     if( !(p_update->release.psz_url = malloc( i_len + 1)) )
250         goto error;
251     strncpy( p_update->release.psz_url, psz_update_data_parser, i_len );
252     p_update->release.psz_url[i_len] = '\0';
253
254     psz_update_data_parser += i_len;
255     while( *psz_update_data_parser == '\r' || *psz_update_data_parser == '\n' )
256         psz_update_data_parser++;
257
258     /* Remaining data : description */
259     i_len = strlen( psz_update_data_parser );
260     if( i_len == 0 )
261     {
262         msg_Err( p_update->p_libvlc,
263                 "Update file %s is corrupted: description missing",
264                 UPDATE_VLC_STATUS_URL );
265         goto error;
266     }
267
268     if( !(p_update->release.psz_desc = malloc( i_len + 1)) )
269         goto error;
270     strncpy( p_update->release.psz_desc, psz_update_data_parser, i_len );
271     p_update->release.psz_desc[i_len] = '\0';
272
273     /* Now that we know the status is valid, we must download its signature
274      * to authenticate it */
275     signature_packet_t sign;
276     if( download_signature( VLC_OBJECT( p_update->p_libvlc ), &sign,
277             UPDATE_VLC_STATUS_URL ) != VLC_SUCCESS )
278     {
279         msg_Err( p_update->p_libvlc, "Couldn't download signature of status file" );
280         goto error;
281     }
282
283     if( sign.type != BINARY_SIGNATURE && sign.type != TEXT_SIGNATURE )
284     {
285         msg_Err( p_update->p_libvlc, "Invalid signature type" );
286         goto error;
287     }
288
289     p_update->p_pkey = (public_key_t*)malloc( sizeof( public_key_t ) );
290     if( !p_update->p_pkey )
291         goto error;
292
293     if( parse_public_key( videolan_public_key, sizeof( videolan_public_key ),
294                         p_update->p_pkey, NULL ) != VLC_SUCCESS )
295     {
296         msg_Err( p_update->p_libvlc, "Couldn't parse embedded public key, something went really wrong..." );
297         FREENULL( p_update->p_pkey );
298         goto error;
299     }
300
301     memcpy( p_update->p_pkey->longid, videolan_public_key_longid, 8 );
302
303     if( memcmp( sign.issuer_longid, p_update->p_pkey->longid , 8 ) != 0 )
304     {
305         msg_Dbg( p_update->p_libvlc, "Need to download the GPG key" );
306         public_key_t *p_new_pkey = download_key(
307                 VLC_OBJECT(p_update->p_libvlc),
308                 sign.issuer_longid, videolan_public_key_longid );
309         if( !p_new_pkey )
310         {
311             msg_Err( p_update->p_libvlc, "Couldn't download GPG key" );
312             FREENULL( p_update->p_pkey );
313             goto error;
314         }
315
316         uint8_t *p_hash = hash_from_public_key( p_new_pkey );
317         if( !p_hash )
318         {
319             msg_Err( p_update->p_libvlc, "Failed to hash signature" );
320             free( p_new_pkey );
321             FREENULL( p_update->p_pkey );
322             goto error;
323         }
324
325         if( verify_signature( &p_new_pkey->sig,
326                     &p_update->p_pkey->key, p_hash ) == VLC_SUCCESS )
327         {
328             free( p_hash );
329             msg_Info( p_update->p_libvlc, "Key authenticated" );
330             free( p_update->p_pkey );
331             p_update->p_pkey = p_new_pkey;
332         }
333         else
334         {
335             free( p_hash );
336             msg_Err( p_update->p_libvlc, "Key signature invalid !" );
337             goto error;
338         }
339     }
340
341     uint8_t *p_hash = hash_from_text( psz_update_data, &sign );
342     if( !p_hash )
343     {
344         msg_Warn( p_update->p_libvlc, "Can't compute hash for status file" );
345         goto error;
346     }
347
348     else if( p_hash[0] != sign.hash_verification[0] ||
349         p_hash[1] != sign.hash_verification[1] )
350     {
351         msg_Warn( p_update->p_libvlc, "Bad hash for status file" );
352         free( p_hash );
353         goto error;
354     }
355
356     else if( verify_signature( &sign, &p_update->p_pkey->key, p_hash )
357             != VLC_SUCCESS )
358     {
359         msg_Err( p_update->p_libvlc, "BAD SIGNATURE for status file" );
360         free( p_hash );
361         goto error;
362     }
363
364     else
365     {
366         msg_Info( p_update->p_libvlc, "Status file authenticated" );
367         free( p_hash );
368         free( psz_version_line );
369         free( psz_update_data );
370         return true;
371     }
372
373 error:
374     if( p_stream )
375         stream_Delete( p_stream );
376     free( psz_version_line );
377     free( psz_update_data );
378     return false;
379 }
380
381 static void* update_CheckReal( void * );
382
383 /**
384  * Check for updates
385  *
386  * \param p_update pointer to update struct
387  * \param pf_callback pointer to a function to call when the update_check is finished
388  * \param p_data pointer to some datas to give to the callback
389  * \returns nothing
390  */
391 void update_Check( update_t *p_update, void (*pf_callback)( void*, bool ), void *p_data )
392 {
393     assert( p_update );
394
395     // If the object already exist, destroy it
396     if( p_update->p_check )
397     {
398         vlc_join( p_update->p_check->thread, NULL );
399         free( p_update->p_check );
400     }
401
402     update_check_thread_t *p_uct = calloc( 1, sizeof( *p_uct ) );
403     if( !p_uct ) return;
404
405     p_uct->p_update = p_update;
406     p_update->p_check = p_uct;
407     p_uct->pf_callback = pf_callback;
408     p_uct->p_data = p_data;
409
410     vlc_clone( &p_uct->thread, update_CheckReal, p_uct, VLC_THREAD_PRIORITY_LOW );
411 }
412
413 void* update_CheckReal( void *obj )
414 {
415     update_check_thread_t *p_uct = (update_check_thread_t *)obj;
416     bool b_ret;
417     int canc;
418
419     canc = vlc_savecancel ();
420     vlc_mutex_lock( &p_uct->p_update->lock );
421
422     EmptyRelease( p_uct->p_update );
423     b_ret = GetUpdateFile( p_uct->p_update );
424     vlc_mutex_unlock( &p_uct->p_update->lock );
425
426     if( p_uct->pf_callback )
427         (p_uct->pf_callback)( p_uct->p_data, b_ret );
428
429     vlc_restorecancel (canc);
430     return NULL;
431 }
432
433 bool update_NeedUpgrade( update_t *p_update )
434 {
435     assert( p_update );
436
437     static const int current[4] = {
438         PACKAGE_VERSION_MAJOR,
439         PACKAGE_VERSION_MINOR,
440         PACKAGE_VERSION_REVISION,
441         PACKAGE_VERSION_EXTRA
442     };
443     const int latest[4] = {
444         p_update->release.i_major,
445         p_update->release.i_minor,
446         p_update->release.i_revision,
447         p_update->release.i_extra
448     };
449
450     for (unsigned i = 0; i < sizeof latest / sizeof *latest; i++) {
451         /* there is a new version available */
452         if (latest[i] > current[i])
453             return true;
454
455         /* current version is more recent than the latest version ?! */
456         if (latest[i] < current[i])
457             return false;
458     }
459
460     /* current version is not a release, it's a -git or -rc version */
461     if (*PACKAGE_VERSION_DEV)
462         return true;
463
464     /* current version is latest version */
465     return false;
466 }
467
468 /**
469  * Convert a long int size in bytes to a string
470  *
471  * \param l_size the size in bytes
472  * \return the size as a string
473  */
474 static char *size_str( uint64_t l_size )
475 {
476     char *psz_tmp = NULL;
477     int i_retval = 0;
478     if( l_size >> 30 )
479         i_retval = asprintf( &psz_tmp, _("%.1f GiB"), (float)l_size/(1<<30) );
480     else if( l_size >> 20 )
481         i_retval = asprintf( &psz_tmp, _("%.1f MiB"), (float)l_size/(1<<20) );
482     else if( l_size >> 10 )
483         i_retval = asprintf( &psz_tmp, _("%.1f KiB"), (float)l_size/(1<<10) );
484     else
485         i_retval = asprintf( &psz_tmp, _("%"PRIu64" B"), l_size );
486
487     return i_retval == -1 ? NULL : psz_tmp;
488 }
489
490 static void* update_DownloadReal( void * );
491
492 /**
493  * Download the file given in the update_t
494  *
495  * \param p_update structure
496  * \param dir to store the download file
497  * \return nothing
498  */
499 void update_Download( update_t *p_update, const char *psz_destdir )
500 {
501     assert( p_update );
502
503     // If the object already exist, destroy it
504     if( p_update->p_download )
505     {
506         atomic_store( &p_update->p_download->aborted, true );
507         vlc_join( p_update->p_download->thread, NULL );
508         vlc_object_release( p_update->p_download );
509     }
510
511     update_download_thread_t *p_udt =
512         vlc_custom_create( p_update->p_libvlc, sizeof( *p_udt ),
513                            "update download" );
514     if( !p_udt )
515         return;
516
517     p_udt->p_update = p_update;
518     p_update->p_download = p_udt;
519     p_udt->psz_destdir = psz_destdir ? strdup( psz_destdir ) : NULL;
520
521     atomic_store(&p_udt->aborted, false);
522     vlc_clone( &p_udt->thread, update_DownloadReal, p_udt, VLC_THREAD_PRIORITY_LOW );
523 }
524
525 static void* update_DownloadReal( void *obj )
526 {
527     update_download_thread_t *p_udt = (update_download_thread_t *)obj;
528     dialog_progress_bar_t *p_progress = NULL;
529     uint64_t l_size;
530     uint64_t l_downloaded = 0;
531     float f_progress;
532     char *psz_status;
533     char *psz_downloaded = NULL;
534     char *psz_size = NULL;
535     char *psz_destfile = NULL;
536     char *psz_tmpdestfile = NULL;
537
538     FILE *p_file = NULL;
539     stream_t *p_stream = NULL;
540     void* p_buffer = NULL;
541     int i_read;
542     int canc;
543
544     update_t *p_update = p_udt->p_update;
545     char *psz_destdir = p_udt->psz_destdir;
546
547     msg_Dbg( p_udt, "Opening Stream '%s'", p_update->release.psz_url );
548     canc = vlc_savecancel ();
549
550     /* Open the stream */
551     p_stream = stream_UrlNew( p_udt, p_update->release.psz_url );
552     if( !p_stream )
553     {
554         msg_Err( p_udt, "Failed to open %s for reading", p_update->release.psz_url );
555         goto end;
556     }
557
558     /* Get the stream size */
559     if( stream_GetSize( p_stream, &l_size ) || l_size == 0 )
560         goto end;
561
562     /* Get the file name and open it*/
563     psz_tmpdestfile = strrchr( p_update->release.psz_url, '/' );
564     if( !psz_tmpdestfile )
565     {
566         msg_Err( p_udt, "The URL %s is badly formated",
567                  p_update->release.psz_url );
568         goto end;
569     }
570     psz_tmpdestfile++;
571     if( asprintf( &psz_destfile, "%s%s", psz_destdir, psz_tmpdestfile ) == -1 )
572         goto end;
573
574     p_file = vlc_fopen( psz_destfile, "w" );
575     if( !p_file )
576     {
577         msg_Err( p_udt, "Failed to open %s for writing", psz_destfile );
578         dialog_FatalWait( p_udt, _("Saving file failed"),
579             _("Failed to open \"%s\" for writing"),
580              psz_destfile );
581         goto end;
582     }
583
584     /* Create a buffer and fill it with the downloaded file */
585     p_buffer = (void *)malloc( 1 << 10 );
586     if( unlikely(p_buffer == NULL) )
587         goto end;
588
589     msg_Dbg( p_udt, "Downloading Stream '%s'", p_update->release.psz_url );
590
591     psz_size = size_str( l_size );
592     if( asprintf( &psz_status, _("%s\nDownloading... %s/%s %.1f%% done"),
593         p_update->release.psz_url, "0.0", psz_size, 0.0 ) == -1 )
594         goto end;
595
596     p_progress = dialog_ProgressCreate( p_udt, _( "Downloading..."),
597                                         psz_status, _("Cancel") );
598
599     free( psz_status );
600     if( p_progress == NULL )
601         goto end;
602
603     while( !atomic_load( &p_udt->aborted ) &&
604            ( i_read = stream_Read( p_stream, p_buffer, 1 << 10 ) ) &&
605            !dialog_ProgressCancelled( p_progress ) )
606     {
607         if( fwrite( p_buffer, i_read, 1, p_file ) < 1 )
608         {
609             msg_Err( p_udt, "Failed to write into %s", psz_destfile );
610             break;
611         }
612
613         l_downloaded += i_read;
614         psz_downloaded = size_str( l_downloaded );
615         f_progress = (float)l_downloaded/(float)l_size;
616
617         if( asprintf( &psz_status, _( "%s\nDownloading... %s/%s - %.1f%% done" ),
618                       p_update->release.psz_url, psz_downloaded, psz_size,
619                       f_progress*100 ) != -1 )
620         {
621             dialog_ProgressSet( p_progress, psz_status, f_progress );
622             free( psz_status );
623         }
624         free( psz_downloaded );
625     }
626
627     /* Finish the progress bar or delete the file if the user had canceled */
628     fclose( p_file );
629     p_file = NULL;
630
631     if( !atomic_load( &p_udt->aborted ) &&
632         !dialog_ProgressCancelled( p_progress ) )
633     {
634         dialog_ProgressDestroy( p_progress );
635         p_progress = NULL;
636     }
637     else
638     {
639         vlc_unlink( psz_destfile );
640         goto end;
641     }
642
643     signature_packet_t sign;
644     if( download_signature( VLC_OBJECT( p_udt ), &sign,
645             p_update->release.psz_url ) != VLC_SUCCESS )
646     {
647         vlc_unlink( psz_destfile );
648
649         dialog_FatalWait( p_udt, _("File could not be verified"),
650             _("It was not possible to download a cryptographic signature for "
651               "the downloaded file \"%s\". Thus, it was deleted."),
652             psz_destfile );
653         msg_Err( p_udt, "Couldn't download signature of downloaded file" );
654         goto end;
655     }
656
657     if( memcmp( sign.issuer_longid, p_update->p_pkey->longid, 8 ) )
658     {
659         vlc_unlink( psz_destfile );
660         msg_Err( p_udt, "Invalid signature issuer" );
661         dialog_FatalWait( p_udt, _("Invalid signature"),
662             _("The cryptographic signature for the downloaded file \"%s\" was "
663               "invalid and could not be used to securely verify it. Thus, the "
664               "file was deleted."),
665             psz_destfile );
666         goto end;
667     }
668
669     if( sign.type != BINARY_SIGNATURE )
670     {
671         vlc_unlink( psz_destfile );
672         msg_Err( p_udt, "Invalid signature type" );
673         dialog_FatalWait( p_udt, _("Invalid signature"),
674             _("The cryptographic signature for the downloaded file \"%s\" was "
675               "invalid and could not be used to securely verify it. Thus, the "
676               "file was deleted."),
677             psz_destfile );
678         goto end;
679     }
680
681     uint8_t *p_hash = hash_from_file( psz_destfile, &sign );
682     if( !p_hash )
683     {
684         msg_Err( p_udt, "Unable to hash %s", psz_destfile );
685         vlc_unlink( psz_destfile );
686         dialog_FatalWait( p_udt, _("File not verifiable"),
687             _("It was not possible to securely verify the downloaded file"
688               " \"%s\". Thus, it was deleted."),
689             psz_destfile );
690
691         goto end;
692     }
693
694     if( p_hash[0] != sign.hash_verification[0] ||
695         p_hash[1] != sign.hash_verification[1] )
696     {
697         vlc_unlink( psz_destfile );
698         dialog_FatalWait( p_udt, _("File corrupted"),
699             _("Downloaded file \"%s\" was corrupted. Thus, it was deleted."),
700              psz_destfile );
701         msg_Err( p_udt, "Bad hash for %s", psz_destfile );
702         free( p_hash );
703         goto end;
704     }
705
706     if( verify_signature( &sign, &p_update->p_pkey->key, p_hash )
707             != VLC_SUCCESS )
708     {
709         vlc_unlink( psz_destfile );
710         dialog_FatalWait( p_udt, _("File corrupted"),
711             _("Downloaded file \"%s\" was corrupted. Thus, it was deleted."),
712              psz_destfile );
713         msg_Err( p_udt, "BAD SIGNATURE for %s", psz_destfile );
714         free( p_hash );
715         goto end;
716     }
717
718     msg_Info( p_udt, "%s authenticated", psz_destfile );
719     free( p_hash );
720
721 #ifdef _WIN32
722     int answer = dialog_Question( p_udt, _("Update VLC media player"),
723     _("The new version was successfully downloaded. Do you want to close VLC and install it now?"),
724     _("Install"), _("Cancel"), NULL);
725
726     if(answer == 1)
727     {
728         wchar_t psz_wdestfile[MAX_PATH];
729         MultiByteToWideChar( CP_UTF8, 0, psz_destfile, -1, psz_wdestfile, MAX_PATH );
730         answer = (int)ShellExecuteW( NULL, L"open", psz_wdestfile, NULL, NULL, SW_SHOW);
731         if(answer > 32)
732             libvlc_Quit(p_udt->p_libvlc);
733     }
734 #endif
735 end:
736     if( p_progress )
737         dialog_ProgressDestroy( p_progress );
738     if( p_stream )
739         stream_Delete( p_stream );
740     if( p_file )
741         fclose( p_file );
742     free( psz_destdir );
743     free( psz_destfile );
744     free( p_buffer );
745     free( psz_size );
746
747     vlc_restorecancel( canc );
748     return NULL;
749 }
750
751 update_release_t *update_GetRelease( update_t *p_update )
752 {
753     return &p_update->release;
754 }
755
756 #else
757 #undef update_New
758 update_t *update_New( vlc_object_t *p_this )
759 {
760     (void)p_this;
761     return NULL;
762 }
763
764 void update_Delete( update_t *p_update )
765 {
766     (void)p_update;
767 }
768
769 void update_Check( update_t *p_update, void (*pf_callback)( void*, bool ),
770                    void *p_data )
771 {
772     (void)p_update; (void)pf_callback; (void)p_data;
773 }
774
775 bool update_NeedUpgrade( update_t *p_update )
776 {
777     (void)p_update;
778     return false;
779 }
780
781 void update_Download( update_t *p_update, const char *psz_destdir )
782 {
783     (void)p_update; (void)psz_destdir;
784 }
785
786 update_release_t *update_GetRelease( update_t *p_update )
787 {
788     (void)p_update;
789     return NULL;
790 }
791 #endif