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 "wine/unicode.h"
33 #include "msi.h"
34 #include "msiquery.h"
35 #include "objbase.h"
36 #include "objidl.h"
37 #include "msipriv.h"
38 #include "winnls.h"
39
40 #include "query.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(msidb);
43
44 typedef struct _msistring
45 {
46 USHORT persistent_refcount;
47 USHORT nonpersistent_refcount;
48 LPWSTR str;
49 } msistring;
50
51 struct string_table
52 {
53 UINT maxcount; /* the number of strings */
54 UINT freeslot;
55 UINT codepage;
56 UINT sortcount;
57 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 (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].str );
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 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(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 int find_insert_index( const string_table *st, UINT string_id )
166 {
167 int i, c, low = 0, high = st->sortcount - 1;
168
169 while (low <= high)
170 {
171 i = (low + high) / 2;
172 c = strcmpW( st->strings[string_id].str, st->strings[st->sorted[i]].str );
173
174 if (c < 0)
175 high = i - 1;
176 else if (c > 0)
177 low = i + 1;
178 else
179 return -1; /* already exists */
180 }
181 return high + 1;
182 }
183
184 static void insert_string_sorted( string_table *st, UINT string_id )
185 {
186 int i;
187
188 i = find_insert_index( st, string_id );
189 if (i == -1)
190 return;
191
192 memmove( &st->sorted[i] + 1, &st->sorted[i], (st->sortcount - i) * sizeof(UINT) );
193 st->sorted[i] = string_id;
194 st->sortcount++;
195 }
196
197 static void set_st_entry( string_table *st, UINT n, LPWSTR str, USHORT refcount, enum StringPersistence persistence )
198 {
199 if (persistence == StringPersistent)
200 {
201 st->strings[n].persistent_refcount = refcount;
202 st->strings[n].nonpersistent_refcount = 0;
203 }
204 else
205 {
206 st->strings[n].persistent_refcount = 0;
207 st->strings[n].nonpersistent_refcount = refcount;
208 }
209
210 st->strings[n].str = str;
211
212 insert_string_sorted( st, n );
213
214 if( n < st->maxcount )
215 st->freeslot = n + 1;
216 }
217
218 static UINT msi_string2idA( const string_table *st, LPCSTR buffer, UINT *id )
219 {
220 DWORD sz;
221 UINT r = ERROR_INVALID_PARAMETER;
222 LPWSTR str;
223
224 TRACE("Finding string %s in string table\n", debugstr_a(buffer) );
225
226 if( buffer[0] == 0 )
227 {
228 *id = 0;
229 return ERROR_SUCCESS;
230 }
231
232 sz = MultiByteToWideChar( st->codepage, 0, buffer, -1, NULL, 0 );
233 if( sz <= 0 )
234 return r;
235 str = msi_alloc( sz*sizeof(WCHAR) );
236 if( !str )
237 return ERROR_NOT_ENOUGH_MEMORY;
238 MultiByteToWideChar( st->codepage, 0, buffer, -1, str, sz );
239
240 r = msi_string2idW( st, str, id );
241 msi_free( str );
242
243 return r;
244 }
245
246 static int msi_addstring( string_table *st, UINT n, const CHAR *data, int len, USHORT refcount, enum StringPersistence persistence )
247 {
248 LPWSTR str;
249 int sz;
250
251 if( !data )
252 return 0;
253 if( !data[0] )
254 return 0;
255 if( n > 0 )
256 {
257 if( st->strings[n].persistent_refcount ||
258 st->strings[n].nonpersistent_refcount )
259 return -1;
260 }
261 else
262 {
263 if( ERROR_SUCCESS == msi_string2idA( st, data, &n ) )
264 {
265 if (persistence == StringPersistent)
266 st->strings[n].persistent_refcount += refcount;
267 else
268 st->strings[n].nonpersistent_refcount += refcount;
269 return n;
270 }
271 n = st_find_free_entry( st );
272 if( n == -1 )
273 return -1;
274 }
275
276 if( n < 1 )
277 {
278 ERR("invalid index adding %s (%d)\n", debugstr_a( data ), n );
279 return -1;
280 }
281
282 /* allocate a new string */
283 if( len < 0 )
284 len = strlen(data);
285 sz = MultiByteToWideChar( st->codepage, 0, data, len, NULL, 0 );
286 str = msi_alloc( (sz+1)*sizeof(WCHAR) );
287 if( !str )
288 return -1;
289 MultiByteToWideChar( st->codepage, 0, data, len, str, sz );
290 str[sz] = 0;
291
292 set_st_entry( st, n, str, refcount, persistence );
293
294 return n;
295 }
296
297 int msi_addstringW( string_table *st, const WCHAR *data, int len, USHORT refcount, enum StringPersistence persistence )
298 {
299 UINT n;
300 LPWSTR str;
301
302 if( !data )
303 return 0;
304 if( !data[0] )
305 return 0;
306
307 if( msi_string2idW( st, data, &n ) == ERROR_SUCCESS )
308 {
309 if (persistence == StringPersistent)
310 st->strings[n].persistent_refcount += refcount;
311 else
312 st->strings[n].nonpersistent_refcount += refcount;
313 return n;
314 }
315
316 n = st_find_free_entry( st );
317 if( n == -1 )
318 return -1;
319
320 /* allocate a new string */
321 if(len<0)
322 len = strlenW(data);
323 TRACE("%s, n = %d len = %d\n", debugstr_w(data), n, len );
324
325 str = msi_alloc( (len+1)*sizeof(WCHAR) );
326 if( !str )
327 return -1;
328 memcpy( str, data, len*sizeof(WCHAR) );
329 str[len] = 0;
330
331 set_st_entry( st, n, str, refcount, persistence );
332
333 return n;
334 }
335
336 /* find the string identified by an id - return null if there's none */
337 const WCHAR *msi_string_lookup_id( const string_table *st, UINT id )
338 {
339 if( id == 0 )
340 return szEmpty;
341
342 if( id >= st->maxcount )
343 return NULL;
344
345 if( id && !st->strings[id].persistent_refcount && !st->strings[id].nonpersistent_refcount)
346 return NULL;
347
348 return st->strings[id].str;
349 }
350
351 /*
352 * msi_id2stringA
353 *
354 * [in] st - pointer to the string table
355 * [in] id - id of the string to retrieve
356 * [out] buffer - destination of the UTF8 string
357 * [in/out] sz - number of bytes available in the buffer on input
358 * number of bytes used on output
359 *
360 * The size includes the terminating nul character. Short buffers
361 * will be filled, but not nul terminated.
362 */
363 static UINT msi_id2stringA( const string_table *st, UINT id, LPSTR buffer, UINT *sz )
364 {
365 UINT len;
366 const WCHAR *str;
367 int n;
368
369 TRACE("Finding string %d of %d\n", id, st->maxcount);
370
371 str = msi_string_lookup_id( st, id );
372 if( !str )
373 return ERROR_FUNCTION_FAILED;
374
375 len = WideCharToMultiByte( st->codepage, 0, str, -1, NULL, 0, NULL, NULL );
376
377 if( !buffer )
378 {
379 *sz = len;
380 return ERROR_SUCCESS;
381 }
382
383 if( len > *sz )
384 {
385 n = strlenW( str ) + 1;
386 while( n && (len > *sz) )
387 len = WideCharToMultiByte( st->codepage, 0,
388 str, --n, NULL, 0, NULL, NULL );
389 }
390 else
391 n = -1;
392
393 *sz = WideCharToMultiByte( st->codepage, 0, str, n, buffer, len, NULL, NULL );
394
395 return ERROR_SUCCESS;
396 }
397
398 /*
399 * msi_string2idW
400 *
401 * [in] st - pointer to the string table
402 * [in] str - string to find in the string table
403 * [out] id - id of the string, if found
404 */
405 UINT msi_string2idW( const string_table *st, LPCWSTR str, UINT *id )
406 {
407 int i, c, low = 0, high = st->sortcount - 1;
408
409 while (low <= high)
410 {
411 i = (low + high) / 2;
412 c = strcmpW( str, st->strings[st->sorted[i]].str );
413
414 if (c < 0)
415 high = i - 1;
416 else if (c > 0)
417 low = i + 1;
418 else
419 {
420 *id = st->sorted[i];
421 return ERROR_SUCCESS;
422 }
423 }
424
425 return ERROR_INVALID_PARAMETER;
426 }
427
428 static void string_totalsize( const string_table *st, UINT *datasize, UINT *poolsize )
429 {
430 UINT i, len, holesize;
431
432 if( st->strings[0].str || st->strings[0].persistent_refcount || st->strings[0].nonpersistent_refcount)
433 ERR("oops. element 0 has a string\n");
434
435 *poolsize = 4;
436 *datasize = 0;
437 holesize = 0;
438 for( i=1; i<st->maxcount; i++ )
439 {
440 if( !st->strings[i].persistent_refcount )
441 {
442 TRACE("[%u] nonpersistent = %s\n", i, debugstr_w(st->strings[i].str));
443 (*poolsize) += 4;
444 }
445 else if( st->strings[i].str )
446 {
447 TRACE("[%u] = %s\n", i, debugstr_w(st->strings[i].str));
448 len = WideCharToMultiByte( st->codepage, 0,
449 st->strings[i].str, -1, NULL, 0, NULL, NULL);
450 if( len )
451 len--;
452 (*datasize) += len;
453 if (len>0xffff)
454 (*poolsize) += 4;
455 (*poolsize) += holesize + 4;
456 holesize = 0;
457 }
458 else
459 holesize += 4;
460 }
461 TRACE("data %u pool %u codepage %x\n", *datasize, *poolsize, st->codepage );
462 }
463
464 HRESULT msi_init_string_table( IStorage *stg )
465 {
466 USHORT zero[2] = { 0, 0 };
467 UINT ret;
468
469 /* create the StringPool stream... add the zero string to it*/
470 ret = write_stream_data(stg, szStringPool, zero, sizeof zero, TRUE);
471 if (ret != ERROR_SUCCESS)
472 return E_FAIL;
473
474 /* create the StringData stream... make it zero length */
475 ret = write_stream_data(stg, szStringData, NULL, 0, TRUE);
476 if (ret != ERROR_SUCCESS)
477 return E_FAIL;
478
479 return S_OK;
480 }
481
482 string_table *msi_load_string_table( IStorage *stg, UINT *bytes_per_strref )
483 {
484 string_table *st = NULL;
485 CHAR *data = NULL;
486 USHORT *pool = NULL;
487 UINT r, datasize = 0, poolsize = 0, codepage;
488 DWORD i, count, offset, len, n, refs;
489
490 r = read_stream_data( stg, szStringPool, TRUE, (BYTE **)&pool, &poolsize );
491 if( r != ERROR_SUCCESS)
492 goto end;
493 r = read_stream_data( stg, szStringData, TRUE, (BYTE **)&data, &datasize );
494 if( r != ERROR_SUCCESS)
495 goto end;
496
497 if ( (poolsize > 4) && (pool[1] & 0x8000) )
498 *bytes_per_strref = LONG_STR_BYTES;
499 else
500 *bytes_per_strref = sizeof(USHORT);
501
502 count = poolsize/4;
503 if( poolsize > 4 )
504 codepage = pool[0] | ( (pool[1] & ~0x8000) << 16 );
505 else
506 codepage = CP_ACP;
507 st = init_stringtable( count, codepage );
508 if (!st)
509 goto end;
510
511 offset = 0;
512 n = 1;
513 i = 1;
514 while( i<count )
515 {
516 /* the string reference count is always the second word */
517 refs = pool[i*2+1];
518
519 /* empty entries have two zeros, still have a string id */
520 if (pool[i*2] == 0 && refs == 0)
521 {
522 i++;
523 n++;
524 continue;
525 }
526
527 /*
528 * If a string is over 64k, the previous string entry is made null
529 * and its the high word of the length is inserted in the null string's
530 * reference count field.
531 */
532 if( pool[i*2] == 0)
533 {
534 len = (pool[i*2+3] << 16) + pool[i*2+2];
535 i += 2;
536 }
537 else
538 {
539 len = pool[i*2];
540 i += 1;
541 }
542
543 if ( (offset + len) > datasize )
544 {
545 ERR("string table corrupt?\n");
546 break;
547 }
548
549 r = msi_addstring( st, n, data+offset, len, refs, StringPersistent );
550 if( r != n )
551 ERR("Failed to add string %d\n", n );
552 n++;
553 offset += len;
554 }
555
556 if ( datasize != offset )
557 ERR("string table load failed! (%08x != %08x), please report\n", datasize, offset );
558
559 TRACE("Loaded %d strings\n", count);
560
561 end:
562 msi_free( pool );
563 msi_free( data );
564
565 return st;
566 }
567
568 UINT msi_save_string_table( const string_table *st, IStorage *storage, UINT *bytes_per_strref )
569 {
570 UINT i, datasize = 0, poolsize = 0, sz, used, r, codepage, n;
571 UINT ret = ERROR_FUNCTION_FAILED;
572 CHAR *data = NULL;
573 USHORT *pool = NULL;
574
575 TRACE("\n");
576
577 /* construct the new table in memory first */
578 string_totalsize( st, &datasize, &poolsize );
579
580 TRACE("%u %u %u\n", st->maxcount, datasize, poolsize );
581
582 pool = msi_alloc( poolsize );
583 if( ! pool )
584 {
585 WARN("Failed to alloc pool %d bytes\n", poolsize );
586 goto err;
587 }
588 data = msi_alloc( datasize );
589 if( ! data )
590 {
591 WARN("Failed to alloc data %d bytes\n", poolsize );
592 goto err;
593 }
594
595 used = 0;
596 codepage = st->codepage;
597 pool[0] = codepage & 0xffff;
598 pool[1] = codepage >> 16;
599 if (st->maxcount > 0xffff)
600 {
601 pool[1] |= 0x8000;
602 *bytes_per_strref = LONG_STR_BYTES;
603 }
604 else
605 *bytes_per_strref = sizeof(USHORT);
606
607 n = 1;
608 for( i=1; i<st->maxcount; i++ )
609 {
610 if( !st->strings[i].persistent_refcount )
611 {
612 pool[ n*2 ] = 0;
613 pool[ n*2 + 1] = 0;
614 n++;
615 continue;
616 }
617
618 sz = datasize - used;
619 r = msi_id2stringA( st, i, data+used, &sz );
620 if( r != ERROR_SUCCESS )
621 {
622 ERR("failed to fetch string\n");
623 sz = 0;
624 }
625 if( sz && (sz < (datasize - used ) ) )
626 sz--;
627
628 if (sz)
629 pool[ n*2 + 1 ] = st->strings[i].persistent_refcount;
630 else
631 pool[ n*2 + 1 ] = 0;
632 if (sz < 0x10000)
633 {
634 pool[ n*2 ] = sz;
635 n++;
636 }
637 else
638 {
639 pool[ n*2 ] = 0;
640 pool[ n*2 + 2 ] = sz&0xffff;
641 pool[ n*2 + 3 ] = (sz>>16);
642 n += 2;
643 }
644 used += sz;
645 if( used > datasize )
646 {
647 ERR("oops overran %d >= %d\n", used, datasize);
648 goto err;
649 }
650 }
651
652 if( used != datasize )
653 {
654 ERR("oops used %d != datasize %d\n", used, datasize);
655 goto err;
656 }
657
658 /* write the streams */
659 r = write_stream_data( storage, szStringData, data, datasize, TRUE );
660 TRACE("Wrote StringData r=%08x\n", r);
661 if( r )
662 goto err;
663 r = write_stream_data( storage, szStringPool, pool, poolsize, TRUE );
664 TRACE("Wrote StringPool r=%08x\n", r);
665 if( r )
666 goto err;
667
668 ret = ERROR_SUCCESS;
669
670 err:
671 msi_free( data );
672 msi_free( pool );
673
674 return ret;
675 }
676
677 UINT msi_get_string_table_codepage( const string_table *st )
678 {
679 return st->codepage;
680 }
681
682 UINT msi_set_string_table_codepage( string_table *st, UINT codepage )
683 {
684 if (validate_codepage( codepage ))
685 {
686 st->codepage = codepage;
687 return ERROR_SUCCESS;
688 }
689 return ERROR_FUNCTION_FAILED;
690 }
691
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.