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