2002-04-02 04:57:50 +02:00
|
|
|
/*
|
|
|
|
* Setupapi install routines
|
|
|
|
*
|
|
|
|
* Copyright 2002 Alexandre Julliard 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
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "windef.h"
|
|
|
|
#include "winbase.h"
|
|
|
|
#include "ntddk.h"
|
|
|
|
#include "winerror.h"
|
|
|
|
#include "setupapi.h"
|
|
|
|
#include "wine/unicode.h"
|
|
|
|
#include "setupapi_private.h"
|
|
|
|
#include "wine/debug.h"
|
|
|
|
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
|
|
|
|
|
|
|
|
/* info passed to callback functions dealing with files */
|
|
|
|
struct files_callback_info
|
|
|
|
{
|
|
|
|
HSPFILEQ queue;
|
|
|
|
PCWSTR src_root;
|
|
|
|
UINT copy_flags;
|
|
|
|
HINF layout;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* info passed to callback functions dealing with the registry */
|
|
|
|
struct registry_callback_info
|
|
|
|
{
|
|
|
|
HKEY default_root;
|
|
|
|
BOOL delete;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef BOOL (*iterate_fields_func)( HINF hinf, PCWSTR field, void *arg );
|
|
|
|
|
|
|
|
/* Unicode constants */
|
|
|
|
static const WCHAR CopyFiles[] = {'C','o','p','y','F','i','l','e','s',0};
|
|
|
|
static const WCHAR DelFiles[] = {'D','e','l','F','i','l','e','s',0};
|
|
|
|
static const WCHAR RenFiles[] = {'R','e','n','F','i','l','e','s',0};
|
|
|
|
static const WCHAR Ini2Reg[] = {'I','n','i','2','R','e','g',0};
|
|
|
|
static const WCHAR LogConf[] = {'L','o','g','C','o','n','f',0};
|
|
|
|
static const WCHAR AddReg[] = {'A','d','d','R','e','g',0};
|
|
|
|
static const WCHAR DelReg[] = {'D','e','l','R','e','g',0};
|
|
|
|
static const WCHAR UpdateInis[] = {'U','p','d','a','t','e','I','n','i','s',0};
|
|
|
|
static const WCHAR UpdateIniFields[] = {'U','p','d','a','t','e','I','n','i','F','i','e','l','d','s',0};
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* get_field_string
|
|
|
|
*
|
|
|
|
* Retrieve the contents of a field, dynamically growing the buffer if necessary.
|
|
|
|
*/
|
|
|
|
static WCHAR *get_field_string( INFCONTEXT *context, DWORD index, WCHAR *buffer,
|
|
|
|
WCHAR *static_buffer, DWORD *size )
|
|
|
|
{
|
|
|
|
DWORD required;
|
|
|
|
|
|
|
|
if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
|
|
|
|
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
|
|
|
|
{
|
|
|
|
/* now grow the buffer */
|
|
|
|
if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
|
|
|
|
if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required*sizeof(WCHAR) ))) return NULL;
|
|
|
|
*size = required;
|
|
|
|
if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
|
|
|
|
}
|
|
|
|
if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* copy_files_callback
|
|
|
|
*
|
|
|
|
* Called once for each CopyFiles entry in a given section.
|
|
|
|
*/
|
|
|
|
static BOOL copy_files_callback( HINF hinf, PCWSTR field, void *arg )
|
|
|
|
{
|
|
|
|
struct files_callback_info *info = arg;
|
|
|
|
|
|
|
|
if (field[0] == '@') /* special case: copy single file */
|
|
|
|
SetupQueueDefaultCopyW( info->queue, info->layout, info->src_root, NULL, field, info->copy_flags );
|
|
|
|
else
|
|
|
|
SetupQueueCopySectionW( info->queue, info->src_root, info->layout, hinf, field, info->copy_flags );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* delete_files_callback
|
|
|
|
*
|
|
|
|
* Called once for each DelFiles entry in a given section.
|
|
|
|
*/
|
|
|
|
static BOOL delete_files_callback( HINF hinf, PCWSTR field, void *arg )
|
|
|
|
{
|
|
|
|
struct files_callback_info *info = arg;
|
|
|
|
SetupQueueDeleteSectionW( info->queue, hinf, 0, field );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* rename_files_callback
|
|
|
|
*
|
|
|
|
* Called once for each RenFiles entry in a given section.
|
|
|
|
*/
|
|
|
|
static BOOL rename_files_callback( HINF hinf, PCWSTR field, void *arg )
|
|
|
|
{
|
|
|
|
struct files_callback_info *info = arg;
|
|
|
|
SetupQueueRenameSectionW( info->queue, hinf, 0, field );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* get_root_key
|
|
|
|
*
|
|
|
|
* Retrieve the registry root key from its name.
|
|
|
|
*/
|
|
|
|
static HKEY get_root_key( const WCHAR *name, HKEY def_root )
|
|
|
|
{
|
|
|
|
static const WCHAR HKCR[] = {'H','K','C','R',0};
|
|
|
|
static const WCHAR HKCU[] = {'H','K','C','U',0};
|
|
|
|
static const WCHAR HKLM[] = {'H','K','L','M',0};
|
|
|
|
static const WCHAR HKU[] = {'H','K','U',0};
|
|
|
|
static const WCHAR HKR[] = {'H','K','R',0};
|
|
|
|
|
|
|
|
if (!strcmpiW( name, HKCR )) return HKEY_CLASSES_ROOT;
|
|
|
|
if (!strcmpiW( name, HKCU )) return HKEY_CURRENT_USER;
|
|
|
|
if (!strcmpiW( name, HKLM )) return HKEY_LOCAL_MACHINE;
|
|
|
|
if (!strcmpiW( name, HKU )) return HKEY_USERS;
|
|
|
|
if (!strcmpiW( name, HKR )) return def_root;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* append_multi_sz_value
|
|
|
|
*
|
|
|
|
* Append a multisz string to a multisz registry value.
|
|
|
|
*/
|
|
|
|
static void append_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *strings,
|
|
|
|
DWORD str_size )
|
|
|
|
{
|
|
|
|
DWORD size, type, total;
|
|
|
|
WCHAR *buffer, *p;
|
|
|
|
|
|
|
|
if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
|
|
|
|
if (type != REG_MULTI_SZ) return;
|
|
|
|
|
|
|
|
if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (size + str_size) * sizeof(WCHAR) ))) return;
|
|
|
|
if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
|
|
|
|
|
|
|
|
/* compare each string against all the existing ones */
|
|
|
|
total = size;
|
|
|
|
while (*strings)
|
|
|
|
{
|
|
|
|
int len = strlenW(strings) + 1;
|
|
|
|
|
|
|
|
for (p = buffer; *p; p += strlenW(p) + 1)
|
|
|
|
if (!strcmpiW( p, strings )) break;
|
|
|
|
|
|
|
|
if (!*p) /* not found, need to append it */
|
|
|
|
{
|
|
|
|
memcpy( p, strings, len * sizeof(WCHAR) );
|
|
|
|
p[len] = 0;
|
|
|
|
total += len;
|
|
|
|
}
|
|
|
|
strings += len;
|
|
|
|
}
|
|
|
|
if (total != size)
|
|
|
|
{
|
|
|
|
TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer) );
|
|
|
|
RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, (BYTE *)buffer, total );
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
HeapFree( GetProcessHeap(), 0, buffer );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* delete_multi_sz_value
|
|
|
|
*
|
|
|
|
* Remove a string from a multisz registry value.
|
|
|
|
*/
|
|
|
|
static void delete_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *string )
|
|
|
|
{
|
|
|
|
DWORD size, type;
|
|
|
|
WCHAR *buffer, *src, *dst;
|
|
|
|
|
|
|
|
if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
|
|
|
|
if (type != REG_MULTI_SZ) return;
|
|
|
|
/* allocate double the size, one for value before and one for after */
|
|
|
|
if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * 2 * sizeof(WCHAR) ))) return;
|
|
|
|
if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
|
|
|
|
src = buffer;
|
|
|
|
dst = buffer + size;
|
|
|
|
while (*src)
|
|
|
|
{
|
|
|
|
int len = strlenW(src) + 1;
|
|
|
|
if (strcmpiW( src, string ))
|
|
|
|
{
|
|
|
|
memcpy( dst, src, len * sizeof(WCHAR) );
|
|
|
|
dst += len;
|
|
|
|
}
|
|
|
|
src += len;
|
|
|
|
}
|
|
|
|
*dst++ = 0;
|
|
|
|
if (dst != buffer + 2*size) /* did we remove something? */
|
|
|
|
{
|
|
|
|
TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer + size) );
|
|
|
|
RegSetValueExW( hkey, value, 0, REG_MULTI_SZ,
|
|
|
|
(BYTE *)(buffer + size), dst - (buffer + size) );
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
HeapFree( GetProcessHeap(), 0, buffer );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* do_reg_operation
|
|
|
|
*
|
|
|
|
* Perform an add/delete registry operation depending on the flags.
|
|
|
|
*/
|
|
|
|
static BOOL do_reg_operation( HKEY hkey, const WCHAR *value, INFCONTEXT *context, INT flags )
|
|
|
|
{
|
|
|
|
DWORD type, size;
|
|
|
|
|
|
|
|
if (flags & (FLG_ADDREG_DELREG_BIT | FLG_ADDREG_DELVAL)) /* deletion */
|
|
|
|
{
|
|
|
|
if (*value && !(flags & FLG_DELREG_KEYONLY_COMMON))
|
|
|
|
{
|
|
|
|
if ((flags & FLG_DELREG_MULTI_SZ_DELSTRING) == FLG_DELREG_MULTI_SZ_DELSTRING)
|
|
|
|
{
|
|
|
|
WCHAR *str;
|
|
|
|
|
|
|
|
if (!SetupGetStringFieldW( context, 5, NULL, 0, &size ) || !size) return TRUE;
|
|
|
|
if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
|
|
|
|
SetupGetStringFieldW( context, 5, str, size, NULL );
|
|
|
|
delete_multi_sz_value( hkey, value, str );
|
|
|
|
HeapFree( GetProcessHeap(), 0, str );
|
|
|
|
}
|
|
|
|
else RegDeleteValueW( hkey, value );
|
|
|
|
}
|
|
|
|
else RegDeleteKeyW( hkey, NULL );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & (FLG_ADDREG_KEYONLY|FLG_ADDREG_KEYONLY_COMMON)) return TRUE;
|
|
|
|
|
|
|
|
if (flags & (FLG_ADDREG_NOCLOBBER|FLG_ADDREG_OVERWRITEONLY))
|
|
|
|
{
|
|
|
|
BOOL exists = !RegQueryValueExW( hkey, value, NULL, NULL, NULL, NULL );
|
|
|
|
if (exists && (flags & FLG_ADDREG_NOCLOBBER)) return TRUE;
|
|
|
|
if (!exists & (flags & FLG_ADDREG_OVERWRITEONLY)) return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(flags & FLG_ADDREG_TYPE_MASK)
|
|
|
|
{
|
|
|
|
case FLG_ADDREG_TYPE_SZ: type = REG_SZ; break;
|
|
|
|
case FLG_ADDREG_TYPE_MULTI_SZ: type = REG_MULTI_SZ; break;
|
|
|
|
case FLG_ADDREG_TYPE_EXPAND_SZ: type = REG_EXPAND_SZ; break;
|
|
|
|
case FLG_ADDREG_TYPE_BINARY: type = REG_BINARY; break;
|
|
|
|
case FLG_ADDREG_TYPE_DWORD: type = REG_DWORD; break;
|
|
|
|
case FLG_ADDREG_TYPE_NONE: type = REG_NONE; break;
|
|
|
|
default: type = flags >> 16; break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(flags & FLG_ADDREG_BINVALUETYPE) ||
|
|
|
|
(type == REG_DWORD && SetupGetFieldCount(context) == 5))
|
|
|
|
{
|
|
|
|
static const WCHAR empty;
|
|
|
|
WCHAR *str = NULL;
|
|
|
|
|
|
|
|
if (type == REG_MULTI_SZ)
|
|
|
|
{
|
|
|
|
if (!SetupGetMultiSzFieldW( context, 5, NULL, 0, &size )) size = 0;
|
|
|
|
if (size)
|
|
|
|
{
|
|
|
|
if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
|
|
|
|
SetupGetMultiSzFieldW( context, 5, str, size, NULL );
|
|
|
|
}
|
|
|
|
if (flags & FLG_ADDREG_APPEND)
|
|
|
|
{
|
|
|
|
if (!str) return TRUE;
|
|
|
|
append_multi_sz_value( hkey, value, str, size );
|
|
|
|
HeapFree( GetProcessHeap(), 0, str );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
/* else fall through to normal string handling */
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!SetupGetStringFieldW( context, 5, NULL, 0, &size )) size = 0;
|
|
|
|
if (size)
|
|
|
|
{
|
|
|
|
if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
|
|
|
|
SetupGetStringFieldW( context, 5, str, size, NULL );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (type == REG_DWORD)
|
|
|
|
{
|
2002-05-16 20:58:47 +02:00
|
|
|
DWORD dw = str ? strtolW( str, NULL, 16 ) : 0;
|
2002-04-02 04:57:50 +02:00
|
|
|
TRACE( "setting dword %s to %lx\n", debugstr_w(value), dw );
|
|
|
|
RegSetValueExW( hkey, value, 0, type, (BYTE *)&dw, sizeof(dw) );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(str) );
|
|
|
|
if (str) RegSetValueExW( hkey, value, 0, type, (BYTE *)str, size * sizeof(WCHAR) );
|
|
|
|
else RegSetValueExW( hkey, value, 0, type, (BYTE *)&empty, sizeof(WCHAR) );
|
|
|
|
}
|
|
|
|
HeapFree( GetProcessHeap(), 0, str );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
else /* get the binary data */
|
|
|
|
{
|
|
|
|
BYTE *data = NULL;
|
|
|
|
|
|
|
|
if (!SetupGetBinaryField( context, 5, NULL, 0, &size )) size = 0;
|
|
|
|
if (size)
|
|
|
|
{
|
|
|
|
if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
|
|
|
|
TRACE( "setting binary data %s len %ld\n", debugstr_w(value), size );
|
|
|
|
SetupGetBinaryField( context, 5, data, size, NULL );
|
|
|
|
}
|
|
|
|
RegSetValueExW( hkey, value, 0, type, data, size );
|
|
|
|
HeapFree( GetProcessHeap(), 0, data );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* registry_callback
|
|
|
|
*
|
|
|
|
* Called once for each AddReg and DelReg entry in a given section.
|
|
|
|
*/
|
|
|
|
static BOOL registry_callback( HINF hinf, PCWSTR field, void *arg )
|
|
|
|
{
|
|
|
|
struct registry_callback_info *info = arg;
|
|
|
|
INFCONTEXT context;
|
|
|
|
HKEY root_key, hkey;
|
|
|
|
|
|
|
|
BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
|
|
|
|
|
|
|
|
for (; ok; ok = SetupFindNextLine( &context, &context ))
|
|
|
|
{
|
|
|
|
WCHAR buffer[MAX_INF_STRING_LENGTH];
|
|
|
|
INT flags;
|
|
|
|
|
|
|
|
/* get root */
|
|
|
|
if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
|
|
|
|
continue;
|
|
|
|
if (!(root_key = get_root_key( buffer, info->default_root )))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* get key */
|
|
|
|
if (!SetupGetStringFieldW( &context, 2, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
|
|
|
|
*buffer = 0;
|
|
|
|
|
|
|
|
/* get flags */
|
|
|
|
if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
|
|
|
|
|
|
|
|
if (!info->delete)
|
|
|
|
{
|
|
|
|
if (flags & FLG_ADDREG_DELREG_BIT) continue; /* ignore this entry */
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!flags) flags = FLG_ADDREG_DELREG_BIT;
|
|
|
|
else if (!(flags & FLG_ADDREG_DELREG_BIT)) continue; /* ignore this entry */
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info->delete || (flags & FLG_ADDREG_OVERWRITEONLY))
|
|
|
|
{
|
|
|
|
if (RegOpenKeyW( root_key, buffer, &hkey )) continue; /* ignore if it doesn't exist */
|
|
|
|
}
|
|
|
|
else if (RegCreateKeyW( root_key, buffer, &hkey ))
|
|
|
|
{
|
|
|
|
ERR( "could not create key %08x %s\n", root_key, debugstr_w(buffer) );
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
TRACE( "key %08x %s\n", root_key, debugstr_w(buffer) );
|
|
|
|
|
|
|
|
/* get value name */
|
|
|
|
if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
|
|
|
|
*buffer = 0;
|
|
|
|
|
|
|
|
/* and now do it */
|
|
|
|
if (!do_reg_operation( hkey, buffer, &context, flags ))
|
|
|
|
{
|
|
|
|
RegCloseKey( hkey );
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
RegCloseKey( hkey );
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static BOOL update_ini_callback( HINF hinf, PCWSTR field, void *arg )
|
|
|
|
{
|
2002-06-13 23:51:45 +02:00
|
|
|
INFCONTEXT context;
|
|
|
|
|
|
|
|
BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
|
|
|
|
|
|
|
|
for (; ok; ok = SetupFindNextLine( &context, &context ))
|
|
|
|
{
|
|
|
|
WCHAR buffer[MAX_INF_STRING_LENGTH];
|
|
|
|
WCHAR filename[MAX_INF_STRING_LENGTH];
|
|
|
|
WCHAR section[MAX_INF_STRING_LENGTH];
|
|
|
|
WCHAR entry[MAX_INF_STRING_LENGTH];
|
|
|
|
WCHAR string[MAX_INF_STRING_LENGTH];
|
|
|
|
LPWSTR divider;
|
|
|
|
|
|
|
|
if (!SetupGetStringFieldW( &context, 1, filename,
|
|
|
|
sizeof(filename)/sizeof(WCHAR), NULL ))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!SetupGetStringFieldW( &context, 2, section,
|
|
|
|
sizeof(section)/sizeof(WCHAR), NULL ))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!SetupGetStringFieldW( &context, 4, buffer,
|
|
|
|
sizeof(buffer)/sizeof(WCHAR), NULL ))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
divider = strchrW(buffer,'=');
|
|
|
|
if (divider)
|
|
|
|
{
|
|
|
|
*divider = 0;
|
|
|
|
strcpyW(entry,buffer);
|
|
|
|
divider++;
|
|
|
|
strcpyW(string,divider);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
strcpyW(entry,buffer);
|
|
|
|
string[0]=0;
|
|
|
|
}
|
|
|
|
|
|
|
|
TRACE("Writing %s = %s in %s of file %s\n",debugstr_w(entry),
|
|
|
|
debugstr_w(string),debugstr_w(section),debugstr_w(filename));
|
|
|
|
WritePrivateProfileStringW(section,entry,string,filename);
|
|
|
|
|
|
|
|
}
|
2002-04-02 04:57:50 +02:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BOOL update_ini_fields_callback( HINF hinf, PCWSTR field, void *arg )
|
|
|
|
{
|
|
|
|
FIXME( "should update ini fields %s\n", debugstr_w(field) );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BOOL ini2reg_callback( HINF hinf, PCWSTR field, void *arg )
|
|
|
|
{
|
|
|
|
FIXME( "should do ini2reg %s\n", debugstr_w(field) );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static BOOL logconf_callback( HINF hinf, PCWSTR field, void *arg )
|
|
|
|
{
|
|
|
|
FIXME( "should do logconf %s\n", debugstr_w(field) );
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* iterate_section_fields
|
|
|
|
*
|
|
|
|
* Iterate over all fields of a certain key of a certain section
|
|
|
|
*/
|
|
|
|
static BOOL iterate_section_fields( HINF hinf, PCWSTR section, PCWSTR key,
|
|
|
|
iterate_fields_func callback, void *arg )
|
|
|
|
{
|
|
|
|
WCHAR static_buffer[200];
|
|
|
|
WCHAR *buffer = static_buffer;
|
|
|
|
DWORD size = sizeof(static_buffer)/sizeof(WCHAR);
|
|
|
|
INFCONTEXT context;
|
|
|
|
BOOL ret = FALSE;
|
|
|
|
|
|
|
|
BOOL ok = SetupFindFirstLineW( hinf, section, key, &context );
|
|
|
|
while (ok)
|
|
|
|
{
|
|
|
|
UINT i, count = SetupGetFieldCount( &context );
|
|
|
|
for (i = 1; i <= count; i++)
|
|
|
|
{
|
|
|
|
if (!(buffer = get_field_string( &context, i, buffer, static_buffer, &size )))
|
|
|
|
goto done;
|
|
|
|
if (!callback( hinf, buffer, arg ))
|
|
|
|
{
|
|
|
|
ERR("callback failed for %s %s\n", debugstr_w(section), debugstr_w(buffer) );
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ok = SetupFindNextMatchLineW( &context, key, &context );
|
|
|
|
}
|
|
|
|
ret = TRUE;
|
|
|
|
done:
|
|
|
|
if (buffer && buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* SetupInstallFilesFromInfSectionA (SETUPAPI.@)
|
|
|
|
*/
|
|
|
|
BOOL WINAPI SetupInstallFilesFromInfSectionA( HINF hinf, HINF hlayout, HSPFILEQ queue,
|
|
|
|
PCSTR section, PCSTR src_root, UINT flags )
|
|
|
|
{
|
|
|
|
UNICODE_STRING sectionW;
|
|
|
|
BOOL ret = FALSE;
|
|
|
|
|
|
|
|
if (!RtlCreateUnicodeStringFromAsciiz( §ionW, section ))
|
|
|
|
{
|
|
|
|
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (!src_root)
|
|
|
|
ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
|
|
|
|
NULL, flags );
|
|
|
|
else
|
|
|
|
{
|
|
|
|
UNICODE_STRING srcW;
|
|
|
|
if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
|
|
|
|
{
|
|
|
|
ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
|
|
|
|
srcW.Buffer, flags );
|
|
|
|
RtlFreeUnicodeString( &srcW );
|
|
|
|
}
|
|
|
|
else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
|
|
}
|
|
|
|
RtlFreeUnicodeString( §ionW );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* SetupInstallFilesFromInfSectionW (SETUPAPI.@)
|
|
|
|
*/
|
|
|
|
BOOL WINAPI SetupInstallFilesFromInfSectionW( HINF hinf, HINF hlayout, HSPFILEQ queue,
|
|
|
|
PCWSTR section, PCWSTR src_root, UINT flags )
|
|
|
|
{
|
|
|
|
struct files_callback_info info;
|
|
|
|
|
|
|
|
info.queue = queue;
|
|
|
|
info.src_root = src_root;
|
|
|
|
info.copy_flags = flags;
|
|
|
|
info.layout = hlayout;
|
|
|
|
return iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* SetupInstallFromInfSectionA (SETUPAPI.@)
|
|
|
|
*/
|
|
|
|
BOOL WINAPI SetupInstallFromInfSectionA( HWND owner, HINF hinf, PCSTR section, UINT flags,
|
|
|
|
HKEY key_root, PCSTR src_root, UINT copy_flags,
|
|
|
|
PSP_FILE_CALLBACK_A callback, PVOID context,
|
|
|
|
HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
|
|
|
|
{
|
|
|
|
UNICODE_STRING sectionW, src_rootW;
|
|
|
|
struct callback_WtoA_context ctx;
|
|
|
|
BOOL ret = FALSE;
|
|
|
|
|
|
|
|
src_rootW.Buffer = NULL;
|
|
|
|
if (src_root && !RtlCreateUnicodeStringFromAsciiz( &src_rootW, src_root ))
|
|
|
|
{
|
|
|
|
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (RtlCreateUnicodeStringFromAsciiz( §ionW, section ))
|
|
|
|
{
|
|
|
|
ctx.orig_context = context;
|
|
|
|
ctx.orig_handler = callback;
|
|
|
|
ret = SetupInstallFromInfSectionW( owner, hinf, sectionW.Buffer, flags, key_root,
|
|
|
|
src_rootW.Buffer, copy_flags, QUEUE_callback_WtoA,
|
|
|
|
&ctx, devinfo, devinfo_data );
|
|
|
|
RtlFreeUnicodeString( §ionW );
|
|
|
|
}
|
|
|
|
else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
|
|
|
|
|
|
RtlFreeUnicodeString( &src_rootW );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
* SetupInstallFromInfSectionW (SETUPAPI.@)
|
|
|
|
*/
|
|
|
|
BOOL WINAPI SetupInstallFromInfSectionW( HWND owner, HINF hinf, PCWSTR section, UINT flags,
|
|
|
|
HKEY key_root, PCWSTR src_root, UINT copy_flags,
|
|
|
|
PSP_FILE_CALLBACK_W callback, PVOID context,
|
|
|
|
HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
|
|
|
|
{
|
|
|
|
if (flags & SPINST_FILES)
|
|
|
|
{
|
|
|
|
struct files_callback_info info;
|
|
|
|
HSPFILEQ queue;
|
|
|
|
BOOL ret;
|
|
|
|
|
|
|
|
if (!(queue = SetupOpenFileQueue())) return FALSE;
|
|
|
|
info.queue = queue;
|
|
|
|
info.src_root = src_root;
|
|
|
|
info.copy_flags = copy_flags;
|
|
|
|
info.layout = hinf;
|
|
|
|
ret = (iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info ) &&
|
|
|
|
iterate_section_fields( hinf, section, DelFiles, delete_files_callback, &info ) &&
|
|
|
|
iterate_section_fields( hinf, section, RenFiles, rename_files_callback, &info ) &&
|
|
|
|
SetupCommitFileQueueW( owner, queue, callback, context ));
|
|
|
|
SetupCloseFileQueue( queue );
|
|
|
|
if (!ret) return FALSE;
|
|
|
|
}
|
|
|
|
if (flags & SPINST_INIFILES)
|
|
|
|
{
|
|
|
|
if (!iterate_section_fields( hinf, section, UpdateInis, update_ini_callback, NULL ) ||
|
|
|
|
!iterate_section_fields( hinf, section, UpdateIniFields,
|
|
|
|
update_ini_fields_callback, NULL ))
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (flags & SPINST_INI2REG)
|
|
|
|
{
|
|
|
|
if (!iterate_section_fields( hinf, section, Ini2Reg, ini2reg_callback, NULL ))
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & SPINST_LOGCONFIG)
|
|
|
|
{
|
|
|
|
if (!iterate_section_fields( hinf, section, LogConf, logconf_callback, NULL ))
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & SPINST_REGISTRY)
|
|
|
|
{
|
|
|
|
struct registry_callback_info info;
|
|
|
|
|
|
|
|
info.default_root = key_root;
|
|
|
|
info.delete = TRUE;
|
|
|
|
if (!iterate_section_fields( hinf, section, DelReg, registry_callback, &info ))
|
|
|
|
return FALSE;
|
2002-06-13 23:51:45 +02:00
|
|
|
info.delete = FALSE;
|
|
|
|
if (!iterate_section_fields( hinf, section, AddReg, registry_callback, &info ))
|
|
|
|
return FALSE;
|
2002-04-02 04:57:50 +02:00
|
|
|
}
|
|
|
|
if (flags & (SPINST_BITREG|SPINST_REGSVR|SPINST_UNREGSVR|SPINST_PROFILEITEMS|SPINST_COPYINF))
|
|
|
|
FIXME( "unsupported flags %x\n", flags );
|
|
|
|
return TRUE;
|
|
|
|
}
|