12f707e5e57ce391018e519e17c3b86b0c7621aa
[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 {
260 LPCWSTR name_ptr = NULL;
261
262 static const WCHAR Name[] = {'N','a','m','e',0};
263 static const WCHAR Data[] = {'D','a','t','a',0};
264
265 TRACE("(%p, %d, %p, %p, %p)\n", view, n, name, type, temporary);
266
267 if (n == 0 || n > NUM_STREAMS_COLS)
268 return ERROR_INVALID_PARAMETER;
269
270 switch (n)
271 {
272 case 1:
273 name_ptr = Name;
274 if (type) *type = MSITYPE_STRING | MAX_STREAM_NAME_LEN;
275 break;
276
277 case 2:
278 name_ptr = Data;
279 if (type) *type = MSITYPE_STRING | MSITYPE_VALID | MSITYPE_NULLABLE;
280 break;
281 }
282
283 if (name)
284 {
285 *name = strdupW(name_ptr);
286 if (!*name) return ERROR_FUNCTION_FAILED;
287 }
288
289 if (temporary)
290 *temporary = FALSE;
291
292 return ERROR_SUCCESS;
293 }
294
295 static UINT streams_find_row(MSISTREAMSVIEW *sv, MSIRECORD *rec, UINT *row)
296 {
297 LPCWSTR str;
298 UINT i, id, data;
299
300 str = MSI_RecordGetString(rec, 1);
301 msi_string2idW(sv->db->strings, str, &id);
302
303 for (i = 0; i < sv->num_rows; i++)
304 {
305 STREAMS_fetch_int(&sv->view, i, 1, &data);
306
307 if (data == id)
308 {
309 *row = i;
310 return ERROR_SUCCESS;
311 }
312 }
313
314 return ERROR_FUNCTION_FAILED;
315 }
316
317 static UINT streams_modify_update(struct tagMSIVIEW *view, MSIRECORD *rec)
318 {
319 MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
320 UINT r, row;
321
322 r = streams_find_row(sv, rec, &row);
323 if (r != ERROR_SUCCESS)
324 return ERROR_FUNCTION_FAILED;
325
326 return STREAMS_set_row(view, row, rec, 0);
327 }
328
329 static UINT streams_modify_assign(struct tagMSIVIEW *view, MSIRECORD *rec)
330 {
331 MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
332 UINT r, row;
333
334 r = streams_find_row(sv, rec, &row);
335 if (r == ERROR_SUCCESS)
336 return streams_modify_update(view, rec);
337
338 return STREAMS_insert_row(view, rec, -1, FALSE);
339 }
340
341 static UINT STREAMS_modify(struct tagMSIVIEW *view, MSIMODIFY eModifyMode, MSIRECORD *rec, UINT row)
342 {
343 UINT r;
344
345 TRACE("%p %d %p\n", view, eModifyMode, rec);
346
347 switch (eModifyMode)
348 {
349 case MSIMODIFY_ASSIGN:
350 r = streams_modify_assign(view, rec);
351 break;
352
353 case MSIMODIFY_INSERT:
354 r = STREAMS_insert_row(view, rec, -1, FALSE);
355 break;
356
357 case MSIMODIFY_UPDATE:
358 r = streams_modify_update(view, rec);
359 break;
360
361 case MSIMODIFY_VALIDATE_NEW:
362 case MSIMODIFY_INSERT_TEMPORARY:
363 case MSIMODIFY_REFRESH:
364 case MSIMODIFY_REPLACE:
365 case MSIMODIFY_MERGE:
366 case MSIMODIFY_DELETE:
367 case MSIMODIFY_VALIDATE:
368 case MSIMODIFY_VALIDATE_FIELD:
369 case MSIMODIFY_VALIDATE_DELETE:
370 FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
371 r = ERROR_CALL_NOT_IMPLEMENTED;
372 break;
373
374 default:
375 r = ERROR_INVALID_DATA;
376 }
377
378 return r;
379 }
380
381 static UINT STREAMS_delete(struct tagMSIVIEW *view)
382 {
383 MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
384 UINT i;
385
386 TRACE("(%p)\n", view);
387
388 for (i = 0; i < sv->num_rows; i++)
389 {
390 if (sv->streams[i] && sv->streams[i]->stream)
391 IStream_Release(sv->streams[i]->stream);
392 msi_free(sv->streams[i]);
393 }
394
395 msi_free(sv->streams);
396
397 return ERROR_SUCCESS;
398 }
399
400 static UINT STREAMS_find_matching_rows(struct tagMSIVIEW *view, UINT col,
401 UINT val, UINT *row, MSIITERHANDLE *handle)
402 {
403 MSISTREAMSVIEW *sv = (MSISTREAMSVIEW *)view;
404 UINT index = (UINT)*handle;
405
406 TRACE("(%d, %d): %d\n", *row, col, val);
407
408 if (col == 0 || col > NUM_STREAMS_COLS)
409 return ERROR_INVALID_PARAMETER;
410
411 while (index < sv->num_rows)
412 {
413 if (sv->streams[index]->str_index == val)
414 {
415 *row = index;
416 break;
417 }
418
419 index++;
420 }
421
422 *handle = (MSIITERHANDLE)++index;
423 if (index >= sv->num_rows)
424 return ERROR_NO_MORE_ITEMS;
425
426 return ERROR_SUCCESS;
427 }
428
429 static const MSIVIEWOPS streams_ops =
430 {
431 STREAMS_fetch_int,
432 STREAMS_fetch_stream,
433 STREAMS_get_row,
434 STREAMS_set_row,
435 STREAMS_insert_row,
436 STREAMS_delete_row,
437 STREAMS_execute,
438 STREAMS_close,
439 STREAMS_get_dimensions,
440 STREAMS_get_column_info,
441 STREAMS_modify,
442 STREAMS_delete,
443 STREAMS_find_matching_rows,
444 NULL,
445 NULL,
446 NULL,
447 NULL,
448 NULL,
449 NULL,
450 };
451
452 static INT add_streams_to_table(MSISTREAMSVIEW *sv)
453 {
454 IEnumSTATSTG *stgenum = NULL;
455 STATSTG stat;
456 STREAM *stream = NULL;
457 HRESULT hr;
458 UINT count = 0, size;
459
460 hr = IStorage_EnumElements(sv->db->storage, 0, NULL, 0, &stgenum);
461 if (FAILED(hr))
462 return -1;
463
464 sv->max_streams = 1;
465 sv->streams = msi_alloc_zero(sizeof(STREAM *));
466 if (!sv->streams)
467 return -1;
468
469 while (TRUE)
470 {
471 size = 0;
472 hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &size);
473 if (FAILED(hr) || !size)
474 break;
475
476 if (stat.type != STGTY_STREAM)
477 continue;
478
479 /* table streams are not in the _Streams table */
480 if (*stat.pwcsName == 0x4840)
481 {
482 CoTaskMemFree(stat.pwcsName);
483 continue;
484 }
485
486 stream = create_stream(sv, stat.pwcsName, TRUE, NULL);
487 if (!stream)
488 {
489 count = -1;
490 CoTaskMemFree(stat.pwcsName);
491 break;
492 }
493
494 IStorage_OpenStream(sv->db->storage, stat.pwcsName, 0,
495 STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stream->stream);
496 CoTaskMemFree(stat.pwcsName);
497
498 if (!streams_set_table_size(sv, ++count))
499 {
500 count = -1;
501 break;
502 }
503
504 sv->streams[count - 1] = stream;
505 }
506
507 IEnumSTATSTG_Release(stgenum);
508 return count;
509 }
510
511 UINT STREAMS_CreateView(MSIDATABASE *db, MSIVIEW **view)
512 {
513 MSISTREAMSVIEW *sv;
514 INT rows;
515
516 TRACE("(%p, %p)\n", db, view);
517
518 sv = msi_alloc(sizeof(MSISTREAMSVIEW));
519 if (!sv)
520 return ERROR_FUNCTION_FAILED;
521
522 sv->view.ops = &streams_ops;
523 sv->db = db;
524 rows = add_streams_to_table(sv);
525 if (rows < 0)
526 {
527 msi_free( sv );
528 return ERROR_FUNCTION_FAILED;
529 }
530 sv->num_rows = rows;
531
532 *view = (MSIVIEW *)sv;
533
534 return ERROR_SUCCESS;
535 }