dlls/msi/format.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2005 Mike McCormack for CodeWeavers
   5  * Copyright 2005 Aric Stewart for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24
  25 #define COBJMACROS
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winerror.h"
  30 #include "wine/debug.h"
  31 #include "msi.h"
  32 #include "winnls.h"
  33 #include "objbase.h"
  34 #include "oleauto.h"
  35
  36 #include "msipriv.h"
  37 #include "msiserver.h"
  38 #include "wine/unicode.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  41
  42 /* types arranged by precedence */
  43 #define FORMAT_NULL         0x0001
  44 #define FORMAT_LITERAL      0x0002
  45 #define FORMAT_NUMBER       0x0004
  46 #define FORMAT_LBRACK       0x0010
  47 #define FORMAT_LBRACE       0x0020
  48 #define FORMAT_RBRACK       0x0011
  49 #define FORMAT_RBRACE       0x0021
  50 #define FORMAT_ESCAPE       0x0040
  51 #define FORMAT_PROPNULL     0x0080
  52 #define FORMAT_ERROR        0x1000
  53 #define FORMAT_FAIL         0x2000
  54
  55 #define left_type(x) (x & 0xF0)
  56
  57 typedef struct _tagFORMAT
  58 {
  59     MSIPACKAGE *package;
  60     MSIRECORD *record;
  61     LPWSTR deformatted;
  62     int len;
  63     int n;
  64     BOOL propfailed;
  65     BOOL groupfailed;
  66     int groups;
  67 } FORMAT;
  68
  69 typedef struct _tagFORMSTR
  70 {
  71     struct list entry;
  72     int n;
  73     int len;
  74     int type;
  75     BOOL propfound;
  76     BOOL nonprop;
  77 } FORMSTR;
  78
  79 typedef struct _tagSTACK
  80 {
  81     struct list items;
  82 } STACK;
  83
  84 static STACK *create_stack(void)
  85 {
  86     STACK *stack = msi_alloc(sizeof(STACK));
  87     list_init(&stack->items);
  88     return stack;
  89 }
  90
  91 static void free_stack(STACK *stack)
  92 {
  93     while (!list_empty(&stack->items))
  94     {
  95         FORMSTR *str = LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
  96         list_remove(&str->entry);
  97         msi_free(str);
  98     }
  99
 100     msi_free(stack);
 101 }
 102
 103 static void stack_push(STACK *stack, FORMSTR *str)
 104 {
 105     list_add_head(&stack->items, &str->entry);
 106 }
 107
 108 static FORMSTR *stack_pop(STACK *stack)
 109 {
 110     FORMSTR *ret;
 111
 112     if (list_empty(&stack->items))
 113         return NULL;
 114
 115     ret = LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
 116     list_remove(&ret->entry);
 117     return ret;
 118 }
 119
 120 static FORMSTR *stack_find(STACK *stack, int type)
 121 {
 122     FORMSTR *str;
 123
 124     LIST_FOR_EACH_ENTRY(str, &stack->items, FORMSTR, entry)
 125     {
 126         if (str->type == type)
 127             return str;
 128     }
 129
 130     return NULL;
 131 }
 132
 133 static FORMSTR *stack_peek(STACK *stack)
 134 {
 135     return LIST_ENTRY(list_head(&stack->items), FORMSTR, entry);
 136 }
 137
 138 static LPCWSTR get_formstr_data(FORMAT *format, FORMSTR *str)
 139 {
 140     return &format->deformatted[str->n];
 141 }
 142
 143 static WCHAR *dup_formstr( FORMAT *format, FORMSTR *str, int *ret_len )
 144 {
 145     WCHAR *val;
 146
 147     if (!str->len) return NULL;
 148     if ((val = msi_alloc( (str->len + 1) * sizeof(WCHAR) )))
 149     {
 150         memcpy( val, get_formstr_data(format, str), str->len * sizeof(WCHAR) );
 151         val[str->len] = 0;
 152         *ret_len = str->len;
 153     }
 154     return val;
 155 }
 156
 157 static WCHAR *deformat_index( FORMAT *format, FORMSTR *str, int *ret_len )
 158 {
 159     WCHAR *val, *ret;
 160     DWORD len;
 161     int field;
 162
 163     if (!(val = msi_alloc( (str->len + 1) * sizeof(WCHAR) ))) return NULL;
 164     lstrcpynW(val, get_formstr_data(format, str), str->len + 1);
 165     field = atoiW( val );
 166     msi_free( val );
 167
 168     if (MSI_RecordIsNull( format->record, field ) ||
 169         MSI_RecordGetStringW( format->record, field, NULL, &len )) return NULL;
 170
 171     len++;
 172     if (!(ret = msi_alloc( len * sizeof(WCHAR) ))) return NULL;
 173     ret[0] = 0;
 174     if (MSI_RecordGetStringW( format->record, field, ret, &len ))
 175     {
 176         msi_free( ret );
 177         return NULL;
 178     }
 179     *ret_len = len;
 180     return ret;
 181 }
 182
 183 static WCHAR *deformat_property( FORMAT *format, FORMSTR *str, int *ret_len )
 184 {
 185     WCHAR *prop, *ret;
 186     DWORD len = 0;
 187     UINT r;
 188
 189     if (!(prop = msi_alloc( (str->len + 1) * sizeof(WCHAR) ))) return NULL;
 190     lstrcpynW( prop, get_formstr_data(format, str), str->len + 1 );
 191
 192     r = msi_get_property( format->package->db, prop, NULL, &len );
 193     if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
 194     {
 195         msi_free( prop );
 196         return NULL;
 197     }
 198     len++;
 199     if ((ret = msi_alloc( len * sizeof(WCHAR) )))
 200         msi_get_property( format->package->db, prop, ret, &len );
 201     msi_free( prop );
 202     *ret_len = len;
 203     return ret;
 204 }
 205
 206 static WCHAR *deformat_component( FORMAT *format, FORMSTR *str, int *ret_len )
 207 {
 208     WCHAR *key, *ret;
 209     MSICOMPONENT *comp;
 210
 211     if (!(key = msi_alloc( (str->len + 1) * sizeof(WCHAR) ))) return NULL;
 212     lstrcpynW(key, get_formstr_data(format, str), str->len + 1);
 213
 214     if (!(comp = msi_get_loaded_component( format->package, key )))
 215     {
 216         msi_free( key );
 217         return NULL;
 218     }
 219     if (comp->Action == INSTALLSTATE_SOURCE)
 220         ret = msi_resolve_source_folder( format->package, comp->Directory, NULL );
 221     else
 222         ret = strdupW( msi_get_target_folder( format->package, comp->Directory ) );
 223
 224     if (ret) *ret_len = strlenW( ret );
 225     else *ret_len = 0;
 226     msi_free( key );
 227     return ret;
 228 }
 229
 230 static WCHAR *deformat_file( FORMAT *format, FORMSTR *str, BOOL shortname, int *ret_len )
 231 {
 232     WCHAR *key, *ret = NULL;
 233     const MSIFILE *file;
 234     DWORD len = 0;
 235
 236     if (!(key = msi_alloc( (str->len + 1) * sizeof(WCHAR) ))) return NULL;
 237     lstrcpynW(key, get_formstr_data(format, str), str->len + 1);
 238
 239     if (!(file = msi_get_loaded_file( format->package, key ))) goto done;
 240     if (!shortname)
 241     {
 242         if ((ret = strdupW( file->TargetPath ))) len = strlenW( ret );
 243         goto done;
 244     }
 245     if ((len = GetShortPathNameW(file->TargetPath, NULL, 0)) <= 0)
 246     {
 247         if ((ret = strdupW( file->TargetPath ))) len = strlenW( ret );
 248         goto done;
 249     }
 250     len++;
 251     if ((ret = msi_alloc( len * sizeof(WCHAR) )))
 252         len = GetShortPathNameW( file->TargetPath, ret, len );
 253
 254 done:
 255     msi_free( key );
 256     *ret_len = len;
 257     return ret;
 258 }
 259
 260 static WCHAR *deformat_environment( FORMAT *format, FORMSTR *str, int *ret_len )
 261 {
 262     WCHAR *key, *ret = NULL;
 263     DWORD len;
 264
 265     if (!(key = msi_alloc((str->len + 1) * sizeof(WCHAR)))) return NULL;
 266     lstrcpynW(key, get_formstr_data(format, str), str->len + 1);
 267
 268     if ((len = GetEnvironmentVariableW( key, NULL, 0 )))
 269     {
 270         len++;
 271         if ((ret = msi_alloc( len * sizeof(WCHAR) )))
 272             *ret_len = GetEnvironmentVariableW( key, ret, len );
 273     }
 274     msi_free( key );
 275     return ret;
 276 }
 277
 278 static WCHAR *deformat_literal( FORMAT *format, FORMSTR *str, BOOL *propfound,
 279                                 BOOL *nonprop, int *type, int *len )
 280 {
 281     LPCWSTR data = get_formstr_data(format, str);
 282     WCHAR *replaced = NULL;
 283     char ch = data[0];
 284
 285     if (ch == '\\')
 286     {
 287         str->n++;
 288         if (str->len == 1)
 289         {
 290             str->len = 0;
 291             replaced = NULL;
 292         }
 293         else
 294         {
 295             str->len = 1;
 296             replaced = dup_formstr( format, str, len );
 297         }
 298     }
 299     else if (ch == '~')
 300     {
 301         if (str->len != 1)
 302             replaced = NULL;
 303         else if ((replaced = msi_alloc( sizeof(WCHAR) )))
 304         {
 305             *replaced = 0;
 306             *len = 0;
 307         }
 308     }
 309     else if (ch == '%' || ch == '#' || ch == '!' || ch == '$')
 310     {
 311         str->n++;
 312         str->len--;
 313
 314         switch (ch)
 315         {
 316         case '%':
 317             replaced = deformat_environment( format, str, len ); break;
 318         case '#':
 319             replaced = deformat_file( format, str, FALSE, len ); break;
 320         case '!':
 321             replaced = deformat_file( format, str, TRUE, len ); break;
 322         case '$':
 323             replaced = deformat_component( format, str, len ); break;
 324         }
 325
 326         *type = FORMAT_LITERAL;
 327     }
 328     else
 329     {
 330         replaced = deformat_property( format, str, len );
 331         *type = FORMAT_LITERAL;
 332
 333         if (replaced)
 334             *propfound = TRUE;
 335         else
 336             format->propfailed = TRUE;
 337     }
 338
 339     return replaced;
 340 }
 341
 342 static LPWSTR build_default_format(const MSIRECORD* record)
 343 {
 344     int i;
 345     int count;
 346     LPWSTR rc, buf;
 347     static const WCHAR fmt[] = {'%','i',':',' ','%','s',' ',0};
 348     static const WCHAR fmt_null[] = {'%','i',':',' ',' ',0};
 349     static const WCHAR fmt_index[] = {'%','i',0};
 350     LPCWSTR str;
 351     WCHAR index[10];
 352     DWORD size, max_len, len;
 353
 354     count = MSI_RecordGetFieldCount(record);
 355
 356     max_len = MAX_PATH;
 357     buf = msi_alloc((max_len + 1) * sizeof(WCHAR));
 358
 359     rc = NULL;
 360     size = 1;
 361     for (i = 1; i <= count; i++)
 362     {
 363         sprintfW(index, fmt_index, i);
 364         str = MSI_RecordGetString(record, i);
 365         len = (str) ? lstrlenW(str) : 0;
 366         len += (sizeof(fmt_null)/sizeof(fmt_null[0]) - 3) + lstrlenW(index);
 367         size += len;
 368
 369         if (len > max_len)
 370         {
 371             max_len = len;
 372             buf = msi_realloc(buf, (max_len + 1) * sizeof(WCHAR));
 373             if (!buf)
 374             {
 375                 msi_free(rc);
 376                 return NULL;
 377             }
 378         }
 379
 380         if (str)
 381             sprintfW(buf, fmt, i, str);
 382         else
 383             sprintfW(buf, fmt_null, i);
 384
 385         if (!rc)
 386         {
 387             rc = msi_alloc(size * sizeof(WCHAR));
 388             lstrcpyW(rc, buf);
 389         }
 390         else
 391         {
 392             rc = msi_realloc(rc, size * sizeof(WCHAR));
 393             lstrcatW(rc, buf);
 394         }
 395     }
 396
 397     msi_free(buf);
 398     return rc;
 399 }
 400
 401 static BOOL format_is_number(WCHAR x)
 402 {
 403     return ((x >= '0') && (x <= '9'));
 404 }
 405
 406 static BOOL format_str_is_number(LPWSTR str)
 407 {
 408     LPWSTR ptr;
 409
 410     for (ptr = str; *ptr; ptr++)
 411         if (!format_is_number(*ptr))
 412             return FALSE;
 413
 414     return TRUE;
 415 }
 416
 417 static BOOL format_is_alpha(WCHAR x)
 418 {
 419     return (!format_is_number(x) && x != '\0' &&
 420             x != '[' && x != ']' && x != '{' && x != '}');
 421 }
 422
 423 static BOOL format_is_literal(WCHAR x)
 424 {
 425     return (format_is_alpha(x) || format_is_number(x));
 426 }
 427
 428 static int format_lex(FORMAT *format, FORMSTR **out)
 429 {
 430     int type, len = 1;
 431     FORMSTR *str;
 432     LPCWSTR data;
 433     WCHAR ch;
 434
 435     *out = NULL;
 436
 437     if (!format->deformatted)
 438         return FORMAT_NULL;
 439
 440     *out = msi_alloc_zero(sizeof(FORMSTR));
 441     if (!*out)
 442         return FORMAT_FAIL;
 443
 444     str = *out;
 445     str->n = format->n;
 446     str->len = 1;
 447     data = get_formstr_data(format, str);
 448
 449     ch = data[0];
 450     switch (ch)
 451     {
 452         case '{': type = FORMAT_LBRACE; break;
 453         case '}': type = FORMAT_RBRACE; break;
 454         case '[': type = FORMAT_LBRACK; break;
 455         case ']': type = FORMAT_RBRACK; break;
 456         case '~': type = FORMAT_PROPNULL; break;
 457         case '\0': type = FORMAT_NULL; break;
 458
 459         default:
 460             type = 0;
 461     }
 462
 463     if (type)
 464     {
 465         str->type = type;
 466         format->n++;
 467         return type;
 468     }
 469
 470     if (ch == '\\')
 471     {
 472         while (data[len] && data[len] != ']')
 473             len++;
 474
 475         type = FORMAT_ESCAPE;
 476     }
 477     else if (format_is_alpha(ch))
 478     {
 479         while (format_is_literal(data[len]))
 480             len++;
 481
 482         type = FORMAT_LITERAL;
 483     }
 484     else if (format_is_number(ch))
 485     {
 486         while (format_is_number(data[len]))
 487             len++;
 488
 489         type = FORMAT_NUMBER;
 490
 491         if (data[len] != ']')
 492         {
 493             while (format_is_literal(data[len]))
 494                 len++;
 495
 496             type = FORMAT_LITERAL;
 497         }
 498     }
 499     else
 500     {
 501         ERR("Got unknown character %c(%x)\n", ch, ch);
 502         return FORMAT_ERROR;
 503     }
 504
 505     format->n += len;
 506     str->len = len;
 507     str->type = type;
 508
 509     return type;
 510 }
 511
 512 static FORMSTR *format_replace( FORMAT *format, BOOL propfound, BOOL nonprop,
 513                                 int oldsize, int type, WCHAR *replace, int len )
 514 {
 515     FORMSTR *ret;
 516     LPWSTR str, ptr;
 517     DWORD size = 0;
 518     int n;
 519
 520     if (replace)
 521     {
 522         if (!len)
 523             size = 1;
 524         else
 525             size = len;
 526     }
 527
 528     size -= oldsize;
 529     size = format->len + size + 1;
 530
 531     if (size <= 1)
 532     {
 533         msi_free(format->deformatted);
 534         format->deformatted = NULL;
 535         format->len = 0;
 536         return NULL;
 537     }
 538
 539     str = msi_alloc(size * sizeof(WCHAR));
 540     if (!str)
 541         return NULL;
 542
 543     str[0] = '\0';
 544     memcpy(str, format->deformatted, format->n * sizeof(WCHAR));
 545     n = format->n;
 546
 547     if (replace)
 548     {
 549         if (!len) str[n++] = 0;
 550         else
 551         {
 552             memcpy( str + n, replace, len * sizeof(WCHAR) );
 553             n += len;
 554             str[n] = 0;
 555         }
 556     }
 557
 558     ptr = &format->deformatted[format->n + oldsize];
 559     memcpy(&str[n], ptr, (lstrlenW(ptr) + 1) * sizeof(WCHAR));
 560
 561     msi_free(format->deformatted);
 562     format->deformatted = str;
 563     format->len = size - 1;
 564
 565     /* don't reformat the NULL */
 566     if (replace && !len)
 567         format->n++;
 568
 569     if (!replace)
 570         return NULL;
 571
 572     ret = msi_alloc_zero(sizeof(FORMSTR));
 573     if (!ret)
 574         return NULL;
 575
 576     ret->len = len;
 577     ret->type = type;
 578     ret->n = format->n;
 579     ret->propfound = propfound;
 580     ret->nonprop = nonprop;
 581
 582     return ret;
 583 }
 584
 585 static WCHAR *replace_stack_group( FORMAT *format, STACK *values,
 586                                    BOOL *propfound, BOOL *nonprop,
 587                                    int *oldsize, int *type, int *len )
 588 {
 589     WCHAR *replaced;
 590     FORMSTR *content, *node;
 591     int n;
 592
 593     *nonprop = FALSE;
 594     *propfound = FALSE;
 595
 596     node = stack_pop(values);
 597     n = node->n;
 598     *oldsize = node->len;
 599     msi_free(node);
 600
 601     while ((node = stack_pop(values)))
 602     {
 603         *oldsize += node->len;
 604
 605         if (node->nonprop)
 606             *nonprop = TRUE;
 607
 608         if (node->propfound)
 609             *propfound = TRUE;
 610
 611         msi_free(node);
 612     }
 613
 614     content = msi_alloc_zero(sizeof(FORMSTR));
 615     content->n = n;
 616     content->len = *oldsize;
 617     content->type = FORMAT_LITERAL;
 618
 619     if (!format->groupfailed && (*oldsize == 2 ||
 620         (format->propfailed && !*nonprop)))
 621     {
 622         msi_free(content);
 623         return NULL;
 624     }
 625     else if (format->deformatted[content->n + 1] == '{' &&
 626              format->deformatted[content->n + content->len - 2] == '}')
 627     {
 628         format->groupfailed = FALSE;
 629         content->len = 0;
 630     }
 631     else if (*propfound && !*nonprop &&
 632              !format->groupfailed && format->groups == 0)
 633     {
 634         content->n++;
 635         content->len -= 2;
 636     }
 637     else
 638     {
 639         if (format->groups != 0)
 640             format->groupfailed = TRUE;
 641
 642         *nonprop = TRUE;
 643     }
 644
 645     replaced = dup_formstr( format, content, len );
 646     *type = content->type;
 647     msi_free(content);
 648
 649     if (format->groups == 0)
 650         format->propfailed = FALSE;
 651
 652     return replaced;
 653 }
 654
 655 static WCHAR *replace_stack_prop( FORMAT *format, STACK *values,
 656                                   BOOL *propfound, BOOL *nonprop,
 657                                   int *oldsize, int *type, int *len )
 658 {
 659     WCHAR *replaced;
 660     FORMSTR *content, *node;
 661     int n;
 662
 663     *propfound = FALSE;
 664     *nonprop = FALSE;
 665
 666     node = stack_pop(values);
 667     n = node->n;
 668     *oldsize = node->len;
 669     *type = stack_peek(values)->type;
 670     msi_free(node);
 671
 672     while ((node = stack_pop(values)))
 673     {
 674         *oldsize += node->len;
 675
 676         if (*type != FORMAT_ESCAPE &&
 677             stack_peek(values) && node->type != *type)
 678             *type = FORMAT_LITERAL;
 679
 680         msi_free(node);
 681     }
 682
 683     content = msi_alloc_zero(sizeof(FORMSTR));
 684     content->n = n + 1;
 685     content->len = *oldsize - 2;
 686     content->type = *type;
 687
 688     if (*type == FORMAT_NUMBER)
 689     {
 690         replaced = deformat_index( format, content, len );
 691         if (replaced)
 692             *propfound = TRUE;
 693         else
 694             format->propfailed = TRUE;
 695
 696         if (replaced)
 697             *type = format_str_is_number(replaced) ?
 698                 FORMAT_NUMBER : FORMAT_LITERAL;
 699     }
 700     else if (format->package)
 701     {
 702         replaced = deformat_literal( format, content, propfound, nonprop, type, len );
 703     }
 704     else
 705     {
 706         *nonprop = TRUE;
 707         content->n--;
 708         content->len += 2;
 709         replaced = dup_formstr( format, content, len );
 710     }
 711     msi_free(content);
 712     return replaced;
 713 }
 714
 715 static UINT replace_stack(FORMAT *format, STACK *stack, STACK *values)
 716 {
 717     WCHAR *replaced = NULL;
 718     FORMSTR *beg, *top, *node;
 719     BOOL propfound = FALSE, nonprop = FALSE, group = FALSE;
 720     int type, n, len = 0, oldsize = 0;
 721
 722     node = stack_peek(values);
 723     type = node->type;
 724     n = node->n;
 725
 726     if (type == FORMAT_LBRACK)
 727         replaced = replace_stack_prop( format, values, &propfound,
 728                                        &nonprop, &oldsize, &type, &len );
 729     else if (type == FORMAT_LBRACE)
 730     {
 731         replaced = replace_stack_group( format, values, &propfound,
 732                                         &nonprop, &oldsize, &type, &len );
 733         group = TRUE;
 734     }
 735
 736     format->n = n;
 737     beg = format_replace( format, propfound, nonprop, oldsize, type, replaced, len );
 738     msi_free(replaced);
 739     if (!beg)
 740         return ERROR_SUCCESS;
 741
 742     format->n = beg->n + beg->len;
 743
 744     top = stack_peek(stack);
 745     if (top)
 746     {
 747         type = top->type;
 748
 749         if ((type == FORMAT_LITERAL || type == FORMAT_NUMBER) &&
 750             type == beg->type)
 751         {
 752             top->len += beg->len;
 753
 754             if (group)
 755                 top->nonprop = FALSE;
 756
 757             if (type == FORMAT_LITERAL)
 758                 top->nonprop = beg->nonprop;
 759
 760             if (beg->propfound)
 761                 top->propfound = TRUE;
 762
 763             msi_free(beg);
 764             return ERROR_SUCCESS;
 765         }
 766     }
 767
 768     stack_push(stack, beg);
 769     return ERROR_SUCCESS;
 770 }
 771
 772 static BOOL verify_format(LPWSTR data)
 773 {
 774     int count = 0;
 775
 776     while (*data)
 777     {
 778         if (*data == '[' && *(data - 1) != '\\')
 779             count++;
 780         else if (*data == ']')
 781             count--;
 782
 783         data++;
 784     }
 785
 786     if (count > 0)
 787         return FALSE;
 788
 789     return TRUE;
 790 }
 791
 792 static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
 793                                       WCHAR** data, DWORD *len,
 794                                       MSIRECORD* record, INT* failcount)
 795 {
 796     FORMAT format;
 797     FORMSTR *str = NULL;
 798     STACK *stack, *temp;
 799     FORMSTR *node;
 800     int type;
 801
 802     if (!ptr)
 803     {
 804         *data = NULL;
 805         *len = 0;
 806         return ERROR_SUCCESS;
 807     }
 808
 809     *data = strdupW(ptr);
 810     *len = lstrlenW(ptr);
 811
 812     ZeroMemory(&format, sizeof(FORMAT));
 813     format.package = package;
 814     format.record = record;
 815     format.deformatted = *data;
 816     format.len = *len;
 817
 818     if (!verify_format(*data))
 819         return ERROR_SUCCESS;
 820
 821     stack = create_stack();
 822     temp = create_stack();
 823
 824     while ((type = format_lex(&format, &str)) != FORMAT_NULL)
 825     {
 826         if (type == FORMAT_LBRACK || type == FORMAT_LBRACE ||
 827             type == FORMAT_LITERAL || type == FORMAT_NUMBER ||
 828             type == FORMAT_ESCAPE || type == FORMAT_PROPNULL)
 829         {
 830             if (type == FORMAT_LBRACE)
 831             {
 832                 format.propfailed = FALSE;
 833                 format.groups++;
 834             }
 835             else if (type == FORMAT_ESCAPE &&
 836                      !stack_find(stack, FORMAT_LBRACK))
 837             {
 838                 format.n -= str->len - 1;
 839                 str->len = 1;
 840             }
 841
 842             stack_push(stack, str);
 843         }
 844         else if (type == FORMAT_RBRACK || type == FORMAT_RBRACE)
 845         {
 846             if (type == FORMAT_RBRACE)
 847                 format.groups--;
 848
 849             stack_push(stack, str);
 850
 851             if (stack_find(stack, left_type(type)))
 852             {
 853                 do
 854                 {
 855                     node = stack_pop(stack);
 856                     stack_push(temp, node);
 857                 } while (node->type != left_type(type));
 858
 859                 replace_stack(&format, stack, temp);
 860             }
 861         }
 862     }
 863
 864     *data = format.deformatted;
 865     *len = format.len;
 866
 867     msi_free(str);
 868     free_stack(stack);
 869     free_stack(temp);
 870
 871     return ERROR_SUCCESS;
 872 }
 873
 874 UINT MSI_FormatRecordW( MSIPACKAGE* package, MSIRECORD* record, LPWSTR buffer,
 875                         LPDWORD size )
 876 {
 877     WCHAR *format, *deformated;
 878     UINT rc = ERROR_INVALID_PARAMETER;
 879     DWORD len;
 880
 881     TRACE("%p %p %p %p\n", package, record, buffer, size);
 882
 883     if (!(format = msi_dup_record_field( record, 0 )))
 884         format = build_default_format( record );
 885
 886     TRACE("%s\n", debugstr_w(format));
 887
 888     deformat_string_internal( package, format, &deformated, &len, record, NULL );
 889     if (buffer)
 890     {
 891         if (*size>len)
 892         {
 893             memcpy(buffer,deformated,len*sizeof(WCHAR));
 894             rc = ERROR_SUCCESS;
 895             buffer[len] = 0;
 896         }
 897         else
 898         {
 899             if (*size > 0)
 900             {
 901                 memcpy(buffer,deformated,(*size)*sizeof(WCHAR));
 902                 buffer[(*size)-1] = 0;
 903             }
 904             rc = ERROR_MORE_DATA;
 905         }
 906     }
 907     else rc = ERROR_SUCCESS;
 908
 909     *size = len;
 910     msi_free( format );
 911     msi_free( deformated );
 912     return rc;
 913 }
 914
 915 UINT WINAPI MsiFormatRecordW( MSIHANDLE hInstall, MSIHANDLE hRecord,
 916                               LPWSTR szResult, LPDWORD sz )
 917 {
 918     UINT r = ERROR_INVALID_HANDLE;
 919     MSIPACKAGE *package;
 920     MSIRECORD *record;
 921
 922     TRACE("%d %d %p %p\n", hInstall, hRecord, szResult, sz);
 923
 924     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 925     if (!package)
 926     {
 927         HRESULT hr;
 928         IWineMsiRemotePackage *remote_package;
 929         BSTR value = NULL;
 930         awstring wstr;
 931
 932         remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall );
 933         if (remote_package)
 934         {
 935             hr = IWineMsiRemotePackage_FormatRecord( remote_package, hRecord,
 936                                                      &value );
 937             if (FAILED(hr))
 938                 goto done;
 939
 940             wstr.unicode = TRUE;
 941             wstr.str.w = szResult;
 942             r = msi_strcpy_to_awstring( value, SysStringLen(value), &wstr, sz );
 943
 944 done:
 945             IWineMsiRemotePackage_Release( remote_package );
 946             SysFreeString( value );
 947
 948             if (FAILED(hr))
 949             {
 950                 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
 951                     return HRESULT_CODE(hr);
 952
 953                 return ERROR_FUNCTION_FAILED;
 954             }
 955
 956             return r;
 957         }
 958     }
 959
 960     record = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
 961
 962     if (!record)
 963         return ERROR_INVALID_HANDLE;
 964     if (!sz)
 965     {
 966         msiobj_release( &record->hdr );
 967         if (szResult)
 968             return ERROR_INVALID_PARAMETER;
 969         else
 970             return ERROR_SUCCESS;
 971     }
 972
 973     r = MSI_FormatRecordW( package, record, szResult, sz );
 974     msiobj_release( &record->hdr );
 975     if (package)
 976         msiobj_release( &package->hdr );
 977     return r;
 978 }
 979
 980 UINT WINAPI MsiFormatRecordA( MSIHANDLE hInstall, MSIHANDLE hRecord,
 981                               LPSTR szResult, LPDWORD sz )
 982 {
 983     UINT r;
 984     DWORD len, save;
 985     LPWSTR value;
 986
 987     TRACE("%d %d %p %p\n", hInstall, hRecord, szResult, sz);
 988
 989     if (!hRecord)
 990         return ERROR_INVALID_HANDLE;
 991
 992     if (!sz)
 993     {
 994         if (szResult)
 995             return ERROR_INVALID_PARAMETER;
 996         else
 997             return ERROR_SUCCESS;
 998     }
 999
1000     r = MsiFormatRecordW( hInstall, hRecord, NULL, &len );
1001     if (r != ERROR_SUCCESS)
1002         return r;
1003
1004     value = msi_alloc(++len * sizeof(WCHAR));
1005     if (!value)
1006         return ERROR_OUTOFMEMORY;
1007
1008     r = MsiFormatRecordW( hInstall, hRecord, value, &len );
1009     if (r != ERROR_SUCCESS)
1010         goto done;
1011
1012     save = len + 1;
1013     len = WideCharToMultiByte(CP_ACP, 0, value, len + 1, NULL, 0, NULL, NULL);
1014     WideCharToMultiByte(CP_ACP, 0, value, len, szResult, *sz, NULL, NULL);
1015
1016     if (szResult && len > *sz)
1017     {
1018         if (*sz) szResult[*sz - 1] = '\0';
1019         r = ERROR_MORE_DATA;
1020     }
1021
1022     *sz = save - 1;
1023
1024 done:
1025     msi_free(value);
1026     return r;
1027 }
1028
1029 /* wrapper to resist a need for a full rewrite right now */
1030 DWORD deformat_string( MSIPACKAGE *package, const WCHAR *fmt, WCHAR **data )
1031 {
1032     DWORD len;
1033     MSIRECORD *rec;
1034
1035     *data = NULL;
1036     if (!fmt) return 0;
1037     if (!(rec = MSI_CreateRecord( 1 ))) return 0;
1038
1039     MSI_RecordSetStringW( rec, 0, fmt );
1040     MSI_FormatRecordW( package, rec, NULL, &len );
1041     if (!(*data = msi_alloc( ++len * sizeof(WCHAR) )))
1042     {
1043         msiobj_release( &rec->hdr );
1044         return 0;
1045     }
1046     MSI_FormatRecordW( package, rec, *data, &len );
1047     msiobj_release( &rec->hdr );
1048     return len;
1049 }