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  * RegisterClassInfo
  23  * RegisterProgIdInfo
  24  * RegisterExtensionInfo
  25  * RegisterMIMEInfo
  26  * UnRegisterClassInfo (TODO)
  27  * UnRegisterProgIdInfo (TODO)
  28  * UnRegisterExtensionInfo (TODO)
  29  * UnRegisterMIMEInfo (TODO)
  30  */
  31
  32 #include <stdarg.h>
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winerror.h"
  37 #include "winreg.h"
  38 #include "wine/debug.h"
  39 #include "msipriv.h"
  40 #include "winuser.h"
  41 #include "wine/unicode.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     MSIRECORD *row;
  77     MSIAPPID *appid;
  78     static const WCHAR ExecSeqQuery[] =
  79         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
  80          '`','A','p','p','I','d','`',' ','W','H','E','R','E',' ',
  81          '`','A','p','p','I','d','`',' ','=',' ','\'','%','s','\'',0};
  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 (lstrcmpiW( appid->AppID, name )==0)
  90         {
  91             TRACE("found appid %s %p\n", debugstr_w(name), appid);
  92             return appid;
  93         }
  94     }
  95
  96     row = MSI_QueryGetRecord(package->db, ExecSeqQuery, name);
  97     if (!row)
  98         return NULL;
  99
 100     appid = load_appid(package, row);
 101     msiobj_release(&row->hdr);
 102
 103     return appid;
 104 }
 105
 106 static MSIPROGID *load_given_progid(MSIPACKAGE *package, LPCWSTR progid);
 107 static MSICLASS *load_given_class( MSIPACKAGE *package, LPCWSTR classid );
 108
 109 static MSIPROGID *load_progid( MSIPACKAGE* package, MSIRECORD *row )
 110 {
 111     MSIPROGID *progid;
 112     LPCWSTR buffer;
 113
 114     /* fill in the data */
 115
 116     progid = msi_alloc_zero( sizeof(MSIPROGID) );
 117     if (!progid)
 118         return NULL;
 119
 120     list_add_tail( &package->progids, &progid->entry );
 121
 122     progid->ProgID = msi_dup_record_field(row,1);
 123     TRACE("loading progid %s\n",debugstr_w(progid->ProgID));
 124
 125     buffer = MSI_RecordGetString(row,2);
 126     progid->Parent = load_given_progid(package,buffer);
 127     if (progid->Parent == NULL && buffer)
 128         FIXME("Unknown parent ProgID %s\n",debugstr_w(buffer));
 129
 130     buffer = MSI_RecordGetString(row,3);
 131     progid->Class = load_given_class(package,buffer);
 132     if (progid->Class == NULL && buffer)
 133         FIXME("Unknown class %s\n",debugstr_w(buffer));
 134
 135     progid->Description = msi_dup_record_field(row,4);
 136
 137     if (!MSI_RecordIsNull(row,6))
 138     {
 139         INT icon_index = MSI_RecordGetInteger(row,6);
 140         LPCWSTR FileName = MSI_RecordGetString(row,5);
 141         LPWSTR FilePath;
 142         static const WCHAR fmt[] = {'%','s',',','%','i',0};
 143
 144         FilePath = build_icon_path(package,FileName);
 145
 146         progid->IconPath = msi_alloc( (strlenW(FilePath)+10)* sizeof(WCHAR) );
 147
 148         sprintfW(progid->IconPath,fmt,FilePath,icon_index);
 149
 150         msi_free(FilePath);
 151     }
 152     else
 153     {
 154         buffer = MSI_RecordGetString(row,5);
 155         if (buffer)
 156             progid->IconPath = build_icon_path(package,buffer);
 157     }
 158
 159     progid->CurVer = NULL;
 160     progid->VersionInd = NULL;
 161
 162     /* if we have a parent then we may be that parents CurVer */
 163     if (progid->Parent && progid->Parent != progid)
 164     {
 165         MSIPROGID *parent = progid->Parent;
 166
 167         while (parent->Parent && parent->Parent != parent)
 168             parent = parent->Parent;
 169
 170         /* FIXME: need to determine if we are really the CurVer */
 171
 172         progid->CurVer = parent;
 173         parent->VersionInd = progid;
 174     }
 175
 176     return progid;
 177 }
 178
 179 static MSIPROGID *load_given_progid(MSIPACKAGE *package, LPCWSTR name)
 180 {
 181     MSIPROGID *progid;
 182     MSIRECORD *row;
 183     static const WCHAR ExecSeqQuery[] =
 184         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 185          '`','P','r','o','g','I','d','`',' ','W','H','E','R','E',' ',
 186          '`','P','r','o','g','I','d','`',' ','=',' ','\'','%','s','\'',0};
 187
 188     if (!name)
 189         return NULL;
 190
 191     /* check for progids already loaded */
 192     LIST_FOR_EACH_ENTRY( progid, &package->progids, MSIPROGID, entry )
 193     {
 194         if (strcmpiW( progid->ProgID,name )==0)
 195         {
 196             TRACE("found progid %s (%p)\n",debugstr_w(name), progid );
 197             return progid;
 198         }
 199     }
 200
 201     row = MSI_QueryGetRecord( package->db, ExecSeqQuery, name );
 202     if (!row)
 203         return NULL;
 204
 205     progid = load_progid(package, row);
 206     msiobj_release(&row->hdr);
 207
 208     return progid;
 209 }
 210
 211 static MSICLASS *load_class( MSIPACKAGE* package, MSIRECORD *row )
 212 {
 213     MSICLASS *cls;
 214     DWORD i;
 215     LPCWSTR buffer;
 216
 217     /* fill in the data */
 218
 219     cls = msi_alloc_zero( sizeof(MSICLASS) );
 220     if (!cls)
 221         return NULL;
 222
 223     list_add_tail( &package->classes, &cls->entry );
 224
 225     cls->clsid = msi_dup_record_field( row, 1 );
 226     TRACE("loading class %s\n",debugstr_w(cls->clsid));
 227     cls->Context = msi_dup_record_field( row, 2 );
 228     buffer = MSI_RecordGetString(row,3);
 229     cls->Component = get_loaded_component(package, buffer);
 230
 231     cls->ProgIDText = msi_dup_record_field(row,4);
 232     cls->ProgID = load_given_progid(package, cls->ProgIDText);
 233
 234     cls->Description = msi_dup_record_field(row,5);
 235
 236     buffer = MSI_RecordGetString(row,6);
 237     if (buffer)
 238         cls->AppID = load_given_appid(package, buffer);
 239
 240     cls->FileTypeMask = msi_dup_record_field(row,7);
 241
 242     if (!MSI_RecordIsNull(row,9))
 243     {
 244
 245         INT icon_index = MSI_RecordGetInteger(row,9);
 246         LPCWSTR FileName = MSI_RecordGetString(row,8);
 247         LPWSTR FilePath;
 248         static const WCHAR fmt[] = {'%','s',',','%','i',0};
 249
 250         FilePath = build_icon_path(package,FileName);
 251
 252         cls->IconPath = msi_alloc( (strlenW(FilePath)+5)* sizeof(WCHAR) );
 253
 254         sprintfW(cls->IconPath,fmt,FilePath,icon_index);
 255
 256         msi_free(FilePath);
 257     }
 258     else
 259     {
 260         buffer = MSI_RecordGetString(row,8);
 261         if (buffer)
 262             cls->IconPath = build_icon_path(package,buffer);
 263     }
 264
 265     if (!MSI_RecordIsNull(row,10))
 266     {
 267         i = MSI_RecordGetInteger(row,10);
 268         if (i != MSI_NULL_INTEGER && i > 0 &&  i < 4)
 269         {
 270             static const WCHAR ole2[] = {'o','l','e','2','.','d','l','l',0};
 271             static const WCHAR ole32[] = {'o','l','e','3','2','.','d','l','l',0};
 272
 273             switch(i)
 274             {
 275                 case 1:
 276                     cls->DefInprocHandler = strdupW(ole2);
 277                     break;
 278                 case 2:
 279                     cls->DefInprocHandler32 = strdupW(ole32);
 280                     break;
 281                 case 3:
 282                     cls->DefInprocHandler = strdupW(ole2);
 283                     cls->DefInprocHandler32 = strdupW(ole32);
 284                     break;
 285             }
 286         }
 287         else
 288         {
 289             cls->DefInprocHandler32 = msi_dup_record_field( row, 10);
 290             reduce_to_longfilename(cls->DefInprocHandler32);
 291         }
 292     }
 293     buffer = MSI_RecordGetString(row,11);
 294     deformat_string(package,buffer,&cls->Argument);
 295
 296     buffer = MSI_RecordGetString(row,12);
 297     cls->Feature = get_loaded_feature(package,buffer);
 298
 299     cls->Attributes = MSI_RecordGetInteger(row,13);
 300
 301     return cls;
 302 }
 303
 304 /*
 305  * the Class table has 3 primary keys. Generally it is only
 306  * referenced through the first CLSID key. However when loading
 307  * all of the classes we need to make sure we do not ignore rows
 308  * with other Context and ComponentIndexs
 309  */
 310 static MSICLASS *load_given_class(MSIPACKAGE *package, LPCWSTR classid)
 311 {
 312     MSICLASS *cls;
 313     MSIRECORD *row;
 314     static const WCHAR ExecSeqQuery[] =
 315         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 316          '`','C','l','a','s','s','`',' ','W','H','E','R','E',' ',
 317          '`','C','L','S','I','D','`',' ','=',' ','\'','%','s','\'',0};
 318
 319     if (!classid)
 320         return NULL;
 321
 322     /* check for classes already loaded */
 323     LIST_FOR_EACH_ENTRY( cls, &package->classes, MSICLASS, entry )
 324     {
 325         if (lstrcmpiW( cls->clsid, classid )==0)
 326         {
 327             TRACE("found class %s (%p)\n",debugstr_w(classid), cls);
 328             return cls;
 329         }
 330     }
 331
 332     row = MSI_QueryGetRecord(package->db, ExecSeqQuery, classid);
 333     if (!row)
 334         return NULL;
 335
 336     cls = load_class(package, row);
 337     msiobj_release(&row->hdr);
 338
 339     return cls;
 340 }
 341
 342 static MSIEXTENSION *load_given_extension( MSIPACKAGE *package, LPCWSTR extension );
 343
 344 static MSIMIME *load_mime( MSIPACKAGE* package, MSIRECORD *row )
 345 {
 346     LPCWSTR buffer;
 347     MSIMIME *mt;
 348
 349     /* fill in the data */
 350
 351     mt = msi_alloc_zero( sizeof(MSIMIME) );
 352     if (!mt)
 353         return mt;
 354
 355     mt->ContentType = msi_dup_record_field( row, 1 );
 356     TRACE("loading mime %s\n", debugstr_w(mt->ContentType));
 357
 358     buffer = MSI_RecordGetString( row, 2 );
 359     mt->Extension = load_given_extension( package, buffer );
 360
 361     mt->clsid = msi_dup_record_field( row, 3 );
 362     mt->Class = load_given_class( package, mt->clsid );
 363
 364     list_add_tail( &package->mimes, &mt->entry );
 365
 366     return mt;
 367 }
 368
 369 static MSIMIME *load_given_mime( MSIPACKAGE *package, LPCWSTR mime )
 370 {
 371     MSIRECORD *row;
 372     static const WCHAR ExecSeqQuery[] =
 373         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 374          '`','M','I','M','E','`',' ','W','H','E','R','E',' ',
 375          '`','C','o','n','t','e','n','t','T','y','p','e','`',' ','=',' ',
 376          '\'','%','s','\'',0};
 377     MSIMIME *mt;
 378
 379     if (!mime)
 380         return NULL;
 381
 382     /* check for mime already loaded */
 383     LIST_FOR_EACH_ENTRY( mt, &package->mimes, MSIMIME, entry )
 384     {
 385         if (strcmpiW(mt->ContentType,mime)==0)
 386         {
 387             TRACE("found mime %s (%p)\n",debugstr_w(mime), mt);
 388             return mt;
 389         }
 390     }
 391
 392     row = MSI_QueryGetRecord(package->db, ExecSeqQuery, mime);
 393     if (!row)
 394         return NULL;
 395
 396     mt = load_mime(package, row);
 397     msiobj_release(&row->hdr);
 398
 399     return mt;
 400 }
 401
 402 static MSIEXTENSION *load_extension( MSIPACKAGE* package, MSIRECORD *row )
 403 {
 404     MSIEXTENSION *ext;
 405     LPCWSTR buffer;
 406
 407     /* fill in the data */
 408
 409     ext = msi_alloc_zero( sizeof(MSIEXTENSION) );
 410     if (!ext)
 411         return NULL;
 412
 413     list_init( &ext->verbs );
 414
 415     list_add_tail( &package->extensions, &ext->entry );
 416
 417     ext->Extension = msi_dup_record_field( row, 1 );
 418     TRACE("loading extension %s\n", debugstr_w(ext->Extension));
 419
 420     buffer = MSI_RecordGetString( row, 2 );
 421     ext->Component = get_loaded_component( package,buffer );
 422
 423     ext->ProgIDText = msi_dup_record_field( row, 3 );
 424     ext->ProgID = load_given_progid( package, ext->ProgIDText );
 425
 426     buffer = MSI_RecordGetString( row, 4 );
 427     ext->Mime = load_given_mime( package, buffer );
 428
 429     buffer = MSI_RecordGetString(row,5);
 430     ext->Feature = get_loaded_feature( package, buffer );
 431
 432     return ext;
 433 }
 434
 435 /*
 436  * While the extension table has 2 primary keys, this function is only looking
 437  * at the Extension key which is what is referenced as a foreign key
 438  */
 439 static MSIEXTENSION *load_given_extension( MSIPACKAGE *package, LPCWSTR name )
 440 {
 441     MSIRECORD *row;
 442     MSIEXTENSION *ext;
 443     static const WCHAR ExecSeqQuery[] =
 444         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 445          '`','E','x','t','e','n','s','i','o','n','`',' ',
 446          'W','H','E','R','E',' ',
 447          '`','E','x','t','e','n','s','i','o','n','`',' ','=',' ',
 448          '\'','%','s','\'',0};
 449
 450     if (!name)
 451         return NULL;
 452
 453     if (name[0] == '.')
 454         name++;
 455
 456     /* check for extensions already loaded */
 457     LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
 458     {
 459         if (strcmpiW( ext->Extension, name )==0)
 460         {
 461             TRACE("extension %s already loaded %p\n", debugstr_w(name), ext);
 462             return ext;
 463         }
 464     }
 465
 466     row = MSI_QueryGetRecord( package->db, ExecSeqQuery, name );
 467     if (!row)
 468         return NULL;
 469
 470     ext = load_extension(package, row);
 471     msiobj_release(&row->hdr);
 472
 473     return ext;
 474 }
 475
 476 static UINT iterate_load_verb(MSIRECORD *row, LPVOID param)
 477 {
 478     MSIPACKAGE* package = param;
 479     MSIVERB *verb;
 480     LPCWSTR buffer;
 481     MSIEXTENSION *extension;
 482
 483     buffer = MSI_RecordGetString(row,1);
 484     extension = load_given_extension( package, buffer );
 485     if (!extension)
 486     {
 487         ERR("Verb unable to find loaded extension %s\n", debugstr_w(buffer));
 488         return ERROR_SUCCESS;
 489     }
 490
 491     /* fill in the data */
 492
 493     verb = msi_alloc_zero( sizeof(MSIVERB) );
 494     if (!verb)
 495         return ERROR_OUTOFMEMORY;
 496
 497     verb->Verb = msi_dup_record_field(row,2);
 498     TRACE("loading verb %s\n",debugstr_w(verb->Verb));
 499     verb->Sequence = MSI_RecordGetInteger(row,3);
 500
 501     buffer = MSI_RecordGetString(row,4);
 502     deformat_string(package,buffer,&verb->Command);
 503
 504     buffer = MSI_RecordGetString(row,5);
 505     deformat_string(package,buffer,&verb->Argument);
 506
 507     /* associate the verb with the correct extension */
 508     list_add_tail( &extension->verbs, &verb->entry );
 509
 510     return ERROR_SUCCESS;
 511 }
 512
 513 static UINT iterate_all_classes(MSIRECORD *rec, LPVOID param)
 514 {
 515     MSICOMPONENT *comp;
 516     LPCWSTR clsid;
 517     LPCWSTR context;
 518     LPCWSTR buffer;
 519     MSIPACKAGE* package = param;
 520     MSICLASS *cls;
 521     BOOL match = FALSE;
 522
 523     clsid = MSI_RecordGetString(rec,1);
 524     context = MSI_RecordGetString(rec,2);
 525     buffer = MSI_RecordGetString(rec,3);
 526     comp = get_loaded_component(package,buffer);
 527
 528     LIST_FOR_EACH_ENTRY( cls, &package->classes, MSICLASS, entry )
 529     {
 530         if (strcmpiW( clsid, cls->clsid ))
 531             continue;
 532         if (strcmpW( context, cls->Context ))
 533             continue;
 534         if (comp == cls->Component)
 535         {
 536             match = TRUE;
 537             break;
 538         }
 539     }
 540
 541     if (!match)
 542         load_class(package, rec);
 543
 544     return ERROR_SUCCESS;
 545 }
 546
 547 static VOID load_all_classes(MSIPACKAGE *package)
 548 {
 549     UINT rc = ERROR_SUCCESS;
 550     MSIQUERY *view;
 551
 552     static const WCHAR ExecSeqQuery[] =
 553         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
 554          '`','C','l','a','s','s','`',0};
 555
 556     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 557     if (rc != ERROR_SUCCESS)
 558         return;
 559
 560     rc = MSI_IterateRecords(view, NULL, iterate_all_classes, package);
 561     msiobj_release(&view->hdr);
 562 }
 563
 564 static UINT iterate_all_extensions(MSIRECORD *rec, LPVOID param)
 565 {
 566     MSICOMPONENT *comp;
 567     LPCWSTR buffer;
 568     LPCWSTR extension;
 569     MSIPACKAGE* package = param;
 570     BOOL match = FALSE;
 571     MSIEXTENSION *ext;
 572
 573     extension = MSI_RecordGetString(rec,1);
 574     buffer = MSI_RecordGetString(rec,2);
 575     comp = get_loaded_component(package,buffer);
 576
 577     LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
 578     {
 579         if (strcmpiW(extension,ext->Extension))
 580             continue;
 581         if (comp == ext->Component)
 582         {
 583             match = TRUE;
 584             break;
 585         }
 586     }
 587
 588     if (!match)
 589         load_extension(package, rec);
 590
 591     return ERROR_SUCCESS;
 592 }
 593
 594 static VOID load_all_extensions(MSIPACKAGE *package)
 595 {
 596     UINT rc = ERROR_SUCCESS;
 597     MSIQUERY *view;
 598
 599     static const WCHAR ExecSeqQuery[] =
 600         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 601          '`','E','x','t','e','n','s','i','o','n','`',0};
 602
 603     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 604     if (rc != ERROR_SUCCESS)
 605         return;
 606
 607     rc = MSI_IterateRecords(view, NULL, iterate_all_extensions, package);
 608     msiobj_release(&view->hdr);
 609 }
 610
 611 static UINT iterate_all_progids(MSIRECORD *rec, LPVOID param)
 612 {
 613     LPCWSTR buffer;
 614     MSIPACKAGE* package = param;
 615
 616     buffer = MSI_RecordGetString(rec,1);
 617     load_given_progid(package,buffer);
 618     return ERROR_SUCCESS;
 619 }
 620
 621 static VOID load_all_progids(MSIPACKAGE *package)
 622 {
 623     UINT rc = ERROR_SUCCESS;
 624     MSIQUERY *view;
 625
 626     static const WCHAR ExecSeqQuery[] =
 627         {'S','E','L','E','C','T',' ','`','P','r','o','g','I','d','`',' ',
 628          'F','R','O','M',' ', '`','P','r','o','g','I','d','`',0};
 629
 630     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 631     if (rc != ERROR_SUCCESS)
 632         return;
 633
 634     rc = MSI_IterateRecords(view, NULL, iterate_all_progids, package);
 635     msiobj_release(&view->hdr);
 636 }
 637
 638 static VOID load_all_verbs(MSIPACKAGE *package)
 639 {
 640     UINT rc = ERROR_SUCCESS;
 641     MSIQUERY *view;
 642
 643     static const WCHAR ExecSeqQuery[] =
 644         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 645          '`','V','e','r','b','`',0};
 646
 647     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 648     if (rc != ERROR_SUCCESS)
 649         return;
 650
 651     rc = MSI_IterateRecords(view, NULL, iterate_load_verb, package);
 652     msiobj_release(&view->hdr);
 653 }
 654
 655 static UINT iterate_all_mimes(MSIRECORD *rec, LPVOID param)
 656 {
 657     LPCWSTR buffer;
 658     MSIPACKAGE* package = param;
 659
 660     buffer = MSI_RecordGetString(rec,1);
 661     load_given_mime(package,buffer);
 662     return ERROR_SUCCESS;
 663 }
 664
 665 static VOID load_all_mimes(MSIPACKAGE *package)
 666 {
 667     UINT rc = ERROR_SUCCESS;
 668     MSIQUERY *view;
 669
 670     static const WCHAR ExecSeqQuery[] =
 671         {'S','E','L','E','C','T',' ',
 672          '`','C','o','n','t','e','n','t','T','y','p','e','`',
 673          ' ','F','R','O','M',' ',
 674          '`','M','I','M','E','`',0};
 675
 676     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 677     if (rc != ERROR_SUCCESS)
 678         return;
 679
 680     rc = MSI_IterateRecords(view, NULL, iterate_all_mimes, package);
 681     msiobj_release(&view->hdr);
 682 }
 683
 684 static void load_classes_and_such(MSIPACKAGE *package)
 685 {
 686     TRACE("Loading all the class info and related tables\n");
 687
 688     /* check if already loaded */
 689     if (!list_empty( &package->classes ) ||
 690         !list_empty( &package->mimes ) ||
 691         !list_empty( &package->extensions ) ||
 692         !list_empty( &package->progids ) )
 693         return;
 694
 695     load_all_classes(package);
 696     load_all_extensions(package);
 697     load_all_progids(package);
 698     /* these loads must come after the other loads */
 699     load_all_verbs(package);
 700     load_all_mimes(package);
 701 }
 702
 703 static void mark_progid_for_install( MSIPACKAGE* package, MSIPROGID *progid )
 704 {
 705     MSIPROGID *child;
 706
 707     if (!progid)
 708         return;
 709
 710     if (progid->InstallMe)
 711         return;
 712
 713     progid->InstallMe = TRUE;
 714
 715     /* all children if this is a parent also install */
 716     LIST_FOR_EACH_ENTRY( child, &package->progids, MSIPROGID, entry )
 717     {
 718         if (child->Parent == progid)
 719             mark_progid_for_install( package, child );
 720     }
 721 }
 722
 723 static void mark_mime_for_install( MSIMIME *mime )
 724 {
 725     if (!mime)
 726         return;
 727     mime->InstallMe = TRUE;
 728 }
 729
 730 static UINT register_appid(const MSIAPPID *appid, LPCWSTR app )
 731 {
 732     static const WCHAR szAppID[] = { 'A','p','p','I','D',0 };
 733     static const WCHAR szRemoteServerName[] =
 734          {'R','e','m','o','t','e','S','e','r','v','e','r','N','a','m','e',0};
 735     static const WCHAR szLocalService[] =
 736          {'L','o','c','a','l','S','e','r','v','i','c','e',0};
 737     static const WCHAR szService[] =
 738          {'S','e','r','v','i','c','e','P','a','r','a','m','e','t','e','r','s',0};
 739     static const WCHAR szDLL[] =
 740          {'D','l','l','S','u','r','r','o','g','a','t','e',0};
 741     static const WCHAR szActivate[] =
 742          {'A','c','t','i','v','a','t','e','A','s','S','t','o','r','a','g','e',0};
 743     static const WCHAR szY[] = {'Y',0};
 744     static const WCHAR szRunAs[] = {'R','u','n','A','s',0};
 745     static const WCHAR szUser[] =
 746          {'I','n','t','e','r','a','c','t','i','v','e',' ','U','s','e','r',0};
 747
 748     HKEY hkey2,hkey3;
 749
 750     RegCreateKeyW(HKEY_CLASSES_ROOT,szAppID,&hkey2);
 751     RegCreateKeyW( hkey2, appid->AppID, &hkey3 );
 752     RegCloseKey(hkey2);
 753     msi_reg_set_val_str( hkey3, NULL, app );
 754
 755     if (appid->RemoteServerName)
 756         msi_reg_set_val_str( hkey3, szRemoteServerName, appid->RemoteServerName );
 757
 758     if (appid->LocalServer)
 759         msi_reg_set_val_str( hkey3, szLocalService, appid->LocalServer );
 760
 761     if (appid->ServiceParameters)
 762         msi_reg_set_val_str( hkey3, szService, appid->ServiceParameters );
 763
 764     if (appid->DllSurrogate)
 765         msi_reg_set_val_str( hkey3, szDLL, appid->DllSurrogate );
 766
 767     if (appid->ActivateAtStorage)
 768         msi_reg_set_val_str( hkey3, szActivate, szY );
 769
 770     if (appid->RunAsInteractiveUser)
 771         msi_reg_set_val_str( hkey3, szRunAs, szUser );
 772
 773     RegCloseKey(hkey3);
 774     return ERROR_SUCCESS;
 775 }
 776
 777 UINT ACTION_RegisterClassInfo(MSIPACKAGE *package)
 778 {
 779     /*
 780      * Again I am assuming the words, "Whose key file represents" when referring
 781      * to a Component as to meaning that Components KeyPath file
 782      */
 783
 784     UINT rc;
 785     MSIRECORD *uirow;
 786     static const WCHAR szCLSID[] = { 'C','L','S','I','D',0 };
 787     static const WCHAR szProgID[] = { 'P','r','o','g','I','D',0 };
 788     static const WCHAR szVIProgID[] = { 'V','e','r','s','i','o','n','I','n','d','e','p','e','n','d','e','n','t','P','r','o','g','I','D',0 };
 789     static const WCHAR szAppID[] = { 'A','p','p','I','D',0 };
 790     static const WCHAR szFileType_fmt[] = {'F','i','l','e','T','y','p','e','\\','%','s','\\','%','i',0};
 791     HKEY hkey,hkey2,hkey3;
 792     MSICLASS *cls;
 793
 794     load_classes_and_such(package);
 795     rc = RegCreateKeyW(HKEY_CLASSES_ROOT,szCLSID,&hkey);
 796     if (rc != ERROR_SUCCESS)
 797         return ERROR_FUNCTION_FAILED;
 798
 799     LIST_FOR_EACH_ENTRY( cls, &package->classes, MSICLASS, entry )
 800     {
 801         MSICOMPONENT *comp;
 802         MSIFILE *file;
 803         DWORD size;
 804         LPWSTR argument;
 805         MSIFEATURE *feature;
 806
 807         comp = cls->Component;
 808         if ( !comp )
 809             continue;
 810
 811         feature = cls->Feature;
 812         if (!feature)
 813             continue;
 814
 815         /*
 816          * MSDN says that these are based on Feature not on Component.
 817          */
 818         if (feature->ActionRequest != INSTALLSTATE_LOCAL &&
 819             feature->ActionRequest != INSTALLSTATE_ADVERTISED )
 820         {
 821             TRACE("Feature %s not scheduled for installation, skipping regstration of class %s\n",
 822                   debugstr_w(feature->Feature), debugstr_w(cls->clsid));
 823             continue;
 824         }
 825
 826         TRACE("Registering class %s (%p)\n", debugstr_w(cls->clsid), cls);
 827
 828         cls->Installed = TRUE;
 829         mark_progid_for_install( package, cls->ProgID );
 830
 831         RegCreateKeyW( hkey, cls->clsid, &hkey2 );
 832
 833         if (cls->Description)
 834             msi_reg_set_val_str( hkey2, NULL, cls->Description );
 835
 836         RegCreateKeyW( hkey2, cls->Context, &hkey3 );
 837         file = get_loaded_file( package, comp->KeyPath );
 838         if (!file)
 839         {
 840             TRACE("COM server not provided, skipping class %s\n", debugstr_w(cls->clsid));
 841             continue;
 842         }
 843
 844         /*
 845          * FIXME: Implement install on demand (advertised components).
 846          *
 847          * ole32.dll should call msi.MsiProvideComponentFromDescriptor()
 848          *  when it needs an InProcServer that doesn't exist.
 849          * The component advertise string should be in the "InProcServer" value.
 850          */
 851         size = lstrlenW( file->TargetPath )+1;
 852         if (cls->Argument)
 853             size += lstrlenW(cls->Argument)+1;
 854
 855         argument = msi_alloc( size * sizeof(WCHAR) );
 856         lstrcpyW( argument, file->TargetPath );
 857
 858         if (cls->Argument)
 859         {
 860             lstrcatW( argument, szSpace );
 861             lstrcatW( argument, cls->Argument );
 862         }
 863
 864         msi_reg_set_val_str( hkey3, NULL, argument );
 865         msi_free(argument);
 866
 867         RegCloseKey(hkey3);
 868
 869         if (cls->ProgID || cls->ProgIDText)
 870         {
 871             LPCWSTR progid;
 872
 873             if (cls->ProgID)
 874                 progid = cls->ProgID->ProgID;
 875             else
 876                 progid = cls->ProgIDText;
 877
 878             msi_reg_set_subkey_val( hkey2, szProgID, NULL, progid );
 879
 880             if (cls->ProgID && cls->ProgID->VersionInd)
 881             {
 882                 msi_reg_set_subkey_val( hkey2, szVIProgID, NULL,
 883                                         cls->ProgID->VersionInd->ProgID );
 884             }
 885         }
 886
 887         if (cls->AppID)
 888         {
 889             MSIAPPID *appid = cls->AppID;
 890
 891             msi_reg_set_val_str( hkey2, szAppID, appid->AppID );
 892
 893             register_appid( appid, cls->Description );
 894         }
 895
 896         if (cls->IconPath)
 897         {
 898             static const WCHAR szDefaultIcon[] =
 899                 {'D','e','f','a','u','l','t','I','c','o','n',0};
 900
 901             msi_reg_set_subkey_val( hkey2, szDefaultIcon, NULL, cls->IconPath );
 902         }
 903
 904         if (cls->DefInprocHandler)
 905         {
 906             static const WCHAR szInproc[] =
 907                 {'I','n','p','r','o','c','H','a','n','d','l','e','r',0};
 908
 909             msi_reg_set_subkey_val( hkey2, szInproc, NULL, cls->DefInprocHandler );
 910         }
 911
 912         if (cls->DefInprocHandler32)
 913         {
 914             static const WCHAR szInproc32[] =
 915                 {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
 916
 917             msi_reg_set_subkey_val( hkey2, szInproc32, NULL, cls->DefInprocHandler32 );
 918         }
 919
 920         RegCloseKey(hkey2);
 921
 922         /* if there is a FileTypeMask, register the FileType */
 923         if (cls->FileTypeMask)
 924         {
 925             LPWSTR ptr, ptr2;
 926             LPWSTR keyname;
 927             INT index = 0;
 928             ptr = cls->FileTypeMask;
 929             while (ptr && *ptr)
 930             {
 931                 ptr2 = strchrW(ptr,';');
 932                 if (ptr2)
 933                     *ptr2 = 0;
 934                 keyname = msi_alloc( (strlenW(szFileType_fmt) + strlenW(cls->clsid) + 4) * sizeof(WCHAR));
 935                 sprintfW( keyname, szFileType_fmt, cls->clsid, index );
 936
 937                 msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, ptr );
 938                 msi_free(keyname);
 939
 940                 if (ptr2)
 941                     ptr = ptr2+1;
 942                 else
 943                     ptr = NULL;
 944
 945                 index ++;
 946             }
 947         }
 948
 949         uirow = MSI_CreateRecord(1);
 950
 951         MSI_RecordSetStringW( uirow, 1, cls->clsid );
 952         ui_actiondata(package,szRegisterClassInfo,uirow);
 953         msiobj_release(&uirow->hdr);
 954     }
 955
 956     RegCloseKey(hkey);
 957     return rc;
 958 }
 959
 960 static LPCWSTR get_clsid_of_progid( const MSIPROGID *progid )
 961 {
 962     while (progid)
 963     {
 964         if (progid->Class)
 965             return progid->Class->clsid;
 966         if (progid->Parent == progid)
 967             break;
 968         progid = progid->Parent;
 969     }
 970     return NULL;
 971 }
 972
 973 static UINT register_progid( const MSIPROGID* progid )
 974 {
 975     static const WCHAR szCLSID[] = { 'C','L','S','I','D',0 };
 976     static const WCHAR szDefaultIcon[] =
 977         {'D','e','f','a','u','l','t','I','c','o','n',0};
 978     static const WCHAR szCurVer[] =
 979         {'C','u','r','V','e','r',0};
 980     HKEY hkey = 0;
 981     UINT rc;
 982
 983     rc = RegCreateKeyW( HKEY_CLASSES_ROOT, progid->ProgID, &hkey );
 984     if (rc == ERROR_SUCCESS)
 985     {
 986         LPCWSTR clsid = get_clsid_of_progid( progid );
 987
 988         if (clsid)
 989             msi_reg_set_subkey_val( hkey, szCLSID, NULL, clsid );
 990         else
 991             ERR("%s has no class\n", debugstr_w( progid->ProgID ) );
 992
 993         if (progid->Description)
 994             msi_reg_set_val_str( hkey, NULL, progid->Description );
 995
 996         if (progid->IconPath)
 997             msi_reg_set_subkey_val( hkey, szDefaultIcon, NULL, progid->IconPath );
 998
 999         /* write out the current version */
1000         if (progid->CurVer)
1001             msi_reg_set_subkey_val( hkey, szCurVer, NULL, progid->CurVer->ProgID );
1002
1003         RegCloseKey(hkey);
1004     }
1005     else
1006         ERR("failed to create key %s\n", debugstr_w( progid->ProgID ) );
1007
1008     return rc;
1009 }
1010
1011 UINT ACTION_RegisterProgIdInfo(MSIPACKAGE *package)
1012 {
1013     MSIPROGID *progid;
1014     MSIRECORD *uirow;
1015
1016     load_classes_and_such(package);
1017
1018     LIST_FOR_EACH_ENTRY( progid, &package->progids, MSIPROGID, entry )
1019     {
1020         /* check if this progid is to be installed */
1021         if (progid->Class && progid->Class->Installed)
1022             progid->InstallMe = TRUE;
1023
1024         if (!progid->InstallMe)
1025         {
1026             TRACE("progid %s not scheduled to be installed\n",
1027                              debugstr_w(progid->ProgID));
1028             continue;
1029         }
1030
1031         TRACE("Registering progid %s\n", debugstr_w(progid->ProgID));
1032
1033         register_progid( progid );
1034
1035         uirow = MSI_CreateRecord( 1 );
1036         MSI_RecordSetStringW( uirow, 1, progid->ProgID );
1037         ui_actiondata( package, szRegisterProgIdInfo, uirow );
1038         msiobj_release( &uirow->hdr );
1039     }
1040
1041     return ERROR_SUCCESS;
1042 }
1043
1044 static UINT register_verb(MSIPACKAGE *package, LPCWSTR progid,
1045                 MSICOMPONENT* component, const MSIEXTENSION* extension,
1046                 MSIVERB* verb, INT* Sequence )
1047 {
1048     LPWSTR keyname;
1049     HKEY key;
1050     static const WCHAR szShell[] = {'s','h','e','l','l',0};
1051     static const WCHAR szCommand[] = {'c','o','m','m','a','n','d',0};
1052     static const WCHAR fmt[] = {'\"','%','s','\"',' ','%','s',0};
1053     static const WCHAR fmt2[] = {'\"','%','s','\"',0};
1054     LPWSTR command;
1055     DWORD size;
1056     LPWSTR advertise;
1057
1058     keyname = build_directory_name(4, progid, szShell, verb->Verb, szCommand);
1059
1060     TRACE("Making Key %s\n",debugstr_w(keyname));
1061     RegCreateKeyW(HKEY_CLASSES_ROOT, keyname, &key);
1062     size = strlenW(component->FullKeypath);
1063     if (verb->Argument)
1064         size += strlenW(verb->Argument);
1065      size += 4;
1066
1067      command = msi_alloc(size * sizeof (WCHAR));
1068      if (verb->Argument)
1069         sprintfW(command, fmt, component->FullKeypath, verb->Argument);
1070      else
1071         sprintfW(command, fmt2, component->FullKeypath);
1072
1073      msi_reg_set_val_str( key, NULL, command );
1074      msi_free(command);
1075
1076      advertise = create_component_advertise_string(package, component,
1077                                                    extension->Feature->Feature);
1078
1079      size = strlenW(advertise);
1080
1081      if (verb->Argument)
1082          size += strlenW(verb->Argument);
1083      size += 4;
1084
1085      command = msi_alloc_zero(size * sizeof (WCHAR));
1086
1087      strcpyW(command,advertise);
1088      if (verb->Argument)
1089      {
1090          strcatW(command,szSpace);
1091          strcatW(command,verb->Argument);
1092      }
1093
1094      msi_reg_set_val_multi_str( key, szCommand, command );
1095
1096      RegCloseKey(key);
1097      msi_free(keyname);
1098      msi_free(advertise);
1099      msi_free(command);
1100
1101      if (verb->Command)
1102      {
1103         keyname = build_directory_name(3, progid, szShell, verb->Verb);
1104         msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Command );
1105         msi_free(keyname);
1106      }
1107
1108      if (verb->Sequence != MSI_NULL_INTEGER)
1109      {
1110         if (*Sequence == MSI_NULL_INTEGER || verb->Sequence < *Sequence)
1111         {
1112             *Sequence = verb->Sequence;
1113             keyname = build_directory_name(2, progid, szShell);
1114             msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Verb );
1115             msi_free(keyname);
1116         }
1117     }
1118     return ERROR_SUCCESS;
1119 }
1120
1121 UINT ACTION_RegisterExtensionInfo(MSIPACKAGE *package)
1122 {
1123     static const WCHAR szContentType[] =
1124         {'C','o','n','t','e','n','t',' ','T','y','p','e',0 };
1125     HKEY hkey;
1126     MSIEXTENSION *ext;
1127     MSIRECORD *uirow;
1128     BOOL install_on_demand = TRUE;
1129
1130     load_classes_and_such(package);
1131
1132     /* We need to set install_on_demand based on if the shell handles advertised
1133      * shortcuts and the like. Because Mike McCormack is working on this i am
1134      * going to default to TRUE
1135      */
1136
1137     LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
1138     {
1139         LPWSTR extension;
1140         MSIFEATURE *feature;
1141
1142         if (!ext->Component)
1143             continue;
1144
1145         feature = ext->Feature;
1146         if (!feature)
1147             continue;
1148
1149         /*
1150          * yes. MSDN says that these are based on _Feature_ not on
1151          * Component.  So verify the feature is to be installed
1152          */
1153         if (feature->ActionRequest != INSTALLSTATE_LOCAL &&
1154             !(install_on_demand && feature->ActionRequest == INSTALLSTATE_ADVERTISED))
1155         {
1156             TRACE("Feature %s not scheduled for installation, skipping registration of extension %s\n",
1157                    debugstr_w(feature->Feature), debugstr_w(ext->Extension));
1158             continue;
1159         }
1160
1161         TRACE("Registering extension %s (%p)\n", debugstr_w(ext->Extension), ext);
1162
1163         ext->Installed = TRUE;
1164
1165         /* this is only registered if the extension has at least 1 verb
1166          * according to MSDN
1167          */
1168         if (ext->ProgID && !list_empty( &ext->verbs ) )
1169             mark_progid_for_install( package, ext->ProgID );
1170
1171         mark_mime_for_install(ext->Mime);
1172
1173         extension = msi_alloc( (lstrlenW( ext->Extension ) + 2)*sizeof(WCHAR) );
1174         extension[0] = '.';
1175         lstrcpyW(extension+1,ext->Extension);
1176
1177         RegCreateKeyW(HKEY_CLASSES_ROOT,extension,&hkey);
1178         msi_free( extension );
1179
1180         if (ext->Mime)
1181             msi_reg_set_val_str( hkey, szContentType, ext->Mime->ContentType );
1182
1183         if (ext->ProgID || ext->ProgIDText)
1184         {
1185             static const WCHAR szSN[] =
1186                 {'\\','S','h','e','l','l','N','e','w',0};
1187             HKEY hkey2;
1188             LPWSTR newkey;
1189             LPCWSTR progid;
1190             MSIVERB *verb;
1191             INT Sequence = MSI_NULL_INTEGER;
1192
1193             if (ext->ProgID)
1194                 progid = ext->ProgID->ProgID;
1195             else
1196                 progid = ext->ProgIDText;
1197
1198             msi_reg_set_val_str( hkey, NULL, progid );
1199
1200             newkey = msi_alloc( (strlenW(progid)+strlenW(szSN)+1) * sizeof(WCHAR));
1201
1202             strcpyW(newkey,progid);
1203             strcatW(newkey,szSN);
1204             RegCreateKeyW(hkey,newkey,&hkey2);
1205             RegCloseKey(hkey2);
1206
1207             msi_free(newkey);
1208
1209             /* do all the verbs */
1210             LIST_FOR_EACH_ENTRY( verb, &ext->verbs, MSIVERB, entry )
1211             {
1212                 register_verb( package, progid, ext->Component,
1213                                ext, verb, &Sequence);
1214             }
1215         }
1216
1217         RegCloseKey(hkey);
1218
1219         uirow = MSI_CreateRecord(1);
1220         MSI_RecordSetStringW( uirow, 1, ext->Extension );
1221         ui_actiondata(package,szRegisterExtensionInfo,uirow);
1222         msiobj_release(&uirow->hdr);
1223     }
1224
1225     return ERROR_SUCCESS;
1226 }
1227
1228 UINT ACTION_RegisterMIMEInfo(MSIPACKAGE *package)
1229 {
1230     static const WCHAR szExten[] =
1231         {'E','x','t','e','n','s','i','o','n',0 };
1232     MSIRECORD *uirow;
1233     MSIMIME *mt;
1234
1235     load_classes_and_such(package);
1236
1237     LIST_FOR_EACH_ENTRY( mt, &package->mimes, MSIMIME, entry )
1238     {
1239         LPWSTR extension;
1240         LPCWSTR exten;
1241         LPCWSTR mime;
1242         static const WCHAR fmt[] =
1243             {'M','I','M','E','\\','D','a','t','a','b','a','s','e','\\',
1244              'C','o','n','t','e','n','t',' ','T','y','p','e','\\', '%','s',0};
1245         LPWSTR key;
1246
1247         /*
1248          * check if the MIME is to be installed. Either as requested by an
1249          * extension or Class
1250          */
1251         mt->InstallMe = (mt->InstallMe ||
1252               (mt->Class && mt->Class->Installed) ||
1253               (mt->Extension && mt->Extension->Installed));
1254
1255         if (!mt->InstallMe)
1256         {
1257             TRACE("MIME %s not scheduled to be installed\n",
1258                              debugstr_w(mt->ContentType));
1259             continue;
1260         }
1261
1262         mime = mt->ContentType;
1263         exten = mt->Extension->Extension;
1264
1265         extension = msi_alloc( (lstrlenW( exten ) + 2)*sizeof(WCHAR) );
1266         extension[0] = '.';
1267         lstrcpyW(extension+1,exten);
1268
1269         key = msi_alloc( (strlenW(mime)+strlenW(fmt)+1) * sizeof(WCHAR) );
1270         sprintfW(key,fmt,mime);
1271         msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, key, szExten, extension );
1272
1273         msi_free(extension);
1274         msi_free(key);
1275
1276         if (mt->clsid)
1277             FIXME("Handle non null for field 3\n");
1278
1279         uirow = MSI_CreateRecord(2);
1280         MSI_RecordSetStringW(uirow,1,mt->ContentType);
1281         MSI_RecordSetStringW(uirow,2,exten);
1282         ui_actiondata(package,szRegisterMIMEInfo,uirow);
1283         msiobj_release(&uirow->hdr);
1284     }
1285
1286     return ERROR_SUCCESS;
1287 }