dlls/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 }