/* * Implementation of the Microsoft Installer (msi.dll) * * Copyright 2002-2005 Mike McCormack 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include <stdarg.h> #define COBJMACROS #include "windef.h" #include "winbase.h" #include "winerror.h" #include "wine/debug.h" #include "wine/unicode.h" #include "msi.h" #include "msiquery.h" #include "objbase.h" #include "objidl.h" #include "msipriv.h" #include "winnls.h" #include "query.h" #include "msiserver.h" #include "initguid.h" WINE_DEFAULT_DEBUG_CHANNEL(msi); static void MSI_CloseView( MSIOBJECTHDR *arg ) { MSIQUERY *query = (MSIQUERY*) arg; struct list *ptr, *t; if( query->view && query->view->ops->delete ) query->view->ops->delete( query->view ); msiobj_release( &query->db->hdr ); LIST_FOR_EACH_SAFE( ptr, t, &query->mem ) { msi_free( ptr ); } } UINT VIEW_find_column( MSIVIEW *table, LPCWSTR name, LPCWSTR table_name, UINT *n ) { LPCWSTR col_name, haystack_table_name; UINT i, count, r; r = table->ops->get_dimensions( table, NULL, &count ); if( r != ERROR_SUCCESS ) return r; for( i=1; i<=count; i++ ) { INT x; r = table->ops->get_column_info( table, i, &col_name, NULL, NULL, &haystack_table_name ); if( r != ERROR_SUCCESS ) return r; x = strcmpW( name, col_name ); if( table_name ) x |= strcmpW( table_name, haystack_table_name ); if( !x ) { *n = i; return ERROR_SUCCESS; } } return ERROR_INVALID_PARAMETER; } UINT WINAPI MsiDatabaseOpenViewA(MSIHANDLE hdb, LPCSTR szQuery, MSIHANDLE *phView) { UINT r; LPWSTR szwQuery; TRACE("%d %s %p\n", hdb, debugstr_a(szQuery), phView); if( szQuery ) { szwQuery = strdupAtoW( szQuery ); if( !szwQuery ) return ERROR_FUNCTION_FAILED; } else szwQuery = NULL; r = MsiDatabaseOpenViewW( hdb, szwQuery, phView); msi_free( szwQuery ); return r; } UINT MSI_DatabaseOpenViewW(MSIDATABASE *db, LPCWSTR szQuery, MSIQUERY **pView) { MSIQUERY *query; UINT r; TRACE("%s %p\n", debugstr_w(szQuery), pView); if( !szQuery) return ERROR_INVALID_PARAMETER; /* pre allocate a handle to hold a pointer to the view */ query = alloc_msiobject( MSIHANDLETYPE_VIEW, sizeof (MSIQUERY), MSI_CloseView ); if( !query ) return ERROR_FUNCTION_FAILED; msiobj_addref( &db->hdr ); query->db = db; list_init( &query->mem ); r = MSI_ParseSQL( db, szQuery, &query->view, &query->mem ); if( r == ERROR_SUCCESS ) { msiobj_addref( &query->hdr ); *pView = query; } msiobj_release( &query->hdr ); return r; } UINT MSI_OpenQuery( MSIDATABASE *db, MSIQUERY **view, LPCWSTR fmt, ... ) { UINT r; int size = 100, res; LPWSTR query; /* construct the string */ for (;;) { va_list va; query = msi_alloc( size*sizeof(WCHAR) ); va_start(va, fmt); res = vsnprintfW(query, size, fmt, va); va_end(va); if (res == -1) size *= 2; else if (res >= size) size = res + 1; else break; msi_free( query ); } /* perform the query */ r = MSI_DatabaseOpenViewW(db, query, view); msi_free(query); return r; } UINT MSI_IterateRecords( MSIQUERY *view, LPDWORD count, record_func func, LPVOID param ) { MSIRECORD *rec = NULL; UINT r, n = 0, max = 0; r = MSI_ViewExecute( view, NULL ); if( r != ERROR_SUCCESS ) return r; if( count ) max = *count; /* iterate a query */ for( n = 0; (max == 0) || (n < max); n++ ) { r = MSI_ViewFetch( view, &rec ); if( r != ERROR_SUCCESS ) break; if (func) r = func( rec, param ); msiobj_release( &rec->hdr ); if( r != ERROR_SUCCESS ) break; } MSI_ViewClose( view ); if( count ) *count = n; if( r == ERROR_NO_MORE_ITEMS ) r = ERROR_SUCCESS; return r; } /* return a single record from a query */ MSIRECORD *MSI_QueryGetRecord( MSIDATABASE *db, LPCWSTR fmt, ... ) { MSIRECORD *rec = NULL; MSIQUERY *view = NULL; UINT r; int size = 100, res; LPWSTR query; /* construct the string */ for (;;) { va_list va; query = msi_alloc( size*sizeof(WCHAR) ); va_start(va, fmt); res = vsnprintfW(query, size, fmt, va); va_end(va); if (res == -1) size *= 2; else if (res >= size) size = res + 1; else break; msi_free( query ); } /* perform the query */ r = MSI_DatabaseOpenViewW(db, query, &view); msi_free(query); if( r == ERROR_SUCCESS ) { MSI_ViewExecute( view, NULL ); MSI_ViewFetch( view, &rec ); MSI_ViewClose( view ); msiobj_release( &view->hdr ); } return rec; } UINT WINAPI MsiDatabaseOpenViewW(MSIHANDLE hdb, LPCWSTR szQuery, MSIHANDLE *phView) { MSIDATABASE *db; MSIQUERY *query = NULL; UINT ret; TRACE("%s %p\n", debugstr_w(szQuery), phView); db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE ); if( !db ) { HRESULT hr; IWineMsiRemoteDatabase *remote_database; remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hdb ); if ( !remote_database ) return ERROR_INVALID_HANDLE; hr = IWineMsiRemoteDatabase_OpenView( remote_database, szQuery, phView ); IWineMsiRemoteDatabase_Release( remote_database ); if (FAILED(hr)) { if (HRESULT_FACILITY(hr) == FACILITY_WIN32) return HRESULT_CODE(hr); return ERROR_FUNCTION_FAILED; } return ERROR_SUCCESS; } ret = MSI_DatabaseOpenViewW( db, szQuery, &query ); if( ret == ERROR_SUCCESS ) { *phView = alloc_msihandle( &query->hdr ); if (! *phView) ret = ERROR_NOT_ENOUGH_MEMORY; msiobj_release( &query->hdr ); } msiobj_release( &db->hdr ); return ret; } UINT msi_view_get_row(MSIDATABASE *db, MSIVIEW *view, UINT row, MSIRECORD **rec) { UINT row_count = 0, col_count = 0, i, ival, ret, type; TRACE("%p %p %d %p\n", db, view, row, rec); ret = view->ops->get_dimensions(view, &row_count, &col_count); if (ret) return ret; if (!col_count) return ERROR_INVALID_PARAMETER; if (row >= row_count) return ERROR_NO_MORE_ITEMS; *rec = MSI_CreateRecord(col_count); if (!*rec) return ERROR_FUNCTION_FAILED; for (i = 1; i <= col_count; i++) { ret = view->ops->get_column_info(view, i, NULL, &type, NULL, NULL); if (ret) { ERR("Error getting column type for %d\n", i); continue; } if (MSITYPE_IS_BINARY(type)) { IStream *stm = NULL; ret = view->ops->fetch_stream(view, row, i, &stm); if ((ret == ERROR_SUCCESS) && stm) { MSI_RecordSetIStream(*rec, i, stm); IStream_Release(stm); } else WARN("failed to get stream\n"); continue; } ret = view->ops->fetch_int(view, row, i, &ival); if (ret) { ERR("Error fetching data for %d\n", i); continue; } if (! (type & MSITYPE_VALID)) ERR("Invalid type!\n"); /* check if it's nul (0) - if so, don't set anything */ if (!ival) continue; if (type & MSITYPE_STRING) { int len; const WCHAR *sval = msi_string_lookup( db->strings, ival, &len ); msi_record_set_string( *rec, i, sval, len ); } else { if ((type & MSI_DATASIZEMASK) == 2) MSI_RecordSetInteger(*rec, i, ival - (1<<15)); else MSI_RecordSetInteger(*rec, i, ival - (1u<<31)); } } return ERROR_SUCCESS; } UINT MSI_ViewFetch(MSIQUERY *query, MSIRECORD **prec) { MSIVIEW *view; UINT r; TRACE("%p %p\n", query, prec ); view = query->view; if( !view ) return ERROR_FUNCTION_FAILED; r = msi_view_get_row(query->db, view, query->row, prec); if (r == ERROR_SUCCESS) { query->row ++; MSI_RecordSetIntPtr(*prec, 0, (INT_PTR)query); } return r; } UINT WINAPI MsiViewFetch(MSIHANDLE hView, MSIHANDLE *record) { MSIQUERY *query; MSIRECORD *rec = NULL; UINT ret; TRACE("%d %p\n", hView, record); if( !record ) return ERROR_INVALID_PARAMETER; *record = 0; query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW ); if( !query ) return ERROR_INVALID_HANDLE; ret = MSI_ViewFetch( query, &rec ); if( ret == ERROR_SUCCESS ) { *record = alloc_msihandle( &rec->hdr ); if (! *record) ret = ERROR_NOT_ENOUGH_MEMORY; msiobj_release( &rec->hdr ); } msiobj_release( &query->hdr ); return ret; } UINT MSI_ViewClose(MSIQUERY *query) { MSIVIEW *view; TRACE("%p\n", query ); view = query->view; if( !view ) return ERROR_FUNCTION_FAILED; if( !view->ops->close ) return ERROR_FUNCTION_FAILED; return view->ops->close( view ); } UINT WINAPI MsiViewClose(MSIHANDLE hView) { MSIQUERY *query; UINT ret; TRACE("%d\n", hView ); query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW ); if( !query ) return ERROR_INVALID_HANDLE; ret = MSI_ViewClose( query ); msiobj_release( &query->hdr ); return ret; } UINT MSI_ViewExecute(MSIQUERY *query, MSIRECORD *rec ) { MSIVIEW *view; TRACE("%p %p\n", query, rec); view = query->view; if( !view ) return ERROR_FUNCTION_FAILED; if( !view->ops->execute ) return ERROR_FUNCTION_FAILED; query->row = 0; return view->ops->execute( view, rec ); } UINT WINAPI MsiViewExecute(MSIHANDLE hView, MSIHANDLE hRec) { MSIQUERY *query; MSIRECORD *rec = NULL; UINT ret; TRACE("%d %d\n", hView, hRec); query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW ); if( !query ) return ERROR_INVALID_HANDLE; if( hRec ) { rec = msihandle2msiinfo( hRec, MSIHANDLETYPE_RECORD ); if( !rec ) { ret = ERROR_INVALID_HANDLE; goto out; } } msiobj_lock( &rec->hdr ); ret = MSI_ViewExecute( query, rec ); msiobj_unlock( &rec->hdr ); out: msiobj_release( &query->hdr ); if( rec ) msiobj_release( &rec->hdr ); return ret; } static UINT msi_set_record_type_string( MSIRECORD *rec, UINT field, UINT type, BOOL temporary ) { static const WCHAR fmt[] = { '%','d',0 }; WCHAR szType[0x10]; if (MSITYPE_IS_BINARY(type)) szType[0] = 'v'; else if (type & MSITYPE_LOCALIZABLE) szType[0] = 'l'; else if (type & MSITYPE_UNKNOWN) szType[0] = 'f'; else if (type & MSITYPE_STRING) { if (temporary) szType[0] = 'g'; else szType[0] = 's'; } else { if (temporary) szType[0] = 'j'; else szType[0] = 'i'; } if (type & MSITYPE_NULLABLE) szType[0] &= ~0x20; sprintfW( &szType[1], fmt, (type&0xff) ); TRACE("type %04x -> %s\n", type, debugstr_w(szType) ); return MSI_RecordSetStringW( rec, field, szType ); } UINT MSI_ViewGetColumnInfo( MSIQUERY *query, MSICOLINFO info, MSIRECORD **prec ) { UINT r = ERROR_FUNCTION_FAILED, i, count = 0, type; MSIRECORD *rec; MSIVIEW *view = query->view; LPCWSTR name; BOOL temporary; if( !view ) return ERROR_FUNCTION_FAILED; if( !view->ops->get_dimensions ) return ERROR_FUNCTION_FAILED; r = view->ops->get_dimensions( view, NULL, &count ); if( r != ERROR_SUCCESS ) return r; if( !count ) return ERROR_INVALID_PARAMETER; rec = MSI_CreateRecord( count ); if( !rec ) return ERROR_FUNCTION_FAILED; for( i=0; i<count; i++ ) { name = NULL; r = view->ops->get_column_info( view, i+1, &name, &type, &temporary, NULL ); if( r != ERROR_SUCCESS ) continue; if (info == MSICOLINFO_NAMES) MSI_RecordSetStringW( rec, i+1, name ); else msi_set_record_type_string( rec, i+1, type, temporary ); } *prec = rec; return ERROR_SUCCESS; } UINT WINAPI MsiViewGetColumnInfo(MSIHANDLE hView, MSICOLINFO info, MSIHANDLE *hRec) { MSIQUERY *query = NULL; MSIRECORD *rec = NULL; UINT r; TRACE("%d %d %p\n", hView, info, hRec); if( !hRec ) return ERROR_INVALID_PARAMETER; if( info != MSICOLINFO_NAMES && info != MSICOLINFO_TYPES ) return ERROR_INVALID_PARAMETER; query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW ); if( !query ) return ERROR_INVALID_HANDLE; r = MSI_ViewGetColumnInfo( query, info, &rec ); if ( r == ERROR_SUCCESS ) { *hRec = alloc_msihandle( &rec->hdr ); if ( !*hRec ) r = ERROR_NOT_ENOUGH_MEMORY; msiobj_release( &rec->hdr ); } msiobj_release( &query->hdr ); return r; } UINT MSI_ViewModify( MSIQUERY *query, MSIMODIFY mode, MSIRECORD *rec ) { MSIVIEW *view = NULL; UINT r; if ( !query || !rec ) return ERROR_INVALID_HANDLE; view = query->view; if ( !view || !view->ops->modify) return ERROR_FUNCTION_FAILED; if ( mode == MSIMODIFY_UPDATE && MSI_RecordGetIntPtr( rec, 0 ) != (INT_PTR)query ) return ERROR_FUNCTION_FAILED; r = view->ops->modify( view, mode, rec, query->row ); if (mode == MSIMODIFY_DELETE && r == ERROR_SUCCESS) query->row--; return r; } UINT WINAPI MsiViewModify( MSIHANDLE hView, MSIMODIFY eModifyMode, MSIHANDLE hRecord) { MSIQUERY *query = NULL; MSIRECORD *rec = NULL; UINT r = ERROR_FUNCTION_FAILED; TRACE("%d %x %d\n", hView, eModifyMode, hRecord); query = msihandle2msiinfo( hView, MSIHANDLETYPE_VIEW ); if( !query ) return ERROR_INVALID_HANDLE; rec = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD ); r = MSI_ViewModify( query, eModifyMode, rec ); msiobj_release( &query->hdr ); if( rec ) msiobj_release( &rec->hdr ); return r; } MSIDBERROR WINAPI MsiViewGetErrorW( MSIHANDLE handle, LPWSTR buffer, LPDWORD buflen ) { MSIQUERY *query; const WCHAR *column; MSIDBERROR r; DWORD len; TRACE("%u %p %p\n", handle, buffer, buflen); if (!buflen) return MSIDBERROR_INVALIDARG; query = msihandle2msiinfo( handle, MSIHANDLETYPE_VIEW ); if( !query ) return MSIDBERROR_INVALIDARG; if ((r = query->view->error)) column = query->view->error_column; else column = szEmpty; len = strlenW( column ); if (buffer) { if (*buflen > len) strcpyW( buffer, column ); else r = MSIDBERROR_MOREDATA; } *buflen = len; msiobj_release( &query->hdr ); return r; } MSIDBERROR WINAPI MsiViewGetErrorA( MSIHANDLE handle, LPSTR buffer, LPDWORD buflen ) { MSIQUERY *query; const WCHAR *column; MSIDBERROR r; DWORD len; TRACE("%u %p %p\n", handle, buffer, buflen); if (!buflen) return MSIDBERROR_INVALIDARG; query = msihandle2msiinfo( handle, MSIHANDLETYPE_VIEW ); if (!query) return MSIDBERROR_INVALIDARG; if ((r = query->view->error)) column = query->view->error_column; else column = szEmpty; len = WideCharToMultiByte( CP_ACP, 0, column, -1, NULL, 0, NULL, NULL ); if (buffer) { if (*buflen >= len) WideCharToMultiByte( CP_ACP, 0, column, -1, buffer, *buflen, NULL, NULL ); else r = MSIDBERROR_MOREDATA; } *buflen = len - 1; msiobj_release( &query->hdr ); return r; } MSIHANDLE WINAPI MsiGetLastErrorRecord( void ) { FIXME("\n"); return 0; } UINT MSI_DatabaseApplyTransformW( MSIDATABASE *db, LPCWSTR szTransformFile, int iErrorCond ) { HRESULT r; UINT ret = ERROR_FUNCTION_FAILED; IStorage *stg = NULL; STATSTG stat; TRACE("%p %s %d\n", db, debugstr_w(szTransformFile), iErrorCond); r = StgOpenStorage( szTransformFile, NULL, STGM_DIRECT|STGM_READ|STGM_SHARE_DENY_WRITE, NULL, 0, &stg); if ( FAILED(r) ) { WARN("failed to open transform 0x%08x\n", r); return ret; } r = IStorage_Stat( stg, &stat, STATFLAG_NONAME ); if ( FAILED( r ) ) goto end; if ( !IsEqualGUID( &stat.clsid, &CLSID_MsiTransform ) ) goto end; if( TRACE_ON( msi ) ) enum_stream_names( stg ); ret = msi_table_apply_transform( db, stg ); end: IStorage_Release( stg ); return ret; } UINT WINAPI MsiDatabaseApplyTransformW( MSIHANDLE hdb, LPCWSTR szTransformFile, int iErrorCond) { MSIDATABASE *db; UINT r; db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE ); if( !db ) { IWineMsiRemoteDatabase *remote_database; remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hdb ); if ( !remote_database ) return ERROR_INVALID_HANDLE; IWineMsiRemoteDatabase_Release( remote_database ); WARN("MsiDatabaseApplyTransform not allowed during a custom action!\n"); return ERROR_SUCCESS; } r = MSI_DatabaseApplyTransformW( db, szTransformFile, iErrorCond ); msiobj_release( &db->hdr ); return r; } UINT WINAPI MsiDatabaseApplyTransformA( MSIHANDLE hdb, LPCSTR szTransformFile, int iErrorCond) { LPWSTR wstr; UINT ret; TRACE("%d %s %d\n", hdb, debugstr_a(szTransformFile), iErrorCond); wstr = strdupAtoW( szTransformFile ); if( szTransformFile && !wstr ) return ERROR_NOT_ENOUGH_MEMORY; ret = MsiDatabaseApplyTransformW( hdb, wstr, iErrorCond); msi_free( wstr ); return ret; } UINT WINAPI MsiDatabaseGenerateTransformA( MSIHANDLE hdb, MSIHANDLE hdbref, LPCSTR szTransformFile, int iReserved1, int iReserved2 ) { FIXME("%d %d %s %d %d\n", hdb, hdbref, debugstr_a(szTransformFile), iReserved1, iReserved2); return ERROR_CALL_NOT_IMPLEMENTED; } UINT WINAPI MsiDatabaseGenerateTransformW( MSIHANDLE hdb, MSIHANDLE hdbref, LPCWSTR szTransformFile, int iReserved1, int iReserved2 ) { FIXME("%d %d %s %d %d\n", hdb, hdbref, debugstr_w(szTransformFile), iReserved1, iReserved2); return ERROR_CALL_NOT_IMPLEMENTED; } UINT WINAPI MsiDatabaseCommit( MSIHANDLE hdb ) { MSIDATABASE *db; UINT r; TRACE("%d\n", hdb); db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE ); if( !db ) { IWineMsiRemoteDatabase *remote_database; remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hdb ); if ( !remote_database ) return ERROR_INVALID_HANDLE; IWineMsiRemoteDatabase_Release( remote_database ); WARN("not allowed during a custom action!\n"); return ERROR_SUCCESS; } if (db->mode == MSIDBOPEN_READONLY) { msiobj_release( &db->hdr ); return ERROR_SUCCESS; } /* FIXME: lock the database */ r = msi_commit_streams( db ); if (r != ERROR_SUCCESS) ERR("Failed to commit streams!\n"); else { r = MSI_CommitTables( db ); if (r != ERROR_SUCCESS) ERR("Failed to commit tables!\n"); } /* FIXME: unlock the database */ msiobj_release( &db->hdr ); if (r == ERROR_SUCCESS) { msi_free( db->deletefile ); db->deletefile = NULL; } return r; } struct msi_primary_key_record_info { DWORD n; MSIRECORD *rec; }; static UINT msi_primary_key_iterator( MSIRECORD *rec, LPVOID param ) { struct msi_primary_key_record_info *info = param; LPCWSTR name, table; DWORD type; type = MSI_RecordGetInteger( rec, 4 ); if( type & MSITYPE_KEY ) { info->n++; if( info->rec ) { if ( info->n == 1 ) { table = MSI_RecordGetString( rec, 1 ); MSI_RecordSetStringW( info->rec, 0, table); } name = MSI_RecordGetString( rec, 3 ); MSI_RecordSetStringW( info->rec, info->n, name ); } } return ERROR_SUCCESS; } UINT MSI_DatabaseGetPrimaryKeys( MSIDATABASE *db, LPCWSTR table, MSIRECORD **prec ) { static const WCHAR sql[] = { 's','e','l','e','c','t',' ','*',' ', 'f','r','o','m',' ','`','_','C','o','l','u','m','n','s','`',' ', 'w','h','e','r','e',' ', '`','T','a','b','l','e','`',' ','=',' ','\'','%','s','\'',0 }; struct msi_primary_key_record_info info; MSIQUERY *query = NULL; UINT r; if (!TABLE_Exists( db, table )) return ERROR_INVALID_TABLE; r = MSI_OpenQuery( db, &query, sql, table ); if( r != ERROR_SUCCESS ) return r; /* count the number of primary key records */ info.n = 0; info.rec = 0; r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info ); if( r == ERROR_SUCCESS ) { TRACE("Found %d primary keys\n", info.n ); /* allocate a record and fill in the names of the tables */ info.rec = MSI_CreateRecord( info.n ); info.n = 0; r = MSI_IterateRecords( query, 0, msi_primary_key_iterator, &info ); if( r == ERROR_SUCCESS ) *prec = info.rec; else msiobj_release( &info.rec->hdr ); } msiobj_release( &query->hdr ); return r; } UINT WINAPI MsiDatabaseGetPrimaryKeysW( MSIHANDLE hdb, LPCWSTR table, MSIHANDLE* phRec ) { MSIRECORD *rec = NULL; MSIDATABASE *db; UINT r; TRACE("%d %s %p\n", hdb, debugstr_w(table), phRec); db = msihandle2msiinfo( hdb, MSIHANDLETYPE_DATABASE ); if( !db ) { HRESULT hr; IWineMsiRemoteDatabase *remote_database; remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hdb ); if ( !remote_database ) return ERROR_INVALID_HANDLE; hr = IWineMsiRemoteDatabase_GetPrimaryKeys( remote_database, table, phRec ); IWineMsiRemoteDatabase_Release( remote_database ); if (FAILED(hr)) { if (HRESULT_FACILITY(hr) == FACILITY_WIN32) return HRESULT_CODE(hr); return ERROR_FUNCTION_FAILED; } return ERROR_SUCCESS; } r = MSI_DatabaseGetPrimaryKeys( db, table, &rec ); if( r == ERROR_SUCCESS ) { *phRec = alloc_msihandle( &rec->hdr ); if (! *phRec) r = ERROR_NOT_ENOUGH_MEMORY; msiobj_release( &rec->hdr ); } msiobj_release( &db->hdr ); return r; } UINT WINAPI MsiDatabaseGetPrimaryKeysA(MSIHANDLE hdb, LPCSTR table, MSIHANDLE* phRec) { LPWSTR szwTable = NULL; UINT r; TRACE("%d %s %p\n", hdb, debugstr_a(table), phRec); if( table ) { szwTable = strdupAtoW( table ); if( !szwTable ) return ERROR_OUTOFMEMORY; } r = MsiDatabaseGetPrimaryKeysW( hdb, szwTable, phRec ); msi_free( szwTable ); return r; } MSICONDITION WINAPI MsiDatabaseIsTablePersistentA( MSIHANDLE hDatabase, LPCSTR szTableName) { LPWSTR szwTableName = NULL; MSICONDITION r; TRACE("%x %s\n", hDatabase, debugstr_a(szTableName)); if( szTableName ) { szwTableName = strdupAtoW( szTableName ); if( !szwTableName ) return MSICONDITION_ERROR; } r = MsiDatabaseIsTablePersistentW( hDatabase, szwTableName ); msi_free( szwTableName ); return r; } MSICONDITION WINAPI MsiDatabaseIsTablePersistentW( MSIHANDLE hDatabase, LPCWSTR szTableName) { MSIDATABASE *db; MSICONDITION r; TRACE("%x %s\n", hDatabase, debugstr_w(szTableName)); db = msihandle2msiinfo( hDatabase, MSIHANDLETYPE_DATABASE ); if( !db ) { HRESULT hr; MSICONDITION condition; IWineMsiRemoteDatabase *remote_database; remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( hDatabase ); if ( !remote_database ) return MSICONDITION_ERROR; hr = IWineMsiRemoteDatabase_IsTablePersistent( remote_database, szTableName, &condition ); IWineMsiRemoteDatabase_Release( remote_database ); if (FAILED(hr)) return MSICONDITION_ERROR; return condition; } r = MSI_DatabaseIsTablePersistent( db, szTableName ); msiobj_release( &db->hdr ); return r; }