dlls/msi/string.c

   1 /*
   2  * String Table Functions
   3  *
   4  * Copyright 2002-2004, Mike McCormack for CodeWeavers
   5  * Copyright 2007 Robert Shearman for CodeWeavers
   6  * Copyright 2010 Hans Leidekker for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26 #include <assert.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "wine/debug.h"
  32 #include "msi.h"
  33 #include "msiquery.h"
  34 #include "objbase.h"
  35 #include "objidl.h"
  36 #include "msipriv.h"
  37 #include "winnls.h"
  38
  39 #include "query.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
  42
  43 struct msistring
  44 {
  45     USHORT persistent_refcount;
  46     USHORT nonpersistent_refcount;
  47     WCHAR *data;
  48     int    len;
  49 };
  50
  51 struct string_table
  52 {
  53     UINT maxcount;         /* the number of strings */
  54     UINT freeslot;
  55     UINT codepage;
  56     UINT sortcount;
  57     struct msistring *strings; /* an array of strings */
  58     UINT *sorted;              /* index */
  59 };
  60
  61 static BOOL validate_codepage( UINT codepage )
  62 {
  63     if (codepage != CP_ACP && !IsValidCodePage( codepage ))
  64     {
  65         WARN("invalid codepage %u\n", codepage);
  66         return FALSE;
  67     }
  68     return TRUE;
  69 }
  70
  71 static string_table *init_stringtable( int entries, UINT codepage )
  72 {
  73     string_table *st;
  74
  75     if (!validate_codepage( codepage ))
  76         return NULL;
  77
  78     st = msi_alloc( sizeof (string_table) );
  79     if( !st )
  80         return NULL;
  81     if( entries < 1 )
  82         entries = 1;
  83
  84     st->strings = msi_alloc_zero( sizeof(struct msistring) * entries );
  85     if( !st->strings )
  86     {
  87         msi_free( st );
  88         return NULL;
  89     }
  90
  91     st->sorted = msi_alloc( sizeof (UINT) * entries );
  92     if( !st->sorted )
  93     {
  94         msi_free( st->strings );
  95         msi_free( st );
  96         return NULL;
  97     }
  98
  99     st->maxcount = entries;
 100     st->freeslot = 1;
 101     st->codepage = codepage;
 102     st->sortcount = 0;
 103
 104     return st;
 105 }
 106
 107 VOID msi_destroy_stringtable( string_table *st )
 108 {
 109     UINT i;
 110
 111     for( i=0; i<st->maxcount; i++ )
 112     {
 113         if( st->strings[i].persistent_refcount ||
 114             st->strings[i].nonpersistent_refcount )
 115             msi_free( st->strings[i].data );
 116     }
 117     msi_free( st->strings );
 118     msi_free( st->sorted );
 119     msi_free( st );
 120 }
 121
 122 static int st_find_free_entry( string_table *st )
 123 {
 124     UINT i, sz, *s;
 125     struct msistring *p;
 126
 127     TRACE("%p\n", st);
 128
 129     if( st->freeslot )
 130     {
 131         for( i = st->freeslot; i < st->maxcount; i++ )
 132             if( !st->strings[i].persistent_refcount &&
 133                 !st->strings[i].nonpersistent_refcount )
 134                 return i;
 135     }
 136     for( i = 1; i < st->maxcount; i++ )
 137         if( !st->strings[i].persistent_refcount &&
 138             !st->strings[i].nonpersistent_refcount )
 139             return i;
 140
 141     /* dynamically resize */
 142     sz = st->maxcount + 1 + st->maxcount/2;
 143     p = msi_realloc_zero( st->strings, sz * sizeof(struct msistring) );
 144     if( !p )
 145         return -1;
 146
 147     s = msi_realloc( st->sorted, sz*sizeof(UINT) );
 148     if( !s )
 149     {
 150         msi_free( p );
 151         return -1;
 152     }
 153
 154     st->strings = p;
 155     st->sorted = s;
 156
 157     st->freeslot = st->maxcount;
 158     st->maxcount = sz;
 159     if( st->strings[st->freeslot].persistent_refcount ||
 160         st->strings[st->freeslot].nonpersistent_refcount )
 161         ERR("oops. expected freeslot to be free...\n");
 162     return st->freeslot;
 163 }
 164
 165 static inline int cmp_string( const WCHAR *str1, int len1, const WCHAR *str2, int len2 )
 166 {
 167     if (len1 < len2) return -1;
 168     else if (len1 > len2) return 1;
 169     while (len1)
 170     {
 171         if (*str1 == *str2) { str1++; str2++; }
 172         else return *str1 - *str2;
 173         len1--;
 174     }
 175     return 0;
 176 }
 177
 178 static int find_insert_index( const string_table *st, UINT string_id )
 179 {
 180     int i, c, low = 0, high = st->sortcount - 1;
 181
 182     while (low <= high)
 183     {
 184         i = (low + high) / 2;
 185         c = cmp_string( st->strings[string_id].data, st->strings[string_id].len,
 186                         st->strings[st->sorted[i]].data, st->strings[st->sorted[i]].len );
 187         if (c < 0)
 188             high = i - 1;
 189         else if (c > 0)
 190             low = i + 1;
 191         else
 192             return -1; /* already exists */
 193     }
 194     return high + 1;
 195 }
 196
 197 static void insert_string_sorted( string_table *st, UINT string_id )
 198 {
 199     int i;
 200
 201     i = find_insert_index( st, string_id );
 202     if (i == -1)
 203         return;
 204
 205     memmove( &st->sorted[i] + 1, &st->sorted[i], (st->sortcount - i) * sizeof(UINT) );
 206     st->sorted[i] = string_id;
 207     st->sortcount++;
 208 }
 209
 210 static void set_st_entry( string_table *st, UINT n, WCHAR *str, int len, USHORT refcount,
 211                           BOOL persistent )
 212 {
 213     if (persistent)
 214     {
 215         st->strings[n].persistent_refcount = refcount;
 216         st->strings[n].nonpersistent_refcount = 0;
 217     }
 218     else
 219     {
 220         st->strings[n].persistent_refcount = 0;
 221         st->strings[n].nonpersistent_refcount = refcount;
 222     }
 223
 224     st->strings[n].data = str;
 225     st->strings[n].len  = len;
 226
 227     insert_string_sorted( st, n );
 228
 229     if( n < st->maxcount )
 230         st->freeslot = n + 1;
 231 }
 232
 233 static UINT string2id( const string_table *st, const char *buffer, UINT *id )
 234 {
 235     int sz;
 236     UINT r = ERROR_INVALID_PARAMETER;
 237     LPWSTR str;
 238
 239     TRACE("Finding string %s in string table\n", debugstr_a(buffer) );
 240
 241     if( buffer[0] == 0 )
 242     {
 243         *id = 0;
 244         return ERROR_SUCCESS;
 245     }
 246
 247     if (!(sz = MultiByteToWideChar( st->codepage, 0, buffer, -1, NULL, 0 )))
 248         return r;
 249     str = msi_alloc( sz*sizeof(WCHAR) );
 250     if( !str )
 251         return ERROR_NOT_ENOUGH_MEMORY;
 252     MultiByteToWideChar( st->codepage, 0, buffer, -1, str, sz );
 253
 254     r = msi_string2id( st, str, sz - 1, id );
 255     msi_free( str );
 256     return r;
 257 }
 258
 259 static int add_string( string_table *st, UINT n, const char *data, UINT len, USHORT refcount, BOOL persistent )
 260 {
 261     LPWSTR str;
 262     int sz;
 263
 264     if( !data || !len )
 265         return 0;
 266     if( n > 0 )
 267     {
 268         if( st->strings[n].persistent_refcount ||
 269             st->strings[n].nonpersistent_refcount )
 270             return -1;
 271     }
 272     else
 273     {
 274         if (string2id( st, data, &n ) == ERROR_SUCCESS)
 275         {
 276             if (persistent)
 277                 st->strings[n].persistent_refcount += refcount;
 278             else
 279                 st->strings[n].nonpersistent_refcount += refcount;
 280             return n;
 281         }
 282         n = st_find_free_entry( st );
 283         if( n == -1 )
 284             return -1;
 285     }
 286
 287     if( n < 1 )
 288     {
 289         ERR("invalid index adding %s (%d)\n", debugstr_a( data ), n );
 290         return -1;
 291     }
 292
 293     /* allocate a new string */
 294     sz = MultiByteToWideChar( st->codepage, 0, data, len, NULL, 0 );
 295     str = msi_alloc( (sz+1)*sizeof(WCHAR) );
 296     if( !str )
 297         return -1;
 298     MultiByteToWideChar( st->codepage, 0, data, len, str, sz );
 299     str[sz] = 0;
 300
 301     set_st_entry( st, n, str, sz, refcount, persistent );
 302     return n;
 303 }
 304
 305 int msi_add_string( string_table *st, const WCHAR *data, int len, BOOL persistent )
 306 {
 307     UINT n;
 308     LPWSTR str;
 309
 310     if( !data )
 311         return 0;
 312
 313     if (len < 0) len = lstrlenW( data );
 314
 315     if( !data[0] && !len )
 316         return 0;
 317
 318     if (msi_string2id( st, data, len, &n) == ERROR_SUCCESS )
 319     {
 320         if (persistent)
 321             st->strings[n].persistent_refcount++;
 322         else
 323             st->strings[n].nonpersistent_refcount++;
 324         return n;
 325     }
 326
 327     n = st_find_free_entry( st );
 328     if( n == -1 )
 329         return -1;
 330
 331     /* allocate a new string */
 332     TRACE( "%s, n = %d len = %d\n", debugstr_wn(data, len), n, len );
 333
 334     str = msi_alloc( (len+1)*sizeof(WCHAR) );
 335     if( !str )
 336         return -1;
 337     memcpy( str, data, len*sizeof(WCHAR) );
 338     str[len] = 0;
 339
 340     set_st_entry( st, n, str, len, 1, persistent );
 341     return n;
 342 }
 343
 344 /* find the string identified by an id - return null if there's none */
 345 const WCHAR *msi_string_lookup( const string_table *st, UINT id, int *len )
 346 {
 347     if( id == 0 )
 348     {
 349         if (len) *len = 0;
 350         return szEmpty;
 351     }
 352     if( id >= st->maxcount )
 353         return NULL;
 354
 355     if( id && !st->strings[id].persistent_refcount && !st->strings[id].nonpersistent_refcount)
 356         return NULL;
 357
 358     if (len) *len = st->strings[id].len;
 359
 360     return st->strings[id].data;
 361 }
 362
 363 /*
 364  *  id2string
 365  *
 366  *  [in] st         - pointer to the string table
 367  *  [in] id         - id of the string to retrieve
 368  *  [out] buffer    - destination of the UTF8 string
 369  *  [in/out] sz     - number of bytes available in the buffer on input
 370  *                    number of bytes used on output
 371  *
 372  *  Returned string is not nul terminated.
 373  */
 374 static UINT id2string( const string_table *st, UINT id, char *buffer, UINT *sz )
 375 {
 376     int len, lenW;
 377     const WCHAR *str;
 378
 379     TRACE("Finding string %d of %d\n", id, st->maxcount);
 380
 381     str = msi_string_lookup( st, id, &lenW );
 382     if( !str )
 383         return ERROR_FUNCTION_FAILED;
 384
 385     len = WideCharToMultiByte( st->codepage, 0, str, lenW, NULL, 0, NULL, NULL );
 386     if( *sz < len )
 387     {
 388         *sz = len;
 389         return ERROR_MORE_DATA;
 390     }
 391     *sz = WideCharToMultiByte( st->codepage, 0, str, lenW, buffer, *sz, NULL, NULL );
 392     return ERROR_SUCCESS;
 393 }
 394
 395 /*
 396  *  msi_string2id
 397  *
 398  *  [in] st         - pointer to the string table
 399  *  [in] str        - string to find in the string table
 400  *  [out] id        - id of the string, if found
 401  */
 402 UINT msi_string2id( const string_table *st, const WCHAR *str, int len, UINT *id )
 403 {
 404     int i, c, low = 0, high = st->sortcount - 1;
 405
 406     if (len < 0) len = lstrlenW( str );
 407
 408     while (low <= high)
 409     {
 410         i = (low + high) / 2;
 411         c = cmp_string( str, len, st->strings[st->sorted[i]].data, st->strings[st->sorted[i]].len );
 412
 413         if (c < 0)
 414             high = i - 1;
 415         else if (c > 0)
 416             low = i + 1;
 417         else
 418         {
 419             *id = st->sorted[i];
 420             return ERROR_SUCCESS;
 421         }
 422     }
 423     return ERROR_INVALID_PARAMETER;
 424 }
 425
 426 static void string_totalsize( const string_table *st, UINT *datasize, UINT *poolsize )
 427 {
 428     UINT i, len, holesize;
 429
 430     if( st->strings[0].data || st->strings[0].persistent_refcount || st->strings[0].nonpersistent_refcount)
 431         ERR("oops. element 0 has a string\n");
 432
 433     *poolsize = 4;
 434     *datasize = 0;
 435     holesize = 0;
 436     for( i=1; i<st->maxcount; i++ )
 437     {
 438         if( !st->strings[i].persistent_refcount )
 439         {
 440             TRACE("[%u] nonpersistent = %s\n", i, debugstr_wn(st->strings[i].data, st->strings[i].len));
 441             (*poolsize) += 4;
 442         }
 443         else if( st->strings[i].data )
 444         {
 445             TRACE("[%u] = %s\n", i, debugstr_wn(st->strings[i].data, st->strings[i].len));
 446             len = WideCharToMultiByte( st->codepage, 0, st->strings[i].data, st->strings[i].len + 1,
 447                                        NULL, 0, NULL, NULL);
 448             if( len )
 449                 len--;
 450             (*datasize) += len;
 451             if (len>0xffff)
 452                 (*poolsize) += 4;
 453             (*poolsize) += holesize + 4;
 454             holesize = 0;
 455         }
 456         else
 457             holesize += 4;
 458     }
 459     TRACE("data %u pool %u codepage %x\n", *datasize, *poolsize, st->codepage );
 460 }
 461
 462 HRESULT msi_init_string_table( IStorage *stg )
 463 {
 464     USHORT zero[2] = { 0, 0 };
 465     UINT ret;
 466
 467     /* create the StringPool stream... add the zero string to it*/
 468     ret = write_stream_data(stg, szStringPool, zero, sizeof zero, TRUE);
 469     if (ret != ERROR_SUCCESS)
 470         return E_FAIL;
 471
 472     /* create the StringData stream... make it zero length */
 473     ret = write_stream_data(stg, szStringData, NULL, 0, TRUE);
 474     if (ret != ERROR_SUCCESS)
 475         return E_FAIL;
 476
 477     return S_OK;
 478 }
 479
 480 string_table *msi_load_string_table( IStorage *stg, UINT *bytes_per_strref )
 481 {
 482     string_table *st = NULL;
 483     CHAR *data = NULL;
 484     USHORT *pool = NULL;
 485     UINT r, datasize = 0, poolsize = 0, codepage;
 486     DWORD i, count, offset, len, n, refs;
 487
 488     r = read_stream_data( stg, szStringPool, TRUE, (BYTE **)&pool, &poolsize );
 489     if( r != ERROR_SUCCESS)
 490         goto end;
 491     r = read_stream_data( stg, szStringData, TRUE, (BYTE **)&data, &datasize );
 492     if( r != ERROR_SUCCESS)
 493         goto end;
 494
 495     if ( (poolsize > 4) && (pool[1] & 0x8000) )
 496         *bytes_per_strref = LONG_STR_BYTES;
 497     else
 498         *bytes_per_strref = sizeof(USHORT);
 499
 500     count = poolsize/4;
 501     if( poolsize > 4 )
 502         codepage = pool[0] | ( (pool[1] & ~0x8000) << 16 );
 503     else
 504         codepage = CP_ACP;
 505     st = init_stringtable( count, codepage );
 506     if (!st)
 507         goto end;
 508
 509     offset = 0;
 510     n = 1;
 511     i = 1;
 512     while( i<count )
 513     {
 514         /* the string reference count is always the second word */
 515         refs = pool[i*2+1];
 516
 517         /* empty entries have two zeros, still have a string id */
 518         if (pool[i*2] == 0 && refs == 0)
 519         {
 520             i++;
 521             n++;
 522             continue;
 523         }
 524
 525         /*
 526          * If a string is over 64k, the previous string entry is made null
 527          * and its the high word of the length is inserted in the null string's
 528          * reference count field.
 529          */
 530         if( pool[i*2] == 0)
 531         {
 532             len = (pool[i*2+3] << 16) + pool[i*2+2];
 533             i += 2;
 534         }
 535         else
 536         {
 537             len = pool[i*2];
 538             i += 1;
 539         }
 540
 541         if ( (offset + len) > datasize )
 542         {
 543             ERR("string table corrupt?\n");
 544             break;
 545         }
 546
 547         r = add_string( st, n, data+offset, len, refs, TRUE );
 548         if( r != n )
 549             ERR("Failed to add string %d\n", n );
 550         n++;
 551         offset += len;
 552     }
 553
 554     if ( datasize != offset )
 555         ERR("string table load failed! (%08x != %08x), please report\n", datasize, offset );
 556
 557     TRACE("Loaded %d strings\n", count);
 558
 559 end:
 560     msi_free( pool );
 561     msi_free( data );
 562
 563     return st;
 564 }
 565
 566 UINT msi_save_string_table( const string_table *st, IStorage *storage, UINT *bytes_per_strref )
 567 {
 568     UINT i, datasize = 0, poolsize = 0, sz, used, r, codepage, n;
 569     UINT ret = ERROR_FUNCTION_FAILED;
 570     CHAR *data = NULL;
 571     USHORT *pool = NULL;
 572
 573     TRACE("\n");
 574
 575     /* construct the new table in memory first */
 576     string_totalsize( st, &datasize, &poolsize );
 577
 578     TRACE("%u %u %u\n", st->maxcount, datasize, poolsize );
 579
 580     pool = msi_alloc( poolsize );
 581     if( ! pool )
 582     {
 583         WARN("Failed to alloc pool %d bytes\n", poolsize );
 584         goto err;
 585     }
 586     data = msi_alloc( datasize );
 587     if( ! data )
 588     {
 589         WARN("Failed to alloc data %d bytes\n", datasize );
 590         goto err;
 591     }
 592
 593     used = 0;
 594     codepage = st->codepage;
 595     pool[0] = codepage & 0xffff;
 596     pool[1] = codepage >> 16;
 597     if (st->maxcount > 0xffff)
 598     {
 599         pool[1] |= 0x8000;
 600         *bytes_per_strref = LONG_STR_BYTES;
 601     }
 602     else
 603         *bytes_per_strref = sizeof(USHORT);
 604
 605     n = 1;
 606     for( i=1; i<st->maxcount; i++ )
 607     {
 608         if( !st->strings[i].persistent_refcount )
 609         {
 610             pool[ n*2 ] = 0;
 611             pool[ n*2 + 1] = 0;
 612             n++;
 613             continue;
 614         }
 615
 616         sz = datasize - used;
 617         r = id2string( st, i, data+used, &sz );
 618         if( r != ERROR_SUCCESS )
 619         {
 620             ERR("failed to fetch string\n");
 621             sz = 0;
 622         }
 623
 624         if (sz)
 625             pool[ n*2 + 1 ] = st->strings[i].persistent_refcount;
 626         else
 627             pool[ n*2 + 1 ] = 0;
 628         if (sz < 0x10000)
 629         {
 630             pool[ n*2 ] = sz;
 631             n++;
 632         }
 633         else
 634         {
 635             pool[ n*2 ] = 0;
 636             pool[ n*2 + 2 ] = sz&0xffff;
 637             pool[ n*2 + 3 ] = (sz>>16);
 638             n += 2;
 639         }
 640         used += sz;
 641         if( used > datasize  )
 642         {
 643             ERR("oops overran %d >= %d\n", used, datasize);
 644             goto err;
 645         }
 646     }
 647
 648     if( used != datasize )
 649     {
 650         ERR("oops used %d != datasize %d\n", used, datasize);
 651         goto err;
 652     }
 653
 654     /* write the streams */
 655     r = write_stream_data( storage, szStringData, data, datasize, TRUE );
 656     TRACE("Wrote StringData r=%08x\n", r);
 657     if( r )
 658         goto err;
 659     r = write_stream_data( storage, szStringPool, pool, poolsize, TRUE );
 660     TRACE("Wrote StringPool r=%08x\n", r);
 661     if( r )
 662         goto err;
 663
 664     ret = ERROR_SUCCESS;
 665
 666 err:
 667     msi_free( data );
 668     msi_free( pool );
 669
 670     return ret;
 671 }
 672
 673 UINT msi_get_string_table_codepage( const string_table *st )
 674 {
 675     return st->codepage;
 676 }
 677
 678 UINT msi_set_string_table_codepage( string_table *st, UINT codepage )
 679 {
 680     if (validate_codepage( codepage ))
 681     {
 682         st->codepage = codepage;
 683         return ERROR_SUCCESS;
 684     }
 685     return ERROR_FUNCTION_FAILED;
 686 }