oleaut32: Implement ITypeLibComp::BindType.
[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_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 }