6a8134b5627552c9e95af6b617858161ecd459a4
[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 static const WCHAR _Storages[] = {'_','S','t','o','r','a','g','e','s',0};
300
301 TRACE("(%p, %d, %p, %p, %p, %p)\n", view, n, name, type, temporary,
302 table_name);
303
304 if (n == 0 || n > NUM_STORAGES_COLS)
305 return ERROR_INVALID_PARAMETER;
306
307 switch (n)
308 {
309 case 1:
310 name_ptr = Name;
311 if (type) *type = MSITYPE_STRING | MAX_STORAGES_NAME_LEN;
312 break;
313
314 case 2:
315 name_ptr = Data;
316 if (type) *type = MSITYPE_STRING | MSITYPE_VALID | MSITYPE_NULLABLE;
317 break;
318 }
319
320 if (name)
321 {
322 *name = strdupW(name_ptr);
323 if (!*name) return ERROR_FUNCTION_FAILED;
324 }
325
326 if (table_name)
327 {
328 *table_name = strdupW(_Storages);
329 if (!*table_name)
330 {
331 msi_free(name);
332 return ERROR_FUNCTION_FAILED;
333 }
334 }
335
336 if (temporary)
337 *temporary = FALSE;
338
339 return ERROR_SUCCESS;
340 }
341
342 static UINT storages_find_row(MSISTORAGESVIEW *sv, MSIRECORD *rec, UINT *row)
343 {
344 LPCWSTR str;
345 UINT i, id, data;
346
347 str = MSI_RecordGetString(rec, 1);
348 msi_string2idW(sv->db->strings, str, &id);
349
350 for (i = 0; i < sv->num_rows; i++)
351 {
352 STORAGES_fetch_int(&sv->view, i, 1, &data);
353
354 if (data == id)
355 {
356 *row = i;
357 return ERROR_SUCCESS;
358 }
359 }
360
361 return ERROR_FUNCTION_FAILED;
362 }
363
364 static UINT storages_modify_update(struct tagMSIVIEW *view, MSIRECORD *rec)
365 {
366 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
367 UINT r, row;
368
369 r = storages_find_row(sv, rec, &row);
370 if (r != ERROR_SUCCESS)
371 return ERROR_FUNCTION_FAILED;
372
373 return STORAGES_set_row(view, row, rec, 0);
374 }
375
376 static UINT storages_modify_assign(struct tagMSIVIEW *view, MSIRECORD *rec)
377 {
378 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
379 UINT r, row;
380
381 r = storages_find_row(sv, rec, &row);
382 if (r == ERROR_SUCCESS)
383 return storages_modify_update(view, rec);
384
385 return STORAGES_insert_row(view, rec, -1, FALSE);
386 }
387
388 static UINT STORAGES_modify(struct tagMSIVIEW *view, MSIMODIFY eModifyMode, MSIRECORD *rec, UINT row)
389 {
390 UINT r;
391
392 TRACE("%p %d %p\n", view, eModifyMode, rec);
393
394 switch (eModifyMode)
395 {
396 case MSIMODIFY_ASSIGN:
397 r = storages_modify_assign(view, rec);
398 break;
399
400 case MSIMODIFY_INSERT:
401 r = STORAGES_insert_row(view, rec, -1, FALSE);
402 break;
403
404 case MSIMODIFY_UPDATE:
405 r = storages_modify_update(view, rec);
406 break;
407
408 case MSIMODIFY_VALIDATE_NEW:
409 case MSIMODIFY_INSERT_TEMPORARY:
410 case MSIMODIFY_REFRESH:
411 case MSIMODIFY_REPLACE:
412 case MSIMODIFY_MERGE:
413 case MSIMODIFY_DELETE:
414 case MSIMODIFY_VALIDATE:
415 case MSIMODIFY_VALIDATE_FIELD:
416 case MSIMODIFY_VALIDATE_DELETE:
417 FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
418 r = ERROR_CALL_NOT_IMPLEMENTED;
419 break;
420
421 default:
422 r = ERROR_INVALID_DATA;
423 }
424
425 return r;
426 }
427
428 static UINT STORAGES_delete(struct tagMSIVIEW *view)
429 {
430 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
431 UINT i;
432
433 TRACE("(%p)\n", view);
434
435 for (i = 0; i < sv->num_rows; i++)
436 {
437 if (sv->storages[i]->storage)
438 IStorage_Release(sv->storages[i]->storage);
439
440 msi_free(sv->storages[i]->name);
441 msi_free(sv->storages[i]);
442 }
443
444 msi_free(sv->storages);
445 sv->storages = NULL;
446 msi_free(sv);
447
448 return ERROR_SUCCESS;
449 }
450
451 static UINT STORAGES_find_matching_rows(struct tagMSIVIEW *view, UINT col,
452 UINT val, UINT *row, MSIITERHANDLE *handle)
453 {
454 MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
455 UINT index = PtrToUlong(*handle);
456
457 TRACE("(%d, %d): %d\n", *row, col, val);
458
459 if (col == 0 || col > NUM_STORAGES_COLS)
460 return ERROR_INVALID_PARAMETER;
461
462 while (index < sv->num_rows)
463 {
464 if (sv->storages[index]->str_index == val)
465 {
466 *row = index;
467 break;
468 }
469
470 index++;
471 }
472
473 *handle = UlongToPtr(++index);
474 if (index >= sv->num_rows)
475 return ERROR_NO_MORE_ITEMS;
476
477 return ERROR_SUCCESS;
478 }
479
480 static const MSIVIEWOPS storages_ops =
481 {
482 STORAGES_fetch_int,
483 STORAGES_fetch_stream,
484 STORAGES_get_row,
485 STORAGES_set_row,
486 STORAGES_insert_row,
487 STORAGES_delete_row,
488 STORAGES_execute,
489 STORAGES_close,
490 STORAGES_get_dimensions,
491 STORAGES_get_column_info,
492 STORAGES_modify,
493 STORAGES_delete,
494 STORAGES_find_matching_rows,
495 NULL,
496 NULL,
497 NULL,
498 NULL,
499 NULL,
500 NULL,
501 };
502
503 static INT add_storages_to_table(MSISTORAGESVIEW *sv)
504 {
505 STORAGE *storage = NULL;
506 IEnumSTATSTG *stgenum = NULL;
507 STATSTG stat;
508 HRESULT hr;
509 UINT count = 0, size;
510
511 hr = IStorage_EnumElements(sv->db->storage, 0, NULL, 0, &stgenum);
512 if (FAILED(hr))
513 return -1;
514
515 sv->max_storages = 1;
516 sv->storages = msi_alloc(sizeof(STORAGE *));
517 if (!sv->storages)
518 return -1;
519
520 while (TRUE)
521 {
522 size = 0;
523 hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &size);
524 if (FAILED(hr) || !size)
525 break;
526
527 if (stat.type != STGTY_STORAGE)
528 {
529 CoTaskMemFree(stat.pwcsName);
530 continue;
531 }
532
533 TRACE("enumerated storage %s\n", debugstr_w(stat.pwcsName));
534
535 storage = create_storage(sv, stat.pwcsName, NULL);
536 if (!storage)
537 {
538 count = -1;
539 CoTaskMemFree(stat.pwcsName);
540 break;
541 }
542
543 IStorage_OpenStorage(sv->db->storage, stat.pwcsName, NULL,
544 STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0,
545 &storage->storage);
546 CoTaskMemFree(stat.pwcsName);
547
548 if (!storages_set_table_size(sv, ++count))
549 {
550 count = -1;
551 break;
552 }
553
554 sv->storages[count - 1] = storage;
555 }
556
557 IEnumSTATSTG_Release(stgenum);
558 return count;
559 }
560
561 UINT STORAGES_CreateView(MSIDATABASE *db, MSIVIEW **view)
562 {
563 MSISTORAGESVIEW *sv;
564 INT rows;
565
566 TRACE("(%p, %p)\n", db, view);
567
568 sv = msi_alloc(sizeof(MSISTORAGESVIEW));
569 if (!sv)
570 return ERROR_FUNCTION_FAILED;
571
572 sv->view.ops = &storages_ops;
573 sv->db = db;
574
575 rows = add_storages_to_table(sv);
576 if (rows < 0)
577 {
578 msi_free( sv );
579 return ERROR_FUNCTION_FAILED;
580 }
581 sv->num_rows = rows;
582
583 *view = (MSIVIEW *)sv;
584
585 return ERROR_SUCCESS;
586 }