msi: Don't publish the upgrade key to an invalid location.
[wine] / dlls / msi / handle.c
1 /*
2  * Implementation of the Microsoft Installer (msi.dll)
3  *
4  * Copyright 2002-2004 Mike McCormack 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 #define COBJMACROS
22
23 #include <stdarg.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winreg.h"
28 #include "shlwapi.h"
29 #include "wine/debug.h"
30 #include "msi.h"
31 #include "msiquery.h"
32 #include "msipriv.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(msi);
35
36 static CRITICAL_SECTION MSI_handle_cs;
37 static CRITICAL_SECTION_DEBUG MSI_handle_cs_debug =
38 {
39     0, 0, &MSI_handle_cs,
40     { &MSI_handle_cs_debug.ProcessLocksList, 
41       &MSI_handle_cs_debug.ProcessLocksList },
42       0, 0, { (DWORD_PTR)(__FILE__ ": MSI_handle_cs") }
43 };
44 static CRITICAL_SECTION MSI_handle_cs = { &MSI_handle_cs_debug, -1, 0, 0, 0, 0 };
45
46 static CRITICAL_SECTION MSI_object_cs;
47 static CRITICAL_SECTION_DEBUG MSI_object_cs_debug =
48 {
49     0, 0, &MSI_object_cs,
50     { &MSI_object_cs_debug.ProcessLocksList, 
51       &MSI_object_cs_debug.ProcessLocksList },
52       0, 0, { (DWORD_PTR)(__FILE__ ": MSI_object_cs") }
53 };
54 static CRITICAL_SECTION MSI_object_cs = { &MSI_object_cs_debug, -1, 0, 0, 0, 0 };
55
56 typedef struct msi_handle_info_t
57 {
58     BOOL remote;
59     union {
60         MSIOBJECTHDR *obj;
61         IUnknown *unk;
62     } u;
63     DWORD dwThreadId;
64 } msi_handle_info;
65
66 static msi_handle_info *msihandletable = NULL;
67 static unsigned int msihandletable_size = 0;
68
69 void msi_free_handle_table(void)
70 {
71     msi_free( msihandletable );
72     msihandletable = NULL;
73     msihandletable_size = 0;
74 }
75
76 static MSIHANDLE alloc_handle_table_entry(void)
77 {
78     UINT i;
79
80     /* find a slot */
81     for(i=0; i<msihandletable_size; i++)
82         if( !msihandletable[i].u.obj && !msihandletable[i].u.unk )
83             break;
84     if( i==msihandletable_size )
85     {
86         msi_handle_info *p;
87         int newsize;
88         if (msihandletable_size == 0)
89         {
90             newsize = 256;
91             p = msi_alloc_zero(newsize*sizeof(msi_handle_info));
92         }
93         else
94         {
95             newsize = msihandletable_size * 2;
96             p = msi_realloc_zero(msihandletable,
97                             newsize*sizeof(msi_handle_info));
98         }
99         if (!p)
100             return 0;
101         msihandletable = p;
102         msihandletable_size = newsize;
103     }
104     return i + 1;
105 }
106
107 MSIHANDLE alloc_msihandle( MSIOBJECTHDR *obj )
108 {
109     msi_handle_info *entry;
110     MSIHANDLE ret;
111
112     EnterCriticalSection( &MSI_handle_cs );
113
114     ret = alloc_handle_table_entry();
115     if (ret)
116     {
117         entry = &msihandletable[ ret - 1 ];
118         msiobj_addref( obj );
119         entry->u.obj = obj;
120         entry->dwThreadId = GetCurrentThreadId();
121         entry->remote = FALSE;
122     }
123
124     LeaveCriticalSection( &MSI_handle_cs );
125
126     TRACE("%p -> %ld\n", obj, ret );
127
128     return ret;
129 }
130
131 MSIHANDLE alloc_msi_remote_handle( IUnknown *unk )
132 {
133     msi_handle_info *entry;
134     MSIHANDLE ret;
135
136     EnterCriticalSection( &MSI_handle_cs );
137
138     ret = alloc_handle_table_entry();
139     if (ret)
140     {
141         entry = &msihandletable[ ret - 1 ];
142         IUnknown_AddRef( unk );
143         entry->u.unk = unk;
144         entry->dwThreadId = GetCurrentThreadId();
145         entry->remote = TRUE;
146     }
147
148     LeaveCriticalSection( &MSI_handle_cs );
149
150     TRACE("%p -> %ld\n", unk, ret);
151
152     return ret;
153 }
154
155 void *msihandle2msiinfo(MSIHANDLE handle, UINT type)
156 {
157     MSIOBJECTHDR *ret = NULL;
158
159     EnterCriticalSection( &MSI_handle_cs );
160     handle--;
161     if( handle >= msihandletable_size )
162         goto out;
163     if( msihandletable[handle].remote)
164         goto out;
165     if( !msihandletable[handle].u.obj )
166         goto out;
167     if( msihandletable[handle].u.obj->magic != MSIHANDLE_MAGIC )
168         goto out;
169     if( type && (msihandletable[handle].u.obj->type != type) )
170         goto out;
171     ret = msihandletable[handle].u.obj;
172     msiobj_addref( ret );
173
174 out:
175     LeaveCriticalSection( &MSI_handle_cs );
176
177     return (void*) ret;
178 }
179
180 IUnknown *msi_get_remote( MSIHANDLE handle )
181 {
182     IUnknown *unk = NULL;
183
184     EnterCriticalSection( &MSI_handle_cs );
185     handle--;
186     if( handle>=msihandletable_size )
187         goto out;
188     if( !msihandletable[handle].remote)
189         goto out;
190     unk = msihandletable[handle].u.unk;
191     if( unk )
192         IUnknown_AddRef( unk );
193
194 out:
195     LeaveCriticalSection( &MSI_handle_cs );
196
197     return unk;
198 }
199
200 void *alloc_msiobject(UINT type, UINT size, msihandledestructor destroy )
201 {
202     MSIOBJECTHDR *info;
203
204     info = msi_alloc_zero( size );
205     if( info )
206     {
207         info->magic = MSIHANDLE_MAGIC;
208         info->type = type;
209         info->refcount = 1;
210         info->destructor = destroy;
211     }
212
213     return info;
214 }
215
216 void msiobj_addref( MSIOBJECTHDR *info )
217 {
218     if( !info )
219         return;
220
221     if( info->magic != MSIHANDLE_MAGIC )
222     {
223         ERR("Invalid handle!\n");
224         return;
225     }
226
227     InterlockedIncrement(&info->refcount);
228 }
229
230 void msiobj_lock( MSIOBJECTHDR *info )
231 {
232     EnterCriticalSection( &MSI_object_cs );
233 }
234
235 void msiobj_unlock( MSIOBJECTHDR *info )
236 {
237     LeaveCriticalSection( &MSI_object_cs );
238 }
239
240 int msiobj_release( MSIOBJECTHDR *info )
241 {
242     int ret;
243
244     if( !info )
245         return -1;
246
247     if( info->magic != MSIHANDLE_MAGIC )
248     {
249         ERR("Invalid handle!\n");
250         return -1;
251     }
252
253     ret = InterlockedDecrement( &info->refcount );
254     if( ret==0 )
255     {
256         if( info->destructor )
257             info->destructor( info );
258         msi_free( info );
259         TRACE("object %p destroyed\n", info);
260     }
261
262     return ret;
263 }
264
265 /***********************************************************
266  *   MsiCloseHandle   [MSI.@]
267  */
268 UINT WINAPI MsiCloseHandle(MSIHANDLE handle)
269 {
270     MSIOBJECTHDR *info = NULL;
271     UINT ret = ERROR_INVALID_HANDLE;
272
273     TRACE("%lx\n",handle);
274
275     if (!handle)
276         return ERROR_SUCCESS;
277
278     EnterCriticalSection( &MSI_handle_cs );
279
280     handle--;
281     if (handle >= msihandletable_size)
282         goto out;
283
284     if (msihandletable[handle].remote)
285     {
286         IUnknown_Release( msihandletable[handle].u.unk );
287     }
288     else
289     {
290         info = msihandletable[handle].u.obj;
291         if( !info )
292             goto out;
293
294         if( info->magic != MSIHANDLE_MAGIC )
295         {
296             ERR("Invalid handle!\n");
297             goto out;
298         }
299     }
300
301     msihandletable[handle].u.obj = NULL;
302     msihandletable[handle].remote = 0;
303     msihandletable[handle].dwThreadId = 0;
304
305     ret = ERROR_SUCCESS;
306
307     TRACE("handle %lx destroyed\n", handle+1);
308 out:
309     LeaveCriticalSection( &MSI_handle_cs );
310     if( info )
311         msiobj_release( info );
312
313     return ret;
314 }
315
316 /***********************************************************
317  *   MsiCloseAllHandles   [MSI.@]
318  *
319  *  Closes all handles owned by the current thread
320  *
321  *  RETURNS:
322  *   The number of handles closed
323  */
324 UINT WINAPI MsiCloseAllHandles(void)
325 {
326     UINT i, n=0;
327
328     TRACE("\n");
329
330     EnterCriticalSection( &MSI_handle_cs );
331     for(i=0; i<msihandletable_size; i++)
332     {
333         if(msihandletable[i].dwThreadId == GetCurrentThreadId())
334         {
335             LeaveCriticalSection( &MSI_handle_cs );
336             MsiCloseHandle( i+1 );
337             EnterCriticalSection( &MSI_handle_cs );
338             n++;
339         }
340     }
341     LeaveCriticalSection( &MSI_handle_cs );
342
343     return n;
344 }