git.oblomov.eu Git - wine/blob - 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 /*
  23 http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msi/setup/msiformatrecord.asp
  24  */
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28
  29 #define COBJMACROS
  30
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winerror.h"
  34 #include "wine/debug.h"
  35 #include "msi.h"
  36 #include "msipriv.h"
  37 #include "winnls.h"
  38 #include "wine/unicode.h"
  39 #include "action.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  42
  43
  44 static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
  45                                      WCHAR** data, DWORD len, MSIRECORD* record,
  46                                      BOOL* in_group);
  47
  48
  49 static LPWSTR build_default_format(MSIRECORD* record)
  50 {
  51     int i;
  52     int count;
  53     LPWSTR rc;
  54     static const WCHAR fmt[] = {'%','i',':',' ','[','%','i',']',' ',0};
  55     WCHAR buf[11];
  56
  57     count = MSI_RecordGetFieldCount(record);
  58
  59     rc = msi_alloc((11*count)*sizeof(WCHAR));
  60     rc[0] = 0;
  61     for (i = 1; i <= count; i++)
  62     {
  63         sprintfW(buf,fmt,i,i);
  64         strcatW(rc,buf);
  65     }
  66     return rc;
  67 }
  68
  69 static const WCHAR* scanW(LPCWSTR buf, WCHAR token, DWORD len)
  70 {
  71     DWORD i;
  72     for (i = 0; i < len; i++)
  73         if (buf[i] == token)
  74             return &buf[i];
  75     return NULL;
  76 }
  77
  78 /* break out helper functions for deformating */
  79 static LPWSTR deformat_component(MSIPACKAGE* package, LPCWSTR key, DWORD* sz)
  80 {
  81     LPWSTR value = NULL;
  82     MSICOMPONENT *comp;
  83
  84     *sz = 0;
  85     if (!package)
  86         return NULL;
  87
  88     FIXME("component key %s\n", debugstr_w(key));
  89     comp = get_loaded_component(package,key);
  90     if (comp)
  91     {
  92         value = resolve_folder(package, comp->Directory, FALSE, FALSE, NULL);
  93         *sz = (strlenW(value)) * sizeof(WCHAR);
  94     }
  95
  96     return value;
  97 }
  98
  99 static LPWSTR deformat_file(MSIPACKAGE* package, LPCWSTR key, DWORD* sz,
 100                             BOOL shortname)
 101 {
 102     LPWSTR value = NULL;
 103     MSIFILE *file;
 104
 105     *sz = 0;
 106
 107     if (!package)
 108         return NULL;
 109
 110     file = get_loaded_file( package, key );
 111     if (file)
 112     {
 113         if (!shortname)
 114         {
 115             value = strdupW( file->TargetPath );
 116             *sz = (strlenW(value)) * sizeof(WCHAR);
 117         }
 118         else
 119         {
 120             DWORD size = 0;
 121             size = GetShortPathNameW( file->TargetPath, NULL, 0 );
 122
 123             if (size > 0)
 124             {
 125                 *sz = (size-1) * sizeof (WCHAR);
 126                 size ++;
 127                 value = msi_alloc(size * sizeof(WCHAR));
 128                 GetShortPathNameW( file->TargetPath, value, size );
 129             }
 130             else
 131             {
 132                 ERR("Unable to get ShortPath size (%s)\n",
 133                     debugstr_w( file->TargetPath) );
 134                 value = NULL;
 135                 *sz = 0;
 136             }
 137         }
 138     }
 139
 140     return value;
 141 }
 142
 143 static LPWSTR deformat_environment(MSIPACKAGE* package, LPCWSTR key,
 144                                    DWORD* chunk)
 145 {
 146     LPWSTR value = NULL;
 147     DWORD sz;
 148
 149     sz  = GetEnvironmentVariableW(key,NULL,0);
 150     if (sz > 0)
 151     {
 152         sz++;
 153         value = msi_alloc(sz * sizeof(WCHAR));
 154         GetEnvironmentVariableW(key,value,sz);
 155         *chunk = (strlenW(value)) * sizeof(WCHAR);
 156     }
 157     else
 158     {
 159         ERR("Unknown environment variable %s\n", debugstr_w(key));
 160         *chunk = 0;
 161         value = NULL;
 162     }
 163     return value;
 164 }
 165
 166
 167 static LPWSTR deformat_NULL(DWORD* chunk)
 168 {
 169     LPWSTR value;
 170
 171     value = msi_alloc(sizeof(WCHAR)*2);
 172     value[0] =  0;
 173     *chunk = sizeof(WCHAR);
 174     return value;
 175 }
 176
 177 static LPWSTR deformat_escape(LPCWSTR key, DWORD* chunk)
 178 {
 179     LPWSTR value;
 180
 181     value = msi_alloc(sizeof(WCHAR)*2);
 182     value[0] =  key[0];
 183     *chunk = sizeof(WCHAR);
 184
 185     return value;
 186 }
 187
 188
 189 static BOOL is_key_number(LPCWSTR key)
 190 {
 191     INT index = 0;
 192     if (key[0] == 0)
 193         return FALSE;
 194
 195     while (isdigitW(key[index])) index++;
 196     if (key[index] == 0)
 197         return TRUE;
 198     else
 199         return FALSE;
 200 }
 201
 202 static LPWSTR deformat_index(MSIRECORD* record, LPCWSTR key, DWORD* chunk )
 203 {
 204     INT index;
 205     LPWSTR value;
 206
 207     index = atoiW(key);
 208     TRACE("record index %i\n",index);
 209     value = msi_dup_record_field(record,index);
 210     if (value)
 211         *chunk = strlenW(value) * sizeof(WCHAR);
 212     else
 213     {
 214         value = NULL;
 215         *chunk = 0;
 216     }
 217     return value;
 218 }
 219
 220 static LPWSTR deformat_property(MSIPACKAGE* package, LPCWSTR key, DWORD* chunk)
 221 {
 222     LPWSTR value;
 223
 224     if (!package)
 225         return NULL;
 226
 227     value = msi_dup_property( package, key );
 228
 229     if (value)
 230         *chunk = (strlenW(value)) * sizeof(WCHAR);
 231
 232     return value;
 233 }
 234
 235 /*
 236  * Groups cannot be nested. They are just treated as from { to next }
 237  */
 238 static BOOL find_next_group(LPCWSTR source, DWORD len_remaining,
 239                                     LPWSTR *group, LPCWSTR *mark,
 240                                     LPCWSTR* mark2)
 241 {
 242     int i;
 243     BOOL found = FALSE;
 244
 245     *mark = scanW(source,'{',len_remaining);
 246     if (!*mark)
 247         return FALSE;
 248
 249     for (i = 1; (*mark - source) + i < len_remaining; i++)
 250     {
 251         if ((*mark)[i] == '}')
 252         {
 253             found = TRUE;
 254             break;
 255         }
 256     }
 257     if (! found)
 258         return FALSE;
 259
 260     *mark2 = &(*mark)[i];
 261
 262     i = *mark2 - *mark;
 263     *group = msi_alloc(i*sizeof(WCHAR));
 264
 265     i -= 1;
 266     memcpy(*group,&(*mark)[1],i*sizeof(WCHAR));
 267     (*group)[i] = 0;
 268
 269     TRACE("Found group %s\n",debugstr_w(*group));
 270     return TRUE;
 271 }
 272
 273
 274 static BOOL find_next_outermost_key(LPCWSTR source, DWORD len_remaining,
 275                                     LPWSTR *key, LPCWSTR *mark, LPCWSTR* mark2,
 276                                     BOOL *nested)
 277 {
 278     INT count = 0;
 279     INT total_count = 0;
 280     int i;
 281
 282     *mark = scanW(source,'[',len_remaining);
 283     if (!*mark)
 284         return FALSE;
 285
 286     count = 1;
 287     total_count = 1;
 288     *nested = FALSE;
 289     for (i = 1; (*mark - source) + i < len_remaining && count > 0; i++)
 290     {
 291         if ((*mark)[i] == '[' && (*mark)[i-1] != '\\')
 292         {
 293             count ++;
 294             total_count ++;
 295             *nested = TRUE;
 296         }
 297         else if ((*mark)[i] == ']' && (*mark)[i-1] != '\\')
 298         {
 299             count --;
 300         }
 301     }
 302
 303     if (count > 0)
 304         return FALSE;
 305
 306     *mark2 = &(*mark)[i-1];
 307
 308     i = *mark2 - *mark;
 309     *key = msi_alloc(i*sizeof(WCHAR));
 310     /* do not have the [] in the key */
 311     i -= 1;
 312     memcpy(*key,&(*mark)[1],i*sizeof(WCHAR));
 313     (*key)[i] = 0;
 314
 315     TRACE("Found Key %s\n",debugstr_w(*key));
 316     return TRUE;
 317 }
 318
 319 static LPWSTR deformat_group(MSIPACKAGE* package, LPWSTR group, DWORD len,
 320                       MSIRECORD* record, DWORD* size)
 321 {
 322     LPWSTR value = NULL;
 323     LPCWSTR mark, mark2;
 324     LPWSTR key;
 325     BOOL nested;
 326     INT failcount;
 327     static const WCHAR fmt[] = {'{','%','s','}',0};
 328     UINT sz;
 329
 330     if (!group || group[0] == 0)
 331     {
 332         *size = 0;
 333         return NULL;
 334     }
 335     /* if no [] then group is returned as is */
 336
 337      if (!find_next_outermost_key(group, len, &key, &mark, &mark2, &nested))
 338      {
 339          *size = (len+2)*sizeof(WCHAR);
 340          value = msi_alloc(*size);
 341          sprintfW(value,fmt,group);
 342          /* do not return size of the null at the end */
 343          *size = (len+1)*sizeof(WCHAR);
 344          return value;
 345      }
 346
 347      msi_free(key);
 348      failcount = 0;
 349      sz = deformat_string_internal(package, group, &value, strlenW(group),
 350                                      record, &failcount);
 351      if (failcount==0)
 352      {
 353         *size = sz * sizeof(WCHAR);
 354         return value;
 355      }
 356      else if (failcount < 0)
 357      {
 358          LPWSTR v2;
 359
 360          v2 = msi_alloc((sz+2)*sizeof(WCHAR));
 361          v2[0] = '{';
 362          memcpy(&v2[1],value,sz*sizeof(WCHAR));
 363          v2[sz+1]='}';
 364          msi_free(value);
 365
 366          *size = (sz+2)*sizeof(WCHAR);
 367          return v2;
 368      }
 369      else
 370      {
 371          msi_free(value);
 372          *size = 0;
 373          return NULL;
 374      }
 375 }
 376
 377
 378 /*
 379  * len is in WCHARs
 380  * return is also in WCHARs
 381  */
 382 static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
 383                                      WCHAR** data, DWORD len, MSIRECORD* record,
 384                                      INT* failcount)
 385 {
 386     LPCWSTR mark = NULL;
 387     LPCWSTR mark2 = NULL;
 388     DWORD size=0;
 389     DWORD chunk=0;
 390     LPWSTR key;
 391     LPWSTR value = NULL;
 392     DWORD sz;
 393     LPBYTE newdata = NULL;
 394     const WCHAR* progress = NULL;
 395     BOOL nested;
 396
 397     if (ptr==NULL)
 398     {
 399         TRACE("Deformatting NULL string\n");
 400         *data = NULL;
 401         return 0;
 402     }
 403
 404     TRACE("Starting with %s\n",debugstr_wn(ptr,len));
 405
 406     /* scan for special characters... fast exit */
 407     if ((!scanW(ptr,'[',len) || (scanW(ptr,'[',len) && !scanW(ptr,']',len))) &&
 408         (scanW(ptr,'{',len) && !scanW(ptr,'}',len)))
 409     {
 410         /* not formatted */
 411         *data = msi_alloc((len*sizeof(WCHAR)));
 412         memcpy(*data,ptr,len*sizeof(WCHAR));
 413         TRACE("Returning %s\n",debugstr_wn(*data,len));
 414         return len;
 415     }
 416
 417     progress = ptr;
 418
 419     while (progress - ptr < len)
 420     {
 421         /* seek out first group if existing */
 422         if (find_next_group(progress, len - (progress - ptr), &key,
 423                                 &mark, &mark2))
 424         {
 425             value = deformat_group(package, key, strlenW(key)+1, record,
 426                             &chunk);
 427             msi_free( key );
 428             key = NULL;
 429             nested = FALSE;
 430         }
 431         /* formatted string located */
 432         else if (!find_next_outermost_key(progress, len - (progress - ptr),
 433                                 &key, &mark, &mark2, &nested))
 434         {
 435             LPBYTE nd2;
 436
 437             TRACE("after value %s\n", debugstr_wn((LPWSTR)newdata,
 438                                     size/sizeof(WCHAR)));
 439             chunk = (len - (progress - ptr)) * sizeof(WCHAR);
 440             TRACE("after chunk is %li + %li\n",size,chunk);
 441             if (size)
 442                 nd2 = msi_realloc(newdata,(size+chunk));
 443             else
 444                 nd2 = msi_alloc(chunk);
 445
 446             newdata = nd2;
 447             memcpy(&newdata[size],progress,chunk);
 448             size+=chunk;
 449             break;
 450         }
 451
 452         if (mark != progress)
 453         {
 454             LPBYTE tgt;
 455             DWORD old_size = size;
 456             INT cnt = (mark - progress);
 457             TRACE("%i  (%i) characters before marker\n",cnt,(mark-progress));
 458             size += cnt * sizeof(WCHAR);
 459             if (!old_size)
 460                 tgt = msi_alloc(size);
 461             else
 462                 tgt = msi_realloc(newdata,size);
 463             newdata  = tgt;
 464             memcpy(&newdata[old_size],progress,(cnt * sizeof(WCHAR)));
 465         }
 466
 467         progress = mark;
 468
 469         if (nested)
 470         {
 471             TRACE("Nested key... %s\n",debugstr_w(key));
 472             deformat_string_internal(package, key, &value, strlenW(key)+1,
 473                                      record, failcount);
 474
 475             msi_free(key);
 476             key = value;
 477         }
 478
 479         TRACE("Current %s .. %s\n",debugstr_wn((LPWSTR)newdata,
 480                                 size/sizeof(WCHAR)),debugstr_w(key));
 481
 482         if (!package)
 483         {
 484             /* only deformat number indexs */
 485             if (key && is_key_number(key))
 486             {
 487                 value = deformat_index(record,key,&chunk);
 488                 if (!chunk && failcount && *failcount >= 0)
 489                     (*failcount)++;
 490             }
 491             else
 492             {
 493                 if (failcount)
 494                     *failcount = -1;
 495                 if(key)
 496                 {
 497                     DWORD keylen = strlenW(key);
 498                     chunk = (keylen + 2)*sizeof(WCHAR);
 499                     value = msi_alloc(chunk);
 500                     value[0] = '[';
 501                     memcpy(&value[1],key,keylen*sizeof(WCHAR));
 502                     value[1+keylen] = ']';
 503                 }
 504             }
 505         }
 506         else
 507         {
 508             sz = 0;
 509             if (key) switch (key[0])
 510             {
 511                 case '~':
 512                     value = deformat_NULL(&chunk);
 513                 break;
 514                 case '$':
 515                     value = deformat_component(package,&key[1],&chunk);
 516                 break;
 517                 case '#':
 518                     value = deformat_file(package,&key[1], &chunk, FALSE);
 519                 break;
 520                 case '!': /* should be short path */
 521                     value = deformat_file(package,&key[1], &chunk, TRUE);
 522                 break;
 523                 case '\\':
 524                     value = deformat_escape(&key[1],&chunk);
 525                 break;
 526                 case '%':
 527                     value = deformat_environment(package,&key[1],&chunk);
 528                 break;
 529                 default:
 530                     /* index keys cannot be nested */
 531                     if (is_key_number(key))
 532                         if (!nested)
 533                             value = deformat_index(record,key,&chunk);
 534                         else
 535                         {
 536                             static const WCHAR fmt[] = {'[','%','s',']',0};
 537                             value = msi_alloc(10);
 538                             sprintfW(value,fmt,key);
 539                             chunk = strlenW(value)*sizeof(WCHAR);
 540                         }
 541                     else
 542                         value = deformat_property(package,key,&chunk);
 543                 break;
 544             }
 545         }
 546
 547         msi_free(key);
 548
 549         if (value!=NULL)
 550         {
 551             LPBYTE nd2;
 552             TRACE("value %s, chunk %li size %li\n",debugstr_w((LPWSTR)value),
 553                     chunk, size);
 554             if (size)
 555                 nd2= msi_realloc(newdata,(size + chunk));
 556             else
 557                 nd2= msi_alloc(chunk);
 558             newdata = nd2;
 559             memcpy(&newdata[size],value,chunk);
 560             size+=chunk;
 561             msi_free(value);
 562         }
 563         else if (failcount && *failcount >=0 )
 564             (*failcount)++;
 565
 566         progress = mark2+1;
 567     }
 568
 569     TRACE("after everything %s\n",debugstr_wn((LPWSTR)newdata,
 570                             size/sizeof(WCHAR)));
 571
 572     *data = (LPWSTR)newdata;
 573     return size / sizeof(WCHAR);
 574 }
 575
 576
 577 UINT MSI_FormatRecordW( MSIPACKAGE* package, MSIRECORD* record, LPWSTR buffer,
 578                         DWORD *size )
 579 {
 580     LPWSTR deformated;
 581     LPWSTR rec;
 582     DWORD len;
 583     UINT rc = ERROR_INVALID_PARAMETER;
 584
 585     TRACE("%p %p %p %li\n",package, record ,buffer, *size);
 586
 587     rec = msi_dup_record_field(record,0);
 588     if (!rec)
 589         rec = build_default_format(record);
 590
 591     TRACE("(%s)\n",debugstr_w(rec));
 592
 593     len = deformat_string_internal(package,rec,&deformated,strlenW(rec),
 594                                    record, NULL);
 595
 596     if (buffer)
 597     {
 598         if (*size>len)
 599         {
 600             memcpy(buffer,deformated,len*sizeof(WCHAR));
 601             rc = ERROR_SUCCESS;
 602             buffer[len] = 0;
 603         }
 604         else
 605         {
 606             if (*size > 0)
 607             {
 608                 memcpy(buffer,deformated,(*size)*sizeof(WCHAR));
 609                 buffer[(*size)-1] = 0;
 610             }
 611             rc = ERROR_MORE_DATA;
 612         }
 613     }
 614     else
 615         rc = ERROR_SUCCESS;
 616
 617     *size = len;
 618
 619     msi_free(rec);
 620     msi_free(deformated);
 621     return rc;
 622 }
 623
 624 UINT MSI_FormatRecordA( MSIPACKAGE* package, MSIRECORD* record, LPSTR buffer,
 625                         DWORD *size )
 626 {
 627     LPWSTR deformated;
 628     LPWSTR rec;
 629     DWORD len,lenA;
 630     UINT rc = ERROR_INVALID_PARAMETER;
 631
 632     TRACE("%p %p %p %li\n",package, record ,buffer, *size);
 633
 634     rec = msi_dup_record_field(record,0);
 635     if (!rec)
 636         rec = build_default_format(record);
 637
 638     TRACE("(%s)\n",debugstr_w(rec));
 639
 640     len = deformat_string_internal(package,rec,&deformated,strlenW(rec),
 641                                    record, NULL);
 642     /* If len is zero then WideCharToMultiByte will return 0 indicating
 643      * failure, but that will do just as well since we are ignoring
 644      * possible errors.
 645      */
 646     lenA = WideCharToMultiByte(CP_ACP,0,deformated,len,NULL,0,NULL,NULL);
 647
 648     if (buffer)
 649     {
 650         /* Ditto above */
 651         WideCharToMultiByte(CP_ACP,0,deformated,len,buffer,*size,NULL, NULL);
 652         if (*size>lenA)
 653         {
 654             rc = ERROR_SUCCESS;
 655             buffer[lenA] = 0;
 656         }
 657         else
 658         {
 659             rc = ERROR_MORE_DATA;
 660             if (*size)
 661                 buffer[(*size)-1] = 0;
 662         }
 663     }
 664     else
 665         rc = ERROR_SUCCESS;
 666
 667     *size = lenA;
 668
 669     msi_free(rec);
 670     msi_free(deformated);
 671     return rc;
 672 }
 673
 674
 675 UINT WINAPI MsiFormatRecordW( MSIHANDLE hInstall, MSIHANDLE hRecord,
 676                               LPWSTR szResult, DWORD *sz )
 677 {
 678     UINT r = ERROR_INVALID_HANDLE;
 679     MSIPACKAGE *package;
 680     MSIRECORD *record;
 681
 682     TRACE("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
 683
 684     record = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
 685
 686     if (!record)
 687         return ERROR_INVALID_HANDLE;
 688     if (!sz)
 689     {
 690         msiobj_release( &record->hdr );
 691         if (szResult)
 692             return ERROR_INVALID_PARAMETER;
 693         else
 694             return ERROR_SUCCESS;
 695     }
 696
 697     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 698
 699     r = MSI_FormatRecordW( package, record, szResult, sz );
 700     msiobj_release( &record->hdr );
 701     if (package)
 702         msiobj_release( &package->hdr );
 703     return r;
 704 }
 705
 706 UINT WINAPI MsiFormatRecordA( MSIHANDLE hInstall, MSIHANDLE hRecord,
 707                               LPSTR szResult, DWORD *sz )
 708 {
 709     UINT r = ERROR_INVALID_HANDLE;
 710     MSIPACKAGE *package = NULL;
 711     MSIRECORD *record = NULL;
 712
 713     TRACE("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
 714
 715     record = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
 716
 717     if (!record)
 718         return ERROR_INVALID_HANDLE;
 719     if (!sz)
 720     {
 721         msiobj_release( &record->hdr );
 722         if (szResult)
 723             return ERROR_INVALID_PARAMETER;
 724         else
 725             return ERROR_SUCCESS;
 726     }
 727
 728     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 729
 730     r = MSI_FormatRecordA( package, record, szResult, sz );
 731     msiobj_release( &record->hdr );
 732     if (package)
 733         msiobj_release( &package->hdr );
 734     return r;
 735 }