-sync msi with wine 1.1.32
[reactos.git] / reactos / dll / win32 / 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
813 /*
814 * MSDN says that these are based on Feature not on Component.
815 */
816 if (!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL ) &&
817 !ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ADVERTISED ))
818 {
819 TRACE("Skipping class %s reg due to disabled feature %s\n",
820 debugstr_w(cls->clsid), debugstr_w(feature->Feature));
821
822 continue;
823 }
824
825 TRACE("Registering class %s (%p)\n", debugstr_w(cls->clsid), cls);
826
827 cls->Installed = TRUE;
828 mark_progid_for_install( package, cls->ProgID );
829
830 RegCreateKeyW( hkey, cls->clsid, &hkey2 );
831
832 if (cls->Description)
833 msi_reg_set_val_str( hkey2, NULL, cls->Description );
834
835 RegCreateKeyW( hkey2, cls->Context, &hkey3 );
836 file = get_loaded_file( package, comp->KeyPath );
837 if (!file)
838 {
839 TRACE("COM server not provided, skipping class %s\n", debugstr_w(cls->clsid));
840 continue;
841 }
842
843 /*
844 * FIXME: Implement install on demand (advertised components).
845 *
846 * ole32.dll should call msi.MsiProvideComponentFromDescriptor()
847 * when it needs an InProcServer that doesn't exist.
848 * The component advertise string should be in the "InProcServer" value.
849 */
850 size = lstrlenW( file->TargetPath )+1;
851 if (cls->Argument)
852 size += lstrlenW(cls->Argument)+1;
853
854 argument = msi_alloc( size * sizeof(WCHAR) );
855 lstrcpyW( argument, file->TargetPath );
856
857 if (cls->Argument)
858 {
859 lstrcatW( argument, szSpace );
860 lstrcatW( argument, cls->Argument );
861 }
862
863 msi_reg_set_val_str( hkey3, NULL, argument );
864 msi_free(argument);
865
866 RegCloseKey(hkey3);
867
868 if (cls->ProgID || cls->ProgIDText)
869 {
870 LPCWSTR progid;
871
872 if (cls->ProgID)
873 progid = cls->ProgID->ProgID;
874 else
875 progid = cls->ProgIDText;
876
877 msi_reg_set_subkey_val( hkey2, szProgID, NULL, progid );
878
879 if (cls->ProgID && cls->ProgID->VersionInd)
880 {
881 msi_reg_set_subkey_val( hkey2, szVIProgID, NULL,
882 cls->ProgID->VersionInd->ProgID );
883 }
884 }
885
886 if (cls->AppID)
887 {
888 MSIAPPID *appid = cls->AppID;
889
890 msi_reg_set_val_str( hkey2, szAppID, appid->AppID );
891
892 register_appid( appid, cls->Description );
893 }
894
895 if (cls->IconPath)
896 {
897 static const WCHAR szDefaultIcon[] =
898 {'D','e','f','a','u','l','t','I','c','o','n',0};
899
900 msi_reg_set_subkey_val( hkey2, szDefaultIcon, NULL, cls->IconPath );
901 }
902
903 if (cls->DefInprocHandler)
904 {
905 static const WCHAR szInproc[] =
906 {'I','n','p','r','o','c','H','a','n','d','l','e','r',0};
907
908 msi_reg_set_subkey_val( hkey2, szInproc, NULL, cls->DefInprocHandler );
909 }
910
911 if (cls->DefInprocHandler32)
912 {
913 static const WCHAR szInproc32[] =
914 {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
915
916 msi_reg_set_subkey_val( hkey2, szInproc32, NULL, cls->DefInprocHandler32 );
917 }
918
919 RegCloseKey(hkey2);
920
921 /* if there is a FileTypeMask, register the FileType */
922 if (cls->FileTypeMask)
923 {
924 LPWSTR ptr, ptr2;
925 LPWSTR keyname;
926 INT index = 0;
927 ptr = cls->FileTypeMask;
928 while (ptr && *ptr)
929 {
930 ptr2 = strchrW(ptr,';');
931 if (ptr2)
932 *ptr2 = 0;
933 keyname = msi_alloc( (strlenW(szFileType_fmt) + strlenW(cls->clsid) + 4) * sizeof(WCHAR));
934 sprintfW( keyname, szFileType_fmt, cls->clsid, index );
935
936 msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, ptr );
937 msi_free(keyname);
938
939 if (ptr2)
940 ptr = ptr2+1;
941 else
942 ptr = NULL;
943
944 index ++;
945 }
946 }
947
948 uirow = MSI_CreateRecord(1);
949
950 MSI_RecordSetStringW( uirow, 1, cls->clsid );
951 ui_actiondata(package,szRegisterClassInfo,uirow);
952 msiobj_release(&uirow->hdr);
953 }
954
955 RegCloseKey(hkey);
956 return rc;
957 }
958
959 static LPCWSTR get_clsid_of_progid( const MSIPROGID *progid )
960 {
961 while (progid)
962 {
963 if (progid->Class)
964 return progid->Class->clsid;
965 if (progid->Parent == progid)
966 break;
967 progid = progid->Parent;
968 }
969 return NULL;
970 }
971
972 static UINT register_progid( const MSIPROGID* progid )
973 {
974 static const WCHAR szCLSID[] = { 'C','L','S','I','D',0 };
975 static const WCHAR szDefaultIcon[] =
976 {'D','e','f','a','u','l','t','I','c','o','n',0};
977 static const WCHAR szCurVer[] =
978 {'C','u','r','V','e','r',0};
979 HKEY hkey = 0;
980 UINT rc;
981
982 rc = RegCreateKeyW( HKEY_CLASSES_ROOT, progid->ProgID, &hkey );
983 if (rc == ERROR_SUCCESS)
984 {
985 LPCWSTR clsid = get_clsid_of_progid( progid );
986
987 if (clsid)
988 msi_reg_set_subkey_val( hkey, szCLSID, NULL, clsid );
989 else
990 ERR("%s has no class\n", debugstr_w( progid->ProgID ) );
991
992 if (progid->Description)
993 msi_reg_set_val_str( hkey, NULL, progid->Description );
994
995 if (progid->IconPath)
996 msi_reg_set_subkey_val( hkey, szDefaultIcon, NULL, progid->IconPath );
997
998 /* write out the current version */
999 if (progid->CurVer)
1000 msi_reg_set_subkey_val( hkey, szCurVer, NULL, progid->CurVer->ProgID );
1001
1002 RegCloseKey(hkey);
1003 }
1004 else
1005 ERR("failed to create key %s\n", debugstr_w( progid->ProgID ) );
1006
1007 return rc;
1008 }
1009
1010 UINT ACTION_RegisterProgIdInfo(MSIPACKAGE *package)
1011 {
1012 MSIPROGID *progid;
1013 MSIRECORD *uirow;
1014
1015 load_classes_and_such(package);
1016
1017 LIST_FOR_EACH_ENTRY( progid, &package->progids, MSIPROGID, entry )
1018 {
1019 /* check if this progid is to be installed */
1020 if (progid->Class && progid->Class->Installed)
1021 progid->InstallMe = TRUE;
1022
1023 if (!progid->InstallMe)
1024 {
1025 TRACE("progid %s not scheduled to be installed\n",
1026 debugstr_w(progid->ProgID));
1027 continue;
1028 }
1029
1030 TRACE("Registering progid %s\n", debugstr_w(progid->ProgID));
1031
1032 register_progid( progid );
1033
1034 uirow = MSI_CreateRecord( 1 );
1035 MSI_RecordSetStringW( uirow, 1, progid->ProgID );
1036 ui_actiondata( package, szRegisterProgIdInfo, uirow );
1037 msiobj_release( &uirow->hdr );
1038 }
1039
1040 return ERROR_SUCCESS;
1041 }
1042
1043 static UINT register_verb(MSIPACKAGE *package, LPCWSTR progid,
1044 MSICOMPONENT* component, const MSIEXTENSION* extension,
1045 MSIVERB* verb, INT* Sequence )
1046 {
1047 LPWSTR keyname;
1048 HKEY key;
1049 static const WCHAR szShell[] = {'s','h','e','l','l',0};
1050 static const WCHAR szCommand[] = {'c','o','m','m','a','n','d',0};
1051 static const WCHAR fmt[] = {'\"','%','s','\"',' ','%','s',0};
1052 static const WCHAR fmt2[] = {'\"','%','s','\"',0};
1053 LPWSTR command;
1054 DWORD size;
1055 LPWSTR advertise;
1056
1057 keyname = build_directory_name(4, progid, szShell, verb->Verb, szCommand);
1058
1059 TRACE("Making Key %s\n",debugstr_w(keyname));
1060 RegCreateKeyW(HKEY_CLASSES_ROOT, keyname, &key);
1061 size = strlenW(component->FullKeypath);
1062 if (verb->Argument)
1063 size += strlenW(verb->Argument);
1064 size += 4;
1065
1066 command = msi_alloc(size * sizeof (WCHAR));
1067 if (verb->Argument)
1068 sprintfW(command, fmt, component->FullKeypath, verb->Argument);
1069 else
1070 sprintfW(command, fmt2, component->FullKeypath);
1071
1072 msi_reg_set_val_str( key, NULL, command );
1073 msi_free(command);
1074
1075 advertise = create_component_advertise_string(package, component,
1076 extension->Feature->Feature);
1077
1078 size = strlenW(advertise);
1079
1080 if (verb->Argument)
1081 size += strlenW(verb->Argument);
1082 size += 4;
1083
1084 command = msi_alloc_zero(size * sizeof (WCHAR));
1085
1086 strcpyW(command,advertise);
1087 if (verb->Argument)
1088 {
1089 strcatW(command,szSpace);
1090 strcatW(command,verb->Argument);
1091 }
1092
1093 msi_reg_set_val_multi_str( key, szCommand, command );
1094
1095 RegCloseKey(key);
1096 msi_free(keyname);
1097 msi_free(advertise);
1098 msi_free(command);
1099
1100 if (verb->Command)
1101 {
1102 keyname = build_directory_name(3, progid, szShell, verb->Verb);
1103 msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Command );
1104 msi_free(keyname);
1105 }
1106
1107 if (verb->Sequence != MSI_NULL_INTEGER)
1108 {
1109 if (*Sequence == MSI_NULL_INTEGER || verb->Sequence < *Sequence)
1110 {
1111 *Sequence = verb->Sequence;
1112 keyname = build_directory_name(2, progid, szShell);
1113 msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, keyname, NULL, verb->Verb );
1114 msi_free(keyname);
1115 }
1116 }
1117 return ERROR_SUCCESS;
1118 }
1119
1120 UINT ACTION_RegisterExtensionInfo(MSIPACKAGE *package)
1121 {
1122 static const WCHAR szContentType[] =
1123 {'C','o','n','t','e','n','t',' ','T','y','p','e',0 };
1124 HKEY hkey;
1125 MSIEXTENSION *ext;
1126 MSIRECORD *uirow;
1127 BOOL install_on_demand = TRUE;
1128
1129 load_classes_and_such(package);
1130
1131 /* We need to set install_on_demand based on if the shell handles advertised
1132 * shortcuts and the like. Because Mike McCormack is working on this i am
1133 * going to default to TRUE
1134 */
1135
1136 LIST_FOR_EACH_ENTRY( ext, &package->extensions, MSIEXTENSION, entry )
1137 {
1138 LPWSTR extension;
1139 MSIFEATURE *feature;
1140
1141 if (!ext->Component)
1142 continue;
1143
1144 feature = ext->Feature;
1145
1146 /*
1147 * yes. MSDN says that these are based on _Feature_ not on
1148 * Component. So verify the feature is to be installed
1149 */
1150 if ((!ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_LOCAL )) &&
1151 !(install_on_demand &&
1152 ACTION_VerifyFeatureForAction( feature, INSTALLSTATE_ADVERTISED )))
1153 {
1154 TRACE("Skipping extension %s reg due to disabled feature %s\n",
1155 debugstr_w(ext->Extension), debugstr_w(feature->Feature));
1156
1157 continue;
1158 }
1159
1160 TRACE("Registering extension %s (%p)\n", debugstr_w(ext->Extension), ext);
1161
1162 ext->Installed = TRUE;
1163
1164 /* this is only registered if the extension has at least 1 verb
1165 * according to MSDN
1166 */
1167 if (ext->ProgID && !list_empty( &ext->verbs ) )
1168 mark_progid_for_install( package, ext->ProgID );
1169
1170 mark_mime_for_install(ext->Mime);
1171
1172 extension = msi_alloc( (lstrlenW( ext->Extension ) + 2)*sizeof(WCHAR) );
1173 extension[0] = '.';
1174 lstrcpyW(extension+1,ext->Extension);
1175
1176 RegCreateKeyW(HKEY_CLASSES_ROOT,extension,&hkey);
1177 msi_free( extension );
1178
1179 if (ext->Mime)
1180 msi_reg_set_val_str( hkey, szContentType, ext->Mime->ContentType );
1181
1182 if (ext->ProgID || ext->ProgIDText)
1183 {
1184 static const WCHAR szSN[] =
1185 {'\\','S','h','e','l','l','N','e','w',0};
1186 HKEY hkey2;
1187 LPWSTR newkey;
1188 LPCWSTR progid;
1189 MSIVERB *verb;
1190 INT Sequence = MSI_NULL_INTEGER;
1191
1192 if (ext->ProgID)
1193 progid = ext->ProgID->ProgID;
1194 else
1195 progid = ext->ProgIDText;
1196
1197 msi_reg_set_val_str( hkey, NULL, progid );
1198
1199 newkey = msi_alloc( (strlenW(progid)+strlenW(szSN)+1) * sizeof(WCHAR));
1200
1201 strcpyW(newkey,progid);
1202 strcatW(newkey,szSN);
1203 RegCreateKeyW(hkey,newkey,&hkey2);
1204 RegCloseKey(hkey2);
1205
1206 msi_free(newkey);
1207
1208 /* do all the verbs */
1209 LIST_FOR_EACH_ENTRY( verb, &ext->verbs, MSIVERB, entry )
1210 {
1211 register_verb( package, progid, ext->Component,
1212 ext, verb, &Sequence);
1213 }
1214 }
1215
1216 RegCloseKey(hkey);
1217
1218 uirow = MSI_CreateRecord(1);
1219 MSI_RecordSetStringW( uirow, 1, ext->Extension );
1220 ui_actiondata(package,szRegisterExtensionInfo,uirow);
1221 msiobj_release(&uirow->hdr);
1222 }
1223
1224 return ERROR_SUCCESS;
1225 }
1226
1227 UINT ACTION_RegisterMIMEInfo(MSIPACKAGE *package)
1228 {
1229 static const WCHAR szExten[] =
1230 {'E','x','t','e','n','s','i','o','n',0 };
1231 MSIRECORD *uirow;
1232 MSIMIME *mt;
1233
1234 load_classes_and_such(package);
1235
1236 LIST_FOR_EACH_ENTRY( mt, &package->mimes, MSIMIME, entry )
1237 {
1238 LPWSTR extension;
1239 LPCWSTR exten;
1240 LPCWSTR mime;
1241 static const WCHAR fmt[] =
1242 {'M','I','M','E','\\','D','a','t','a','b','a','s','e','\\',
1243 'C','o','n','t','e','n','t',' ','T','y','p','e','\\', '%','s',0};
1244 LPWSTR key;
1245
1246 /*
1247 * check if the MIME is to be installed. Either as requested by an
1248 * extension or Class
1249 */
1250 mt->InstallMe = (mt->InstallMe ||
1251 (mt->Class && mt->Class->Installed) ||
1252 (mt->Extension && mt->Extension->Installed));
1253
1254 if (!mt->InstallMe)
1255 {
1256 TRACE("MIME %s not scheduled to be installed\n",
1257 debugstr_w(mt->ContentType));
1258 continue;
1259 }
1260
1261 mime = mt->ContentType;
1262 exten = mt->Extension->Extension;
1263
1264 extension = msi_alloc( (lstrlenW( exten ) + 2)*sizeof(WCHAR) );
1265 extension[0] = '.';
1266 lstrcpyW(extension+1,exten);
1267
1268 key = msi_alloc( (strlenW(mime)+strlenW(fmt)+1) * sizeof(WCHAR) );
1269 sprintfW(key,fmt,mime);
1270 msi_reg_set_subkey_val( HKEY_CLASSES_ROOT, key, szExten, extension );
1271
1272 msi_free(extension);
1273 msi_free(key);
1274
1275 if (mt->clsid)
1276 FIXME("Handle non null for field 3\n");
1277
1278 uirow = MSI_CreateRecord(2);
1279 MSI_RecordSetStringW(uirow,1,mt->ContentType);
1280 MSI_RecordSetStringW(uirow,2,exten);
1281 ui_actiondata(package,szRegisterMIMEInfo,uirow);
1282 msiobj_release(&uirow->hdr);
1283 }
1284
1285 return ERROR_SUCCESS;
1286 }