shell32: COM cleanup for the IShellView2 iface.
[wine] / dlls / msi / classes.c
1 /*
2  * Implementation of the Microsoft Installer (msi.dll)
3  *
4  * Copyright 2005 Aric Stewart for CodeWeavers
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 /* Actions handled in this module:
22  *
23  * RegisterClassInfo
24  * RegisterProgIdInfo
25  * RegisterExtensionInfo
26  * RegisterMIMEInfo
27  * UnregisterClassInfo
28  * UnregisterProgIdInfo
29  * UnregisterExtensionInfo
30  * UnregisterMIMEInfo
31  */
32
33 #include <stdarg.h>
34
35 #include "windef.h"
36 #include "winbase.h"
37 #include "winerror.h"
38 #include "winreg.h"
39 #include "wine/debug.h"
40 #include "msipriv.h"
41 #include "winuser.h"
42 #include "wine/unicode.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(msi);
45
46 static MSIAPPID *load_appid( MSIPACKAGE* package, MSIRECORD *row )
47 {
48     LPCWSTR buffer;
49     MSIAPPID *appid;
50
51     /* fill in the data */
52
53     appid = msi_alloc_zero( sizeof(MSIAPPID) );
54     if (!appid)
55         return NULL;
56     
57     appid->AppID = msi_dup_record_field( row, 1 );
58     TRACE("loading appid %s\n", debugstr_w( appid->AppID ));
59
60     buffer = MSI_RecordGetString(row,2);
61     deformat_string( package, buffer, &appid->RemoteServerName );
62
63     appid->LocalServer = msi_dup_record_field(row,3);
64     appid->ServiceParameters = msi_dup_record_field(row,4);
65     appid->DllSurrogate = msi_dup_record_field(row,5);
66
67     appid->ActivateAtStorage = !MSI_RecordIsNull(row,6);
68     appid->RunAsInteractiveUser = !MSI_RecordIsNull(row,7);
69
70     list_add_tail( &package->appids, &appid->entry );
71     
72     return appid;
73 }
74
75 static MSIAPPID *load_given_appid( MSIPACKAGE *package, LPCWSTR name )
76 {
77     MSIRECORD *row;
78     MSIAPPID *appid;
79     static const WCHAR ExecSeqQuery[] =
80         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
81          '`','A','p','p','I','d','`',' ','W','H','E','R','E',' ',
82          '`','A','p','p','I','d','`',' ','=',' ','\'','%','s','\'',0};
83
84     if (!name)
85         return NULL;
86
87     /* check for appids already loaded */
88     LIST_FOR_EACH_ENTRY( appid, &package->appids, MSIAPPID, entry )
89     {
90         if (!strcmpiW( appid->AppID, name ))
91         {
92             TRACE("found appid %s %p\n", debugstr_w(name), appid);
93             return appid;
94         }
95     }
96     
97     row = MSI_QueryGetRecord(package->db, ExecSeqQuery, name);
98     if (!row)
99         return NULL;
100
101     appid = load_appid(package, row);
102     msiobj_release(&row->hdr);
103
104     return appid;
105 }
106
107 static MSIPROGID *load_given_progid(MSIPACKAGE *package, LPCWSTR progid);
108 static MSICLASS *load_given_class( MSIPACKAGE *package, LPCWSTR classid );
109
110 static MSIPROGID *load_progid( MSIPACKAGE* package, MSIRECORD *row )
111 {
112     MSIPROGID *progid;
113     LPCWSTR buffer;
114
115     /* fill in the data */
116
117     progid = msi_alloc_zero( sizeof(MSIPROGID) );
118     if (!progid)
119         return NULL;
120
121     list_add_tail( &package->progids, &progid->entry );
122
123     progid->ProgID = msi_dup_record_field(row,1);
124     TRACE("loading progid %s\n",debugstr_w(progid->ProgID));
125
126     buffer = MSI_RecordGetString(row,2);
127     progid->Parent = load_given_progid(package,buffer);
128     if (progid->Parent == NULL && buffer)
129         FIXME("Unknown parent ProgID %s\n",debugstr_w(buffer));
130
131     buffer = MSI_RecordGetString(row,3);
132     progid->Class = load_given_class(package,buffer);
133     if (progid->Class == NULL && buffer)
134         FIXME("Unknown class %s\n",debugstr_w(buffer));
135
136     progid->Description = msi_dup_record_field(row,4);
137
138     if (!MSI_RecordIsNull(row,6))
139     {
140         INT icon_index = MSI_RecordGetInteger(row,6); 
141         LPCWSTR FileName = MSI_RecordGetString(row,5);
142         LPWSTR FilePath;
143         static const WCHAR fmt[] = {'%','s',',','%','i',0};
144
145         FilePath = msi_build_icon_path(package, FileName);
146        
147         progid->IconPath = msi_alloc( (strlenW(FilePath)+10)* sizeof(WCHAR) );
148
149         sprintfW(progid->IconPath,fmt,FilePath,icon_index);
150
151         msi_free(FilePath);
152     }
153     else
154     {
155         buffer = MSI_RecordGetString(row,5);
156         if (buffer)
157             progid->IconPath = msi_build_icon_path(package, buffer);
158     }
159
160     progid->CurVer = NULL;
161     progid->VersionInd = NULL;
162
163     /* if we have a parent then we may be that parents CurVer */
164     if (progid->Parent && progid->Parent != progid)
165     {
166         MSIPROGID *parent = progid->Parent;
167
168         while (parent->Parent && parent->Parent != parent)
169             parent = parent->Parent;
170
171         /* FIXME: need to determine if we are really the CurVer */
172
173         progid->CurVer = parent;
174         parent->VersionInd = progid;
175     }
176     
177     return progid;
178 }
179
180 static MSIPROGID *load_given_progid(MSIPACKAGE *package, LPCWSTR name)
181 {
182     MSIPROGID *progid;
183     MSIRECORD *row;
184     static const WCHAR ExecSeqQuery[] =
185         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
186          '`','P','r','o','g','I','d','`',' ','W','H','E','R','E',' ',
187          '`','P','r','o','g','I','d','`',' ','=',' ','\'','%','s','\'',0};
188
189     if (!name)
190         return NULL;
191
192     /* check for progids already loaded */
193     LIST_FOR_EACH_ENTRY( progid, &package->progids, MSIPROGID, entry )
194     {
195         if (!strcmpiW( progid->ProgID, name ))
196         {
197             TRACE("found progid %s (%p)\n",debugstr_w(name), progid );
198             return progid;
199         }
200     }
201     
202     row = MSI_QueryGetRecord( package->db, ExecSeqQuery, name );
203     if (!row)
204         return NULL;
205
206     progid = load_progid(package, row);
207     msiobj_release(&row->hdr);
208
209     return progid;
210 }
211
212 static MSICLASS *load_class( MSIPACKAGE* package, MSIRECORD *row )
213 {
214     MSICLASS *cls;
215     DWORD i;
216     LPCWSTR buffer;
217
218     /* fill in the data */
219
220     cls = msi_alloc_zero( sizeof(MSICLASS) );
221     if (!cls)
222         return NULL;
223
224     list_add_tail( &package->classes, &cls->entry );
225
226     cls->clsid = msi_dup_record_field( row, 1 );
227     TRACE("loading class %s\n",debugstr_w(cls->clsid));
228     cls->Context = msi_dup_record_field( row, 2 );
229     buffer = MSI_RecordGetString(row,3);
230     cls->Component = msi_get_loaded_component( package, buffer );
231
232     cls->ProgIDText = msi_dup_record_field(row,4);
233     cls->ProgID = load_given_progid(package, cls->ProgIDText);
234
235     cls->Description = msi_dup_record_field(row,5);
236
237     buffer = MSI_RecordGetString(row,6);
238     if (buffer)
239         cls->AppID = load_given_appid(package, buffer);
240
241     cls->FileTypeMask = msi_dup_record_field(row,7);
242
243     if (!MSI_RecordIsNull(row,9))
244     {
245
246         INT icon_index = MSI_RecordGetInteger(row,9); 
247         LPCWSTR FileName = MSI_RecordGetString(row,8);
248         LPWSTR FilePath;
249         static const WCHAR fmt[] = {'%','s',',','%','i',0};
250
251         FilePath = msi_build_icon_path(package, FileName);
252        
253         cls->IconPath = msi_alloc( (strlenW(FilePath)+5)* sizeof(WCHAR) );
254
255         sprintfW(cls->IconPath,fmt,FilePath,icon_index);
256
257         msi_free(FilePath);
258     }
259     else
260     {
261         buffer = MSI_RecordGetString(row,8);
262         if (buffer)
263             cls->IconPath = msi_build_icon_path(package, buffer);
264     }
265
266     if (!MSI_RecordIsNull(row,10))
267     {
268         i = MSI_RecordGetInteger(row,10);
269         if (i != MSI_NULL_INTEGER && i > 0 &&  i < 4)
270         {
271             static const WCHAR ole2[] = {'o','l','e','2','.','d','l','l',0};
272             static const WCHAR ole32[] = {'o','l','e','3','2','.','d','l','l',0};
273
274             switch(i)
275             {
276                 case 1:
277                     cls->DefInprocHandler = strdupW(ole2);
278                     break;
279                 case 2:
280                     cls->DefInprocHandler32 = strdupW(ole32);
281                     break;
282                 case 3:
283                     cls->DefInprocHandler = strdupW(ole2);
284                     cls->DefInprocHandler32 = strdupW(ole32);
285                     break;
286             }
287         }
288         else
289         {
290             cls->DefInprocHandler32 = msi_dup_record_field( row, 10 );
291             msi_reduce_to_long_filename( cls->DefInprocHandler32 );
292         }
293     }
294     buffer = MSI_RecordGetString(row,11);
295     deformat_string(package,buffer,&cls->Argument);
296
297     buffer = MSI_RecordGetString(row,12);
298     cls->Feature = msi_get_loaded_feature(package, buffer);
299
300     cls->Attributes = MSI_RecordGetInteger(row,13);
301     
302     return cls;
303 }
304
305 /*
306  * the Class table has 3 primary keys. Generally it is only 
307  * referenced through the first CLSID key. However when loading
308  * all of the classes we need to make sure we do not ignore rows
309  * with other Context and ComponentIndexs 
310  */
311 static MSICLASS *load_given_class(MSIPACKAGE *package, LPCWSTR classid)
312 {
313     MSICLASS *cls;
314     MSIRECORD *row;
315     static const WCHAR ExecSeqQuery[] =
316         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
317          '`','C','l','a','s','s','`',' ','W','H','E','R','E',' ',
318          '`','C','L','S','I','D','`',' ','=',' ','\'','%','s','\'',0};
319
320     if (!classid)
321         return NULL;
322     
323     /* check for classes already loaded */
324     LIST_FOR_EACH_ENTRY( cls, &package->classes, MSICLASS, entry )
325     {
326         if (!strcmpiW( cls->clsid, classid ))
327         {
328             TRACE("found class %s (%p)\n",debugstr_w(classid), cls);
329             return cls;
330         }
331     }
332
333     row = MSI_QueryGetRecord(package->db, ExecSeqQuery, classid);
334     if (!row)
335         return NULL;
336
337     cls = load_class(package, row);
338     msiobj_release(&row->hdr);
339
340     return cls;
341 }
342
343 static MSIEXTENSION *load_given_extension( MSIPACKAGE *package, LPCWSTR extension );
344
345 static MSIMIME *load_mime( MSIPACKAGE* package, MSIRECORD *row )
346 {
347     LPCWSTR extension;
348     MSIMIME *mt;
349
350     /* fill in the data */
351
352     mt = msi_alloc_zero( sizeof(MSIMIME) );
353     if (!mt)
354         return mt;
355
356     mt->ContentType = msi_dup_record_field( row, 1 ); 
357     TRACE("loading mime %s\n", debugstr_w(mt->ContentType));
358
359     extension = MSI_RecordGetString( row, 2 );
360     mt->Extension = load_given_extension( package, extension );
361     mt->suffix = strdupW( extension );
362
363     mt->clsid = msi_dup_record_field( row, 3 );
364     mt->Class = load_given_class( package, mt->clsid );
365
366     list_add_tail( &package->mimes, &mt->entry );
367
368     return mt;
369 }
370
371 static MSIMIME *load_given_mime( MSIPACKAGE *package, LPCWSTR mime )
372 {
373     MSIRECORD *row;
374     static const WCHAR ExecSeqQuery[] =
375         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
376          '`','M','I','M','E','`',' ','W','H','E','R','E',' ',
377          '`','C','o','n','t','e','n','t','T','y','p','e','`',' ','=',' ',
378          '\'','%','s','\'',0};
379     MSIMIME *mt;
380
381     if (!mime)
382         return NULL;
383     
384     /* check for mime already loaded */
385     LIST_FOR_EACH_ENTRY( mt, &package->mimes, MSIMIME, entry )
386     {
387         if (!strcmpiW( mt->ContentType, mime ))
388         {
389             TRACE("found mime %s (%p)\n",debugstr_w(mime), mt);
390             return mt;
391         }
392     }
393     
394     row = MSI_QueryGetRecord(package->db, ExecSeqQuery, mime);
395     if (!row)
396         return NULL;
397
398     mt = load_mime(package, row);
399     msiobj_release(&row->hdr);
400
401     return mt;
402 }
403
404 static MSIEXTENSION *load_extension( MSIPACKAGE* package, MSIRECORD *row )
405 {
406     MSIEXTENSION *ext;
407     LPCWSTR buffer;
408
409     /* fill in the data */
410
411     ext = msi_alloc_zero( sizeof(MSIEXTENSION) );
412     if (!ext)
413         return NULL;
414
415     list_init( &ext->verbs );
416
417     list_add_tail( &package->extensions, &ext->entry );
418
419     ext->Extension = msi_dup_record_field( row, 1 );
420     TRACE("loading extension %s\n", debugstr_w(ext->Extension));
421
422     buffer = MSI_RecordGetString( row, 2 );
423     ext->Component = msi_get_loaded_component( package, buffer );
424
425     ext->ProgIDText = msi_dup_record_field( row, 3 );
426     ext->ProgID = load_given_progid( package, ext->ProgIDText );
427
428     buffer = MSI_RecordGetString( row, 4 );
429     ext->Mime = load_given_mime( package, buffer );
430
431     buffer = MSI_RecordGetString(row,5);
432     ext->Feature = msi_get_loaded_feature( package, buffer );
433
434     return ext;
435 }
436
437 /*
438  * While the extension table has 2 primary keys, this function is only looking
439  * at the Extension key which is what is referenced as a foreign key
440  */
441 static MSIEXTENSION *load_given_extension( MSIPACKAGE *package, LPCWSTR name )
442 {
443     MSIRECORD *row;
444     MSIEXTENSION *ext;
445     static const WCHAR ExecSeqQuery[] =
446         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
447          '`','E','x','t','e','n','s','i','o','n','`',' ',
448          'W','H','E','R','E',' ',
449          '`','E','x','t','e','n','s','i','o','n','`',' ','=',' ',
450          '\'','%','s','\'',0};
451
452     if (!name)
453         return NULL;
454
455     if (name[0] == '.')
456         name++;
457
458     /* check for extensions already loaded */
459     LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
460     {
461         if (!strcmpiW( ext->Extension, name ))
462         {
463             TRACE("extension %s already loaded %p\n", debugstr_w(name), ext);
464             return ext;
465         }
466     }
467     
468     row = MSI_QueryGetRecord( package->db, ExecSeqQuery, name );
469     if (!row)
470         return NULL;
471
472     ext = load_extension(package, row);
473     msiobj_release(&row->hdr);
474
475     return ext;
476 }
477
478 static UINT iterate_load_verb(MSIRECORD *row, LPVOID param)
479 {
480     MSIPACKAGE* package = param;
481     MSIVERB *verb;
482     LPCWSTR buffer;
483     MSIEXTENSION *extension;
484
485     buffer = MSI_RecordGetString(row,1);
486     extension = load_given_extension( package, buffer );
487     if (!extension)
488     {
489         ERR("Verb unable to find loaded extension %s\n", debugstr_w(buffer));
490         return ERROR_SUCCESS;
491     }
492
493     /* fill in the data */
494
495     verb = msi_alloc_zero( sizeof(MSIVERB) );
496     if (!verb)
497         return ERROR_OUTOFMEMORY;
498
499     verb->Verb = msi_dup_record_field(row,2);
500     TRACE("loading verb %s\n",debugstr_w(verb->Verb));
501     verb->Sequence = MSI_RecordGetInteger(row,3);
502
503     buffer = MSI_RecordGetString(row,4);
504     deformat_string(package,buffer,&verb->Command);
505
506     buffer = MSI_RecordGetString(row,5);
507     deformat_string(package,buffer,&verb->Argument);
508
509     /* associate the verb with the correct extension */
510     list_add_tail( &extension->verbs, &verb->entry );
511     
512     return ERROR_SUCCESS;
513 }
514
515 static UINT iterate_all_classes(MSIRECORD *rec, LPVOID param)
516 {
517     MSICOMPONENT *comp;
518     LPCWSTR clsid;
519     LPCWSTR context;
520     LPCWSTR buffer;
521     MSIPACKAGE* package = param;
522     MSICLASS *cls;
523     BOOL match = FALSE;
524
525     clsid = MSI_RecordGetString(rec,1);
526     context = MSI_RecordGetString(rec,2);
527     buffer = MSI_RecordGetString(rec,3);
528     comp = msi_get_loaded_component(package, buffer);
529
530     LIST_FOR_EACH_ENTRY( cls, &package->classes, MSICLASS, entry )
531     {
532         if (strcmpiW( clsid, cls->clsid ))
533             continue;
534         if (strcmpW( context, cls->Context ))
535             continue;
536         if (comp == cls->Component)
537         {
538             match = TRUE;
539             break;
540         }
541     }
542     
543     if (!match)
544         load_class(package, rec);
545
546     return ERROR_SUCCESS;
547 }
548
549 static VOID load_all_classes(MSIPACKAGE *package)
550 {
551     UINT rc = ERROR_SUCCESS;
552     MSIQUERY *view;
553
554     static const WCHAR ExecSeqQuery[] =
555         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
556          '`','C','l','a','s','s','`',0};
557
558     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
559     if (rc != ERROR_SUCCESS)
560         return;
561
562     rc = MSI_IterateRecords(view, NULL, iterate_all_classes, package);
563     msiobj_release(&view->hdr);
564 }
565
566 static UINT iterate_all_extensions(MSIRECORD *rec, LPVOID param)
567 {
568     MSICOMPONENT *comp;
569     LPCWSTR buffer;
570     LPCWSTR extension;
571     MSIPACKAGE* package = param;
572     BOOL match = FALSE;
573     MSIEXTENSION *ext;
574
575     extension = MSI_RecordGetString(rec,1);
576     buffer = MSI_RecordGetString(rec,2);
577     comp = msi_get_loaded_component(package, buffer);
578
579     LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
580     {
581         if (strcmpiW(extension, ext->Extension))
582             continue;
583         if (comp == ext->Component)
584         {
585             match = TRUE;
586             break;
587         }
588     }
589
590     if (!match)
591         load_extension(package, rec);
592
593     return ERROR_SUCCESS;
594 }
595
596 static VOID load_all_extensions(MSIPACKAGE *package)
597 {
598     UINT rc = ERROR_SUCCESS;
599     MSIQUERY *view;
600
601     static const WCHAR ExecSeqQuery[] =
602         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
603          '`','E','x','t','e','n','s','i','o','n','`',0};
604
605     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
606     if (rc != ERROR_SUCCESS)
607         return;
608
609     rc = MSI_IterateRecords(view, NULL, iterate_all_extensions, package);
610     msiobj_release(&view->hdr);
611 }
612
613 static UINT iterate_all_progids(MSIRECORD *rec, LPVOID param)
614 {
615     LPCWSTR buffer;
616     MSIPACKAGE* package = param;
617
618     buffer = MSI_RecordGetString(rec,1);
619     load_given_progid(package,buffer);
620     return ERROR_SUCCESS;
621 }
622
623 static VOID load_all_progids(MSIPACKAGE *package)
624 {
625     UINT rc = ERROR_SUCCESS;
626     MSIQUERY *view;
627
628     static const WCHAR ExecSeqQuery[] =
629         {'S','E','L','E','C','T',' ','`','P','r','o','g','I','d','`',' ',
630          'F','R','O','M',' ', '`','P','r','o','g','I','d','`',0};
631
632     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
633     if (rc != ERROR_SUCCESS)
634         return;
635
636     rc = MSI_IterateRecords(view, NULL, iterate_all_progids, package);
637     msiobj_release(&view->hdr);
638 }
639
640 static VOID load_all_verbs(MSIPACKAGE *package)
641 {
642     UINT rc = ERROR_SUCCESS;
643     MSIQUERY *view;
644
645     static const WCHAR ExecSeqQuery[] =
646         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
647          '`','V','e','r','b','`',0};
648
649     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
650     if (rc != ERROR_SUCCESS)
651         return;
652
653     rc = MSI_IterateRecords(view, NULL, iterate_load_verb, package);
654     msiobj_release(&view->hdr);
655 }
656
657 static UINT iterate_all_mimes(MSIRECORD *rec, LPVOID param)
658 {
659     LPCWSTR buffer;
660     MSIPACKAGE* package = param;
661
662     buffer = MSI_RecordGetString(rec,1);
663     load_given_mime(package,buffer);
664     return ERROR_SUCCESS;
665 }
666
667 static VOID load_all_mimes(MSIPACKAGE *package)
668 {
669     UINT rc = ERROR_SUCCESS;
670     MSIQUERY *view;
671
672     static const WCHAR ExecSeqQuery[] =
673         {'S','E','L','E','C','T',' ',
674          '`','C','o','n','t','e','n','t','T','y','p','e','`',
675          ' ','F','R','O','M',' ',
676          '`','M','I','M','E','`',0};
677
678     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
679     if (rc != ERROR_SUCCESS)
680         return;
681
682     rc = MSI_IterateRecords(view, NULL, iterate_all_mimes, package);
683     msiobj_release(&view->hdr);
684 }
685
686 static void load_classes_and_such(MSIPACKAGE *package)
687 {
688     TRACE("Loading all the class info and related tables\n");
689
690     /* check if already loaded */
691     if (!list_empty( &package->classes ) ||
692         !list_empty( &package->mimes ) ||
693         !list_empty( &package->extensions ) ||
694         !list_empty( &package->progids ) )
695         return;
696
697     load_all_classes(package);
698     load_all_extensions(package);
699     load_all_progids(package);
700     /* these loads must come after the other loads */
701     load_all_verbs(package);
702     load_all_mimes(package);
703 }
704
705 static void mark_progid_for_install( MSIPACKAGE* package, MSIPROGID *progid )
706 {
707     MSIPROGID *child;
708
709     if (!progid)
710         return;
711
712     if (progid->InstallMe)
713         return;
714
715     progid->InstallMe = TRUE;
716
717     /* all children if this is a parent also install */
718     LIST_FOR_EACH_ENTRY( child, &package->progids, MSIPROGID, entry )
719     {
720         if (child->Parent == progid)
721             mark_progid_for_install( package, child );
722     }
723 }
724
725 static void mark_progid_for_uninstall( MSIPACKAGE *package, MSIPROGID *progid )
726 {
727     MSIPROGID *child;
728
729     if (!progid)
730         return;
731
732     if (!progid->InstallMe)
733         return;
734
735     progid->InstallMe = FALSE;
736
737     LIST_FOR_EACH_ENTRY( child, &package->progids, MSIPROGID, entry )
738     {
739         if (child->Parent == progid)
740             mark_progid_for_uninstall( package, child );
741     }
742 }
743
744 static void mark_mime_for_install( MSIMIME *mime )
745 {
746     if (!mime)
747         return;
748     mime->InstallMe = TRUE;
749 }
750
751 static void mark_mime_for_uninstall( MSIMIME *mime )
752 {
753     if (!mime)
754         return;
755     mime->InstallMe = FALSE;
756 }
757
758 static UINT register_appid(const MSIAPPID *appid, LPCWSTR app )
759 {
760     static const WCHAR szRemoteServerName[] =
761          {'R','e','m','o','t','e','S','e','r','v','e','r','N','a','m','e',0};
762     static const WCHAR szLocalService[] =
763          {'L','o','c','a','l','S','e','r','v','i','c','e',0};
764     static const WCHAR szService[] =
765          {'S','e','r','v','i','c','e','P','a','r','a','m','e','t','e','r','s',0};
766     static const WCHAR szDLL[] =
767          {'D','l','l','S','u','r','r','o','g','a','t','e',0};
768     static const WCHAR szActivate[] =
769          {'A','c','t','i','v','a','t','e','A','s','S','t','o','r','a','g','e',0};
770     static const WCHAR szY[] = {'Y',0};
771     static const WCHAR szRunAs[] = {'R','u','n','A','s',0};
772     static const WCHAR szUser[] = 
773          {'I','n','t','e','r','a','c','t','i','v','e',' ','U','s','e','r',0};
774
775     HKEY hkey2,hkey3;
776
777     RegCreateKeyW(HKEY_CLASSES_ROOT,szAppID,&hkey2);
778     RegCreateKeyW( hkey2, appid->AppID, &hkey3 );
779     RegCloseKey(hkey2);
780     msi_reg_set_val_str( hkey3, NULL, app );
781
782     if (appid->RemoteServerName)
783         msi_reg_set_val_str( hkey3, szRemoteServerName, appid->RemoteServerName );
784
785     if (appid->LocalServer)
786         msi_reg_set_val_str( hkey3, szLocalService, appid->LocalServer );
787
788     if (appid->ServiceParameters)
789         msi_reg_set_val_str( hkey3, szService, appid->ServiceParameters );
790
791     if (appid->DllSurrogate)
792         msi_reg_set_val_str( hkey3, szDLL, appid->DllSurrogate );
793
794     if (appid->ActivateAtStorage)
795         msi_reg_set_val_str( hkey3, szActivate, szY );
796
797     if (appid->RunAsInteractiveUser)
798         msi_reg_set_val_str( hkey3, szRunAs, szUser );
799
800     RegCloseKey(hkey3);
801     return ERROR_SUCCESS;
802 }
803
804 UINT ACTION_RegisterClassInfo(MSIPACKAGE *package)
805 {
806     static const WCHAR szFileType_fmt[] = {'F','i','l','e','T','y','p','e','\\','%','s','\\','%','i',0};
807     const WCHAR *keypath;
808     MSIRECORD *uirow;
809     HKEY hkey,hkey2,hkey3;
810     MSICLASS *cls;
811
812     load_classes_and_such(package);
813
814     if (is_64bit && package->platform == PLATFORM_INTEL)
815         keypath = szWow6432NodeCLSID;
816     else
817         keypath = szCLSID;
818
819     if (RegCreateKeyW(HKEY_CLASSES_ROOT, keypath, &hkey) != ERROR_SUCCESS)
820         return ERROR_FUNCTION_FAILED;
821
822     LIST_FOR_EACH_ENTRY( cls, &package->classes, MSICLASS, entry )
823     {
824         MSICOMPONENT *comp;
825         MSIFILE *file;
826         DWORD size;
827         LPWSTR argument;
828         MSIFEATURE *feature;
829
830         comp = cls->Component;
831         if ( !comp )
832             continue;
833
834         if (!comp->Enabled)
835         {
836             TRACE("component is disabled\n");
837             continue;
838         }
839
840         feature = cls->Feature;
841         if (!feature)
842             continue;
843
844         if (feature->ActionRequest != INSTALLSTATE_LOCAL &&
845             feature->ActionRequest != INSTALLSTATE_ADVERTISED )
846         {
847             TRACE("Feature %s not scheduled for installation, skipping registration of class %s\n",
848                   debugstr_w(feature->Feature), debugstr_w(cls->clsid));
849             continue;
850         }
851         feature->Action = feature->ActionRequest;
852
853         if (!comp->KeyPath || !(file = msi_get_loaded_file( package, comp->KeyPath )))
854         {
855             TRACE("COM server not provided, skipping class %s\n", debugstr_w(cls->clsid));
856             continue;
857         }
858
859         TRACE("Registering class %s (%p)\n", debugstr_w(cls->clsid), cls);
860
861         cls->Installed = TRUE;
862         mark_progid_for_install( package, cls->ProgID );
863
864         RegCreateKeyW( hkey, cls->clsid, &hkey2 );
865
866         if (cls->Description)
867             msi_reg_set_val_str( hkey2, NULL, cls->Description );
868
869         RegCreateKeyW( hkey2, cls->Context, &hkey3 );
870
871         /*
872          * FIXME: Implement install on demand (advertised components).
873          *
874          * ole32.dll should call msi.MsiProvideComponentFromDescriptor()
875          *  when it needs an InProcServer that doesn't exist.
876          * The component advertise string should be in the "InProcServer" value.
877          */
878         size = lstrlenW( file->TargetPath )+1;
879         if (cls->Argument)
880             size += lstrlenW(cls->Argument)+1;
881
882         argument = msi_alloc( size * sizeof(WCHAR) );
883         lstrcpyW( argument, file->TargetPath );
884
885         if (cls->Argument)
886         {
887             lstrcatW( argument, szSpace );
888             lstrcatW( argument, cls->Argument );
889         }
890
891         msi_reg_set_val_str( hkey3, NULL, argument );
892         msi_free(argument);
893
894         RegCloseKey(hkey3);
895
896         if (cls->ProgID || cls->ProgIDText)
897         {
898             LPCWSTR progid;
899
900             if (cls->ProgID)
901                 progid = cls->ProgID->ProgID;
902             else
903                 progid = cls->ProgIDText;
904
905             msi_reg_set_subkey_val( hkey2, szProgID, NULL, progid );
906
907             if (cls->ProgID && cls->ProgID->VersionInd)
908             {
909                 msi_reg_set_subkey_val( hkey2, szVIProgID, NULL, 
910                                         cls->ProgID->VersionInd->ProgID );
911             }
912         }
913
914         if (cls->AppID)
915         {
916             MSIAPPID *appid = cls->AppID;
917             msi_reg_set_val_str( hkey2, szAppID, appid->AppID );
918             register_appid( appid, cls->Description );
919         }
920
921         if (cls->IconPath)
922             msi_reg_set_subkey_val( hkey2, szDefaultIcon, NULL, cls->IconPath );
923
924         if (cls->DefInprocHandler)
925             msi_reg_set_subkey_val( hkey2, szInprocHandler, NULL, cls->DefInprocHandler );
926
927         if (cls->DefInprocHandler32)
928             msi_reg_set_subkey_val( hkey2, szInprocHandler32, NULL, cls->DefInprocHandler32 );
929         
930         RegCloseKey(hkey2);
931
932         /* if there is a FileTypeMask, register the FileType */
933         if (cls->FileTypeMask)
934         {
935             LPWSTR ptr, ptr2;
936             LPWSTR keyname;
937             INT index = 0;
938             ptr = cls->FileTypeMask;
939             while (ptr && *ptr)
940             {
941                 ptr2 = strchrW(ptr,';');
942                 if (ptr2)
943                     *ptr2 = 0;
944                 keyname = msi_alloc( (strlenW(szFileType_fmt) + strlenW(cls->clsid) + 4) * sizeof(WCHAR));
945                 sprintfW( keyname, szFileType_fmt, cls->clsid, index );
946
947                 msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, ptr );
948                 msi_free(keyname);
949
950                 if (ptr2)
951                     ptr = ptr2+1;
952                 else
953                     ptr = NULL;
954
955                 index ++;
956             }
957         }
958         
959         uirow = MSI_CreateRecord(1);
960         MSI_RecordSetStringW( uirow, 1, cls->clsid );
961         msi_ui_actiondata( package, szRegisterClassInfo, uirow );
962         msiobj_release(&uirow->hdr);
963     }
964
965     RegCloseKey(hkey);
966     return ERROR_SUCCESS;
967 }
968
969 UINT ACTION_UnregisterClassInfo( MSIPACKAGE *package )
970 {
971     static const WCHAR szFileType[] = {'F','i','l','e','T','y','p','e','\\',0};
972     const WCHAR *keypath;
973     MSIRECORD *uirow;
974     MSICLASS *cls;
975     HKEY hkey, hkey2;
976
977     load_classes_and_such( package );
978
979     if (is_64bit && package->platform == PLATFORM_INTEL)
980         keypath = szWow6432NodeCLSID;
981     else
982         keypath = szCLSID;
983
984     if (RegOpenKeyW( HKEY_CLASSES_ROOT, keypath, &hkey ) != ERROR_SUCCESS)
985         return ERROR_SUCCESS;
986
987     LIST_FOR_EACH_ENTRY( cls, &package->classes, MSICLASS, entry )
988     {
989         MSIFEATURE *feature;
990         MSICOMPONENT *comp;
991         LPWSTR filetype;
992         LONG res;
993
994         comp = cls->Component;
995         if (!comp)
996             continue;
997
998         if (!comp->Enabled)
999         {
1000             TRACE("component is disabled\n");
1001             continue;
1002         }
1003
1004         feature = cls->Feature;
1005         if (!feature)
1006             continue;
1007
1008         if (feature->ActionRequest != INSTALLSTATE_ABSENT)
1009         {
1010             TRACE("Feature %s not scheduled for removal, skipping unregistration of class %s\n",
1011                   debugstr_w(feature->Feature), debugstr_w(cls->clsid));
1012             continue;
1013         }
1014         feature->Action = feature->ActionRequest;
1015
1016         TRACE("Unregistering class %s (%p)\n", debugstr_w(cls->clsid), cls);
1017
1018         cls->Installed = FALSE;
1019         mark_progid_for_uninstall( package, cls->ProgID );
1020
1021         res = RegDeleteTreeW( hkey, cls->clsid );
1022         if (res != ERROR_SUCCESS)
1023             WARN("Failed to delete class key %d\n", res);
1024
1025         if (cls->AppID)
1026         {
1027             res = RegOpenKeyW( HKEY_CLASSES_ROOT, szAppID, &hkey2 );
1028             if (res == ERROR_SUCCESS)
1029             {
1030                 res = RegDeleteKeyW( hkey2, cls->AppID->AppID );
1031                 if (res != ERROR_SUCCESS)
1032                     WARN("Failed to delete appid key %d\n", res);
1033                 RegCloseKey( hkey2 );
1034             }
1035         }
1036         if (cls->FileTypeMask)
1037         {
1038             filetype = msi_alloc( (strlenW( szFileType ) + strlenW( cls->clsid ) + 1) * sizeof(WCHAR) );
1039             if (filetype)
1040             {
1041                 strcpyW( filetype, szFileType );
1042                 strcatW( filetype, cls->clsid );
1043                 res = RegDeleteTreeW( HKEY_CLASSES_ROOT, filetype );
1044                 msi_free( filetype );
1045
1046                 if (res != ERROR_SUCCESS)
1047                     WARN("Failed to delete file type %d\n", res);
1048             }
1049         }
1050
1051         uirow = MSI_CreateRecord( 1 );
1052         MSI_RecordSetStringW( uirow, 1, cls->clsid );
1053         msi_ui_actiondata( package, szUnregisterClassInfo, uirow );
1054         msiobj_release( &uirow->hdr );
1055     }
1056
1057     RegCloseKey( hkey );
1058     return ERROR_SUCCESS;
1059 }
1060
1061 static LPCWSTR get_clsid_of_progid( const MSIPROGID *progid )
1062 {
1063     while (progid)
1064     {
1065         if (progid->Class)
1066             return progid->Class->clsid;
1067         if (progid->Parent == progid)
1068             break;
1069         progid = progid->Parent;
1070     }
1071     return NULL;
1072 }
1073
1074 static UINT register_progid( const MSIPROGID* progid )
1075 {
1076     static const WCHAR szCurVer[] = {'C','u','r','V','e','r',0};
1077     HKEY hkey = 0;
1078     UINT rc;
1079
1080     rc = RegCreateKeyW( HKEY_CLASSES_ROOT, progid->ProgID, &hkey );
1081     if (rc == ERROR_SUCCESS)
1082     {
1083         LPCWSTR clsid = get_clsid_of_progid( progid );
1084
1085         if (clsid)
1086             msi_reg_set_subkey_val( hkey, szCLSID, NULL, clsid );
1087         else
1088             TRACE("%s has no class\n", debugstr_w( progid->ProgID ) );
1089
1090         if (progid->Description)
1091             msi_reg_set_val_str( hkey, NULL, progid->Description );
1092
1093         if (progid->IconPath)
1094             msi_reg_set_subkey_val( hkey, szDefaultIcon, NULL, progid->IconPath );
1095
1096         /* write out the current version */
1097         if (progid->CurVer)
1098             msi_reg_set_subkey_val( hkey, szCurVer, NULL, progid->CurVer->ProgID );
1099
1100         RegCloseKey(hkey);
1101     }
1102     else
1103         ERR("failed to create key %s\n", debugstr_w( progid->ProgID ) );
1104
1105     return rc;
1106 }
1107
1108 UINT ACTION_RegisterProgIdInfo(MSIPACKAGE *package)
1109 {
1110     MSIPROGID *progid;
1111     MSIRECORD *uirow;
1112
1113     load_classes_and_such(package);
1114
1115     LIST_FOR_EACH_ENTRY( progid, &package->progids, MSIPROGID, entry )
1116     {
1117         /* check if this progid is to be installed */
1118         if (progid->Class && progid->Class->Installed)
1119             progid->InstallMe = TRUE;
1120
1121         if (!progid->InstallMe)
1122         {
1123             TRACE("progid %s not scheduled to be installed\n",
1124                              debugstr_w(progid->ProgID));
1125             continue;
1126         }
1127        
1128         TRACE("Registering progid %s\n", debugstr_w(progid->ProgID));
1129
1130         register_progid( progid );
1131
1132         uirow = MSI_CreateRecord( 1 );
1133         MSI_RecordSetStringW( uirow, 1, progid->ProgID );
1134         msi_ui_actiondata( package, szRegisterProgIdInfo, uirow );
1135         msiobj_release( &uirow->hdr );
1136     }
1137
1138     return ERROR_SUCCESS;
1139 }
1140
1141 UINT ACTION_UnregisterProgIdInfo( MSIPACKAGE *package )
1142 {
1143     MSIPROGID *progid;
1144     MSIRECORD *uirow;
1145     LONG res;
1146
1147     load_classes_and_such( package );
1148
1149     LIST_FOR_EACH_ENTRY( progid, &package->progids, MSIPROGID, entry )
1150     {
1151         /* check if this progid is to be removed */
1152         if (progid->Class && !progid->Class->Installed)
1153             progid->InstallMe = FALSE;
1154
1155         if (progid->InstallMe)
1156         {
1157             TRACE("progid %s not scheduled to be removed\n", debugstr_w(progid->ProgID));
1158             continue;
1159         }
1160
1161         TRACE("Unregistering progid %s\n", debugstr_w(progid->ProgID));
1162
1163         res = RegDeleteTreeW( HKEY_CLASSES_ROOT, progid->ProgID );
1164         if (res != ERROR_SUCCESS)
1165             TRACE("Failed to delete progid key %d\n", res);
1166
1167         uirow = MSI_CreateRecord( 1 );
1168         MSI_RecordSetStringW( uirow, 1, progid->ProgID );
1169         msi_ui_actiondata( package, szUnregisterProgIdInfo, uirow );
1170         msiobj_release( &uirow->hdr );
1171     }
1172
1173     return ERROR_SUCCESS;
1174 }
1175
1176 static UINT register_verb(MSIPACKAGE *package, LPCWSTR progid, 
1177                 MSICOMPONENT* component, const MSIEXTENSION* extension,
1178                 MSIVERB* verb, INT* Sequence )
1179 {
1180     LPWSTR keyname;
1181     HKEY key;
1182     static const WCHAR szShell[] = {'s','h','e','l','l',0};
1183     static const WCHAR szCommand[] = {'c','o','m','m','a','n','d',0};
1184     static const WCHAR fmt[] = {'\"','%','s','\"',' ','%','s',0};
1185     static const WCHAR fmt2[] = {'\"','%','s','\"',0};
1186     LPWSTR command;
1187     DWORD size;
1188     LPWSTR advertise;
1189
1190     keyname = msi_build_directory_name(4, progid, szShell, verb->Verb, szCommand);
1191
1192     TRACE("Making Key %s\n",debugstr_w(keyname));
1193     RegCreateKeyW(HKEY_CLASSES_ROOT, keyname, &key);
1194     size = strlenW(component->FullKeypath);
1195     if (verb->Argument)
1196         size += strlenW(verb->Argument);
1197      size += 4;
1198
1199      command = msi_alloc(size * sizeof (WCHAR));
1200      if (verb->Argument)
1201         sprintfW(command, fmt, component->FullKeypath, verb->Argument);
1202      else
1203         sprintfW(command, fmt2, component->FullKeypath);
1204
1205      msi_reg_set_val_str( key, NULL, command );
1206      msi_free(command);
1207
1208      advertise = msi_create_component_advertise_string(package, component,
1209                                                        extension->Feature->Feature);
1210      size = strlenW(advertise);
1211
1212      if (verb->Argument)
1213          size += strlenW(verb->Argument);
1214      size += 4;
1215
1216      command = msi_alloc_zero(size * sizeof (WCHAR));
1217
1218      strcpyW(command,advertise);
1219      if (verb->Argument)
1220      {
1221          strcatW(command,szSpace);
1222          strcatW(command,verb->Argument);
1223      }
1224
1225      msi_reg_set_val_multi_str( key, szCommand, command );
1226      
1227      RegCloseKey(key);
1228      msi_free(keyname);
1229      msi_free(advertise);
1230      msi_free(command);
1231
1232      if (verb->Command)
1233      {
1234         keyname = msi_build_directory_name( 3, progid, szShell, verb->Verb );
1235         msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Command );
1236         msi_free(keyname);
1237      }
1238
1239      if (verb->Sequence != MSI_NULL_INTEGER)
1240      {
1241         if (*Sequence == MSI_NULL_INTEGER || verb->Sequence < *Sequence)
1242         {
1243             *Sequence = verb->Sequence;
1244             keyname = msi_build_directory_name( 2, progid, szShell );
1245             msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Verb );
1246             msi_free(keyname);
1247         }
1248     }
1249     return ERROR_SUCCESS;
1250 }
1251
1252 UINT ACTION_RegisterExtensionInfo(MSIPACKAGE *package)
1253 {
1254     static const WCHAR szContentType[] = 
1255         {'C','o','n','t','e','n','t',' ','T','y','p','e',0 };
1256     HKEY hkey = NULL;
1257     MSIEXTENSION *ext;
1258     MSIRECORD *uirow;
1259     BOOL install_on_demand = TRUE;
1260     LONG res;
1261
1262     load_classes_and_such(package);
1263
1264     /* We need to set install_on_demand based on if the shell handles advertised
1265      * shortcuts and the like. Because Mike McCormack is working on this i am
1266      * going to default to TRUE
1267      */
1268     
1269     LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
1270     {
1271         LPWSTR extension;
1272         MSIFEATURE *feature;
1273      
1274         if (!ext->Component)
1275             continue;
1276
1277         if (!ext->Component->Enabled)
1278         {
1279             TRACE("component is disabled\n");
1280             continue;
1281         }
1282
1283         feature = ext->Feature;
1284         if (!feature)
1285             continue;
1286
1287         /* 
1288          * yes. MSDN says that these are based on _Feature_ not on
1289          * Component.  So verify the feature is to be installed
1290          */
1291         if (feature->ActionRequest != INSTALLSTATE_LOCAL &&
1292             !(install_on_demand && feature->ActionRequest == INSTALLSTATE_ADVERTISED))
1293         {
1294             TRACE("Feature %s not scheduled for installation, skipping registration of extension %s\n",
1295                    debugstr_w(feature->Feature), debugstr_w(ext->Extension));
1296             continue;
1297         }
1298         feature->Action = feature->ActionRequest;
1299
1300         TRACE("Registering extension %s (%p)\n", debugstr_w(ext->Extension), ext);
1301
1302         ext->Installed = TRUE;
1303
1304         /* this is only registered if the extension has at least 1 verb
1305          * according to MSDN
1306          */
1307         if (ext->ProgID && !list_empty( &ext->verbs ) )
1308             mark_progid_for_install( package, ext->ProgID );
1309
1310         mark_mime_for_install(ext->Mime);
1311
1312         extension = msi_alloc( (strlenW( ext->Extension ) + 2) * sizeof(WCHAR) );
1313         if (extension)
1314         {
1315             extension[0] = '.';
1316             strcpyW( extension + 1, ext->Extension );
1317             res = RegCreateKeyW( HKEY_CLASSES_ROOT, extension, &hkey );
1318             msi_free( extension );
1319             if (res != ERROR_SUCCESS)
1320                 WARN("Failed to create extension key %d\n", res);
1321         }
1322
1323         if (ext->Mime)
1324             msi_reg_set_val_str( hkey, szContentType, ext->Mime->ContentType );
1325
1326         if (ext->ProgID || ext->ProgIDText)
1327         {
1328             static const WCHAR szSN[] = 
1329                 {'\\','S','h','e','l','l','N','e','w',0};
1330             HKEY hkey2;
1331             LPWSTR newkey;
1332             LPCWSTR progid;
1333             MSIVERB *verb;
1334             INT Sequence = MSI_NULL_INTEGER;
1335             
1336             if (ext->ProgID)
1337                 progid = ext->ProgID->ProgID;
1338             else
1339                 progid = ext->ProgIDText;
1340
1341             msi_reg_set_val_str( hkey, NULL, progid );
1342
1343             newkey = msi_alloc( (strlenW(progid)+strlenW(szSN)+1) * sizeof(WCHAR)); 
1344
1345             strcpyW(newkey,progid);
1346             strcatW(newkey,szSN);
1347             RegCreateKeyW(hkey,newkey,&hkey2);
1348             RegCloseKey(hkey2);
1349
1350             msi_free(newkey);
1351
1352             /* do all the verbs */
1353             LIST_FOR_EACH_ENTRY( verb, &ext->verbs, MSIVERB, entry )
1354             {
1355                 register_verb( package, progid, ext->Component,
1356                                ext, verb, &Sequence);
1357             }
1358         }
1359         
1360         RegCloseKey(hkey);
1361
1362         uirow = MSI_CreateRecord(1);
1363         MSI_RecordSetStringW( uirow, 1, ext->Extension );
1364         msi_ui_actiondata( package, szRegisterExtensionInfo, uirow );
1365         msiobj_release(&uirow->hdr);
1366     }
1367
1368     return ERROR_SUCCESS;
1369 }
1370
1371 UINT ACTION_UnregisterExtensionInfo( MSIPACKAGE *package )
1372 {
1373     MSIEXTENSION *ext;
1374     MSIRECORD *uirow;
1375     LONG res;
1376
1377     load_classes_and_such( package );
1378
1379     LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
1380     {
1381         LPWSTR extension;
1382         MSIFEATURE *feature;
1383
1384         if (!ext->Component)
1385             continue;
1386
1387         if (!ext->Component->Enabled)
1388         {
1389             TRACE("component is disabled\n");
1390             continue;
1391         }
1392
1393         feature = ext->Feature;
1394         if (!feature)
1395             continue;
1396
1397         if (feature->ActionRequest != INSTALLSTATE_ABSENT)
1398         {
1399             TRACE("Feature %s not scheduled for removal, skipping unregistration of extension %s\n",
1400                    debugstr_w(feature->Feature), debugstr_w(ext->Extension));
1401             continue;
1402         }
1403
1404         TRACE("Unregistering extension %s\n", debugstr_w(ext->Extension));
1405
1406         ext->Installed = FALSE;
1407
1408         if (ext->ProgID && !list_empty( &ext->verbs ))
1409             mark_progid_for_uninstall( package, ext->ProgID );
1410
1411         mark_mime_for_uninstall( ext->Mime );
1412
1413         extension = msi_alloc( (strlenW( ext->Extension ) + 2) * sizeof(WCHAR) );
1414         if (extension)
1415         {
1416             extension[0] = '.';
1417             strcpyW( extension + 1, ext->Extension );
1418             res = RegDeleteTreeW( HKEY_CLASSES_ROOT, extension );
1419             msi_free( extension );
1420             if (res != ERROR_SUCCESS)
1421                 WARN("Failed to delete extension key %d\n", res);
1422         }
1423
1424         if (ext->ProgID || ext->ProgIDText)
1425         {
1426             static const WCHAR shellW[] = {'\\','s','h','e','l','l',0};
1427             LPCWSTR progid;
1428             LPWSTR progid_shell;
1429
1430             if (ext->ProgID)
1431                 progid = ext->ProgID->ProgID;
1432             else
1433                 progid = ext->ProgIDText;
1434
1435             progid_shell = msi_alloc( (strlenW( progid ) + strlenW( shellW ) + 1) * sizeof(WCHAR) );
1436             if (progid_shell)
1437             {
1438                 strcpyW( progid_shell, progid );
1439                 strcatW( progid_shell, shellW );
1440                 res = RegDeleteTreeW( HKEY_CLASSES_ROOT, progid_shell );
1441                 msi_free( progid_shell );
1442                 if (res != ERROR_SUCCESS)
1443                     WARN("Failed to delete shell key %d\n", res);
1444                 RegDeleteKeyW( HKEY_CLASSES_ROOT, progid );
1445             }
1446         }
1447
1448         uirow = MSI_CreateRecord( 1 );
1449         MSI_RecordSetStringW( uirow, 1, ext->Extension );
1450         msi_ui_actiondata( package, szUnregisterExtensionInfo, uirow );
1451         msiobj_release( &uirow->hdr );
1452     }
1453
1454     return ERROR_SUCCESS;
1455 }
1456
1457 UINT ACTION_RegisterMIMEInfo(MSIPACKAGE *package)
1458 {
1459     static const WCHAR szExten[] = 
1460         {'E','x','t','e','n','s','i','o','n',0 };
1461     MSIRECORD *uirow;
1462     MSIMIME *mt;
1463
1464     load_classes_and_such(package);
1465
1466     LIST_FOR_EACH_ENTRY( mt, &package->mimes, MSIMIME, entry )
1467     {
1468         LPWSTR extension;
1469         LPWSTR key;
1470
1471         /* 
1472          * check if the MIME is to be installed. Either as requested by an
1473          * extension or Class
1474          */
1475         mt->InstallMe = (mt->InstallMe ||
1476               (mt->Class && mt->Class->Installed) ||
1477               (mt->Extension && mt->Extension->Installed));
1478
1479         if (!mt->InstallMe)
1480         {
1481             TRACE("MIME %s not scheduled to be installed\n", debugstr_w(mt->ContentType));
1482             continue;
1483         }
1484
1485         TRACE("Registering MIME type %s\n", debugstr_w(mt->ContentType));
1486
1487         extension = msi_alloc( (strlenW( mt->Extension->Extension ) + 2) * sizeof(WCHAR) );
1488         key = msi_alloc( (strlenW( mt->ContentType ) + strlenW( szMIMEDatabase ) + 1) * sizeof(WCHAR) );
1489
1490         if (extension && key)
1491         {
1492             extension[0] = '.';
1493             strcpyW( extension + 1, mt->Extension->Extension );
1494
1495             strcpyW( key, szMIMEDatabase );
1496             strcatW( key, mt->ContentType );
1497             msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, key, szExten, extension );
1498
1499             if (mt->clsid)
1500                 msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, key, szCLSID, mt->clsid );
1501         }
1502         msi_free( extension );
1503         msi_free( key );
1504
1505         uirow = MSI_CreateRecord( 2 );
1506         MSI_RecordSetStringW( uirow, 1, mt->ContentType );
1507         MSI_RecordSetStringW( uirow, 2, mt->suffix );
1508         msi_ui_actiondata( package, szRegisterMIMEInfo, uirow );
1509         msiobj_release( &uirow->hdr );
1510     }
1511
1512     return ERROR_SUCCESS;
1513 }
1514
1515 UINT ACTION_UnregisterMIMEInfo( MSIPACKAGE *package )
1516 {
1517     MSIRECORD *uirow;
1518     MSIMIME *mime;
1519
1520     load_classes_and_such( package );
1521
1522     LIST_FOR_EACH_ENTRY( mime, &package->mimes, MSIMIME, entry )
1523     {
1524         LONG res;
1525         LPWSTR mime_key;
1526
1527         mime->InstallMe = (mime->InstallMe ||
1528                           (mime->Class && mime->Class->Installed) ||
1529                           (mime->Extension && mime->Extension->Installed));
1530
1531         if (mime->InstallMe)
1532         {
1533             TRACE("MIME %s not scheduled to be removed\n", debugstr_w(mime->ContentType));
1534             continue;
1535         }
1536
1537         TRACE("Unregistering MIME type %s\n", debugstr_w(mime->ContentType));
1538
1539         mime_key = msi_alloc( (strlenW( szMIMEDatabase ) + strlenW( mime->ContentType ) + 1) * sizeof(WCHAR) );
1540         if (mime_key)
1541         {
1542             strcpyW( mime_key, szMIMEDatabase );
1543             strcatW( mime_key, mime->ContentType );
1544             res = RegDeleteKeyW( HKEY_CLASSES_ROOT, mime_key );
1545             if (res != ERROR_SUCCESS)
1546                 WARN("Failed to delete MIME key %d\n", res);
1547             msi_free( mime_key );
1548         }
1549
1550         uirow = MSI_CreateRecord( 2 );
1551         MSI_RecordSetStringW( uirow, 1, mime->ContentType );
1552         MSI_RecordSetStringW( uirow, 2, mime->suffix );
1553         msi_ui_actiondata( package, szUnregisterMIMEInfo, uirow );
1554         msiobj_release( &uirow->hdr );
1555     }
1556
1557     return ERROR_SUCCESS;
1558 }