gdi32: Move to a more scalable mechanism for picking the default fonts.
[wine] / dlls / msi / patch.c
1 /*
2  * Implementation of the Microsoft Installer (msi.dll)
3  *
4  * Copyright 2004,2005 Aric Stewart for CodeWeavers
5  * Copyright 2011 Hans Leidekker for CodeWeavers
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include <stdarg.h>
23 #define COBJMACROS
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winreg.h"
27 #include "objbase.h"
28 #include "shlwapi.h"
29 #include "wine/debug.h"
30 #include "wine/unicode.h"
31 #include "msipriv.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(msi);
34
35 static BOOL match_language( MSIPACKAGE *package, LANGID langid )
36 {
37     UINT i;
38
39     if (!package->num_langids || !langid) return TRUE;
40     for (i = 0; i < package->num_langids; i++)
41     {
42         if (package->langids[i] == langid) return TRUE;
43     }
44     return FALSE;
45 }
46
47 static UINT check_transform_applicable( MSIPACKAGE *package, IStorage *patch )
48 {
49     LPWSTR prod_code, patch_product, template = NULL;
50     UINT ret = ERROR_FUNCTION_FAILED;
51
52     prod_code = msi_dup_property( package->db, szProductCode );
53     patch_product = msi_get_suminfo_product( patch );
54
55     TRACE("db = %s patch = %s\n", debugstr_w(prod_code), debugstr_w(patch_product));
56
57     if (strstrW( patch_product, prod_code ))
58     {
59         MSISUMMARYINFO *si;
60         const WCHAR *p;
61
62         si = MSI_GetSummaryInformationW( patch, 0 );
63         if (!si)
64         {
65             ERR("no summary information!\n");
66             goto end;
67         }
68         template = msi_suminfo_dup_string( si, PID_TEMPLATE );
69         if (!template)
70         {
71             ERR("no template property!\n");
72             msiobj_release( &si->hdr );
73             goto end;
74         }
75         if (!template[0])
76         {
77             ret = ERROR_SUCCESS;
78             msiobj_release( &si->hdr );
79             goto end;
80         }
81         TRACE("template: %s\n", debugstr_w(template));
82         p = strchrW( template, ';' );
83         if (p && match_language( package, atoiW( p + 1 ) ))
84         {
85             TRACE("applicable transform\n");
86             ret = ERROR_SUCCESS;
87         }
88         /* FIXME: check platform */
89         msiobj_release( &si->hdr );
90     }
91
92 end:
93     msi_free( patch_product );
94     msi_free( prod_code );
95     msi_free( template );
96     return ret;
97 }
98
99 static UINT apply_substorage_transform( MSIPACKAGE *package, MSIDATABASE *patch_db, LPCWSTR name )
100 {
101     UINT ret = ERROR_FUNCTION_FAILED;
102     IStorage *stg = NULL;
103     HRESULT r;
104
105     TRACE("%p %s\n", package, debugstr_w(name));
106
107     if (*name++ != ':')
108     {
109         ERR("expected a colon in %s\n", debugstr_w(name));
110         return ERROR_FUNCTION_FAILED;
111     }
112     r = IStorage_OpenStorage( patch_db->storage, name, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg );
113     if (SUCCEEDED(r))
114     {
115         ret = check_transform_applicable( package, stg );
116         if (ret == ERROR_SUCCESS)
117             msi_table_apply_transform( package->db, stg );
118         else
119             TRACE("substorage transform %s wasn't applicable\n", debugstr_w(name));
120         IStorage_Release( stg );
121     }
122     else
123     {
124         ERR("failed to open substorage %s\n", debugstr_w(name));
125     }
126     return ERROR_SUCCESS;
127 }
128
129 UINT msi_check_patch_applicable( MSIPACKAGE *package, MSISUMMARYINFO *si )
130 {
131     LPWSTR guid_list, *guids, product_code;
132     UINT i, ret = ERROR_FUNCTION_FAILED;
133
134     product_code = msi_dup_property( package->db, szProductCode );
135     if (!product_code)
136     {
137         /* FIXME: the property ProductCode should be written into the DB somewhere */
138         ERR("no product code to check\n");
139         return ERROR_SUCCESS;
140     }
141     guid_list = msi_suminfo_dup_string( si, PID_TEMPLATE );
142     guids = msi_split_string( guid_list, ';' );
143     for (i = 0; guids[i] && ret != ERROR_SUCCESS; i++)
144     {
145         if (!strcmpW( guids[i], product_code )) ret = ERROR_SUCCESS;
146     }
147     msi_free( guids );
148     msi_free( guid_list );
149     msi_free( product_code );
150     return ret;
151 }
152
153 static UINT msi_parse_patch_summary( MSISUMMARYINFO *si, MSIPATCHINFO **patch )
154 {
155     MSIPATCHINFO *pi;
156     UINT r = ERROR_SUCCESS;
157     WCHAR *p;
158
159     if (!(pi = msi_alloc_zero( sizeof(MSIPATCHINFO) )))
160     {
161         return ERROR_OUTOFMEMORY;
162     }
163     if (!(pi->patchcode = msi_suminfo_dup_string( si, PID_REVNUMBER )))
164     {
165         msi_free( pi );
166         return ERROR_OUTOFMEMORY;
167     }
168     p = pi->patchcode;
169     if (*p != '{')
170     {
171         msi_free( pi->patchcode );
172         msi_free( pi );
173         return ERROR_PATCH_PACKAGE_INVALID;
174     }
175     if (!(p = strchrW( p + 1, '}' )))
176     {
177         msi_free( pi->patchcode );
178         msi_free( pi );
179         return ERROR_PATCH_PACKAGE_INVALID;
180     }
181     if (p[1])
182     {
183         FIXME("patch obsoletes %s\n", debugstr_w(p + 1));
184         p[1] = 0;
185     }
186     TRACE("patch code %s\n", debugstr_w(pi->patchcode));
187     if (!(pi->products = msi_suminfo_dup_string( si, PID_TEMPLATE )))
188     {
189         msi_free( pi->patchcode );
190         msi_free( pi );
191         return ERROR_OUTOFMEMORY;
192     }
193     if (!(pi->transforms = msi_suminfo_dup_string( si, PID_LASTAUTHOR )))
194     {
195         msi_free( pi->patchcode );
196         msi_free( pi->products );
197         msi_free( pi );
198         return ERROR_OUTOFMEMORY;
199     }
200     *patch = pi;
201     return r;
202 }
203
204 static UINT patch_set_media_source_prop( MSIPACKAGE *package )
205 {
206     static const WCHAR query[] = {
207         'S','E','L','E','C','T',' ','`','S','o','u','r','c','e','`',' ','F','R','O','M',' ',
208         '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ','`','S','o','u','r','c','e','`',' ',
209         'I','S',' ','N','O','T',' ','N','U','L','L',0};
210     MSIQUERY *view;
211     MSIRECORD *rec;
212     const WCHAR *property;
213     WCHAR *patch;
214     UINT r;
215
216     r = MSI_DatabaseOpenViewW( package->db, query, &view );
217     if (r != ERROR_SUCCESS)
218         return r;
219
220     r = MSI_ViewExecute( view, 0 );
221     if (r != ERROR_SUCCESS)
222         goto done;
223
224     if (MSI_ViewFetch( view, &rec ) == ERROR_SUCCESS)
225     {
226         property = MSI_RecordGetString( rec, 1 );
227         patch = msi_dup_property( package->db, szPatch );
228         msi_set_property( package->db, property, patch );
229         msi_free( patch );
230         msiobj_release( &rec->hdr );
231     }
232
233 done:
234     msiobj_release( &view->hdr );
235     return r;
236 }
237
238 struct patch_offset
239 {
240     struct list entry;
241     WCHAR *name;
242     UINT sequence;
243 };
244
245 struct patch_offset_list
246 {
247     struct list files;
248     UINT count, min, max;
249     UINT offset_to_apply;
250 };
251
252 static struct patch_offset_list *patch_offset_list_create( void )
253 {
254     struct patch_offset_list *pos = msi_alloc( sizeof(struct patch_offset_list) );
255     list_init( &pos->files );
256     pos->count = pos->max = 0;
257     pos->min = 999999;
258     return pos;
259 }
260
261 static void patch_offset_list_free( struct patch_offset_list *pos )
262 {
263     struct patch_offset *po, *po2;
264
265     LIST_FOR_EACH_ENTRY_SAFE( po, po2, &pos->files, struct patch_offset, entry )
266     {
267         msi_free( po->name );
268         msi_free( po );
269     }
270     msi_free( pos );
271 }
272
273 static void patch_offset_get_patches( MSIDATABASE *db, UINT last_sequence, struct patch_offset_list *pos )
274 {
275     static const WCHAR query[] = {
276         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','P','a','t','c','h',' ',
277         'W','H','E','R','E',' ','S','e','q','u','e','n','c','e',' ','<','=',' ','?',' ',
278         'O','R','D','E','R',' ','B','Y',' ','S','e','q','u','e','n','c','e',0};
279     MSIQUERY *view;
280     MSIRECORD *rec;
281     UINT r;
282
283     r = MSI_DatabaseOpenViewW( db, query, &view );
284     if (r != ERROR_SUCCESS)
285         return;
286
287     rec = MSI_CreateRecord( 1 );
288     MSI_RecordSetInteger( rec, 1, last_sequence );
289
290     r = MSI_ViewExecute( view, rec );
291     msiobj_release( &rec->hdr );
292     if (r != ERROR_SUCCESS)
293         return;
294
295     while (MSI_ViewFetch( view, &rec ) == ERROR_SUCCESS)
296     {
297         UINT sequence = MSI_RecordGetInteger( rec, 2 );
298
299         /* FIXME: we only use the max/min sequence numbers for now */
300         pos->min = min( pos->min, sequence );
301         pos->max = max( pos->max, sequence );
302         pos->count++;
303         msiobj_release( &rec->hdr );
304     }
305     msiobj_release( &view->hdr );
306 }
307
308 static void patch_offset_get_files( MSIDATABASE *db, UINT last_sequence, struct patch_offset_list *pos )
309 {
310     static const WCHAR query[] = {
311         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','F','i','l','e',' ',
312         'W','H','E','R','E',' ','S','e','q','u','e','n','c','e',' ','<','=',' ','?',' ',
313         'O','R','D','E','R',' ','B','Y',' ','S','e','q','u','e','n','c','e',0};
314     MSIQUERY *view;
315     MSIRECORD *rec;
316     UINT r;
317
318     r = MSI_DatabaseOpenViewW( db, query, &view );
319     if (r != ERROR_SUCCESS)
320         return;
321
322     rec = MSI_CreateRecord( 1 );
323     MSI_RecordSetInteger( rec, 1, last_sequence );
324
325     r = MSI_ViewExecute( view, rec );
326     msiobj_release( &rec->hdr );
327     if (r != ERROR_SUCCESS)
328         return;
329
330     while (MSI_ViewFetch( view, &rec ) == ERROR_SUCCESS)
331     {
332         UINT attributes = MSI_RecordGetInteger( rec, 7 );
333         if (attributes & msidbFileAttributesPatchAdded)
334         {
335             struct patch_offset *po = msi_alloc( sizeof(struct patch_offset) );
336
337             po->name     = msi_dup_record_field( rec, 1 );
338             po->sequence = MSI_RecordGetInteger( rec, 8 );
339             pos->min     = min( pos->min, po->sequence );
340             pos->max     = max( pos->max, po->sequence );
341             list_add_tail( &pos->files, &po->entry );
342             pos->count++;
343         }
344         msiobj_release( &rec->hdr );
345     }
346     msiobj_release( &view->hdr );
347 }
348
349 static UINT patch_offset_modify_db( MSIDATABASE *db, struct patch_offset_list *pos )
350 {
351     static const WCHAR query[] = {
352         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','F','i','l','e',' ',
353         'W','H','E','R','E',' ','S','e','q','u','e','n','c','e',' ','>','=',' ','?',' ',
354         'A','N','D',' ','S','e','q','u','e','n','c','e',' ','<','=',' ','?',' ',
355         'O','R','D','E','R',' ','B','Y',' ','S','e','q','u','e','n','c','e',0};
356     struct patch_offset *po;
357     MSIRECORD *rec;
358     MSIQUERY *view;
359     UINT r;
360
361     r = MSI_DatabaseOpenViewW( db, query, &view );
362     if (r != ERROR_SUCCESS)
363         return ERROR_SUCCESS;
364
365     rec = MSI_CreateRecord( 2 );
366     MSI_RecordSetInteger( rec, 1, pos->min );
367     MSI_RecordSetInteger( rec, 2, pos->max );
368
369     r = MSI_ViewExecute( view, rec );
370     msiobj_release( &rec->hdr );
371     if (r != ERROR_SUCCESS)
372         goto done;
373
374     LIST_FOR_EACH_ENTRY( po, &pos->files, struct patch_offset, entry )
375     {
376         UINT r_fetch;
377         while ((r_fetch = MSI_ViewFetch( view, &rec )) == ERROR_SUCCESS)
378         {
379             const WCHAR *file = MSI_RecordGetString( rec, 1 );
380             UINT seq;
381
382             if (!strcmpiW( file, po->name ))
383             {
384                 /* update record */
385                 seq = MSI_RecordGetInteger( rec, 8 );
386                 MSI_RecordSetInteger( rec, 8, seq + pos->offset_to_apply );
387                 r = MSI_ViewModify( view, MSIMODIFY_UPDATE, rec );
388                 if (r != ERROR_SUCCESS)
389                     ERR("Failed to update offset for file %s\n", debugstr_w(file));
390                 msiobj_release( &rec->hdr );
391                 break;
392             }
393             msiobj_release( &rec->hdr );
394         }
395         if (r_fetch != ERROR_SUCCESS) break;
396     }
397
398 done:
399     msiobj_release( &view->hdr );
400     return ERROR_SUCCESS;
401 }
402
403 static const WCHAR patch_media_query[] = {
404     'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ','`','M','e','d','i','a','`',' ',
405     'W','H','E','R','E',' ','`','S','o','u','r','c','e','`',' ','I','S',' ','N','O','T',' ','N','U','L','L',' ',
406     'A','N','D',' ','`','C','a','b','i','n','e','t','`',' ','I','S',' ','N','O','T',' ','N','U','L','L',' ',
407     'O','R','D','E','R',' ','B','Y',' ','`','D','i','s','k','I','d','`',0};
408
409 struct patch_media
410 {
411     struct list entry;
412     UINT    disk_id;
413     UINT    last_sequence;
414     WCHAR  *prompt;
415     WCHAR  *cabinet;
416     WCHAR  *volume;
417     WCHAR  *source;
418 };
419
420 static UINT add_patch_media( MSIPACKAGE *package, IStorage *patch )
421 {
422     static const WCHAR delete_query[] = {
423         'D','E','L','E','T','E',' ','F','R','O','M',' ','`','M','e','d','i','a','`',' ',
424         'W','H','E','R','E',' ','`','D','i','s','k','I','d','`','=','?',0};
425     static const WCHAR insert_query[] = {
426         'I','N','S','E','R','T',' ','I','N','T','O',' ','`','M','e','d','i','a','`',' ',
427         '(','`','D','i','s','k','I','d','`',',','`','L','a','s','t','S','e','q','u','e','n','c','e','`',',',
428         '`','D','i','s','k','P','r','o','m','p','t','`',',','`','C','a','b','i','n','e','t','`',',',
429         '`','V','o','l','u','m','e','L','a','b','e','l','`',',','`','S','o','u','r','c','e','`',')',' ',
430         'V','A','L','U','E','S',' ','(','?',',','?',',','?',',','?',',','?',',','?',')',0};
431     MSIQUERY *view;
432     MSIRECORD *rec;
433     UINT r, disk_id;
434     struct list media_list;
435     struct patch_media *media, *next;
436
437     r = MSI_DatabaseOpenViewW( package->db, patch_media_query, &view );
438     if (r != ERROR_SUCCESS) return r;
439
440     r = MSI_ViewExecute( view, 0 );
441     if (r != ERROR_SUCCESS)
442     {
443         msiobj_release( &view->hdr );
444         TRACE("query failed %u\n", r);
445         return r;
446     }
447     list_init( &media_list );
448     while (MSI_ViewFetch( view, &rec ) == ERROR_SUCCESS)
449     {
450         disk_id = MSI_RecordGetInteger( rec, 1 );
451         TRACE("disk_id %u\n", disk_id);
452         if (disk_id >= MSI_INITIAL_MEDIA_TRANSFORM_DISKID)
453         {
454             msiobj_release( &rec->hdr );
455             continue;
456         }
457         if (!(media = msi_alloc( sizeof( *media )))) goto done;
458         media->disk_id = disk_id;
459         media->last_sequence = MSI_RecordGetInteger( rec, 2 );
460         media->prompt  = msi_dup_record_field( rec, 3 );
461         media->cabinet = msi_dup_record_field( rec, 4 );
462         media->volume  = msi_dup_record_field( rec, 5 );
463         media->source  = msi_dup_record_field( rec, 6 );
464
465         list_add_tail( &media_list, &media->entry );
466         msiobj_release( &rec->hdr );
467     }
468     LIST_FOR_EACH_ENTRY( media, &media_list, struct patch_media, entry )
469     {
470         MSIQUERY *delete_view, *insert_view;
471
472         r = MSI_DatabaseOpenViewW( package->db, delete_query, &delete_view );
473         if (r != ERROR_SUCCESS) goto done;
474
475         rec = MSI_CreateRecord( 1 );
476         MSI_RecordSetInteger( rec, 1, media->disk_id );
477
478         r = MSI_ViewExecute( delete_view, rec );
479         msiobj_release( &delete_view->hdr );
480         msiobj_release( &rec->hdr );
481         if (r != ERROR_SUCCESS) goto done;
482
483         r = MSI_DatabaseOpenViewW( package->db, insert_query, &insert_view );
484         if (r != ERROR_SUCCESS) goto done;
485
486         disk_id = package->db->media_transform_disk_id;
487         TRACE("disk id       %u\n", disk_id);
488         TRACE("last sequence %u\n", media->last_sequence);
489         TRACE("prompt        %s\n", debugstr_w(media->prompt));
490         TRACE("cabinet       %s\n", debugstr_w(media->cabinet));
491         TRACE("volume        %s\n", debugstr_w(media->volume));
492         TRACE("source        %s\n", debugstr_w(media->source));
493
494         rec = MSI_CreateRecord( 6 );
495         MSI_RecordSetInteger( rec, 1, disk_id );
496         MSI_RecordSetInteger( rec, 2, media->last_sequence );
497         MSI_RecordSetStringW( rec, 3, media->prompt );
498         MSI_RecordSetStringW( rec, 4, media->cabinet );
499         MSI_RecordSetStringW( rec, 5, media->volume );
500         MSI_RecordSetStringW( rec, 6, media->source );
501
502         r = MSI_ViewExecute( insert_view, rec );
503         msiobj_release( &insert_view->hdr );
504         msiobj_release( &rec->hdr );
505         if (r != ERROR_SUCCESS) goto done;
506
507         r = msi_add_cabinet_stream( package, disk_id, patch, media->cabinet );
508         if (r != ERROR_SUCCESS) WARN("failed to add cabinet stream %u\n", r);
509         package->db->media_transform_disk_id++;
510     }
511
512 done:
513     msiobj_release( &view->hdr );
514     LIST_FOR_EACH_ENTRY_SAFE( media, next, &media_list, struct patch_media, entry )
515     {
516         list_remove( &media->entry );
517         msi_free( media->prompt );
518         msi_free( media->cabinet );
519         msi_free( media->volume );
520         msi_free( media->source );
521         msi_free( media );
522     }
523     return r;
524 }
525
526 static UINT set_patch_offsets( MSIDATABASE *db )
527 {
528     MSIQUERY *view;
529     MSIRECORD *rec;
530     UINT r;
531
532     r = MSI_DatabaseOpenViewW( db, patch_media_query, &view );
533     if (r != ERROR_SUCCESS)
534         return r;
535
536     r = MSI_ViewExecute( view, 0 );
537     if (r != ERROR_SUCCESS)
538         goto done;
539
540     while (MSI_ViewFetch( view, &rec ) == ERROR_SUCCESS)
541     {
542         UINT last_sequence = MSI_RecordGetInteger( rec, 2 );
543         struct patch_offset_list *pos;
544
545         /* FIXME: set/check Source field instead? */
546         if (last_sequence >= MSI_INITIAL_MEDIA_TRANSFORM_OFFSET)
547         {
548             msiobj_release( &rec->hdr );
549             continue;
550         }
551         pos = patch_offset_list_create();
552         patch_offset_get_files( db, last_sequence, pos );
553         patch_offset_get_patches( db, last_sequence, pos );
554         if (pos->count)
555         {
556             UINT offset = db->media_transform_offset - pos->min;
557             last_sequence = offset + pos->max;
558
559             /* FIXME: this is for the patch table, which is not yet properly transformed */
560             last_sequence += pos->min;
561             pos->offset_to_apply = offset;
562             patch_offset_modify_db( db, pos );
563
564             MSI_RecordSetInteger( rec, 2, last_sequence );
565             r = MSI_ViewModify( view, MSIMODIFY_UPDATE, rec );
566             if (r != ERROR_SUCCESS)
567                 ERR("Failed to update Media table entry, expect breakage (%u)\n", r);
568             db->media_transform_offset = last_sequence + 1;
569         }
570         patch_offset_list_free( pos );
571         msiobj_release( &rec->hdr );
572     }
573
574 done:
575     msiobj_release( &view->hdr );
576     return r;
577 }
578
579 static UINT msi_apply_patch_db( MSIPACKAGE *package, MSIDATABASE *patch_db, MSIPATCHINFO *patch )
580 {
581     UINT i, r = ERROR_SUCCESS;
582     WCHAR **substorage;
583
584     /* apply substorage transforms */
585     substorage = msi_split_string( patch->transforms, ';' );
586     for (i = 0; substorage && substorage[i] && r == ERROR_SUCCESS; i++)
587     {
588         r = apply_substorage_transform( package, patch_db, substorage[i] );
589         if (r == ERROR_SUCCESS)
590         {
591             add_patch_media( package, patch_db->storage );
592             set_patch_offsets( package->db );
593         }
594     }
595     msi_free( substorage );
596     if (r != ERROR_SUCCESS)
597         return r;
598
599     patch_set_media_source_prop( package );
600
601     patch->state = MSIPATCHSTATE_APPLIED;
602     list_add_tail( &package->patches, &patch->entry );
603     return ERROR_SUCCESS;
604 }
605
606 void msi_free_patchinfo( MSIPATCHINFO *patch )
607 {
608     msi_free( patch->patchcode );
609     msi_free( patch->products );
610     msi_free( patch->transforms );
611     msi_free( patch->filename );
612     msi_free( patch->localfile );
613     msi_free( patch );
614 }
615
616 static UINT msi_apply_patch_package( MSIPACKAGE *package, const WCHAR *file )
617 {
618     static const WCHAR dotmsp[] = {'.','m','s','p',0};
619     MSIDATABASE *patch_db = NULL;
620     WCHAR localfile[MAX_PATH];
621     MSISUMMARYINFO *si;
622     MSIPATCHINFO *patch = NULL;
623     UINT r = ERROR_SUCCESS;
624
625     TRACE("%p %s\n", package, debugstr_w(file));
626
627     r = MSI_OpenDatabaseW( file, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &patch_db );
628     if (r != ERROR_SUCCESS)
629     {
630         ERR("failed to open patch collection %s\n", debugstr_w( file ) );
631         return r;
632     }
633     if (!(si = MSI_GetSummaryInformationW( patch_db->storage, 0 )))
634     {
635         msiobj_release( &patch_db->hdr );
636         return ERROR_FUNCTION_FAILED;
637     }
638     r = msi_check_patch_applicable( package, si );
639     if (r != ERROR_SUCCESS)
640     {
641         TRACE("patch not applicable\n");
642         r = ERROR_SUCCESS;
643         goto done;
644     }
645     r = msi_parse_patch_summary( si, &patch );
646     if ( r != ERROR_SUCCESS )
647         goto done;
648
649     r = msi_create_empty_local_file( localfile, dotmsp );
650     if ( r != ERROR_SUCCESS )
651         goto done;
652
653     r = ERROR_OUTOFMEMORY;
654     if (!(patch->filename = strdupW( file ))) goto done;
655     if (!(patch->localfile = strdupW( localfile ))) goto done;
656
657     r = msi_apply_patch_db( package, patch_db, patch );
658     if (r != ERROR_SUCCESS) WARN("patch failed to apply %u\n", r);
659
660 done:
661     msiobj_release( &si->hdr );
662     msiobj_release( &patch_db->hdr );
663     if (patch && r != ERROR_SUCCESS)
664     {
665         DeleteFileW( patch->localfile );
666         msi_free_patchinfo( patch );
667     }
668     return r;
669 }
670
671 /* get the PATCH property, and apply all the patches it specifies */
672 UINT msi_apply_patches( MSIPACKAGE *package )
673 {
674     LPWSTR patch_list, *patches;
675     UINT i, r = ERROR_SUCCESS;
676
677     patch_list = msi_dup_property( package->db, szPatch );
678
679     TRACE("patches to be applied: %s\n", debugstr_w(patch_list));
680
681     patches = msi_split_string( patch_list, ';' );
682     for (i = 0; patches && patches[i] && r == ERROR_SUCCESS; i++)
683         r = msi_apply_patch_package( package, patches[i] );
684
685     msi_free( patches );
686     msi_free( patch_list );
687     return r;
688 }
689
690 UINT msi_apply_transforms( MSIPACKAGE *package )
691 {
692     static const WCHAR szTransforms[] = {'T','R','A','N','S','F','O','R','M','S',0};
693     LPWSTR xform_list, *xforms;
694     UINT i, r = ERROR_SUCCESS;
695
696     xform_list = msi_dup_property( package->db, szTransforms );
697     xforms = msi_split_string( xform_list, ';' );
698
699     for (i = 0; xforms && xforms[i] && r == ERROR_SUCCESS; i++)
700     {
701         if (xforms[i][0] == ':')
702             r = apply_substorage_transform( package, package->db, xforms[i] );
703         else
704         {
705             WCHAR *transform;
706
707             if (!PathIsRelativeW( xforms[i] )) transform = xforms[i];
708             else
709             {
710                 WCHAR *p = strrchrW( package->PackagePath, '\\' );
711                 DWORD len = p - package->PackagePath + 1;
712
713                 if (!(transform = msi_alloc( (len + strlenW( xforms[i] ) + 1) * sizeof(WCHAR)) ))
714                 {
715                     msi_free( xforms );
716                     msi_free( xform_list );
717                     return ERROR_OUTOFMEMORY;
718                 }
719                 memcpy( transform, package->PackagePath, len * sizeof(WCHAR) );
720                 memcpy( transform + len, xforms[i], (strlenW( xforms[i] ) + 1) * sizeof(WCHAR) );
721             }
722             r = MSI_DatabaseApplyTransformW( package->db, transform, 0 );
723             if (transform != xforms[i]) msi_free( transform );
724         }
725     }
726     msi_free( xforms );
727     msi_free( xform_list );
728     return r;
729 }
730
731 UINT msi_apply_registered_patch( MSIPACKAGE *package, LPCWSTR patch_code )
732 {
733     UINT r;
734     DWORD len;
735     WCHAR patch_file[MAX_PATH];
736     MSIDATABASE *patch_db;
737     MSIPATCHINFO *patch_info;
738     MSISUMMARYINFO *si;
739
740     len = sizeof(patch_file) / sizeof(WCHAR);
741     r = MsiGetPatchInfoExW( patch_code, package->ProductCode, NULL, package->Context,
742                             INSTALLPROPERTY_LOCALPACKAGEW, patch_file, &len );
743     if (r != ERROR_SUCCESS)
744     {
745         ERR("failed to get patch filename %u\n", r);
746         return r;
747     }
748     r = MSI_OpenDatabaseW( patch_file, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &patch_db );
749     if (r != ERROR_SUCCESS)
750     {
751         ERR("failed to open patch database %s\n", debugstr_w( patch_file ));
752         return r;
753     }
754     si = MSI_GetSummaryInformationW( patch_db->storage, 0 );
755     if (!si)
756     {
757         msiobj_release( &patch_db->hdr );
758         return ERROR_FUNCTION_FAILED;
759     }
760     r = msi_parse_patch_summary( si, &patch_info );
761     msiobj_release( &si->hdr );
762     if (r != ERROR_SUCCESS)
763     {
764         ERR("failed to parse patch summary %u\n", r);
765         msiobj_release( &patch_db->hdr );
766         return r;
767     }
768     patch_info->localfile = strdupW( patch_file );
769     if (!patch_info->localfile)
770     {
771         msiobj_release( &patch_db->hdr );
772         msi_free_patchinfo( patch_info );
773         return ERROR_OUTOFMEMORY;
774     }
775     r = msi_apply_patch_db( package, patch_db, patch_info );
776     msiobj_release( &patch_db->hdr );
777     if (r != ERROR_SUCCESS)
778     {
779         ERR("failed to apply patch %u\n", r);
780         msi_free_patchinfo( patch_info );
781     }
782     return r;
783 }