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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 = HeapAlloc(GetProcessHeap(),0,(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 = HeapAlloc(GetProcessHeap(),0,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 = HeapAlloc(GetProcessHeap(),0,sz * sizeof(WCHAR));
 154         GetEnvironmentVariableW(&key[1],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 = HeapAlloc(GetProcessHeap(),0,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 = HeapAlloc(GetProcessHeap(),0,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 = load_dynamic_stringW(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 = HeapAlloc(GetProcessHeap(),0,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 = HeapAlloc(GetProcessHeap(),0,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;
 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 = HeapAlloc(GetProcessHeap(),0,*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      HeapFree(GetProcessHeap(),0,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 = HeapAlloc(GetProcessHeap(),0,(sz+2)*sizeof(WCHAR));
 361          v2[0] = '{';
 362          memcpy(&v2[1],value,sz*sizeof(WCHAR));
 363          v2[sz+1]='}';
 364          HeapFree(GetProcessHeap(),0,value);
 365
 366          *size = (sz+2)*sizeof(WCHAR);
 367          return v2;
 368      }
 369      else
 370      {
 371          *size = 0;
 372          return NULL;
 373      }
 374 }
 375
 376
 377 /*
 378  * len is in WCHARs
 379  * return is also in WCHARs
 380  */
 381 static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
 382                                      WCHAR** data, DWORD len, MSIRECORD* record,
 383                                      INT* failcount)
 384 {
 385     LPCWSTR mark = NULL;
 386     LPCWSTR mark2 = NULL;
 387     DWORD size=0;
 388     DWORD chunk=0;
 389     LPWSTR key;
 390     LPWSTR value = NULL;
 391     DWORD sz;
 392     LPBYTE newdata = NULL;
 393     const WCHAR* progress = NULL;
 394     BOOL nested;
 395
 396     if (ptr==NULL)
 397     {
 398         TRACE("Deformatting NULL string\n");
 399         *data = NULL;
 400         return 0;
 401     }
 402
 403     TRACE("Starting with %s\n",debugstr_wn(ptr,len));
 404
 405     /* scan for special characters... fast exit */
 406     if ((!scanW(ptr,'[',len) || (scanW(ptr,'[',len) && !scanW(ptr,']',len))) &&
 407         (scanW(ptr,'{',len) && !scanW(ptr,'}',len)))
 408     {
 409         /* not formatted */
 410         *data = HeapAlloc(GetProcessHeap(),0,(len*sizeof(WCHAR)));
 411         memcpy(*data,ptr,len*sizeof(WCHAR));
 412         TRACE("Returning %s\n",debugstr_wn(*data,len));
 413         return len;
 414     }
 415
 416     progress = ptr;
 417
 418     while (progress - ptr < len)
 419     {
 420         /* seek out first group if existing */
 421         if (find_next_group(progress, len - (progress - ptr), &key,
 422                                 &mark, &mark2))
 423         {
 424             value = deformat_group(package, key, strlenW(key)+1, record,
 425                             &chunk);
 426             key = NULL;
 427             nested = FALSE;
 428         }
 429         /* formatted string located */
 430         else if (!find_next_outermost_key(progress, len - (progress - ptr),
 431                                 &key, &mark, &mark2, &nested))
 432         {
 433             LPBYTE nd2;
 434
 435             TRACE("after value %s \n",debugstr_wn((LPWSTR)newdata,
 436                                     size/sizeof(WCHAR)));
 437             chunk = (len - (progress - ptr)) * sizeof(WCHAR);
 438             TRACE("after chunk is %li + %li\n",size,chunk);
 439             if (size)
 440                 nd2 = HeapReAlloc(GetProcessHeap(),0,newdata,(size+chunk));
 441             else
 442                 nd2 = HeapAlloc(GetProcessHeap(),0,chunk);
 443
 444             newdata = nd2;
 445             memcpy(&newdata[size],progress,chunk);
 446             size+=chunk;
 447             break;
 448         }
 449
 450         if (mark != progress)
 451         {
 452             LPBYTE tgt;
 453             DWORD old_size = size;
 454             INT cnt = (mark - progress);
 455             TRACE("%i  (%i) characters before marker\n",cnt,(mark-progress));
 456             size += cnt * sizeof(WCHAR);
 457             if (!old_size)
 458                 tgt = HeapAlloc(GetProcessHeap(),0,size);
 459             else
 460                 tgt = HeapReAlloc(GetProcessHeap(),0,newdata,size);
 461             newdata  = tgt;
 462             memcpy(&newdata[old_size],progress,(cnt * sizeof(WCHAR)));
 463         }
 464
 465         progress = mark;
 466
 467         if (nested)
 468         {
 469             TRACE("Nested key... %s\n",debugstr_w(key));
 470             deformat_string_internal(package, key, &value, strlenW(key)+1,
 471                                      record, failcount);
 472
 473             HeapFree(GetProcessHeap(),0,key);
 474             key = value;
 475         }
 476
 477         TRACE("Current %s .. %s\n",debugstr_wn((LPWSTR)newdata,
 478                                 size/sizeof(WCHAR)),debugstr_w(key));
 479
 480         if (!package)
 481         {
 482             /* only deformat number indexs */
 483             if (key && is_key_number(key))
 484             {
 485                 value = deformat_index(record,key,&chunk);
 486                 if (!chunk && failcount && *failcount >= 0)
 487                     (*failcount)++;
 488             }
 489             else
 490             {
 491                 if (failcount)
 492                     *failcount = -1;
 493                 if(key)
 494                 {
 495                     DWORD keylen = strlenW(key);
 496                     chunk = (keylen + 2)*sizeof(WCHAR);
 497                     value = HeapAlloc(GetProcessHeap(),0,chunk);
 498                     value[0] = '[';
 499                     memcpy(&value[1],key,keylen*sizeof(WCHAR));
 500                     value[1+keylen] = ']';
 501                 }
 502             }
 503         }
 504         else
 505         {
 506             sz = 0;
 507             if (key) switch (key[0])
 508             {
 509                 case '~':
 510                     value = deformat_NULL(&chunk);
 511                 break;
 512                 case '$':
 513                     value = deformat_component(package,&key[1],&chunk);
 514                 break;
 515                 case '#':
 516                     value = deformat_file(package,&key[1], &chunk, FALSE);
 517                 break;
 518                 case '!': /* should be short path */
 519                     value = deformat_file(package,&key[1], &chunk, TRUE);
 520                 break;
 521                 case '\\':
 522                     value = deformat_escape(&key[1],&chunk);
 523                 break;
 524                 case '%':
 525                     value = deformat_environment(package,&key[1],&chunk);
 526                 break;
 527                 default:
 528                     /* index keys cannot be nested */
 529                     if (is_key_number(key))
 530                         if (!nested)
 531                             value = deformat_index(record,key,&chunk);
 532                         else
 533                         {
 534                             static const WCHAR fmt[] = {'[','%','s',']',0};
 535                             value = HeapAlloc(GetProcessHeap(),0,10);
 536                             sprintfW(value,fmt,key);
 537                             chunk = strlenW(value)*sizeof(WCHAR);
 538                         }
 539                     else
 540                         value = deformat_property(package,key,&chunk);
 541                 break;
 542             }
 543         }
 544
 545         HeapFree(GetProcessHeap(),0,key);
 546
 547         if (value!=NULL)
 548         {
 549             LPBYTE nd2;
 550             TRACE("value %s, chunk %li size %li\n",debugstr_w((LPWSTR)value),
 551                     chunk, size);
 552             if (size)
 553                 nd2= HeapReAlloc(GetProcessHeap(),0,newdata,(size + chunk));
 554             else
 555                 nd2= HeapAlloc(GetProcessHeap(),0,chunk);
 556             newdata = nd2;
 557             memcpy(&newdata[size],value,chunk);
 558             size+=chunk;
 559             HeapFree(GetProcessHeap(),0,value);
 560         }
 561         else if (failcount && *failcount >=0 )
 562             (*failcount)++;
 563
 564         progress = mark2+1;
 565     }
 566
 567     TRACE("after everything %s\n",debugstr_wn((LPWSTR)newdata,
 568                             size/sizeof(WCHAR)));
 569
 570     *data = (LPWSTR)newdata;
 571     return size / sizeof(WCHAR);
 572 }
 573
 574
 575 UINT MSI_FormatRecordW( MSIPACKAGE* package, MSIRECORD* record, LPWSTR buffer,
 576                         DWORD *size )
 577 {
 578     LPWSTR deformated;
 579     LPWSTR rec;
 580     DWORD len;
 581     UINT rc = ERROR_INVALID_PARAMETER;
 582
 583     TRACE("%p %p %p %li\n",package, record ,buffer, *size);
 584
 585     rec = load_dynamic_stringW(record,0);
 586     if (!rec)
 587         rec = build_default_format(record);
 588
 589     TRACE("(%s)\n",debugstr_w(rec));
 590
 591     len = deformat_string_internal(package,rec,&deformated,strlenW(rec),
 592                                    record, NULL);
 593
 594     if (buffer)
 595     {
 596         if (*size>len)
 597         {
 598             memcpy(buffer,deformated,len*sizeof(WCHAR));
 599             rc = ERROR_SUCCESS;
 600             buffer[len] = 0;
 601         }
 602         else
 603         {
 604             if (*size > 0)
 605             {
 606                 memcpy(buffer,deformated,(*size)*sizeof(WCHAR));
 607                 buffer[(*size)-1] = 0;
 608             }
 609             rc = ERROR_MORE_DATA;
 610         }
 611     }
 612     else
 613         rc = ERROR_SUCCESS;
 614
 615     *size = len;
 616
 617     HeapFree(GetProcessHeap(),0,rec);
 618     HeapFree(GetProcessHeap(),0,deformated);
 619     return rc;
 620 }
 621
 622 UINT MSI_FormatRecordA( MSIPACKAGE* package, MSIRECORD* record, LPSTR buffer,
 623                         DWORD *size )
 624 {
 625     LPWSTR deformated;
 626     LPWSTR rec;
 627     DWORD len,lenA;
 628     UINT rc = ERROR_INVALID_PARAMETER;
 629
 630     TRACE("%p %p %p %li\n",package, record ,buffer, *size);
 631
 632     rec = load_dynamic_stringW(record,0);
 633     if (!rec)
 634         rec = build_default_format(record);
 635
 636     TRACE("(%s)\n",debugstr_w(rec));
 637
 638     len = deformat_string_internal(package,rec,&deformated,strlenW(rec),
 639                                    record, NULL);
 640     lenA = WideCharToMultiByte(CP_ACP,0,deformated,len,NULL,0,NULL,NULL);
 641
 642     if (buffer)
 643     {
 644         WideCharToMultiByte(CP_ACP,0,deformated,len,buffer,*size,NULL, NULL);
 645         if (*size>lenA)
 646         {
 647             rc = ERROR_SUCCESS;
 648             buffer[lenA] = 0;
 649         }
 650         else
 651         {
 652             rc = ERROR_MORE_DATA;
 653             buffer[(*size)-1] = 0;
 654         }
 655     }
 656     else
 657         rc = ERROR_SUCCESS;
 658
 659     *size = lenA;
 660
 661     HeapFree(GetProcessHeap(),0,rec);
 662     HeapFree(GetProcessHeap(),0,deformated);
 663     return rc;
 664 }
 665
 666
 667 UINT WINAPI MsiFormatRecordW( MSIHANDLE hInstall, MSIHANDLE hRecord,
 668                               LPWSTR szResult, DWORD *sz )
 669 {
 670     UINT r = ERROR_INVALID_HANDLE;
 671     MSIPACKAGE *package;
 672     MSIRECORD *record;
 673
 674     TRACE("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
 675
 676     record = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
 677
 678     if (!record)
 679         return ERROR_INVALID_HANDLE;
 680     if (!sz)
 681     {
 682         msiobj_release( &record->hdr );
 683         if (szResult)
 684             return ERROR_INVALID_PARAMETER;
 685         else
 686             return ERROR_SUCCESS;
 687     }
 688
 689     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 690
 691     r = MSI_FormatRecordW( package, record, szResult, sz );
 692     msiobj_release( &record->hdr );
 693     if (package)
 694         msiobj_release( &package->hdr );
 695     return r;
 696 }
 697
 698 UINT WINAPI MsiFormatRecordA( MSIHANDLE hInstall, MSIHANDLE hRecord,
 699                               LPSTR szResult, DWORD *sz )
 700 {
 701     UINT r = ERROR_INVALID_HANDLE;
 702     MSIPACKAGE *package = NULL;
 703     MSIRECORD *record = NULL;
 704
 705     TRACE("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
 706
 707     record = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
 708
 709     if (!record)
 710         return ERROR_INVALID_HANDLE;
 711     if (!sz)
 712     {
 713         msiobj_release( &record->hdr );
 714         if (szResult)
 715             return ERROR_INVALID_PARAMETER;
 716         else
 717             return ERROR_SUCCESS;
 718     }
 719
 720     package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
 721
 722     r = MSI_FormatRecordA( package, record, szResult, sz );
 723     msiobj_release( &record->hdr );
 724     if (package)
 725         msiobj_release( &package->hdr );
 726     return r;
 727 }