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