333 lines
9.6 KiB
C
333 lines
9.6 KiB
C
/*
|
|
* Implementation of the Microsoft Installer (msi.dll)
|
|
*
|
|
* Copyright 2005 Mike McCormack for CodeWeavers
|
|
* Copyright 2005 Aric Stewart for CodeWeavers
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
/*
|
|
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msi/setup/msiformatrecord.asp
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
|
|
#define COBJMACROS
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winerror.h"
|
|
#include "winreg.h"
|
|
#include "wine/debug.h"
|
|
#include "fdi.h"
|
|
#include "msi.h"
|
|
#include "msiquery.h"
|
|
#include "msvcrt/fcntl.h"
|
|
#include "objbase.h"
|
|
#include "objidl.h"
|
|
#include "msipriv.h"
|
|
#include "winnls.h"
|
|
#include "winuser.h"
|
|
#include "shlobj.h"
|
|
#include "wine/unicode.h"
|
|
#include "ver.h"
|
|
#include "action.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(msi);
|
|
|
|
static const WCHAR* scanW(LPCWSTR buf, WCHAR token, DWORD len)
|
|
{
|
|
DWORD i;
|
|
for (i = 0; i < len; i++)
|
|
if (buf[i] == token)
|
|
return &buf[i];
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* This helper function should probably go a lot of places
|
|
*
|
|
* Thinking about this, maybe this should become yet another Bison file
|
|
*
|
|
* len is in WCHARs
|
|
* return is also in WCHARs
|
|
*/
|
|
static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr,
|
|
WCHAR** data, DWORD len, MSIRECORD* record)
|
|
{
|
|
const WCHAR* mark=NULL;
|
|
WCHAR* mark2;
|
|
DWORD size=0;
|
|
DWORD chunk=0;
|
|
WCHAR key[0x100];
|
|
LPWSTR value = NULL;
|
|
DWORD sz;
|
|
UINT rc;
|
|
INT index;
|
|
LPWSTR newdata = NULL;
|
|
|
|
if (ptr==NULL)
|
|
{
|
|
TRACE("Deformatting NULL string\n");
|
|
*data = NULL;
|
|
return 0;
|
|
}
|
|
|
|
TRACE("Starting with %s\n",debugstr_w(ptr));
|
|
|
|
/* scan for special characters */
|
|
if (!scanW(ptr,'[',len) || (scanW(ptr,'[',len) && !scanW(ptr,']',len)))
|
|
{
|
|
/* not formatted */
|
|
*data = HeapAlloc(GetProcessHeap(),0,(len*sizeof(WCHAR)));
|
|
memcpy(*data,ptr,len*sizeof(WCHAR));
|
|
TRACE("Returning %s\n",debugstr_w(*data));
|
|
return len;
|
|
}
|
|
|
|
/* formatted string located */
|
|
mark = scanW(ptr,'[',len);
|
|
if (mark != ptr)
|
|
{
|
|
INT cnt = (mark - ptr);
|
|
TRACE("%i (%i) characters before marker\n",cnt,(mark-ptr));
|
|
size = cnt * sizeof(WCHAR);
|
|
newdata = HeapAlloc(GetProcessHeap(),0,size);
|
|
memcpy(newdata,ptr,(cnt * sizeof(WCHAR)));
|
|
}
|
|
else
|
|
{
|
|
size = 0;
|
|
newdata = HeapAlloc(GetProcessHeap(),0,size);
|
|
newdata[0]=0;
|
|
}
|
|
mark++;
|
|
/* there should be no null characters in a key so strchrW is ok */
|
|
mark2 = strchrW(mark,']');
|
|
strncpyW(key,mark,mark2-mark);
|
|
key[mark2-mark] = 0;
|
|
mark = strchrW(mark,']');
|
|
mark++;
|
|
TRACE("Current %s .. %s\n",debugstr_w(newdata),debugstr_w(key));
|
|
sz = 0;
|
|
/* expand what we can deformat... Again, this should become a bison file */
|
|
switch (key[0])
|
|
{
|
|
case '~':
|
|
value = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*2);
|
|
value[0] = 0;
|
|
chunk = sizeof(WCHAR);
|
|
rc = ERROR_SUCCESS;
|
|
break;
|
|
case '$':
|
|
ERR("POORLY HANDLED DEFORMAT.. [$componentkey] \n");
|
|
index = get_loaded_component(package,&key[1]);
|
|
if (index >= 0)
|
|
{
|
|
value = resolve_folder(package,
|
|
package->components[index].Directory,
|
|
FALSE, FALSE, NULL);
|
|
chunk = (strlenW(value)) * sizeof(WCHAR);
|
|
rc = 0;
|
|
}
|
|
else
|
|
rc = ERROR_FUNCTION_FAILED;
|
|
break;
|
|
case '#':
|
|
case '!': /* should be short path */
|
|
index = get_loaded_file(package,&key[1]);
|
|
if (index >=0)
|
|
{
|
|
sz = strlenW(package->files[index].TargetPath);
|
|
value = dupstrW(package->files[index].TargetPath);
|
|
chunk = (strlenW(value)) * sizeof(WCHAR);
|
|
rc= ERROR_SUCCESS;
|
|
}
|
|
else
|
|
rc = ERROR_FUNCTION_FAILED;
|
|
break;
|
|
case '\\':
|
|
value = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*2);
|
|
value[0] = key[1];
|
|
chunk = sizeof(WCHAR);
|
|
rc = ERROR_SUCCESS;
|
|
break;
|
|
case '%':
|
|
sz = GetEnvironmentVariableW(&key[1],NULL,0);
|
|
if (sz > 0)
|
|
{
|
|
sz++;
|
|
value = HeapAlloc(GetProcessHeap(),0,sz * sizeof(WCHAR));
|
|
GetEnvironmentVariableW(&key[1],value,sz);
|
|
chunk = (strlenW(value)) * sizeof(WCHAR);
|
|
rc = ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
ERR("Unknown environment variable\n");
|
|
chunk = 0;
|
|
value = NULL;
|
|
rc = ERROR_FUNCTION_FAILED;
|
|
}
|
|
break;
|
|
default:
|
|
/* check for numeric values */
|
|
index = 0;
|
|
while (isdigitW(key[index])) index++;
|
|
if (key[index] == 0)
|
|
{
|
|
index = atoiW(key);
|
|
TRACE("record index %i\n",index);
|
|
value = load_dynamic_stringW(record,index);
|
|
if (value)
|
|
{
|
|
chunk = strlenW(value) * sizeof(WCHAR);
|
|
rc = ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
value = NULL;
|
|
rc = ERROR_FUNCTION_FAILED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
value = load_dynamic_property(package,key, &rc);
|
|
if (rc == ERROR_SUCCESS)
|
|
chunk = (strlenW(value)) * sizeof(WCHAR);
|
|
}
|
|
break;
|
|
}
|
|
if (((rc == ERROR_SUCCESS) || (rc == ERROR_MORE_DATA)) && value!=NULL)
|
|
{
|
|
LPWSTR nd2;
|
|
TRACE("value %s, chunk %li size %li\n",debugstr_w(value),chunk,size);
|
|
|
|
nd2= HeapReAlloc(GetProcessHeap(),0,newdata,(size + chunk));
|
|
newdata = nd2;
|
|
memcpy(&newdata[(size/sizeof(WCHAR))],value,chunk);
|
|
size+=chunk;
|
|
HeapFree(GetProcessHeap(),0,value);
|
|
}
|
|
TRACE("after value %s .. %s\n",debugstr_w(newdata),debugstr_w(mark));
|
|
if (mark - ptr < len)
|
|
{
|
|
LPWSTR nd2;
|
|
chunk = (len - (mark - ptr)) * sizeof(WCHAR);
|
|
TRACE("after chunk is %li\n",chunk);
|
|
nd2 = HeapReAlloc(GetProcessHeap(),0,newdata,(size+chunk));
|
|
newdata = nd2;
|
|
memcpy(&newdata[(size/sizeof(WCHAR))],mark,chunk);
|
|
size+=chunk;
|
|
}
|
|
TRACE("after trailing %s .. %s\n",debugstr_w(newdata),debugstr_w(mark));
|
|
|
|
/* recursively do this to clean up */
|
|
size = deformat_string_internal(package,newdata,data,(size/sizeof(WCHAR)),
|
|
record);
|
|
HeapFree(GetProcessHeap(),0,newdata);
|
|
return size;
|
|
}
|
|
|
|
|
|
UINT MSI_FormatRecordW(MSIPACKAGE* package, MSIRECORD* record, LPWSTR buffer,
|
|
DWORD *size)
|
|
{
|
|
LPWSTR deformated;
|
|
LPWSTR rec;
|
|
DWORD len;
|
|
UINT rc = ERROR_INVALID_PARAMETER;
|
|
|
|
TRACE("%p %p %p %li\n",package, record ,buffer, *size);
|
|
|
|
rec = load_dynamic_stringW(record,0);
|
|
if (!rec)
|
|
return rc;
|
|
|
|
TRACE("(%s)\n",debugstr_w(rec));
|
|
|
|
len = deformat_string_internal(package,rec,&deformated,(strlenW(rec)+1),
|
|
record);
|
|
if (len <= *size)
|
|
{
|
|
*size = len;
|
|
memcpy(buffer,deformated,len*sizeof(WCHAR));
|
|
rc = ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
*size = len;
|
|
rc = ERROR_MORE_DATA;
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(),0,rec);
|
|
HeapFree(GetProcessHeap(),0,deformated);
|
|
return rc;
|
|
}
|
|
|
|
UINT WINAPI MsiFormatRecordA(MSIHANDLE hInstall, MSIHANDLE hRecord, LPSTR
|
|
szResult, DWORD *sz)
|
|
{
|
|
UINT rc;
|
|
MSIPACKAGE* package;
|
|
MSIRECORD* record;
|
|
LPWSTR szwResult;
|
|
DWORD original_len;
|
|
|
|
TRACE("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
|
|
|
|
package = msihandle2msiinfo(hInstall,MSIHANDLETYPE_PACKAGE);
|
|
record = msihandle2msiinfo(hRecord,MSIHANDLETYPE_RECORD);
|
|
|
|
if (!package || !record)
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
original_len = *sz;
|
|
/* +1 just to make sure we have a buffer in case the len is 0 */
|
|
szwResult = HeapAlloc(GetProcessHeap(),0,(original_len+1) * sizeof(WCHAR));
|
|
|
|
rc = MSI_FormatRecordW(package, record, szwResult, sz);
|
|
|
|
WideCharToMultiByte(CP_ACP,0,szwResult,original_len, szResult, original_len,
|
|
NULL,NULL);
|
|
|
|
HeapFree(GetProcessHeap(),0,szwResult);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
UINT WINAPI MsiFormatRecordW(MSIHANDLE hInstall, MSIHANDLE hRecord,
|
|
LPWSTR szResult, DWORD *sz)
|
|
{
|
|
UINT rc;
|
|
MSIPACKAGE* package;
|
|
MSIRECORD* record;
|
|
|
|
TRACE("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
|
|
|
|
package = msihandle2msiinfo(hInstall,MSIHANDLETYPE_PACKAGE);
|
|
record = msihandle2msiinfo(hRecord,MSIHANDLETYPE_RECORD);
|
|
|
|
if (!package || !record)
|
|
return ERROR_INVALID_HANDLE;
|
|
|
|
rc = MSI_FormatRecordW(package, record, szResult, sz);
|
|
|
|
return rc;
|
|
}
|