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