2 * Implementation of the Microsoft Installer (msi.dll)
4 * Copyright 2005 Mike McCormack for CodeWeavers
5 * Copyright 2005 Aric Stewart for CodeWeavers
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #define NONAMELESSUNION
32 #include "wine/debug.h"
36 #include "wine/unicode.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(msi
);
44 * This module will be all the helper functions for registry access by the
47 static const WCHAR szUserFeatures_fmt
[] = {
48 'S','o','f','t','w','a','r','e','\\',
49 'M','i','c','r','o','s','o','f','t','\\',
50 'I','n','s','t','a','l','l','e','r','\\',
51 'F','e','a','t','u','r','e','s','\\',
54 static const WCHAR szInstaller_Features
[] = {
55 'S','o','f','t','w','a','r','e','\\',
56 'M','i','c','r','o','s','o','f','t','\\',
57 'W','i','n','d','o','w','s','\\',
58 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
59 'I','n','s','t','a','l','l','e','r','\\',
60 'F','e','a','t','u','r','e','s',0 };
62 static const WCHAR szInstaller_Features_fmt
[] = {
63 'S','o','f','t','w','a','r','e','\\',
64 'M','i','c','r','o','s','o','f','t','\\',
65 'W','i','n','d','o','w','s','\\',
66 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
67 'I','n','s','t','a','l','l','e','r','\\',
68 'F','e','a','t','u','r','e','s','\\',
71 static const WCHAR szInstaller_Components
[] = {
72 'S','o','f','t','w','a','r','e','\\',
73 'M','i','c','r','o','s','o','f','t','\\',
74 'W','i','n','d','o','w','s','\\',
75 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
76 'I','n','s','t','a','l','l','e','r','\\',
77 'C','o','m','p','o','n','e','n','t','s',0 };
79 static const WCHAR szInstaller_Components_fmt
[] = {
80 'S','o','f','t','w','a','r','e','\\',
81 'M','i','c','r','o','s','o','f','t','\\',
82 'W','i','n','d','o','w','s','\\',
83 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
84 'I','n','s','t','a','l','l','e','r','\\',
85 'C','o','m','p','o','n','e','n','t','s','\\',
88 static const WCHAR szUser_Components_fmt
[] = {
89 'S','o','f','t','w','a','r','e','\\',
90 'M','i','c','r','o','s','o','f','t','\\',
91 'I','n','s','t','a','l','l','e','r','\\',
92 'C','o','m','p','o','n','e','n','t','s','\\',
95 static const WCHAR szUninstall_fmt
[] = {
96 'S','o','f','t','w','a','r','e','\\',
97 'M','i','c','r','o','s','o','f','t','\\',
98 'W','i','n','d','o','w','s','\\',
99 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
100 'U','n','i','n','s','t','a','l','l','\\',
103 static const WCHAR szUserProduct_fmt
[] = {
104 'S','o','f','t','w','a','r','e','\\',
105 'M','i','c','r','o','s','o','f','t','\\',
106 'I','n','s','t','a','l','l','e','r','\\',
107 'P','r','o','d','u','c','t','s','\\',
110 static const WCHAR szInstaller_Products
[] = {
111 'S','o','f','t','w','a','r','e','\\',
112 'M','i','c','r','o','s','o','f','t','\\',
113 'W','i','n','d','o','w','s','\\',
114 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
115 'I','n','s','t','a','l','l','e','r','\\',
116 'P','r','o','d','u','c','t','s',0};
118 static const WCHAR szInstaller_Products_fmt
[] = {
119 'S','o','f','t','w','a','r','e','\\',
120 'M','i','c','r','o','s','o','f','t','\\',
121 'W','i','n','d','o','w','s','\\',
122 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
123 'I','n','s','t','a','l','l','e','r','\\',
124 'P','r','o','d','u','c','t','s','\\',
127 static const WCHAR szInstaller_UpgradeCodes
[] = {
128 'S','o','f','t','w','a','r','e','\\',
129 'M','i','c','r','o','s','o','f','t','\\',
130 'W','i','n','d','o','w','s','\\',
131 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
132 'I','n','s','t','a','l','l','e','r','\\',
133 'U','p','g','r','a','d','e','C','o','d','e','s',0};
135 static const WCHAR szInstaller_UpgradeCodes_fmt
[] = {
136 'S','o','f','t','w','a','r','e','\\',
137 'M','i','c','r','o','s','o','f','t','\\',
138 'W','i','n','d','o','w','s','\\',
139 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
140 'I','n','s','t','a','l','l','e','r','\\',
141 'U','p','g','r','a','d','e','C','o','d','e','s','\\',
144 #define SQUISH_GUID_SIZE 33
146 BOOL
unsquash_guid(LPCWSTR in
, LPWSTR out
)
162 out
[n
++] = in
[17+i
*2];
163 out
[n
++] = in
[16+i
*2];
168 out
[n
++] = in
[17+i
*2];
169 out
[n
++] = in
[16+i
*2];
176 BOOL
squash_guid(LPCWSTR in
, LPWSTR out
)
196 out
[17+i
*2] = in
[n
++];
197 out
[16+i
*2] = in
[n
++];
203 out
[17+i
*2] = in
[n
++];
204 out
[16+i
*2] = in
[n
++];
215 /* tables for encoding and decoding base85 */
216 static const unsigned char table_dec85
[0x80] = {
217 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
218 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
219 0xff,0x00,0xff,0xff,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0xff,
220 0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0xff,0xff,0xff,0x16,0xff,0x17,
221 0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
222 0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,0x30,0x31,0x32,0x33,0xff,0x34,0x35,0x36,
223 0x37,0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42,0x43,0x44,0x45,0x46,
224 0x47,0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,0x50,0x51,0x52,0xff,0x53,0x54,0xff,
227 static const char table_enc85
[] =
228 "!$%&'()*+,-.0123456789=?@ABCDEFGHIJKLMNO"
229 "PQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwx"
233 * Converts a base85 encoded guid into a GUID pointer
234 * Base85 encoded GUIDs should be 20 characters long.
236 * returns TRUE if successful, FALSE if not
238 BOOL
decode_base85_guid( LPCWSTR str
, GUID
*guid
)
240 DWORD i
, val
= 0, base
= 1, *p
;
243 for( i
=0; i
<20; i
++ )
250 val
+= table_dec85
[str
[i
]] * base
;
253 if( table_dec85
[str
[i
]] == 0xff )
263 * Encodes a base85 guid given a GUID pointer
264 * Caller should provide a 21 character buffer for the encoded string.
266 * returns TRUE if successful, FALSE if not
268 BOOL
encode_base85_guid( GUID
*guid
, LPWSTR str
)
270 unsigned int x
, *p
, i
;
272 p
= (unsigned int*) guid
;
276 *str
++ = table_enc85
[x
%85];
278 *str
++ = table_enc85
[x
%85];
280 *str
++ = table_enc85
[x
%85];
282 *str
++ = table_enc85
[x
%85];
284 *str
++ = table_enc85
[x
%85];
292 UINT
MSIREG_OpenUninstallKey(LPCWSTR szProduct
, HKEY
* key
, BOOL create
)
295 WCHAR keypath
[0x200];
296 TRACE("%s\n",debugstr_w(szProduct
));
298 sprintfW(keypath
,szUninstall_fmt
,szProduct
);
301 rc
= RegCreateKeyW(HKEY_LOCAL_MACHINE
, keypath
, key
);
303 rc
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, keypath
, key
);
308 UINT
MSIREG_OpenUserProductsKey(LPCWSTR szProduct
, HKEY
* key
, BOOL create
)
311 WCHAR squished_pc
[GUID_SIZE
];
312 WCHAR keypath
[0x200];
314 TRACE("%s\n",debugstr_w(szProduct
));
315 squash_guid(szProduct
,squished_pc
);
316 TRACE("squished (%s)\n", debugstr_w(squished_pc
));
318 sprintfW(keypath
,szUserProduct_fmt
,squished_pc
);
321 rc
= RegCreateKeyW(HKEY_CURRENT_USER
,keypath
,key
);
323 rc
= RegOpenKeyW(HKEY_CURRENT_USER
,keypath
,key
);
328 UINT
MSIREG_OpenUserFeaturesKey(LPCWSTR szProduct
, HKEY
* key
, BOOL create
)
331 WCHAR squished_pc
[GUID_SIZE
];
332 WCHAR keypath
[0x200];
334 TRACE("%s\n",debugstr_w(szProduct
));
335 squash_guid(szProduct
,squished_pc
);
336 TRACE("squished (%s)\n", debugstr_w(squished_pc
));
338 sprintfW(keypath
,szUserFeatures_fmt
,squished_pc
);
341 rc
= RegCreateKeyW(HKEY_CURRENT_USER
,keypath
,key
);
343 rc
= RegOpenKeyW(HKEY_CURRENT_USER
,keypath
,key
);
348 UINT
MSIREG_OpenFeatures(HKEY
* key
)
350 return RegCreateKeyW(HKEY_LOCAL_MACHINE
,szInstaller_Features
,key
);
353 UINT
MSIREG_OpenFeaturesKey(LPCWSTR szProduct
, HKEY
* key
, BOOL create
)
356 WCHAR squished_pc
[GUID_SIZE
];
357 WCHAR keypath
[0x200];
359 TRACE("%s\n",debugstr_w(szProduct
));
360 squash_guid(szProduct
,squished_pc
);
361 TRACE("squished (%s)\n", debugstr_w(squished_pc
));
363 sprintfW(keypath
,szInstaller_Features_fmt
,squished_pc
);
366 rc
= RegCreateKeyW(HKEY_LOCAL_MACHINE
,keypath
,key
);
368 rc
= RegOpenKeyW(HKEY_LOCAL_MACHINE
,keypath
,key
);
373 UINT
MSIREG_OpenComponents(HKEY
* key
)
375 return RegCreateKeyW(HKEY_LOCAL_MACHINE
,szInstaller_Components
,key
);
378 UINT
MSIREG_OpenComponentsKey(LPCWSTR szComponent
, HKEY
* key
, BOOL create
)
381 WCHAR squished_cc
[GUID_SIZE
];
382 WCHAR keypath
[0x200];
384 TRACE("%s\n",debugstr_w(szComponent
));
385 squash_guid(szComponent
,squished_cc
);
386 TRACE("squished (%s)\n", debugstr_w(squished_cc
));
388 sprintfW(keypath
,szInstaller_Components_fmt
,squished_cc
);
391 rc
= RegCreateKeyW(HKEY_LOCAL_MACHINE
,keypath
,key
);
393 rc
= RegOpenKeyW(HKEY_LOCAL_MACHINE
,keypath
,key
);
398 UINT
MSIREG_OpenUserComponentsKey(LPCWSTR szComponent
, HKEY
* key
, BOOL create
)
401 WCHAR squished_cc
[GUID_SIZE
];
402 WCHAR keypath
[0x200];
404 TRACE("%s\n",debugstr_w(szComponent
));
405 squash_guid(szComponent
,squished_cc
);
406 TRACE("squished (%s)\n", debugstr_w(squished_cc
));
408 sprintfW(keypath
,szUser_Components_fmt
,squished_cc
);
411 rc
= RegCreateKeyW(HKEY_CURRENT_USER
,keypath
,key
);
413 rc
= RegOpenKeyW(HKEY_CURRENT_USER
,keypath
,key
);
418 UINT
MSIREG_OpenProductsKey(LPCWSTR szProduct
, HKEY
* key
, BOOL create
)
421 WCHAR squished_pc
[GUID_SIZE
];
422 WCHAR keypath
[0x200];
424 TRACE("%s\n",debugstr_w(szProduct
));
425 squash_guid(szProduct
,squished_pc
);
426 TRACE("squished (%s)\n", debugstr_w(squished_pc
));
428 sprintfW(keypath
,szInstaller_Products_fmt
,squished_pc
);
431 rc
= RegCreateKeyW(HKEY_LOCAL_MACHINE
,keypath
,key
);
433 rc
= RegOpenKeyW(HKEY_LOCAL_MACHINE
,keypath
,key
);
438 UINT
MSIREG_OpenUpgradeCodesKey(LPCWSTR szUpgradeCode
, HKEY
* key
, BOOL create
)
441 WCHAR squished_pc
[GUID_SIZE
];
442 WCHAR keypath
[0x200];
444 TRACE("%s\n",debugstr_w(szUpgradeCode
));
445 squash_guid(szUpgradeCode
,squished_pc
);
446 TRACE("squished (%s)\n", debugstr_w(squished_pc
));
448 sprintfW(keypath
,szInstaller_UpgradeCodes_fmt
,squished_pc
);
451 rc
= RegCreateKeyW(HKEY_LOCAL_MACHINE
,keypath
,key
);
453 rc
= RegOpenKeyW(HKEY_LOCAL_MACHINE
,keypath
,key
);
458 /*************************************************************************
459 * MsiDecomposeDescriptorW [MSI.@]
461 * Decomposes an MSI descriptor into product, feature and component parts.
462 * An MSI descriptor is a string of the form:
463 * [base 85 guid] [feature code] '>' [base 85 guid]
466 * szDescriptor [I] the descriptor to decompose
467 * szProduct [O] buffer of MAX_FEATURE_CHARS for the product guid
468 * szFeature [O] buffer of MAX_FEATURE_CHARS for the feature code
469 * szComponent [O] buffer of MAX_FEATURE_CHARS for the component guid
470 * pUsed [O] the length of the descriptor
473 * ERROR_SUCCESS if everything worked correctly
474 * ERROR_INVALID_PARAMETER if the descriptor was invalid
477 UINT WINAPI
MsiDecomposeDescriptorW( LPCWSTR szDescriptor
, LPWSTR szProduct
,
478 LPWSTR szFeature
, LPWSTR szComponent
, DWORD
*pUsed
)
482 GUID product
, component
;
484 TRACE("%s %p %p %p %p\n", debugstr_w(szDescriptor
), szProduct
,
485 szFeature
, szComponent
, pUsed
);
487 r
= decode_base85_guid( szDescriptor
, &product
);
489 return ERROR_INVALID_PARAMETER
;
491 TRACE("product %s\n", debugstr_guid( &product
));
493 p
= strchrW(&szDescriptor
[20],'>');
495 return ERROR_INVALID_PARAMETER
;
497 len
= (p
- &szDescriptor
[20]);
498 if( len
> MAX_FEATURE_CHARS
)
499 return ERROR_INVALID_PARAMETER
;
500 memcpy( szFeature
, &szDescriptor
[20], len
*sizeof(WCHAR
) );
503 TRACE("feature %s\n", debugstr_w( szFeature
));
505 r
= decode_base85_guid( p
+1, &component
);
507 return ERROR_INVALID_PARAMETER
;
509 TRACE("component %s\n", debugstr_guid( &component
));
511 StringFromGUID2( &product
, szProduct
, MAX_FEATURE_CHARS
+1 );
512 StringFromGUID2( &component
, szComponent
, MAX_FEATURE_CHARS
+1 );
513 len
= ( &p
[21] - szDescriptor
);
515 TRACE("length = %d\n", len
);
518 return ERROR_SUCCESS
;
521 UINT WINAPI
MsiDecomposeDescriptorA( LPCSTR szDescriptor
, LPSTR szProduct
,
522 LPSTR szFeature
, LPSTR szComponent
, DWORD
*pUsed
)
524 WCHAR product
[MAX_FEATURE_CHARS
+1];
525 WCHAR feature
[MAX_FEATURE_CHARS
+1];
526 WCHAR component
[MAX_FEATURE_CHARS
+1];
530 TRACE("%s %p %p %p %p\n", debugstr_a(szDescriptor
), szProduct
,
531 szFeature
, szComponent
, pUsed
);
535 str
= strdupAtoW( szDescriptor
);
537 return ERROR_OUTOFMEMORY
;
540 r
= MsiDecomposeDescriptorW( str
, product
, feature
, component
, pUsed
);
542 WideCharToMultiByte( CP_ACP
, 0, product
, MAX_FEATURE_CHARS
+1,
543 szProduct
, MAX_FEATURE_CHARS
+1, NULL
, NULL
);
544 WideCharToMultiByte( CP_ACP
, 0, feature
, MAX_FEATURE_CHARS
+1,
545 szFeature
, MAX_FEATURE_CHARS
+1, NULL
, NULL
);
546 WideCharToMultiByte( CP_ACP
, 0, component
, MAX_FEATURE_CHARS
+1,
547 szComponent
, MAX_FEATURE_CHARS
+1, NULL
, NULL
);
549 HeapFree( GetProcessHeap(), 0, str
);
554 UINT WINAPI
MsiEnumProductsA(DWORD index
, LPSTR lpguid
)
557 WCHAR szwGuid
[GUID_SIZE
];
559 TRACE("%ld %p\n",index
,lpguid
);
562 return ERROR_INVALID_PARAMETER
;
563 r
= MsiEnumProductsW(index
, szwGuid
);
564 if( r
== ERROR_SUCCESS
)
565 WideCharToMultiByte(CP_ACP
, 0, szwGuid
, -1, lpguid
, GUID_SIZE
, NULL
, NULL
);
570 UINT WINAPI
MsiEnumProductsW(DWORD index
, LPWSTR lpguid
)
572 HKEY hkeyFeatures
= 0;
574 WCHAR szKeyName
[SQUISH_GUID_SIZE
];
576 TRACE("%ld %p\n",index
,lpguid
);
579 return ERROR_INVALID_PARAMETER
;
581 r
= MSIREG_OpenFeatures(&hkeyFeatures
);
582 if( r
!= ERROR_SUCCESS
)
583 return ERROR_NO_MORE_ITEMS
;
585 r
= RegEnumKeyW(hkeyFeatures
, index
, szKeyName
, SQUISH_GUID_SIZE
);
586 if( r
== ERROR_SUCCESS
)
587 unsquash_guid(szKeyName
, lpguid
);
588 RegCloseKey(hkeyFeatures
);
593 UINT WINAPI
MsiEnumFeaturesA(LPCSTR szProduct
, DWORD index
,
594 LPSTR szFeature
, LPSTR szParent
)
597 WCHAR szwFeature
[GUID_SIZE
], szwParent
[GUID_SIZE
];
598 LPWSTR szwProduct
= NULL
;
600 TRACE("%s %ld %p %p\n",debugstr_a(szProduct
),index
,szFeature
,szParent
);
604 szwProduct
= strdupAtoW( szProduct
);
606 return ERROR_OUTOFMEMORY
;
609 r
= MsiEnumFeaturesW(szwProduct
, index
, szwFeature
, szwParent
);
610 if( r
== ERROR_SUCCESS
)
612 WideCharToMultiByte(CP_ACP
, 0, szwFeature
, -1,
613 szFeature
, GUID_SIZE
, NULL
, NULL
);
614 WideCharToMultiByte(CP_ACP
, 0, szwParent
, -1,
615 szParent
, GUID_SIZE
, NULL
, NULL
);
618 HeapFree( GetProcessHeap(), 0, szwProduct
);
623 UINT WINAPI
MsiEnumFeaturesW(LPCWSTR szProduct
, DWORD index
,
624 LPWSTR szFeature
, LPWSTR szParent
)
626 HKEY hkeyProduct
= 0;
629 TRACE("%s %ld %p %p\n",debugstr_w(szProduct
),index
,szFeature
,szParent
);
631 r
= MSIREG_OpenFeaturesKey(szProduct
,&hkeyProduct
,FALSE
);
632 if( r
!= ERROR_SUCCESS
)
633 return ERROR_NO_MORE_ITEMS
;
636 r
= RegEnumValueW(hkeyProduct
, index
, szFeature
, &sz
, NULL
, NULL
, NULL
, NULL
);
637 RegCloseKey(hkeyProduct
);
642 UINT WINAPI
MsiEnumComponentsA(DWORD index
, LPSTR lpguid
)
645 WCHAR szwGuid
[GUID_SIZE
];
647 TRACE("%ld %p\n",index
,lpguid
);
649 r
= MsiEnumComponentsW(index
, szwGuid
);
650 if( r
== ERROR_SUCCESS
)
651 WideCharToMultiByte(CP_ACP
, 0, szwGuid
, -1, lpguid
, GUID_SIZE
, NULL
, NULL
);
656 UINT WINAPI
MsiEnumComponentsW(DWORD index
, LPWSTR lpguid
)
658 HKEY hkeyComponents
= 0;
660 WCHAR szKeyName
[SQUISH_GUID_SIZE
];
662 TRACE("%ld %p\n",index
,lpguid
);
664 r
= MSIREG_OpenComponents(&hkeyComponents
);
665 if( r
!= ERROR_SUCCESS
)
666 return ERROR_NO_MORE_ITEMS
;
668 r
= RegEnumKeyW(hkeyComponents
, index
, szKeyName
, SQUISH_GUID_SIZE
);
669 if( r
== ERROR_SUCCESS
)
670 unsquash_guid(szKeyName
, lpguid
);
671 RegCloseKey(hkeyComponents
);
676 UINT WINAPI
MsiEnumClientsA(LPCSTR szComponent
, DWORD index
, LPSTR szProduct
)
679 WCHAR szwProduct
[GUID_SIZE
];
680 LPWSTR szwComponent
= NULL
;
682 TRACE("%s %ld %p\n",debugstr_a(szComponent
),index
,szProduct
);
686 szwComponent
= strdupAtoW( szComponent
);
688 return ERROR_OUTOFMEMORY
;
691 r
= MsiEnumClientsW(szComponent
?szwComponent
:NULL
, index
, szwProduct
);
692 if( r
== ERROR_SUCCESS
)
694 WideCharToMultiByte(CP_ACP
, 0, szwProduct
, -1,
695 szProduct
, GUID_SIZE
, NULL
, NULL
);
698 HeapFree( GetProcessHeap(), 0, szwComponent
);
703 UINT WINAPI
MsiEnumClientsW(LPCWSTR szComponent
, DWORD index
, LPWSTR szProduct
)
707 WCHAR szValName
[SQUISH_GUID_SIZE
];
709 TRACE("%s %ld %p\n",debugstr_w(szComponent
),index
,szProduct
);
711 r
= MSIREG_OpenComponentsKey(szComponent
,&hkeyComp
,FALSE
);
712 if( r
!= ERROR_SUCCESS
)
713 return ERROR_NO_MORE_ITEMS
;
715 sz
= SQUISH_GUID_SIZE
;
716 r
= RegEnumValueW(hkeyComp
, index
, szValName
, &sz
, NULL
, NULL
, NULL
, NULL
);
717 if( r
== ERROR_SUCCESS
)
718 unsquash_guid(szValName
, szProduct
);
720 RegCloseKey(hkeyComp
);
725 /*************************************************************************
726 * MsiEnumComponentQualifiersA [MSI.@]
729 UINT WINAPI
MsiEnumComponentQualifiersA( LPSTR szComponent
, DWORD iIndex
,
730 LPSTR lpQualifierBuf
, DWORD
* pcchQualifierBuf
,
731 LPSTR lpApplicationDataBuf
, DWORD
* pcchApplicationDataBuf
)
734 LPWSTR lpwQualifierBuf
;
735 DWORD pcchwQualifierBuf
;
736 LPWSTR lpwApplicationDataBuf
;
737 DWORD pcchwApplicationDataBuf
;
741 TRACE("%s %08lx %p %p %p %p\n", debugstr_a(szComponent
), iIndex
,
742 lpQualifierBuf
, pcchQualifierBuf
, lpApplicationDataBuf
,
743 pcchApplicationDataBuf
);
745 szwComponent
= strdupAtoW(szComponent
);
748 lpwQualifierBuf
= HeapAlloc(GetProcessHeap(),0, (*pcchQualifierBuf
) *
751 lpwQualifierBuf
= NULL
;
753 if (pcchQualifierBuf
)
754 pcchwQualifierBuf
= *pcchQualifierBuf
;
756 pcchwQualifierBuf
= 0;
758 if (lpApplicationDataBuf
)
759 lpwApplicationDataBuf
= HeapAlloc(GetProcessHeap(),0 ,
760 (*pcchApplicationDataBuf
) * sizeof(WCHAR
));
762 lpwApplicationDataBuf
= NULL
;
764 if (pcchApplicationDataBuf
)
765 pcchwApplicationDataBuf
= *pcchApplicationDataBuf
;
767 pcchwApplicationDataBuf
= 0;
769 rc
= MsiEnumComponentQualifiersW( szwComponent
, iIndex
, lpwQualifierBuf
,
770 &pcchwQualifierBuf
, lpwApplicationDataBuf
,
771 &pcchwApplicationDataBuf
);
774 * A bit of wizardry to report back the length without the null.
775 * just in case the buffer is too small and is filled.
779 length
= WideCharToMultiByte(CP_ACP
, 0, lpwQualifierBuf
, -1,
780 lpQualifierBuf
, *pcchQualifierBuf
, NULL
, NULL
);
782 if (*pcchQualifierBuf
== length
&& lpQualifierBuf
[length
-1])
783 *pcchQualifierBuf
= length
;
785 *pcchQualifierBuf
= length
- 1;
787 if (lpApplicationDataBuf
)
789 length
= WideCharToMultiByte(CP_ACP
, 0,
790 lpwApplicationDataBuf
, -1, lpApplicationDataBuf
,
791 *pcchApplicationDataBuf
, NULL
, NULL
);
793 if (*pcchApplicationDataBuf
== length
&& lpApplicationDataBuf
[length
-1])
794 *pcchApplicationDataBuf
= length
;
796 *pcchApplicationDataBuf
= length
- 1;
799 HeapFree(GetProcessHeap(),0,lpwApplicationDataBuf
);
800 HeapFree(GetProcessHeap(),0,lpwQualifierBuf
);
801 HeapFree(GetProcessHeap(),0,szwComponent
);
806 /*************************************************************************
807 * MsiEnumComponentQualifiersW [MSI.@]
810 UINT WINAPI
MsiEnumComponentQualifiersW( LPWSTR szComponent
, DWORD iIndex
,
811 LPWSTR lpQualifierBuf
, DWORD
* pcchQualifierBuf
,
812 LPWSTR lpApplicationDataBuf
, DWORD
* pcchApplicationDataBuf
)
816 DWORD actual_pcchQualifierBuf
= 0;
817 DWORD actual_pcchApplicationDataBuf
= 0;
818 LPWSTR full_buffer
= NULL
;
819 DWORD full_buffer_size
= 0;
822 TRACE("%s %08lx %p %p %p %p\n", debugstr_w(szComponent
), iIndex
,
823 lpQualifierBuf
, pcchQualifierBuf
, lpApplicationDataBuf
,
824 pcchApplicationDataBuf
);
826 if (pcchQualifierBuf
)
827 actual_pcchQualifierBuf
= *pcchQualifierBuf
* sizeof(WCHAR
);
828 if (pcchApplicationDataBuf
)
829 actual_pcchApplicationDataBuf
= *pcchApplicationDataBuf
* sizeof(WCHAR
);
831 rc
= MSIREG_OpenUserComponentsKey(szComponent
, &key
, FALSE
);
832 if (rc
!= ERROR_SUCCESS
)
833 return ERROR_UNKNOWN_COMPONENT
;
835 full_buffer_size
= (52 * sizeof(WCHAR
)) + actual_pcchApplicationDataBuf
;
836 full_buffer
= HeapAlloc(GetProcessHeap(),0,full_buffer_size
);
838 rc
= RegEnumValueW(key
, iIndex
, lpQualifierBuf
, pcchQualifierBuf
, NULL
,
839 NULL
, (LPBYTE
)full_buffer
, &full_buffer_size
);
843 if (rc
== ERROR_SUCCESS
|| rc
== ERROR_MORE_DATA
)
845 if (lpApplicationDataBuf
&& pcchApplicationDataBuf
)
848 /* Skip the first guid */
851 /* Skip the name and the component guid if it exists */
852 if (strchrW(ptr
,'<'))
853 ptr
= strchrW(ptr
,'<');
855 ptr
= strchrW(ptr
,'>') + 21;
857 lstrcpynW(lpApplicationDataBuf
,ptr
,*pcchApplicationDataBuf
);
858 *pcchApplicationDataBuf
= strlenW(ptr
);
860 if (lpQualifierBuf
&& pcchQualifierBuf
)
861 *pcchQualifierBuf
/= sizeof(WCHAR
);
862 TRACE("Providing %s and %s\n", debugstr_w(lpQualifierBuf
),
863 debugstr_w(lpApplicationDataBuf
));
869 /*************************************************************************
870 * MsiEnumRelatedProductsW [MSI.@]
873 UINT WINAPI
MsiEnumRelatedProductsW(LPCWSTR szUpgradeCode
, DWORD dwReserved
,
874 DWORD iProductIndex
, LPWSTR lpProductBuf
)
878 WCHAR szKeyName
[SQUISH_GUID_SIZE
];
880 TRACE("%s %lu %lu %p\n", debugstr_w(szUpgradeCode
), dwReserved
,
881 iProductIndex
, lpProductBuf
);
883 if (NULL
== szUpgradeCode
)
884 return ERROR_INVALID_PARAMETER
;
885 if (NULL
== lpProductBuf
)
886 return ERROR_INVALID_PARAMETER
;
888 r
= MSIREG_OpenUpgradeCodesKey(szUpgradeCode
, &hkey
, FALSE
);
889 if (r
!= ERROR_SUCCESS
)
890 return ERROR_NO_MORE_ITEMS
;
892 r
= RegEnumKeyW(hkey
, iProductIndex
, szKeyName
, SQUISH_GUID_SIZE
);
893 if( r
== ERROR_SUCCESS
)
894 unsquash_guid(szKeyName
, lpProductBuf
);
900 /*************************************************************************
901 * MsiEnumRelatedProductsA [MSI.@]
904 UINT WINAPI
MsiEnumRelatedProductsA(LPCSTR szUpgradeCode
, DWORD dwReserved
,
905 DWORD iProductIndex
, LPSTR lpProductBuf
)
907 LPWSTR szwUpgradeCode
= NULL
;
908 WCHAR productW
[GUID_SIZE
];
911 TRACE("%s %lu %lu %p\n", debugstr_a(szUpgradeCode
), dwReserved
,
912 iProductIndex
, lpProductBuf
);
916 szwUpgradeCode
= strdupAtoW( szUpgradeCode
);
917 if( !szwUpgradeCode
)
918 return ERROR_OUTOFMEMORY
;
921 r
= MsiEnumRelatedProductsW( szwUpgradeCode
, dwReserved
,
922 iProductIndex
, productW
);
923 if (r
== ERROR_SUCCESS
)
925 WideCharToMultiByte( CP_ACP
, 0, productW
, GUID_SIZE
,
926 lpProductBuf
, GUID_SIZE
, NULL
, NULL
);
928 HeapFree(GetProcessHeap(), 0, szwUpgradeCode
);