sync msi to wine 1.1.33
[reactos.git] / reactos / dll / win32 / msi / storages.c
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 2008 James Hawkins
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 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "winerror.h"
29 #include "ole2.h"
30 #include "msi.h"
31 #include "msiquery.h"
32 #include "objbase.h"
33 #include "msipriv.h"
34 #include "query.h"
35
36 #include "wine/debug.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
39
40 #define NUM_STORAGES_COLS 2
41 #define MAX_STORAGES_NAME_LEN 62
42
43 typedef struct tabSTORAGE
44 {
45 UINT str_index;
46 LPWSTR name;
47 IStorage *storage;
48 } STORAGE;
49
50 typedef struct tagMSISTORAGESVIEW
51 {
52 MSIVIEW view;
53 MSIDATABASE *db;
54 STORAGE **storages;
55 UINT max_storages;
56 UINT num_rows;
57 UINT row_size;
58 } MSISTORAGESVIEW;
59
60 static BOOL storages_set_table_size(MSISTORAGESVIEW *sv, UINT size)
61 {
62 if (size >= sv->max_storages)
63 {
64 sv->max_storages *= 2;
65 sv->storages = msi_realloc(sv->storages, sv->max_storages * sizeof(STORAGE *));
66 if (!sv->storages)
67 return FALSE;
68 }
69
70 return TRUE;
71 }
72
73 static STORAGE *create_storage(MSISTORAGESVIEW *sv, LPWSTR name, IStorage *stg)
74 {
75 STORAGE *storage;
76
77 storage = msi_alloc(sizeof(STORAGE));
78 if (!storage)
79 return NULL;
80
81 storage->name = strdupW(name);
82 if (!storage->name)
83 {
84 msi_free(storage);
85 return NULL;
86 }
87
88 storage->str_index = msi_addstringW(sv->db->strings, 0, storage->name, -1, 1, StringNonPersistent);
89 storage->storage = stg;
90
91 if (storage->storage)
92 IStorage_AddRef(storage->storage);
93
94 return storage;
95 }
96
97 static UINT STORAGES_fetch_int(struct tagMSIVIEW *view, UINT row, UINT col, UINT *val)
98 {
99 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
100
101 TRACE("(%p, %d, %d, %p)\n", view, row, col, val);
102
103 if (col != 1)
104 return ERROR_INVALID_PARAMETER;
105
106 if (row >= sv->num_rows)
107 return ERROR_NO_MORE_ITEMS;
108
109 *val = sv->storages[row]->str_index;
110
111 return ERROR_SUCCESS;
112 }
113
114 static UINT STORAGES_fetch_stream(struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm)
115 {
116 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
117
118 TRACE("(%p, %d, %d, %p)\n", view, row, col, stm);
119
120 if (row >= sv->num_rows)
121 return ERROR_FUNCTION_FAILED;
122
123 return ERROR_INVALID_DATA;
124 }
125
126 static UINT STORAGES_get_row( struct tagMSIVIEW *view, UINT row, MSIRECORD **rec )
127 {
128 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
129
130 FIXME("%p %d %p\n", sv, row, rec);
131
132 return ERROR_CALL_NOT_IMPLEMENTED;
133 }
134
135 static HRESULT stream_to_storage(IStream *stm, IStorage **stg)
136 {
137 ILockBytes *lockbytes = NULL;
138 STATSTG stat;
139 LPVOID data;
140 HRESULT hr;
141 DWORD size, read;
142 ULARGE_INTEGER offset;
143
144 hr = IStream_Stat(stm, &stat, STATFLAG_NONAME);
145 if (FAILED(hr))
146 return hr;
147
148 if (stat.cbSize.QuadPart >> 32)
149 {
150 ERR("Storage is too large\n");
151 return E_FAIL;
152 }
153
154 size = stat.cbSize.QuadPart;
155 data = msi_alloc(size);
156 if (!data)
157 return E_OUTOFMEMORY;
158
159 hr = IStream_Read(stm, data, size, &read);
160 if (FAILED(hr) || read != size)
161 goto done;
162
163 hr = CreateILockBytesOnHGlobal(NULL, TRUE, &lockbytes);
164 if (FAILED(hr))
165 goto done;
166
167 ZeroMemory(&offset, sizeof(ULARGE_INTEGER));
168 hr = ILockBytes_WriteAt(lockbytes, offset, data, size, &read);
169 if (FAILED(hr) || read != size)
170 goto done;
171
172 hr = StgOpenStorageOnILockBytes(lockbytes, NULL,
173 STGM_READWRITE | STGM_SHARE_DENY_NONE,
174 NULL, 0, stg);
175 if (FAILED(hr))
176 goto done;
177
178 done:
179 msi_free(data);
180 if (lockbytes) ILockBytes_Release(lockbytes);
181 return hr;
182 }
183
184 static UINT STORAGES_set_row(struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask)
185 {
186 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
187 IStorage *stg, *substg = NULL;
188 IStream *stm;
189 LPWSTR name = NULL;
190 HRESULT hr;
191 UINT r = ERROR_FUNCTION_FAILED;
192
193 TRACE("(%p, %p)\n", view, rec);
194
195 if (row > sv->num_rows)
196 return ERROR_FUNCTION_FAILED;
197
198 r = MSI_RecordGetIStream(rec, 2, &stm);
199 if (r != ERROR_SUCCESS)
200 return r;
201
202 r = stream_to_storage(stm, &stg);
203 if (r != ERROR_SUCCESS)
204 {
205 IStream_Release(stm);
206 return r;
207 }
208
209 name = strdupW(MSI_RecordGetString(rec, 1));
210 if (!name)
211 {
212 r = ERROR_OUTOFMEMORY;
213 goto done;
214 }
215
216 hr = IStorage_CreateStorage(sv->db->storage, name,
217 STGM_WRITE | STGM_SHARE_EXCLUSIVE,
218 0, 0, &substg);
219 if (FAILED(hr))
220 {
221 r = ERROR_FUNCTION_FAILED;
222 goto done;
223 }
224
225 hr = IStorage_CopyTo(stg, 0, NULL, NULL, substg);
226 if (FAILED(hr))
227 {
228 r = ERROR_FUNCTION_FAILED;
229 goto done;
230 }
231
232 sv->storages[row] = create_storage(sv, name, stg);
233 if (!sv->storages[row])
234 r = ERROR_FUNCTION_FAILED;
235
236 done:
237 msi_free(name);
238
239 if (substg) IStorage_Release(substg);
240 IStorage_Release(stg);
241 IStream_Release(stm);
242
243 return r;
244 }
245
246 static UINT STORAGES_insert_row(struct tagMSIVIEW *view, MSIRECORD *rec, UINT row, BOOL temporary)
247 {
248 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
249
250 if (!storages_set_table_size(sv, ++sv->num_rows))
251 return ERROR_FUNCTION_FAILED;
252
253 if (row == -1)
254 row = sv->num_rows - 1;
255
256 /* FIXME have to readjust rows */
257
258 return STORAGES_set_row(view, row, rec, 0);
259 }
260
261 static UINT STORAGES_delete_row(struct tagMSIVIEW *view, UINT row)
262 {
263 FIXME("(%p %d): stub!\n", view, row);
264 return ERROR_SUCCESS;
265 }
266
267 static UINT STORAGES_execute(struct tagMSIVIEW *view, MSIRECORD *record)
268 {
269 TRACE("(%p, %p)\n", view, record);
270 return ERROR_SUCCESS;
271 }
272
273 static UINT STORAGES_close(struct tagMSIVIEW *view)
274 {
275 TRACE("(%p)\n", view);
276 return ERROR_SUCCESS;
277 }
278
279 static UINT STORAGES_get_dimensions(struct tagMSIVIEW *view, UINT *rows, UINT *cols)
280 {
281 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
282
283 TRACE("(%p, %p, %p)\n", view, rows, cols);
284
285 if (cols) *cols = NUM_STORAGES_COLS;
286 if (rows) *rows = sv->num_rows;
287
288 return ERROR_SUCCESS;
289 }
290
291 static UINT STORAGES_get_column_info(struct tagMSIVIEW *view, UINT n,
292 LPWSTR *name, UINT *type, BOOL *temporary,
293 LPWSTR *table_name)
294 {
295 LPCWSTR name_ptr = NULL;
296
297 static const WCHAR Name[] = {'N','a','m','e',0};
298 static const WCHAR Data[] = {'D','a','t','a',0};
299
300 TRACE("(%p, %d, %p, %p, %p, %p)\n", view, n, name, type, temporary,
301 table_name);
302
303 if (n == 0 || n > NUM_STORAGES_COLS)
304 return ERROR_INVALID_PARAMETER;
305
306 switch (n)
307 {
308 case 1:
309 name_ptr = Name;
310 if (type) *type = MSITYPE_STRING | MAX_STORAGES_NAME_LEN;
311 break;
312
313 case 2:
314 name_ptr = Data;
315 if (type) *type = MSITYPE_STRING | MSITYPE_VALID | MSITYPE_NULLABLE;
316 break;
317 }
318
319 if (name)
320 {
321 *name = strdupW(name_ptr);
322 if (!*name) return ERROR_FUNCTION_FAILED;
323 }
324
325 if (temporary)
326 *temporary = FALSE;
327
328 return ERROR_SUCCESS;
329 }
330
331 static UINT storages_find_row(MSISTORAGESVIEW *sv, MSIRECORD *rec, UINT *row)
332 {
333 LPCWSTR str;
334 UINT i, id, data;
335
336 str = MSI_RecordGetString(rec, 1);
337 msi_string2idW(sv->db->strings, str, &id);
338
339 for (i = 0; i < sv->num_rows; i++)
340 {
341 STORAGES_fetch_int(&sv->view, i, 1, &data);
342
343 if (data == id)
344 {
345 *row = i;
346 return ERROR_SUCCESS;
347 }
348 }
349
350 return ERROR_FUNCTION_FAILED;
351 }
352
353 static UINT storages_modify_update(struct tagMSIVIEW *view, MSIRECORD *rec)
354 {
355 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
356 UINT r, row;
357
358 r = storages_find_row(sv, rec, &row);
359 if (r != ERROR_SUCCESS)
360 return ERROR_FUNCTION_FAILED;
361
362 return STORAGES_set_row(view, row, rec, 0);
363 }
364
365 static UINT storages_modify_assign(struct tagMSIVIEW *view, MSIRECORD *rec)
366 {
367 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
368 UINT r, row;
369
370 r = storages_find_row(sv, rec, &row);
371 if (r == ERROR_SUCCESS)
372 return storages_modify_update(view, rec);
373
374 return STORAGES_insert_row(view, rec, -1, FALSE);
375 }
376
377 static UINT STORAGES_modify(struct tagMSIVIEW *view, MSIMODIFY eModifyMode, MSIRECORD *rec, UINT row)
378 {
379 UINT r;
380
381 TRACE("%p %d %p\n", view, eModifyMode, rec);
382
383 switch (eModifyMode)
384 {
385 case MSIMODIFY_ASSIGN:
386 r = storages_modify_assign(view, rec);
387 break;
388
389 case MSIMODIFY_INSERT:
390 r = STORAGES_insert_row(view, rec, -1, FALSE);
391 break;
392
393 case MSIMODIFY_UPDATE:
394 r = storages_modify_update(view, rec);
395 break;
396
397 case MSIMODIFY_VALIDATE_NEW:
398 case MSIMODIFY_INSERT_TEMPORARY:
399 case MSIMODIFY_REFRESH:
400 case MSIMODIFY_REPLACE:
401 case MSIMODIFY_MERGE:
402 case MSIMODIFY_DELETE:
403 case MSIMODIFY_VALIDATE:
404 case MSIMODIFY_VALIDATE_FIELD:
405 case MSIMODIFY_VALIDATE_DELETE:
406 FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
407 r = ERROR_CALL_NOT_IMPLEMENTED;
408 break;
409
410 default:
411 r = ERROR_INVALID_DATA;
412 }
413
414 return r;
415 }
416
417 static UINT STORAGES_delete(struct tagMSIVIEW *view)
418 {
419 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
420 UINT i;
421
422 TRACE("(%p)\n", view);
423
424 for (i = 0; i < sv->num_rows; i++)
425 {
426 if (sv->storages[i]->storage)
427 IStorage_Release(sv->storages[i]->storage);
428
429 msi_free(sv->storages[i]);
430 }
431
432 msi_free(sv->storages);
433 sv->storages = NULL;
434
435 return ERROR_SUCCESS;
436 }
437
438 static UINT STORAGES_find_matching_rows(struct tagMSIVIEW *view, UINT col,
439 UINT val, UINT *row, MSIITERHANDLE *handle)
440 {
441 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
442 UINT index = (UINT)*handle;
443
444 TRACE("(%d, %d): %d\n", *row, col, val);
445
446 if (col == 0 || col > NUM_STORAGES_COLS)
447 return ERROR_INVALID_PARAMETER;
448
449 while (index < sv->num_rows)
450 {
451 if (sv->storages[index]->str_index == val)
452 {
453 *row = index;
454 break;
455 }
456
457 index++;
458 }
459
460 *handle = (MSIITERHANDLE)++index;
461 if (index >= sv->num_rows)
462 return ERROR_NO_MORE_ITEMS;
463
464 return ERROR_SUCCESS;
465 }
466
467 static const MSIVIEWOPS storages_ops =
468 {
469 STORAGES_fetch_int,
470 STORAGES_fetch_stream,
471 STORAGES_get_row,
472 STORAGES_set_row,
473 STORAGES_insert_row,
474 STORAGES_delete_row,
475 STORAGES_execute,
476 STORAGES_close,
477 STORAGES_get_dimensions,
478 STORAGES_get_column_info,
479 STORAGES_modify,
480 STORAGES_delete,
481 STORAGES_find_matching_rows,
482 NULL,
483 NULL,
484 NULL,
485 NULL,
486 NULL,
487 NULL,
488 };
489
490 static INT add_storages_to_table(MSISTORAGESVIEW *sv)
491 {
492 STORAGE *storage = NULL;
493 IEnumSTATSTG *stgenum = NULL;
494 STATSTG stat;
495 HRESULT hr;
496 UINT count = 0, size;
497
498 hr = IStorage_EnumElements(sv->db->storage, 0, NULL, 0, &stgenum);
499 if (FAILED(hr))
500 return -1;
501
502 sv->max_storages = 1;
503 sv->storages = msi_alloc(sizeof(STORAGE *));
504 if (!sv->storages)
505 return -1;
506
507 while (TRUE)
508 {
509 size = 0;
510 hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &size);
511 if (FAILED(hr) || !size)
512 break;
513
514 if (stat.type != STGTY_STORAGE)
515 {
516 CoTaskMemFree(stat.pwcsName);
517 continue;
518 }
519
520 TRACE("enumerated storage %s\n", debugstr_w(stat.pwcsName));
521
522 storage = create_storage(sv, stat.pwcsName, NULL);
523 if (!storage)
524 {
525 count = -1;
526 CoTaskMemFree(stat.pwcsName);
527 break;
528 }
529
530 IStorage_OpenStorage(sv->db->storage, stat.pwcsName, NULL,
531 STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0,
532 &storage->storage);
533 CoTaskMemFree(stat.pwcsName);
534
535 if (!storages_set_table_size(sv, ++count))
536 {
537 count = -1;
538 break;
539 }
540
541 sv->storages[count - 1] = storage;
542 }
543
544 IEnumSTATSTG_Release(stgenum);
545 return count;
546 }
547
548 UINT STORAGES_CreateView(MSIDATABASE *db, MSIVIEW **view)
549 {
550 MSISTORAGESVIEW *sv;
551 INT rows;
552
553 TRACE("(%p, %p)\n", db, view);
554
555 sv = msi_alloc(sizeof(MSISTORAGESVIEW));
556 if (!sv)
557 return ERROR_FUNCTION_FAILED;
558
559 sv->view.ops = &storages_ops;
560 sv->db = db;
561
562 rows = add_storages_to_table(sv);
563 if (rows < 0)
564 {
565 msi_free( sv );
566 return ERROR_FUNCTION_FAILED;
567 }
568 sv->num_rows = rows;
569
570 *view = (MSIVIEW *)sv;
571
572 return ERROR_SUCCESS;
573 }