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