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