git.oblomov.eu Git - wine/blob - 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     IStorage *storage;
  47 } STORAGE;
  48
  49 typedef struct tagMSISTORAGESVIEW
  50 {
  51     MSIVIEW view;
  52     MSIDATABASE *db;
  53     STORAGE **storages;
  54     UINT max_storages;
  55     UINT num_rows;
  56     UINT row_size;
  57 } MSISTORAGESVIEW;
  58
  59 static BOOL storages_set_table_size(MSISTORAGESVIEW *sv, UINT size)
  60 {
  61     if (size >= sv->max_storages)
  62     {
  63         sv->max_storages *= 2;
  64         sv->storages = msi_realloc(sv->storages, sv->max_storages * sizeof(STORAGE *));
  65         if (!sv->storages)
  66             return FALSE;
  67     }
  68
  69     return TRUE;
  70 }
  71
  72 static STORAGE *create_storage(MSISTORAGESVIEW *sv, LPCWSTR name, IStorage *stg)
  73 {
  74     STORAGE *storage;
  75
  76     storage = msi_alloc(sizeof(STORAGE));
  77     if (!storage)
  78         return NULL;
  79
  80     storage->str_index = msi_addstringW(sv->db->strings, name, -1, 1, StringNonPersistent);
  81     storage->storage = stg;
  82
  83     if (storage->storage)
  84         IStorage_AddRef(storage->storage);
  85
  86     return storage;
  87 }
  88
  89 static UINT STORAGES_fetch_int(struct tagMSIVIEW *view, UINT row, UINT col, UINT *val)
  90 {
  91     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
  92
  93     TRACE("(%p, %d, %d, %p)\n", view, row, col, val);
  94
  95     if (col != 1)
  96         return ERROR_INVALID_PARAMETER;
  97
  98     if (row >= sv->num_rows)
  99         return ERROR_NO_MORE_ITEMS;
 100
 101     *val = sv->storages[row]->str_index;
 102
 103     return ERROR_SUCCESS;
 104 }
 105
 106 static UINT STORAGES_fetch_stream(struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm)
 107 {
 108     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
 109
 110     TRACE("(%p, %d, %d, %p)\n", view, row, col, stm);
 111
 112     if (row >= sv->num_rows)
 113         return ERROR_FUNCTION_FAILED;
 114
 115     return ERROR_INVALID_DATA;
 116 }
 117
 118 static UINT STORAGES_get_row( struct tagMSIVIEW *view, UINT row, MSIRECORD **rec )
 119 {
 120     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
 121
 122     FIXME("%p %d %p\n", sv, row, rec);
 123
 124     return ERROR_CALL_NOT_IMPLEMENTED;
 125 }
 126
 127 static HRESULT stream_to_storage(IStream *stm, IStorage **stg)
 128 {
 129     ILockBytes *lockbytes = NULL;
 130     STATSTG stat;
 131     LPVOID data;
 132     HRESULT hr;
 133     DWORD size, read;
 134     ULARGE_INTEGER offset;
 135
 136     hr = IStream_Stat(stm, &stat, STATFLAG_NONAME);
 137     if (FAILED(hr))
 138         return hr;
 139
 140     if (stat.cbSize.QuadPart >> 32)
 141     {
 142         ERR("Storage is too large\n");
 143         return E_FAIL;
 144     }
 145
 146     size = stat.cbSize.QuadPart;
 147     data = msi_alloc(size);
 148     if (!data)
 149         return E_OUTOFMEMORY;
 150
 151     hr = IStream_Read(stm, data, size, &read);
 152     if (FAILED(hr) || read != size)
 153         goto done;
 154
 155     hr = CreateILockBytesOnHGlobal(NULL, TRUE, &lockbytes);
 156     if (FAILED(hr))
 157         goto done;
 158
 159     ZeroMemory(&offset, sizeof(ULARGE_INTEGER));
 160     hr = ILockBytes_WriteAt(lockbytes, offset, data, size, &read);
 161     if (FAILED(hr) || read != size)
 162         goto done;
 163
 164     hr = StgOpenStorageOnILockBytes(lockbytes, NULL,
 165                                     STGM_READWRITE | STGM_SHARE_DENY_NONE,
 166                                     NULL, 0, stg);
 167     if (FAILED(hr))
 168         goto done;
 169
 170 done:
 171     msi_free(data);
 172     if (lockbytes) ILockBytes_Release(lockbytes);
 173     return hr;
 174 }
 175
 176 static UINT STORAGES_set_row(struct tagMSIVIEW *view, UINT row, MSIRECORD *rec, UINT mask)
 177 {
 178     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
 179     IStorage *stg, *substg = NULL;
 180     IStream *stm;
 181     LPWSTR name = NULL;
 182     HRESULT hr;
 183     UINT r = ERROR_FUNCTION_FAILED;
 184
 185     TRACE("(%p, %p)\n", view, rec);
 186
 187     if (row > sv->num_rows)
 188         return ERROR_FUNCTION_FAILED;
 189
 190     r = MSI_RecordGetIStream(rec, 2, &stm);
 191     if (r != ERROR_SUCCESS)
 192         return r;
 193
 194     r = stream_to_storage(stm, &stg);
 195     if (r != ERROR_SUCCESS)
 196     {
 197         IStream_Release(stm);
 198         return r;
 199     }
 200
 201     name = strdupW(MSI_RecordGetString(rec, 1));
 202     if (!name)
 203     {
 204         r = ERROR_OUTOFMEMORY;
 205         goto done;
 206     }
 207
 208     hr = IStorage_CreateStorage(sv->db->storage, name,
 209                                 STGM_WRITE | STGM_SHARE_EXCLUSIVE,
 210                                 0, 0, &substg);
 211     if (FAILED(hr))
 212     {
 213         r = ERROR_FUNCTION_FAILED;
 214         goto done;
 215     }
 216
 217     hr = IStorage_CopyTo(stg, 0, NULL, NULL, substg);
 218     if (FAILED(hr))
 219     {
 220         r = ERROR_FUNCTION_FAILED;
 221         goto done;
 222     }
 223
 224     sv->storages[row] = create_storage(sv, name, stg);
 225     if (!sv->storages[row])
 226         r = ERROR_FUNCTION_FAILED;
 227
 228 done:
 229     msi_free(name);
 230
 231     if (substg) IStorage_Release(substg);
 232     IStorage_Release(stg);
 233     IStream_Release(stm);
 234
 235     return r;
 236 }
 237
 238 static UINT STORAGES_insert_row(struct tagMSIVIEW *view, MSIRECORD *rec, UINT row, BOOL temporary)
 239 {
 240     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
 241
 242     if (!storages_set_table_size(sv, ++sv->num_rows))
 243         return ERROR_FUNCTION_FAILED;
 244
 245     if (row == -1)
 246         row = sv->num_rows - 1;
 247
 248     /* FIXME have to readjust rows */
 249
 250     return STORAGES_set_row(view, row, rec, 0);
 251 }
 252
 253 static UINT STORAGES_delete_row(struct tagMSIVIEW *view, UINT row)
 254 {
 255     FIXME("(%p %d): stub!\n", view, row);
 256     return ERROR_SUCCESS;
 257 }
 258
 259 static UINT STORAGES_execute(struct tagMSIVIEW *view, MSIRECORD *record)
 260 {
 261     TRACE("(%p, %p)\n", view, record);
 262     return ERROR_SUCCESS;
 263 }
 264
 265 static UINT STORAGES_close(struct tagMSIVIEW *view)
 266 {
 267     TRACE("(%p)\n", view);
 268     return ERROR_SUCCESS;
 269 }
 270
 271 static UINT STORAGES_get_dimensions(struct tagMSIVIEW *view, UINT *rows, UINT *cols)
 272 {
 273     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
 274
 275     TRACE("(%p, %p, %p)\n", view, rows, cols);
 276
 277     if (cols) *cols = NUM_STORAGES_COLS;
 278     if (rows) *rows = sv->num_rows;
 279
 280     return ERROR_SUCCESS;
 281 }
 282
 283 static UINT STORAGES_get_column_info(struct tagMSIVIEW *view, UINT n,
 284                                      LPWSTR *name, UINT *type, BOOL *temporary,
 285                                      LPWSTR *table_name)
 286 {
 287     LPCWSTR name_ptr = NULL;
 288
 289     static const WCHAR Name[] = {'N','a','m','e',0};
 290     static const WCHAR Data[] = {'D','a','t','a',0};
 291     static const WCHAR _Storages[] = {'_','S','t','o','r','a','g','e','s',0};
 292
 293     TRACE("(%p, %d, %p, %p, %p, %p)\n", view, n, name, type, temporary,
 294           table_name);
 295
 296     if (n == 0 || n > NUM_STORAGES_COLS)
 297         return ERROR_INVALID_PARAMETER;
 298
 299     switch (n)
 300     {
 301     case 1:
 302         name_ptr = Name;
 303         if (type) *type = MSITYPE_STRING | MAX_STORAGES_NAME_LEN;
 304         break;
 305
 306     case 2:
 307         name_ptr = Data;
 308         if (type) *type = MSITYPE_STRING | MSITYPE_VALID | MSITYPE_NULLABLE;
 309         break;
 310     }
 311
 312     if (name)
 313     {
 314         *name = strdupW(name_ptr);
 315         if (!*name) return ERROR_FUNCTION_FAILED;
 316     }
 317
 318     if (table_name)
 319     {
 320         *table_name = strdupW(_Storages);
 321         if (!*table_name)
 322         {
 323             msi_free(name);
 324             return ERROR_FUNCTION_FAILED;
 325         }
 326     }
 327
 328     if (temporary)
 329         *temporary = FALSE;
 330
 331     return ERROR_SUCCESS;
 332 }
 333
 334 static UINT storages_find_row(MSISTORAGESVIEW *sv, MSIRECORD *rec, UINT *row)
 335 {
 336     LPCWSTR str;
 337     UINT r, i, id, data;
 338
 339     str = MSI_RecordGetString(rec, 1);
 340     r = msi_string2idW(sv->db->strings, str, &id);
 341     if (r != ERROR_SUCCESS)
 342         return r;
 343
 344     for (i = 0; i < sv->num_rows; i++)
 345     {
 346         STORAGES_fetch_int(&sv->view, i, 1, &data);
 347
 348         if (data == id)
 349         {
 350             *row = i;
 351             return ERROR_SUCCESS;
 352         }
 353     }
 354
 355     return ERROR_FUNCTION_FAILED;
 356 }
 357
 358 static UINT storages_modify_update(struct tagMSIVIEW *view, MSIRECORD *rec)
 359 {
 360     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
 361     UINT r, row;
 362
 363     r = storages_find_row(sv, rec, &row);
 364     if (r != ERROR_SUCCESS)
 365         return ERROR_FUNCTION_FAILED;
 366
 367     return STORAGES_set_row(view, row, rec, 0);
 368 }
 369
 370 static UINT storages_modify_assign(struct tagMSIVIEW *view, MSIRECORD *rec)
 371 {
 372     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
 373     UINT r, row;
 374
 375     r = storages_find_row(sv, rec, &row);
 376     if (r == ERROR_SUCCESS)
 377         return storages_modify_update(view, rec);
 378
 379     return STORAGES_insert_row(view, rec, -1, FALSE);
 380 }
 381
 382 static UINT STORAGES_modify(struct tagMSIVIEW *view, MSIMODIFY eModifyMode, MSIRECORD *rec, UINT row)
 383 {
 384     UINT r;
 385
 386     TRACE("%p %d %p\n", view, eModifyMode, rec);
 387
 388     switch (eModifyMode)
 389     {
 390     case MSIMODIFY_ASSIGN:
 391         r = storages_modify_assign(view, rec);
 392         break;
 393
 394     case MSIMODIFY_INSERT:
 395         r = STORAGES_insert_row(view, rec, -1, FALSE);
 396         break;
 397
 398     case MSIMODIFY_UPDATE:
 399         r = storages_modify_update(view, rec);
 400         break;
 401
 402     case MSIMODIFY_VALIDATE_NEW:
 403     case MSIMODIFY_INSERT_TEMPORARY:
 404     case MSIMODIFY_REFRESH:
 405     case MSIMODIFY_REPLACE:
 406     case MSIMODIFY_MERGE:
 407     case MSIMODIFY_DELETE:
 408     case MSIMODIFY_VALIDATE:
 409     case MSIMODIFY_VALIDATE_FIELD:
 410     case MSIMODIFY_VALIDATE_DELETE:
 411         FIXME("%p %d %p - mode not implemented\n", view, eModifyMode, rec );
 412         r = ERROR_CALL_NOT_IMPLEMENTED;
 413         break;
 414
 415     default:
 416         r = ERROR_INVALID_DATA;
 417     }
 418
 419     return r;
 420 }
 421
 422 static UINT STORAGES_delete(struct tagMSIVIEW *view)
 423 {
 424     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
 425     UINT i;
 426
 427     TRACE("(%p)\n", view);
 428
 429     for (i = 0; i < sv->num_rows; i++)
 430     {
 431         if (sv->storages[i]->storage)
 432             IStorage_Release(sv->storages[i]->storage);
 433         msi_free(sv->storages[i]);
 434     }
 435
 436     msi_free(sv->storages);
 437     sv->storages = NULL;
 438     msi_free(sv);
 439
 440     return ERROR_SUCCESS;
 441 }
 442
 443 static UINT STORAGES_find_matching_rows(struct tagMSIVIEW *view, UINT col,
 444                                        UINT val, UINT *row, MSIITERHANDLE *handle)
 445 {
 446     MSISTORAGESVIEW *sv = (MSISTORAGESVIEW *)view;
 447     UINT index = PtrToUlong(*handle);
 448
 449     TRACE("(%d, %d): %d\n", *row, col, val);
 450
 451     if (col == 0 || col > NUM_STORAGES_COLS)
 452         return ERROR_INVALID_PARAMETER;
 453
 454     while (index < sv->num_rows)
 455     {
 456         if (sv->storages[index]->str_index == val)
 457         {
 458             *row = index;
 459             break;
 460         }
 461
 462         index++;
 463     }
 464
 465     *handle = UlongToPtr(++index);
 466     if (index >= sv->num_rows)
 467         return ERROR_NO_MORE_ITEMS;
 468
 469     return ERROR_SUCCESS;
 470 }
 471
 472 static const MSIVIEWOPS storages_ops =
 473 {
 474     STORAGES_fetch_int,
 475     STORAGES_fetch_stream,
 476     STORAGES_get_row,
 477     STORAGES_set_row,
 478     STORAGES_insert_row,
 479     STORAGES_delete_row,
 480     STORAGES_execute,
 481     STORAGES_close,
 482     STORAGES_get_dimensions,
 483     STORAGES_get_column_info,
 484     STORAGES_modify,
 485     STORAGES_delete,
 486     STORAGES_find_matching_rows,
 487     NULL,
 488     NULL,
 489     NULL,
 490     NULL,
 491     NULL,
 492     NULL,
 493 };
 494
 495 static INT add_storages_to_table(MSISTORAGESVIEW *sv)
 496 {
 497     STORAGE *storage = NULL;
 498     IEnumSTATSTG *stgenum = NULL;
 499     STATSTG stat;
 500     HRESULT hr;
 501     UINT count = 0, size;
 502
 503     hr = IStorage_EnumElements(sv->db->storage, 0, NULL, 0, &stgenum);
 504     if (FAILED(hr))
 505         return -1;
 506
 507     sv->max_storages = 1;
 508     sv->storages = msi_alloc(sizeof(STORAGE *));
 509     if (!sv->storages)
 510         return -1;
 511
 512     while (TRUE)
 513     {
 514         size = 0;
 515         hr = IEnumSTATSTG_Next(stgenum, 1, &stat, &size);
 516         if (FAILED(hr) || !size)
 517             break;
 518
 519         if (stat.type != STGTY_STORAGE)
 520         {
 521             CoTaskMemFree(stat.pwcsName);
 522             continue;
 523         }
 524
 525         TRACE("enumerated storage %s\n", debugstr_w(stat.pwcsName));
 526
 527         storage = create_storage(sv, stat.pwcsName, NULL);
 528         if (!storage)
 529         {
 530             count = -1;
 531             CoTaskMemFree(stat.pwcsName);
 532             break;
 533         }
 534
 535         IStorage_OpenStorage(sv->db->storage, stat.pwcsName, NULL,
 536                              STGM_READ | STGM_SHARE_EXCLUSIVE, NULL, 0,
 537                              &storage->storage);
 538         CoTaskMemFree(stat.pwcsName);
 539
 540         if (!storages_set_table_size(sv, ++count))
 541         {
 542             count = -1;
 543             break;
 544         }
 545
 546         sv->storages[count - 1] = storage;
 547     }
 548
 549     IEnumSTATSTG_Release(stgenum);
 550     return count;
 551 }
 552
 553 UINT STORAGES_CreateView(MSIDATABASE *db, MSIVIEW **view)
 554 {
 555     MSISTORAGESVIEW *sv;
 556     INT rows;
 557
 558     TRACE("(%p, %p)\n", db, view);
 559
 560     sv = msi_alloc_zero( sizeof(MSISTORAGESVIEW) );
 561     if (!sv)
 562         return ERROR_FUNCTION_FAILED;
 563
 564     sv->view.ops = &storages_ops;
 565     sv->db = db;
 566
 567     rows = add_storages_to_table(sv);
 568     if (rows < 0)
 569     {
 570         msi_free( sv );
 571         return ERROR_FUNCTION_FAILED;
 572     }
 573     sv->num_rows = rows;
 574
 575     *view = (MSIVIEW *)sv;
 576
 577     return ERROR_SUCCESS;
 578 }