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