wine/misc/registry.c
Alexandre Julliard 2ace16ac08 Release 960428
Sun Apr 28 14:32:43 1996  Alexandre Julliard  <julliard@lrc.epfl.ch>

	* [Makefile.in]
	Subdir memory is now also compiled for Winelib, in order to get
	the Win32 heap functions.

	* [if1632/Makefile.in]
	Renamed winprocs and winprocs32 to wprocs and wprocs32 to avoid
	DLL names > 8 characters.

	* [loader/builtin.c] (New file)
	Grouped all built-in DLLs code in a single file.

	* [memory/global.c]
	Use the Win32 heap code instead of malloc() to allocate linear
	memory. This will help test the heap code.

	* [memory/local.c]
	Fixed FreeSelector() to clear DS and ES correctly for huge blocks.

	* [tools/build.c] [if1632/relay.c]
	Removed 'id' directive in spec files. For relay debugging, the DLL
	entry point is now computed from the CS:IP entry point address.
	Added 'heap' directive to specifiy a local heap for the DLL. USER
	and GDI heap are now created this way.

	* [windows/class.c] [include/class.h]
	Changed the class structure to use pointers instead of handles.
	Changed Get/SetClassWord/Long to use a switch statement; this
	allows changing the layout of the CLASS structure.

	* [windows/win.c] [include/win.h]
	Use a CLASS * instead of a handle for the window class.

Sat Apr 27 18:10:11 Martin von Loewis <loewis@informatik.hu-berlin.de>

	* [if1632/kernel32.spec] [memory/global.c]
	  [win32/memory.c] [win32/process.c]
	GetProcessAffinityMask,GlobalLock,IsBadReadPtr,IsBadWritePtr,
	LocalLock,SetThreadAffinityMask: new relays.

	* [win32/cursoricon32.c]
	Return same handle if a cursor is loaded multiple times.

Sat Apr 27 15:13:37 1996  Bang Jun Young <bangjy@nownuri.nowcom.co.kr>

	* [resources/sysres_Ko.rc]
        Added support for Korean [Ko] language.

Fri Apr 26 00:49:05 1996  Huw D. M. Davies <h.davies1@physics.oxford.ac.uk>

	* [objects/dc.c] [objects/font.c]
	Fixed problem with SaveDC()/RestoreDC() and font cache 'used' count.

	* [objects/metafile.c] [objects/dcvalues.c]
	Fixed broken SetTextAlign() on metafiles.

	* [objects/metafile.c]
	Delete objects in handle table at end of PlayMetaFile().

Wed Apr 24 19:21:01  Marcus Meissner <msmeissn@cip.informatik.uni-erlangen.de>

	* [if1632/ver.spec] [misc/ver.c] [include/ver.h] (New files)
	VER.DLL (partially) implemented (VerFindFile,VerInstallFile)
	[If it doesn't work for you, use -dll -ver and report it to me]

	* [if1632/user32.spec] [if1632/kernel32.spec] [if1632/shell.spec]
	  [if1632/shell32.spec] [misc/ole2nls.c] [windows/message.c]
	  [windows/graphics.c]
	Simple win32 functions, where we can just use the win16 counterpart.
	Misc. stubs. 

	* [misc/lstr.c]
	Someone reported a _lstrlen(NULL). NULL is a valid argument. Fixed.

	* [misc/registry.c]
	Some alloclens were off by 1, one double fclose() fixed.
	Requesting value 0 of a key with no values returns an error 
	(should we always return a made up value NULL? what does win3.1?)

Tue Apr 23 17:00:00 1996 Alex Korobka <alex@phm30.pharm.sunysb.edu>

	* [misc/shell.c]
	Implemented FindEnvironmentString(), DoEnvironmentSubst(),
	ExtractIcon(), InternalExtractIcon() and ExtractAssociatedIcon().

	* [misc/user.c]
	Do extensive cleanup on application exit.

	* [windows/hook.c] [windows/win.c] [windows/class.c]
	Added miscellaneous cleanup routines.

	* [controls/menu.c]
	More efficient popup menu window handling.

Mon Apr 22 21:35:22 1996  Albrecht Kleine  <kleine@ak.sax.de>

	* [include/windows.h][objects/oembitmap.c][include/bitmaps/obm_trtype]
	Added "TT-bitmap" for later usage in a ChooseFont() ownerdraw combobox.
1996-04-28 15:09:19 +00:00

2135 lines
46 KiB
C

/*
* Registry Functions
*
* Copyright 1996 Marcus Meissner
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#include <pwd.h>
#include <time.h>
#include "windows.h"
#include "win.h"
#include "winerror.h"
#include "string32.h"
#include "stddebug.h"
#include "debug.h"
#include "xmalloc.h"
#include "winreg.h"
/* FIXME: following defines should be configured global ... */
/* NOTE: do not append a /. linux' mkdir() WILL FAIL if you do that */
#define WINE_PREFIX "/.wine"
#define SAVE_CURRENT_USER_DEFAULT "/usr/local/etc/wine.userreg"
/* relative in ~user/.wine/ */
#define SAVE_CURRENT_USER "user.reg"
#define SAVE_LOCAL_MACHINE_DEFAULT "/usr/local/etc/wine.systemreg"
/* relative in ~user/.wine/ */
#define SAVE_LOCAL_MACHINE "system.reg"
static KEYSTRUCT *key_classes_root=NULL; /* windows 3.1 global values */
static KEYSTRUCT *key_current_user=NULL; /* user specific values */
static KEYSTRUCT *key_local_machine=NULL;/* machine specific values */
static KEYSTRUCT *key_users=NULL; /* all users? */
/* dynamic, not saved */
static KEYSTRUCT *key_performance_data=NULL;
static KEYSTRUCT *key_current_config=NULL;
static KEYSTRUCT *key_dyn_data=NULL;
/* what valuetypes do we need to convert? */
#define UNICONVMASK ((1<<REG_SZ)|(1<<REG_MULTI_SZ)|(1<<REG_EXPAND_SZ))
#define strdupA2W(x) STRING32_DupAnsiToUni(x)
#define strdupW2A(x) STRING32_DupUniToAnsi(x)
#define strdupW(x) STRING32_strdupW(x)
#define strcmpW(a,b) STRING32_lstrcmpW(a,b)
#define strcmpniW(a,b) STRING32_lstrcmpniW(a,b)
#define strchrW(a,c) STRING32_lstrchrW(a,c)
#define strlenW(a) STRING32_UniLen(a)
#define strcpyWA(a,b) STRING32_UniToAnsi(a,b)
static struct openhandle {
LPKEYSTRUCT lpkey;
HKEY hkey;
REGSAM accessmask;
} *openhandles=NULL;
static int nrofopenhandles=0;
static int currenthandle=1;
static void
add_handle(HKEY hkey,LPKEYSTRUCT lpkey,REGSAM accessmask) {
int i;
for (i=0;i<nrofopenhandles;i++) {
if (openhandles[i].lpkey==lpkey) {
dprintf_reg(stddeb,"add_handle:Tried to add %p twice!\n",lpkey);
}
if (openhandles[i].hkey==hkey) {
dprintf_reg(stddeb,"add_handle:Tried to add %lx twice!\n",(LONG)hkey);
}
}
openhandles=xrealloc( openhandles,
sizeof(struct openhandle)*(nrofopenhandles+1)
);
openhandles[i].lpkey = lpkey;
openhandles[i].hkey = hkey;
openhandles[i].accessmask= accessmask;
nrofopenhandles++;
}
static LPKEYSTRUCT
get_handle(HKEY hkey) {
int i;
for (i=0;i<nrofopenhandles;i++)
if (openhandles[i].hkey==hkey)
return openhandles[i].lpkey;
dprintf_reg(stddeb,"get_handle:Didn't find handle %lx?\n",(LONG)hkey);
return NULL;
}
static void
remove_handle(HKEY hkey) {
int i;
for (i=0;i<nrofopenhandles;i++)
if (openhandles[i].hkey==hkey)
break;
if (i==nrofopenhandles) {
dprintf_reg(stddeb,"remove_handle:Didn't find handle %lx?\n",hkey);
return;
}
memcpy( openhandles+i,
openhandles+i+1,
sizeof(struct openhandle)*(nrofopenhandles-i-1)
);
openhandles=xrealloc(openhandles,sizeof(struct openhandle)*(nrofopenhandles-1));
nrofopenhandles--;
return;
}
/* debug function, converts a unicode into a static memory area
* (sub for using two static strings, in case we need them in a single call)
*/
LPSTR
W2C(LPCWSTR x,int sub) {
static LPSTR unicodedebug[2]={NULL,NULL};
if (x==NULL)
return "<NULL>";
if (sub!=0 && sub!=1)
return "<W2C:bad sub>";
if (unicodedebug[sub]) free(unicodedebug[sub]);
unicodedebug[sub] = strdupW2A(x);
return unicodedebug[sub];
}
static LPKEYSTRUCT
lookup_hkey(HKEY hkey) {
switch (hkey) {
case 0x00000000:
case 0x00000001:
case HKEY_CLASSES_ROOT:
return key_classes_root;
case HKEY_CURRENT_USER:
return key_current_user;
case HKEY_LOCAL_MACHINE:
return key_local_machine;
case HKEY_USERS:
return key_users;
case HKEY_PERFORMANCE_DATA:
return key_performance_data;
case HKEY_DYN_DATA:
return key_dyn_data;
case HKEY_CURRENT_CONFIG:
return key_current_config;
default:
dprintf_reg(stddeb,"lookup_hkey(%lx), special key!\n",
(LONG)hkey
);
return get_handle(hkey);
}
/*NOTREACHED*/
}
/*
* splits the unicode string 'wp' into an array of strings.
* the array is allocated by this function.
* the number of components will be stored in 'wpc'
* Free the array using FREE_KEY_PATH
*/
static void
split_keypath(LPCWSTR wp,LPWSTR **wpv,int *wpc) {
int i,j,len;
LPWSTR ws;
ws = strdupW(wp);
*wpc = 1;
for (i=0;ws[i];i++) {
if (ws[i]=='\\') {
ws[i]=0;
(*wpc)++;
}
}
len = i;
*wpv = (LPWSTR*)xmalloc(sizeof(LPWSTR)*(*wpc+2));
(*wpv)[0]= ws;
j = 1;
for (i=1;i<len;i++)
if (ws[i-1]==0)
(*wpv)[j++]=ws+i;
(*wpv)[j]=NULL;
}
#define FREE_KEY_PATH free(wps[0]);free(wps);
/*
* Shell initialisation, allocates keys.
*/
void
SHELL_Init() {
struct passwd *pwd;
HKEY cl_r_hkey,c_u_hkey;
#define ADD_ROOT_KEY(xx) \
xx = (LPKEYSTRUCT)xmalloc(sizeof(KEYSTRUCT));\
memset(xx,'\0',sizeof(KEYSTRUCT));\
xx->keyname= strdupA2W("<should_not_appear_anywhere>");
ADD_ROOT_KEY(key_local_machine);
if (RegCreateKey(HKEY_LOCAL_MACHINE,"\\SOFTWARE\\Classes",&cl_r_hkey)!=ERROR_SUCCESS) {
fprintf(stderr,"couldn't create HKEY_LOCAL_MACHINE\\SOFTWARE\\Classes. This is impossible.\n");
exit(1);
}
key_classes_root = lookup_hkey(cl_r_hkey);
ADD_ROOT_KEY(key_users);
#if 0
/* FIXME: load all users and their resp. pwd->pw_dir/.wine/user.reg
* (later, when a win32 registry editing tool becomes avail.)
*/
while (pwd=getpwent()) {
if (pwd->pw_name == NULL)
continue;
RegCreateKey(HKEY_USERS,pwd->pw_name,&c_u_hkey);
RegCloseKey(c_u_hkey);
}
#endif
pwd=getpwuid(getuid());
if (pwd && pwd->pw_name) {
RegCreateKey(HKEY_USERS,pwd->pw_name,&c_u_hkey);
key_current_user = lookup_hkey(c_u_hkey);
} else {
ADD_ROOT_KEY(key_current_user);
}
ADD_ROOT_KEY(key_performance_data);
ADD_ROOT_KEY(key_current_config);
ADD_ROOT_KEY(key_dyn_data);
#undef ADD_ROOT_KEY
}
/************************ SAVE Registry Function ****************************/
#define REGISTRY_SAVE_VERSION 0x00000001
/* Registry saveformat:
* If you change it, increase above number by 1, which will flush
* old registry database files.
*
* Global:
* "WINE REGISTRY Version %d"
* subkeys....
* Subkeys:
* keyname
* valuename=lastmodified,type,data
* ...
* subkeys
* ...
* keyname,valuename,stringdata:
* the usual ascii characters from 0x00-0xff (well, not 0x00)
* and \uXXXX as UNICODE value XXXX with XXXX>0xff
* ( "=\\\t" escaped in \uXXXX form.)
* type,lastmodified:
* int
*
* FIXME: doesn't save 'class' (what does it mean anyway?), nor flags.
*/
static void
_write_USTRING(FILE *F,LPWSTR wstr,int escapeeq) {
LPWSTR s;
int doescape;
if (wstr==NULL) {
/* FIXME: NULL equals empty string... I hope
* the empty string isn't a valid valuename
*/
return;
}
s=wstr;
while (*s) {
doescape=0;
if (*s>0xff)
doescape = 1;
if (*s=='\n')
doescape = 1;
if (escapeeq && *s=='=')
doescape = 1;
if (*s=='\\')
fputc(*s,F); /* if \\ than put it twice. */
if (doescape)
fprintf(F,"\\u%04x",*((unsigned short*)s));
else
fputc(*s,F);
s++;
}
}
static int
_do_save_subkey(FILE *F,LPKEYSTRUCT lpkey,int level) {
LPKEYSTRUCT lpxkey;
int i,tabs,j;
lpxkey = lpkey;
while (lpxkey) {
if (!(lpxkey->flags & REG_OPTION_VOLATILE)) {
for (tabs=level;tabs--;)
fputc('\t',F);
_write_USTRING(F,lpxkey->keyname,1);
fputs("\n",F);
for (i=0;i<lpxkey->nrofvalues;i++) {
LPKEYVALUE val=lpxkey->values+i;
for (tabs=level+1;tabs--;)
fputc('\t',F);
_write_USTRING(F,val->name,0);
fputc('=',F);
fprintf(F,"%ld,%ld,",val->type,val->lastmodified);
if ((1<<val->type) & UNICONVMASK)
_write_USTRING(F,(LPWSTR)val->data,0);
else
for (j=0;j<val->len;j++)
fprintf(F,"%02x",*((unsigned char*)val->data+j));
fputs("\n",F);
}
/* descend recursively */
if (!_do_save_subkey(F,lpxkey->nextsub,level+1))
return 0;
}
lpxkey=lpxkey->next;
}
return 1;
}
static int
_do_savesubreg(FILE *F,LPKEYSTRUCT lpkey) {
fprintf(F,"WINE REGISTRY Version %d\n",REGISTRY_SAVE_VERSION);
return _do_save_subkey(F,lpkey->nextsub,0);
}
static void
_SaveSubReg(LPKEYSTRUCT lpkey,char *fn) {
FILE *F;
F=fopen(fn,"w");
if (F==NULL) {
fprintf(stddeb,__FILE__":_SaveSubReg:Couldn't open %s for writing: %s\n",
fn,strerror(errno)
);
return;
}
if (!_do_savesubreg(F,lpkey)) {
fclose(F);
unlink(fn);
fprintf(stddeb,__FILE__":_SaveSubReg:Failed to save keys, perhaps no more diskspace for %s?\n",fn);
return;
}
fclose(F);
}
void
SHELL_SaveRegistry() {
char *fn;
struct passwd *pwd;
pwd=getpwuid(getuid());
if (pwd!=NULL && pwd->pw_dir!=NULL) {
fn=(char*)xmalloc(strlen(pwd->pw_dir)+strlen(WINE_PREFIX)+strlen(SAVE_CURRENT_USER)+2);
strcpy(fn,pwd->pw_dir);
strcat(fn,WINE_PREFIX);
/* create the directory. don't care about errorcodes. */
mkdir(fn,0755); /* drwxr-xr-x */
strcat(fn,"/"SAVE_CURRENT_USER);
_SaveSubReg(key_current_user,fn);
free(fn);
fn=(char*)xmalloc(strlen(pwd->pw_dir)+strlen(WINE_PREFIX)+strlen(SAVE_LOCAL_MACHINE)+2);
strcpy(fn,pwd->pw_dir);
strcat(fn,WINE_PREFIX"/"SAVE_LOCAL_MACHINE);
_SaveSubReg(key_local_machine,fn);
free(fn);
} else {
fprintf(stderr,"SHELL_SaveRegistry:failed to get homedirectory of UID %d.\n",getuid());
}
}
/************************ LOAD Registry Function ****************************/
/* reads a line including dynamically enlarging the readbuffer and throwing
* away comments
*/
static int
_read_line(FILE *F,char **buf,int *len) {
char *s,*curread;
int mylen,curoff;
curread = *buf;
mylen = *len;
**buf = '\0';
while (1) {
while (1) {
s=fgets(curread,mylen,F);
if (s==NULL)
return 0; /* EOF */
if (NULL==(s=strchr(curread,'\n'))) {
/* buffer wasn't large enough */
curoff = strlen(*buf);
*buf = xrealloc(*buf,*len*2);
curread = *buf + curoff;
mylen = *len; /* we filled up the buffer and
* got new '*len' bytes to fill
*/
*len = *len * 2;
} else {
*s='\0';
break;
}
}
/* throw away comments */
if (**buf=='#' || **buf==';') {
curread = *buf;
mylen = *len;
continue;
}
if (s) /* got end of line */
break;
}
return 1;
}
/* converts a char* into a UNICODE string (up to a special char)
* and returns the position exactly after that string
*/
static char*
_read_USTRING(char *buf,LPWSTR *str) {
char *s;
LPWSTR ws;
/* read up to "=" or "\0" or "\n" */
s = buf;
if (*s == '=') {
/* empty string is the win3.1 default value(NULL)*/
*str = NULL;
return s;
}
*str = (LPWSTR)xmalloc(2*strlen(buf)+2);
ws = *str;
while (*s && (*s!='\n') && (*s!='=')) {
if (*s!='\\')
*ws++=*((unsigned char*)s++);
else {
s++;
if (*s=='\\') {
*ws+='\\';
s++;
continue;
}
if (*s!='u') {
fprintf(stderr,"_read_USTRING:Non unicode escape sequence \\%c found in |%s|\n",*s,buf);
*ws++='\\';
*ws++=*s++;
} else {
char xbuf[5];
int wc;
s++;
memcpy(xbuf,s,4);xbuf[4]='\0';
if (!sscanf(xbuf,"%x",&wc))
fprintf(stderr,"_read_USTRING:strange escape sequence %s found in |%s|\n",xbuf,buf);
s+=4;
*ws++ =(unsigned short)wc;
}
}
}
*ws = 0;
ws = *str;
*str = strdupW(*str);
free(ws);
return s;
}
static int
_do_load_subkey(FILE *F,LPKEYSTRUCT lpkey,int level,char **buf,int *buflen) {
LPKEYSTRUCT lpxkey,*lplpkey;
int i;
char *s;
LPWSTR name;
/* good. we already got a line here ... so parse it */
lpxkey = NULL;
while (1) {
i=0;s=*buf;
while (*s=='\t') {
s++;
i++;
}
if (i>level) {
if (lpxkey==NULL) {
fprintf(stderr,"_do_load_subkey:Got a subhierarchy without resp. key?\n");
return 0;
}
_do_load_subkey(F,lpxkey,level+1,buf,buflen);
continue;
}
/* let the caller handle this line */
if (i<level || **buf=='\0')
return 1;
/* good. this is one line for us.
* it can be: a value or a keyname. Parse the name first
*/
s=_read_USTRING(s,&name);
/* switch() default: hack to avoid gotos */
switch (0) {
default:
if (*s=='\0') {
/* this is a new key
* look for the name in the already existing keys
* on this level.
*/
lplpkey= &(lpkey->nextsub);
lpxkey = *lplpkey;
while (lpxkey) {
if (!strcmpW(lpxkey->keyname,name))
break;
lplpkey = &(lpxkey->next);
lpxkey = *lplpkey;
}
if (lpxkey==NULL) {
/* we have no key with that name yet. allocate
* it.
*/
*lplpkey = (LPKEYSTRUCT)xmalloc(sizeof(KEYSTRUCT));
lpxkey = *lplpkey;
memset(lpxkey,'\0',sizeof(KEYSTRUCT));
lpxkey->keyname = name;
} else {
/* already got it. we just remember it in
* 'lpxkey'
*/
free(name);
}
} else {
LPKEYVALUE val=NULL;
LPBYTE data;
int len,lastmodified,type;
if (*s!='=') {
fprintf(stderr,"_do_load_subkey:unexpected character: %c\n",*s);
break;
}
/* good. this looks like a value to me */
s++;
for (i=0;i<lpkey->nrofvalues;i++) {
val=lpkey->values+i;
if (name==NULL) {
if (val->name==NULL)
break;
} else {
if ( val->name!=NULL &&
!strcmpW(val->name,name)
)
break;
}
}
if (i==lpkey->nrofvalues) {
lpkey->values = xrealloc(
lpkey->values,
(++lpkey->nrofvalues)*sizeof(KEYVALUE)
);
val=lpkey->values+i;
memset(val,'\0',sizeof(KEYVALUE));
val->name = name;
} else {
/* value already exists, free name */
free(name);
}
if (2!=sscanf(s,"%d,%d,",&type,&lastmodified)) {
fprintf(stderr,"_do_load_subkey: haven't understood possible value in |%s|, skipping.\n",*buf);
break;
}
/* skip the 2 , */
s=strchr(s,',');s++;
s=strchr(s,',');s++;
if ((1<<type) & UNICONVMASK) {
s=_read_USTRING(s,(LPWSTR*)&data);
if (data)
len = strlenW((LPWSTR)data)*2+2;
else
len = 0;
} else {
len=strlen(s)/2;
data = (LPBYTE)xmalloc(len+1);
for (i=0;i<len;i++) {
data[i]=0;
if (*s>='0' && *s<='9')
data[i]=(*s-'0')<<4;
if (*s>='a' && *s<='f')
data[i]=(*s-'a')<<4;
if (*s>='A' && *s<='F')
data[i]=(*s-'A')<<4;
s++;
if (*s>='0' && *s<='9')
data[i]|=*s-'0';
if (*s>='a' && *s<='f')
data[i]|=*s-'a';
if (*s>='A' && *s<='F')
data[i]|=*s-'A';
s++;
}
}
if (val->lastmodified<lastmodified) {
val->lastmodified=lastmodified;
val->type = type;
val->len = len;
if (val->data)
free(val->data);
val->data = data;
} else {
free(data);
}
}
}
/* read the next line */
if (!_read_line(F,buf,buflen))
return 1;
}
return 1;
}
static int
_do_loadsubreg(FILE *F,LPKEYSTRUCT lpkey) {
int ver;
char *buf;
int buflen;
buf=xmalloc(10);buflen=10;
if (!_read_line(F,&buf,&buflen)) {
free(buf);
return 0;
}
if (!sscanf(buf,"WINE REGISTRY Version %d",&ver)) {
free(buf);
return 0;
}
if (ver!=REGISTRY_SAVE_VERSION) {
dprintf_reg(stddeb,__FILE__":_do_loadsubreg:Old format (%d) registry found, ignoring it. (buf was %s).\n",ver,buf);
free(buf);
return 0;
}
if (!_read_line(F,&buf,&buflen)) {
free(buf);
return 0;
}
if (!_do_load_subkey(F,lpkey,0,&buf,&buflen)) {
free(buf);
/* FIXME: memory leak on failure to read registry ...
* But this won't happen very often.
*/
lpkey->nextsub=NULL;
return 0;
}
free(buf);
return 1;
}
static void
_LoadSubReg(LPKEYSTRUCT lpkey,char *fn) {
FILE *F;
F=fopen(fn,"rb");
if (F==NULL) {
dprintf_reg(stddeb,__FILE__":Couldn't open %s for reading: %s\n",
fn,strerror(errno)
);
return;
}
if (!_do_loadsubreg(F,lpkey)) {
fclose(F);
unlink(fn);
return;
}
fclose(F);
}
void
SHELL_LoadRegistry() {
char *fn;
struct passwd *pwd;
if (key_classes_root==NULL)
SHELL_Init();
/* load the machine-wide defaults first */
_LoadSubReg(key_current_user,SAVE_CURRENT_USER_DEFAULT);
_LoadSubReg(key_local_machine,SAVE_LOCAL_MACHINE_DEFAULT);
/* load the user saved registry. overwriting only newer entries */
pwd=getpwuid(getuid());
if (pwd!=NULL && pwd->pw_dir!=NULL) {
fn=(char*)xmalloc(strlen(pwd->pw_dir)+strlen(WINE_PREFIX)+strlen(SAVE_CURRENT_USER)+2);
strcpy(fn,pwd->pw_dir);
strcat(fn,WINE_PREFIX"/"SAVE_CURRENT_USER);
_LoadSubReg(key_current_user,fn);
free(fn);
fn=(char*)xmalloc(strlen(pwd->pw_dir)+strlen(WINE_PREFIX)+strlen(SAVE_LOCAL_MACHINE)+2);
strcpy(fn,pwd->pw_dir);
strcat(fn,WINE_PREFIX"/"SAVE_LOCAL_MACHINE);
_LoadSubReg(key_local_machine,fn);
free(fn);
} else {
fprintf(stderr,"SHELL_LoadRegistry:failed to get homedirectory of UID %d.\n",getuid());
}
/* FIXME: load all users and their resp. pwd->pw_dir/.wine/user.reg
* (later, when a win32 registry editing tool becomes avail.)
*/
}
/********************* API FUNCTIONS ***************************************/
/*
* Open Keys.
*
* All functions are stubs to RegOpenKeyExW where all the
* magic happens.
*
* FIXME: security,options,desiredaccess,...
*
* Callpath:
* RegOpenKey -> RegOpenKeyA -> RegOpenKeyExA \
* RegOpenKeyW -> RegOpenKeyExW
*/
/* RegOpenKeyExW [ADVAPI32.150] */
WINAPI DWORD
RegOpenKeyExW(
HKEY hkey,
LPCWSTR lpszSubKey,
DWORD dwReserved,
REGSAM samDesired,
LPHKEY retkey
) {
LPKEYSTRUCT lpNextKey,lpxkey;
LPWSTR *wps;
int wpc,i;
dprintf_reg(stddeb,"RegOpenKeyExW(%lx,%s,%ld,%lx,%p)\n",
(LONG)hkey,W2C(lpszSubKey,0),dwReserved,samDesired,retkey
);
lpNextKey = lookup_hkey(hkey);
if (!lpNextKey)
return SHELL_ERROR_BADKEY;
if (!lpszSubKey || !*lpszSubKey) {
add_handle(++currenthandle,lpNextKey,samDesired);
*retkey=currenthandle;
return SHELL_ERROR_SUCCESS;
}
split_keypath(lpszSubKey,&wps,&wpc);
i = 0;
while ((i<wpc) && (wps[i][0]=='\0')) i++;
lpxkey = lpNextKey;
while (i<wpc) {
lpxkey=lpNextKey->nextsub;
while (lpxkey) {
if (!strcmpW(wps[i],lpxkey->keyname))
break;
lpxkey=lpxkey->next;
}
if (!lpxkey) {
FREE_KEY_PATH;
return SHELL_ERROR_BADKEY;
}
i++;
lpNextKey = lpxkey;
}
add_handle(++currenthandle,lpxkey,samDesired);
*retkey = currenthandle;
FREE_KEY_PATH;
return SHELL_ERROR_SUCCESS;
}
/* RegOpenKeyW [ADVAPI32.151] */
WINAPI DWORD
RegOpenKeyW(
HKEY hkey,
LPCWSTR lpszSubKey,
LPHKEY retkey
) {
dprintf_reg(stddeb,"RegOpenKeyW(%lx,%s,%p)\n",
(LONG)hkey,W2C(lpszSubKey,0),retkey
);
return RegOpenKeyExW(hkey,lpszSubKey,0,KEY_ALL_ACCESS,retkey);
}
/* RegOpenKeyExA [ADVAPI32.149] */
WINAPI DWORD
RegOpenKeyExA(
HKEY hkey,
LPCSTR lpszSubKey,
DWORD dwReserved,
REGSAM samDesired,
LPHKEY retkey
) {
LPWSTR lpszSubKeyW;
DWORD ret;
dprintf_reg(stddeb,"RegOpenKeyExA(%lx,%s,%ld,%lx,%p)\n",
(LONG)hkey,lpszSubKey,dwReserved,samDesired,retkey
);
if (lpszSubKey)
lpszSubKeyW=strdupA2W(lpszSubKey);
else
lpszSubKeyW=NULL;
ret=RegOpenKeyExW(hkey,lpszSubKeyW,dwReserved,samDesired,retkey);
if (lpszSubKeyW)
free(lpszSubKeyW);
return ret;
}
/* RegOpenKeyA [ADVAPI32.148] */
WINAPI DWORD
RegOpenKeyA(
HKEY hkey,
LPCSTR lpszSubKey,
LPHKEY retkey
) {
dprintf_reg(stddeb,"RegOpenKeyA(%lx,%s,%p)\n",
(LONG)hkey,lpszSubKey,retkey
);
return RegOpenKeyExA(hkey,lpszSubKey,0,KEY_ALL_ACCESS,retkey);
}
/* RegOpenKey [SHELL.1] [KERNEL.217] */
WINAPI DWORD
RegOpenKey(
HKEY hkey,
LPCSTR lpszSubKey,
LPHKEY retkey
) {
dprintf_reg(stddeb,"RegOpenKey(%lx,%s,%p)\n",
(LONG)hkey,lpszSubKey,retkey
);
return RegOpenKeyA(hkey,lpszSubKey,retkey);
}
/*
* Create keys
*
* All those functions convert their respective
* arguments and call RegCreateKeyExW at the end.
*
* FIXME: no security,no access attrib,no optionhandling yet.
*
* Callpath:
* RegCreateKey -> RegCreateKeyA -> RegCreateKeyExA \
* RegCreateKeyW -> RegCreateKeyExW
*/
/* RegCreateKeyExW [ADVAPI32.131] */
WINAPI DWORD
RegCreateKeyExW(
HKEY hkey,
LPCWSTR lpszSubKey,
DWORD dwReserved,
LPWSTR lpszClass,
DWORD fdwOptions,
REGSAM samDesired,
LPSECURITY_ATTRIBUTES lpSecAttribs,
LPHKEY retkey,
LPDWORD lpDispos
) {
LPKEYSTRUCT *lplpPrevKey,lpNextKey,lpxkey;
LPWSTR *wps;
int wpc,i;
/*FIXME: handle security/access/whatever */
dprintf_reg(stddeb,"RegCreateKeyExW(%lx,%s,%ld,%s,%lx,%lx,%p,%p,%p)\n",
(LONG)hkey,
W2C(lpszSubKey,0),
dwReserved,
W2C(lpszClass,1),
fdwOptions,
samDesired,
lpSecAttribs,
retkey,
lpDispos
);
lpNextKey = lookup_hkey(hkey);
if (!lpNextKey)
return SHELL_ERROR_BADKEY;
if (!lpszSubKey || !*lpszSubKey) {
add_handle(++currenthandle,lpNextKey,samDesired);
*retkey=currenthandle;
return SHELL_ERROR_SUCCESS;
}
split_keypath(lpszSubKey,&wps,&wpc);
i = 0;
while ((i<wpc) && (wps[i][0]=='\0')) i++;
lpxkey = lpNextKey;
while (i<wpc) {
lpxkey=lpNextKey->nextsub;
while (lpxkey) {
if (!strcmpW(wps[i],lpxkey->keyname))
break;
lpxkey=lpxkey->next;
}
if (!lpxkey)
break;
i++;
lpNextKey = lpxkey;
}
if (lpxkey) {
add_handle(++currenthandle,lpxkey,samDesired);
*retkey = currenthandle;
*lpDispos = REG_OPENED_EXISTING_KEY;
FREE_KEY_PATH;
return SHELL_ERROR_SUCCESS;
}
/* good. now the hard part */
while (i<wpc) {
lplpPrevKey = &(lpNextKey->nextsub);
lpxkey = *lplpPrevKey;
while (lpxkey) {
lplpPrevKey = &(lpxkey->next);
lpxkey = *lplpPrevKey;
}
*lplpPrevKey=malloc(sizeof(KEYSTRUCT));
if (!*lplpPrevKey) {
FREE_KEY_PATH;
return SHELL_ERROR_OUTOFMEMORY;
}
memset(*lplpPrevKey,'\0',sizeof(KEYSTRUCT));
(*lplpPrevKey)->keyname = strdupW(wps[i]);
(*lplpPrevKey)->next = NULL;
(*lplpPrevKey)->nextsub = NULL;
(*lplpPrevKey)->values = NULL;
(*lplpPrevKey)->nrofvalues = 0;
if (lpszClass)
(*lplpPrevKey)->class = strdupW(lpszClass);
else
(*lplpPrevKey)->class = NULL;
lpNextKey = *lplpPrevKey;
i++;
}
add_handle(++currenthandle,lpNextKey,samDesired);
/*FIXME: flag handling correct? */
lpNextKey->flags= fdwOptions;
if (lpszClass)
lpNextKey->class = strdupW(lpszClass);
else
lpNextKey->class = NULL;
*retkey = currenthandle;
*lpDispos = REG_CREATED_NEW_KEY;
FREE_KEY_PATH;
return SHELL_ERROR_SUCCESS;
}
/* RegCreateKeyW [ADVAPI32.132] */
WINAPI DWORD
RegCreateKeyW(
HKEY hkey,
LPCWSTR lpszSubKey,
LPHKEY retkey
) {
DWORD junk,ret;
dprintf_reg(stddeb,"RegCreateKeyW(%lx,%s,%p)\n",
(LONG)hkey,W2C(lpszSubKey,0),retkey
);
ret=RegCreateKeyExW(
hkey, /* key handle */
lpszSubKey, /* subkey name */
0, /* reserved = 0 */
NULL, /* lpszClass? FIXME: ? */
REG_OPTION_NON_VOLATILE, /* options */
KEY_ALL_ACCESS, /* desired access attribs */
NULL, /* lpsecurity attributes */
retkey, /* lpretkey */
&junk /* disposition value */
);
return ret;
}
/* RegCreateKeyExA [ADVAPI32.130] */
WINAPI DWORD
RegCreateKeyExA(
HKEY hkey,
LPCSTR lpszSubKey,
DWORD dwReserved,
LPSTR lpszClass,
DWORD fdwOptions,
REGSAM samDesired,
LPSECURITY_ATTRIBUTES lpSecAttribs,
LPHKEY retkey,
LPDWORD lpDispos
) {
LPWSTR lpszSubKeyW,lpszClassW;
DWORD ret;
dprintf_reg(stddeb,"RegCreateKeyExA(%lx,%s,%ld,%s,%lx,%lx,%p,%p,%p)\n",
(LONG)hkey,
lpszSubKey,
dwReserved,
lpszClass,
fdwOptions,
samDesired,
lpSecAttribs,
retkey,
lpDispos
);
if (lpszSubKey)
lpszSubKeyW=strdupA2W(lpszSubKey);
else
lpszSubKeyW=NULL;
if (lpszClass)
lpszClassW=strdupA2W(lpszClass);
else
lpszClassW=NULL;
ret=RegCreateKeyExW(
hkey,
lpszSubKeyW,
dwReserved,
lpszClassW,
fdwOptions,
samDesired,
lpSecAttribs,
retkey,
lpDispos
);
if (lpszSubKeyW)
free(lpszSubKeyW);
if (lpszClassW)
free(lpszClassW);
return ret;
}
/* RegCreateKeyA [ADVAPI32.129] */
WINAPI DWORD
RegCreateKeyA(
HKEY hkey,
LPCSTR lpszSubKey,
LPHKEY retkey
) {
DWORD junk;
dprintf_reg(stddeb,"RegCreateKeyA(%lx,%s,%p)\n",
(LONG)hkey,lpszSubKey,retkey
);
return RegCreateKeyExA(
hkey, /* key handle */
lpszSubKey, /* subkey name */
0, /* reserved = 0 */
NULL, /* lpszClass? FIXME: ? */
REG_OPTION_NON_VOLATILE,/* options */
KEY_ALL_ACCESS, /* desired access attribs */
NULL, /* lpsecurity attributes */
retkey, /* lpretkey */
&junk /* disposition value */
);
}
/* RegCreateKey [SHELL.2] [KERNEL.218] */
WINAPI DWORD
RegCreateKey(
HKEY hkey,
LPCSTR lpszSubKey,
LPHKEY retkey
) {
dprintf_reg(stddeb,"RegCreateKey(%lx,%s,%p)\n",
(LONG)hkey,lpszSubKey,retkey
);
return RegCreateKeyA(hkey,lpszSubKey,retkey);
}
/*
* Query Value Functions
* Win32 differs between keynames and valuenames.
* multiple values may belong to one key, the special value
* with name NULL is the default value used by the win31
* compat functions.
*
* Callpath:
* RegQueryValue -> RegQueryValueA -> RegQueryValueExA \
* RegQueryValueW -> RegQueryValueExW
*/
/* RegQueryValueExW [ADVAPI32.158] */
WINAPI DWORD
RegQueryValueExW(
HKEY hkey,
LPWSTR lpszValueName,
LPDWORD lpdwReserved,
LPDWORD lpdwType,
LPBYTE lpbData,
LPDWORD lpcbData
) {
LPKEYSTRUCT lpkey;
int i;
dprintf_reg(stddeb,"RegQueryValueExW(%lx,%s,%p,%p,%p,%p)\n",
hkey,W2C(lpszValueName,0),lpdwReserved,lpdwType,lpbData,lpcbData
);
lpkey = lookup_hkey(hkey);
if (!lpkey)
return SHELL_ERROR_BADKEY;
if (lpszValueName==NULL) {
for (i=0;i<lpkey->nrofvalues;i++)
if (lpkey->values[i].name==NULL)
break;
} else {
for (i=0;i<lpkey->nrofvalues;i++)
if (!strcmpW(lpszValueName,lpkey->values[i].name))
break;
}
if (i==lpkey->nrofvalues) {
if (lpszValueName==NULL) {
*(WCHAR*)lpbData = 0;
*lpcbData = 2;
*lpdwType = REG_SZ;
return SHELL_ERROR_SUCCESS;
}
return SHELL_ERROR_BADKEY;/*FIXME: correct return? */
}
if (lpdwType)
*lpdwType = lpkey->values[i].type;
if (lpbData==NULL) {
if (lpcbData==NULL)
return SHELL_ERROR_SUCCESS;
*lpcbData = lpkey->values[i].len;
return SHELL_ERROR_SUCCESS;
}
if (*lpcbData<lpkey->values[i].len) {
*(WCHAR*)lpbData
= 0;
*lpcbData = lpkey->values[i].len;
return ERROR_MORE_DATA;
}
memcpy(lpbData,lpkey->values[i].data,lpkey->values[i].len);
*lpcbData = lpkey->values[i].len;
return SHELL_ERROR_SUCCESS;
}
/* RegQueryValueW [ADVAPI32.159] */
WINAPI DWORD
RegQueryValueW(
HKEY hkey,
LPWSTR lpszSubKey,
LPWSTR lpszData,
LPDWORD lpcbData
) {
HKEY xhkey;
DWORD ret,lpdwType;
dprintf_reg(stddeb,"RegQueryValueW(%lx,%s,%p,%p)\n->",
hkey,W2C(lpszSubKey,0),lpszData,lpcbData
);
/* only open subkey, if we really do descend */
if (lpszSubKey && *lpszSubKey) {
ret = RegOpenKeyW(hkey,lpszSubKey,&xhkey);
if (ret!=ERROR_SUCCESS)
return ret;
} else
xhkey = hkey;
lpdwType = REG_SZ;
ret = RegQueryValueExW(
xhkey,
NULL, /* varname NULL -> compat */
NULL, /* lpdwReserved, must be NULL */
&lpdwType,
(LPBYTE)lpszData,
lpcbData
);
if (xhkey!=hkey)
RegCloseKey(xhkey);
return ret;
}
/* RegQueryValueExA [ADVAPI32.157] */
WINAPI DWORD
RegQueryValueExA(
HKEY hkey,
LPSTR lpszValueName,
LPDWORD lpdwReserved,
LPDWORD lpdwType,
LPBYTE lpbData,
LPDWORD lpcbData
) {
LPWSTR lpszValueNameW;
LPBYTE buf;
DWORD ret,myxlen;
DWORD *mylen;
dprintf_reg(stddeb,"RegQueryValueExA(%lx,%s,%p,%p,%p,%p)\n->",
hkey,lpszValueName,lpdwReserved,lpdwType,lpbData,lpcbData
);
if (lpbData) {
/* double buffer */
buf = (LPBYTE)xmalloc((*lpcbData)*2);
myxlen = *lpcbData*2;
mylen = &myxlen;
} else {
buf=NULL;
if (lpcbData) {
myxlen = *lpcbData*2;
mylen = &myxlen;
}
mylen = NULL;
}
if (lpszValueName)
lpszValueNameW=strdupA2W(lpszValueName);
else
lpszValueNameW=NULL;
ret=RegQueryValueExW(
hkey,
lpszValueNameW,
lpdwReserved,
lpdwType,
buf,
mylen
);
if (ret==ERROR_SUCCESS) {
if (buf) {
if (UNICONVMASK & (1<<(*lpdwType))) {
/* convert UNICODE to ASCII */
strcpyWA(lpbData,(LPWSTR)buf);
*lpcbData = myxlen/2;
} else {
if (myxlen>*lpcbData)
ret = ERROR_MORE_DATA;
else
memcpy(lpbData,buf,myxlen);
*lpcbData = myxlen;
}
} else {
if ((UNICONVMASK & (1<<(*lpdwType))) && lpcbData)
*lpcbData = myxlen/2;
}
} else {
if ((UNICONVMASK & (1<<(*lpdwType))) && lpcbData)
*lpcbData = myxlen/2;
}
if (buf)
free(buf);
return ret;
}
/* RegQueryValueEx [KERNEL.225] */
WINAPI DWORD
RegQueryValueEx(
HKEY hkey,
LPSTR lpszValueName,
LPDWORD lpdwReserved,
LPDWORD lpdwType,
LPBYTE lpbData,
LPDWORD lpcbData
) {
dprintf_reg(stddeb,"RegQueryValueEx(%lx,%s,%p,%p,%p,%p)\n",
hkey,lpszValueName,lpdwReserved,lpdwType,lpbData,lpcbData
);
return RegQueryValueExA(
hkey,
lpszValueName,
lpdwReserved,
lpdwType,
lpbData,
lpcbData
);
}
/* RegQueryValueA [ADVAPI32.156] */
WINAPI DWORD
RegQueryValueA(
HKEY hkey,
LPSTR lpszSubKey,
LPSTR lpszData,
LPDWORD lpcbData
) {
HKEY xhkey;
DWORD ret,lpdwType;
dprintf_reg(stddeb,"RegQueryValueA(%lx,%s,%p,%p)\n",
hkey,lpszSubKey,lpszData,lpcbData
);
/* only open subkey, if we really do descend */
if (lpszSubKey && *lpszSubKey) {
ret = RegOpenKey(hkey,lpszSubKey,&xhkey);
if (ret!=ERROR_SUCCESS)
return ret;
} else
xhkey = hkey;
lpdwType = REG_SZ;
ret = RegQueryValueExA(
xhkey,
NULL, /* lpszValueName NULL -> compat */
NULL, /* lpdwReserved, must be NULL */
&lpdwType,
(LPBYTE)lpszData,
lpcbData
);
if (xhkey!=hkey)
RegCloseKey(xhkey);
return ret;
}
/* RegQueryValue [SHELL.6] [KERNEL.224] */
WINAPI DWORD
RegQueryValue(
HKEY hkey,
LPSTR lpszSubKey,
LPSTR lpszData,
LPDWORD lpcbData
) {
dprintf_reg(stddeb,"RegQueryValueA(%lx,%s,%p,%p)\n",
hkey,lpszSubKey,lpszData,lpcbData
);
return RegQueryValueA(hkey,lpszSubKey,lpszData,lpcbData);
}
/*
* Setting values of Registry keys
*
* Callpath:
* RegSetValue -> RegSetValueA -> RegSetValueExA \
* RegSetValueW -> RegSetValueExW
*/
/* RegSetValueExW [ADVAPI32.170] */
WINAPI DWORD
RegSetValueExW(
HKEY hkey,
LPWSTR lpszValueName,
DWORD dwReserved,
DWORD dwType,
LPBYTE lpbData,
DWORD cbData
) {
LPKEYSTRUCT lpkey;
int i;
dprintf_reg(stddeb,"RegSetValueExW(%lx,%s,%ld,%ld,%p,%ld)\n",
hkey,W2C(lpszValueName,0),dwReserved,dwType,lpbData,cbData
);
/* we no longer care about the lpbData dwType here... */
lpkey = lookup_hkey(hkey);
if (!lpkey)
return SHELL_ERROR_BADKEY;
if (lpszValueName==NULL) {
for (i=0;i<lpkey->nrofvalues;i++)
if (lpkey->values[i].name==NULL)
break;
} else {
for (i=0;i<lpkey->nrofvalues;i++)
if (!strcmpW(lpszValueName,lpkey->values[i].name))
break;
}
if (i==lpkey->nrofvalues) {
lpkey->values = (LPKEYVALUE)xrealloc(
lpkey->values,
(lpkey->nrofvalues+1)*sizeof(KEYVALUE)
);
lpkey->nrofvalues++;
memset(lpkey->values+i,'\0',sizeof(KEYVALUE));
}
if (lpkey->values[i].name==NULL)
if (lpszValueName)
lpkey->values[i].name = strdupW(lpszValueName);
else
lpkey->values[i].name = NULL;
lpkey->values[i].len = cbData;
lpkey->values[i].type = dwType;
if (lpkey->values[i].data !=NULL)
free(lpkey->values[i].data);
lpkey->values[i].data = (LPBYTE)xmalloc(cbData);
lpkey->values[i].lastmodified = time(NULL);
memcpy(lpkey->values[i].data,lpbData,cbData);
return SHELL_ERROR_SUCCESS;
}
/* RegSetValueExA [ADVAPI32.169] */
WINAPI DWORD
RegSetValueExA(
HKEY hkey,
LPSTR lpszValueName,
DWORD dwReserved,
DWORD dwType,
LPBYTE lpbData,
DWORD cbData
) {
LPBYTE buf;
LPWSTR lpszValueNameW;
DWORD ret;
dprintf_reg(stddeb,"RegSetValueExA(%lx,%s,%ld,%ld,%p,%ld)\n->",
hkey,lpszValueName,dwReserved,dwType,lpbData,cbData
);
if ((1<<dwType) & UNICONVMASK) {
buf=(LPBYTE)strdupA2W(lpbData);
cbData=2*strlen(lpbData)+2;
} else
buf=lpbData;
if (lpszValueName)
lpszValueNameW = strdupA2W(lpszValueName);
else
lpszValueNameW = NULL;
ret=RegSetValueExW(hkey,lpszValueNameW,dwReserved,dwType,buf,cbData);
if (lpszValueNameW)
free(lpszValueNameW);
if (buf!=lpbData)
free(buf);
return ret;
}
/* RegSetValueEx [KERNEL.226] */
WINAPI DWORD
RegSetValueEx(
HKEY hkey,
LPSTR lpszValueName,
DWORD dwReserved,
DWORD dwType,
LPBYTE lpbData,
DWORD cbData
) {
dprintf_reg(stddeb,"RegSetValueEx(%lx,%s,%ld,%ld,%p,%ld)\n->",
hkey,lpszValueName,dwReserved,dwType,lpbData,cbData
);
return RegSetValueExA(hkey,lpszValueName,dwReserved,dwType,lpbData,cbData);
}
/* RegSetValueW [ADVAPI32.171] */
WINAPI DWORD
RegSetValueW(
HKEY hkey,
LPCWSTR lpszSubKey,
DWORD dwType,
LPCWSTR lpszData,
DWORD cbData
) {
HKEY xhkey;
DWORD ret;
dprintf_reg(stddeb,"RegSetValueW(%lx,%s,%ld,%s,%ld)\n->",
hkey,W2C(lpszSubKey,0),dwType,W2C(lpszData,0),cbData
);
if (lpszSubKey && *lpszSubKey) {
ret=RegCreateKeyW(hkey,lpszSubKey,&xhkey);
if (ret!=ERROR_SUCCESS)
return ret;
} else
xhkey=hkey;
if (dwType!=REG_SZ) {
fprintf(stddeb,"RegSetValueX called with dwType=%ld!\n",dwType);
dwType=REG_SZ;
}
if (cbData!=2*strlenW(lpszData)+2) {
dprintf_reg(stddeb,"RegSetValueX called with len=%ld != strlen(%s)+1=%d!\n",
cbData,W2C(lpszData,0),2*strlenW(lpszData)+2
);
cbData=2*strlenW(lpszData)+2;
}
ret=RegSetValueExW(xhkey,NULL,0,dwType,(LPBYTE)lpszData,cbData);
if (hkey!=xhkey)
RegCloseKey(xhkey);
return ret;
}
/* RegSetValueA [ADVAPI32.168] */
WINAPI DWORD
RegSetValueA(
HKEY hkey,
LPCSTR lpszSubKey,
DWORD dwType,
LPCSTR lpszData,
DWORD cbData
) {
DWORD ret;
HKEY xhkey;
dprintf_reg(stddeb,"RegSetValueA(%lx,%s,%ld,%s,%ld)\n->",
hkey,lpszSubKey,dwType,lpszData,cbData
);
if (lpszSubKey && *lpszSubKey) {
ret=RegCreateKey(hkey,lpszSubKey,&xhkey);
if (ret!=ERROR_SUCCESS)
return ret;
} else
xhkey=hkey;
if (dwType!=REG_SZ) {
dprintf_reg(stddeb,"RegSetValueA called with dwType=%ld!\n",dwType);
dwType=REG_SZ;
}
if (cbData!=strlen(lpszData)+1)
cbData=strlen(lpszData)+1;
ret=RegSetValueExA(xhkey,NULL,0,dwType,(LPBYTE)lpszData,cbData);
if (xhkey!=hkey)
RegCloseKey(xhkey);
return ret;
}
/* RegSetValue [KERNEL.221] [SHELL.5] */
WINAPI DWORD
RegSetValue(
HKEY hkey,
LPCSTR lpszSubKey,
DWORD dwType,
LPCSTR lpszData,
DWORD cbData
) {
DWORD ret;
dprintf_reg(stddeb,"RegSetValue(%lx,%s,%ld,%s,%ld)\n->",
hkey,lpszSubKey,dwType,lpszData,cbData
);
ret=RegSetValueA(hkey,lpszSubKey,dwType,lpszData,cbData);
return ret;
}
/*
* Key Enumeration
*
* Callpath:
* RegEnumKey -> RegEnumKeyA -> RegEnumKeyExA \
* RegEnumKeyW -> RegEnumKeyExW
*/
/* RegEnumKeyExW [ADVAPI32.139] */
WINAPI DWORD
RegEnumKeyExW(
HKEY hkey,
DWORD iSubkey,
LPWSTR lpszName,
LPDWORD lpcchName,
LPDWORD lpdwReserved,
LPWSTR lpszClass,
LPDWORD lpcchClass,
FILETIME *ft
) {
LPKEYSTRUCT lpkey,lpxkey;
dprintf_reg(stddeb,"RegEnumKeyExW(%lx,%ld,%p,%ld,%p,%p,%p,%p)\n",
hkey,iSubkey,lpszName,*lpcchName,lpdwReserved,lpszClass,lpcchClass,ft
);
lpkey=lookup_hkey(hkey);
if (!lpkey)
return SHELL_ERROR_BADKEY;
if (!lpkey->nextsub)
return ERROR_NO_MORE_ITEMS;
lpxkey=lpkey->nextsub;
while (iSubkey && lpxkey) {
iSubkey--;
lpxkey=lpxkey->next;
}
if (iSubkey || !lpxkey)
return ERROR_NO_MORE_ITEMS;
if (2*strlenW(lpxkey->keyname)+2>*lpcchName)
return ERROR_MORE_DATA;
memcpy(lpszName,lpxkey->keyname,strlenW(lpxkey->keyname)*2+2);
if (lpszClass) {
/* what should we write into it? */
*lpszClass = 0;
*lpcchClass = 2;
}
return ERROR_SUCCESS;
}
/* RegEnumKeyW [ADVAPI32.140] */
WINAPI DWORD
RegEnumKeyW(
HKEY hkey,
DWORD iSubkey,
LPWSTR lpszName,
DWORD lpcchName
) {
FILETIME ft;
dprintf_reg(stddeb,"RegEnumKeyW(%lx,%ld,%p,%ld)\n->",
hkey,iSubkey,lpszName,lpcchName
);
return RegEnumKeyExW(hkey,iSubkey,lpszName,&lpcchName,NULL,NULL,NULL,&ft);
}
/* RegEnumKeyExA [ADVAPI32.138] */
WINAPI DWORD
RegEnumKeyExA(
HKEY hkey,
DWORD iSubkey,
LPSTR lpszName,
LPDWORD lpcchName,
LPDWORD lpdwReserved,
LPSTR lpszClass,
LPDWORD lpcchClass,
FILETIME *ft
) {
DWORD ret,lpcchNameW,lpcchClassW;
LPWSTR lpszNameW,lpszClassW;
dprintf_reg(stddeb,"RegEnumKeyExA(%lx,%ld,%p,%ld,%p,%p,%p,%p)\n->",
hkey,iSubkey,lpszName,*lpcchName,lpdwReserved,lpszClass,lpcchClass,ft
);
if (lpszName) {
lpszNameW = (LPWSTR)xmalloc(*lpcchName*2);
lpcchNameW = *lpcchName*2;
} else {
lpszNameW = NULL;
lpcchNameW = 0;
}
if (lpszClass) {
lpszClassW = (LPWSTR)xmalloc(*lpcchClass*2);
lpcchClassW = *lpcchClass*2;
} else {
lpszClassW =0;
lpcchClassW=0;
}
ret=RegEnumKeyExW(
hkey,
iSubkey,
lpszNameW,
&lpcchNameW,
lpdwReserved,
lpszClassW,
&lpcchClassW,
ft
);
if (ret==ERROR_SUCCESS) {
strcpyWA(lpszName,lpszNameW);
*lpcchName=strlen(lpszName);
if (lpszClassW) {
strcpyWA(lpszClass,lpszClassW);
*lpcchClass=strlen(lpszClass);
}
}
if (lpszNameW)
free(lpszNameW);
if (lpszClassW)
free(lpszClassW);
return ret;
}
/* RegEnumKeyA [ADVAPI32.137] */
WINAPI DWORD
RegEnumKeyA(
HKEY hkey,
DWORD iSubkey,
LPSTR lpszName,
DWORD lpcchName
) {
FILETIME ft;
dprintf_reg(stddeb,"RegEnumKeyA(%lx,%ld,%p,%ld)\n->",
hkey,iSubkey,lpszName,lpcchName
);
return RegEnumKeyExA(
hkey,
iSubkey,
lpszName,
&lpcchName,
NULL,
NULL,
NULL,
&ft
);
}
/* RegEnumKey [SHELL.7] [KERNEL.216] */
WINAPI DWORD
RegEnumKey(
HKEY hkey,
DWORD iSubkey,
LPSTR lpszName,
DWORD lpcchName
) {
dprintf_reg(stddeb,"RegEnumKey(%lx,%ld,%p,%ld)\n->",
hkey,iSubkey,lpszName,lpcchName
);
return RegEnumKeyA(hkey,iSubkey,lpszName,lpcchName);
}
/*
* Enumerate Registry Values
*
* Callpath:
* RegEnumValue -> RegEnumValueA -> RegEnumValueW
*/
/* RegEnumValueW [ADVAPI32.142] */
WINAPI DWORD
RegEnumValueW(
HKEY hkey,
DWORD iValue,
LPWSTR lpszValue,
LPDWORD lpcchValue,
LPDWORD lpdReserved,
LPDWORD lpdwType,
LPBYTE lpbData,
LPDWORD lpcbData
) {
LPKEYSTRUCT lpkey;
LPKEYVALUE val;
dprintf_reg(stddeb,"RegEnumValueW(%ld,%ld,%p,%p,%p,%p,%p,%p)\n",
hkey,iValue,lpszValue,lpcchValue,lpdReserved,lpdwType,lpbData,lpcbData
);
lpkey = lookup_hkey(hkey);
if (!lpkey)
return SHELL_ERROR_BADKEY;
if (lpkey->nrofvalues<=iValue)
return ERROR_NO_MORE_ITEMS;
val = lpkey->values+iValue;
if (val->name) {
if (strlenW(val->name)*2+2>*lpcchValue) {
*lpcchValue = strlenW(val->name)*2+2;
return ERROR_MORE_DATA;
}
memcpy(lpszValue,val->name,2*strlenW(val->name)+2);
*lpcchValue=strlenW(val->name)*2+2;
} else {
/* how to handle NULL value? */
*lpszValue = 0;
*lpcchValue = 2;
}
*lpdwType=val->type;
if (lpbData) {
if (val->len>*lpcbData)
return ERROR_MORE_DATA;
memcpy(lpbData,val->data,val->len);
*lpcbData = val->len;
}
return SHELL_ERROR_SUCCESS;
}
/* RegEnumValueA [ADVAPI32.141] */
WINAPI DWORD
RegEnumValueA(
HKEY hkey,
DWORD iValue,
LPSTR lpszValue,
LPDWORD lpcchValue,
LPDWORD lpdReserved,
LPDWORD lpdwType,
LPBYTE lpbData,
LPDWORD lpcbData
) {
LPWSTR lpszValueW;
LPBYTE lpbDataW;
DWORD ret,lpcbDataW;
dprintf_reg(stddeb,"RegEnumValueA(%ld,%ld,%p,%p,%p,%p,%p,%p)\n",
hkey,iValue,lpszValue,lpcchValue,lpdReserved,lpdwType,lpbData,lpcbData
);
lpszValueW = (LPWSTR)xmalloc(*lpcchValue*2);
if (lpbData) {
lpbDataW = (LPBYTE)xmalloc(*lpcbData*2);
lpcbDataW = *lpcbData*2;
} else
lpbDataW = NULL;
ret=RegEnumValueW(
hkey,
iValue,
lpszValueW,
lpcchValue,
lpdReserved,
lpdwType,
lpbDataW,
&lpcbDataW
);
if (ret==ERROR_SUCCESS) {
strcpyWA(lpszValue,lpszValueW);
if (lpbData) {
if ((1<<*lpdwType) & UNICONVMASK) {
strcpyWA(lpbData,(LPWSTR)lpbDataW);
} else {
if (lpcbDataW > *lpcbData)
ret = ERROR_MORE_DATA;
else
memcpy(lpbData,lpbDataW,lpcbDataW);
}
*lpcbData = lpcbDataW;
}
}
if (lpbDataW)
free(lpbDataW);
if (lpszValueW)
free(lpszValueW);
return ret;
}
/* RegEnumValue [KERNEL.223] */
WINAPI DWORD
RegEnumValue(
HKEY hkey,
DWORD iValue,
LPSTR lpszValue,
LPDWORD lpcchValue,
LPDWORD lpdReserved,
LPDWORD lpdwType,
LPBYTE lpbData,
LPDWORD lpcbData
) {
dprintf_reg(stddeb,"RegEnumValue(%ld,%ld,%p,%p,%p,%p,%p,%p)\n",
hkey,iValue,lpszValue,lpcchValue,lpdReserved,lpdwType,lpbData,lpcbData
);
return RegEnumValueA(
hkey,
iValue,
lpszValue,
lpcchValue,
lpdReserved,
lpdwType,
lpbData,
lpcbData
);
}
/*
* Close registry key
*/
/* RegCloseKey [SHELL.3] [KERNEL.220] [ADVAPI32.126] */
WINAPI DWORD
RegCloseKey(HKEY hkey) {
dprintf_reg(stddeb,"RegCloseKey(%ld)\n",hkey);
remove_handle(hkey);
return ERROR_SUCCESS;
}
/*
* Delete registry key
*
* Callpath:
* RegDeleteKey -> RegDeleteKeyA -> RegDeleteKeyW
*/
/* RegDeleteKeyW [ADVAPI32.134] */
WINAPI DWORD
RegDeleteKeyW(HKEY hkey,LPWSTR lpszSubKey) {
LPKEYSTRUCT *lplpPrevKey,lpNextKey,lpxkey;
LPWSTR *wps;
int wpc,i;
dprintf_reg(stddeb,"RegDeleteKeyW(%ld,%s)\n",
hkey,W2C(lpszSubKey,0)
);
lpNextKey = lookup_hkey(hkey);
if (!lpNextKey)
return SHELL_ERROR_BADKEY;
/* we need to know the previous key in the hier. */
if (!lpszSubKey || !*lpszSubKey)
return SHELL_ERROR_BADKEY;
split_keypath(lpszSubKey,&wps,&wpc);
i = 0;
lpxkey = lpNextKey;
while (i<wpc-1) {
lpxkey=lpNextKey->nextsub;
while (lpxkey) {
if (!strcmpW(wps[i],lpxkey->keyname))
break;
lpxkey=lpxkey->next;
}
if (!lpxkey) {
FREE_KEY_PATH;
/* not found is success */
return SHELL_ERROR_SUCCESS;
}
i++;
lpNextKey = lpxkey;
}
lpxkey = lpNextKey->nextsub;
lplpPrevKey = &(lpNextKey->nextsub);
while (lpxkey) {
if (!strcmpW(wps[i],lpxkey->keyname))
break;
lplpPrevKey = &(lpxkey->next);
lpxkey = lpxkey->next;
}
if (!lpxkey)
return SHELL_ERROR_SUCCESS;
if (lpxkey->nextsub)
return SHELL_ERROR_CANTWRITE;
*lplpPrevKey = lpxkey->next;
free(lpxkey->keyname);
if (lpxkey->class)
free(lpxkey->class);
if (lpxkey->values)
free(lpxkey->values);
free(lpxkey);
FREE_KEY_PATH;
return SHELL_ERROR_SUCCESS;
}
/* RegDeleteKeyA [ADVAPI32.133] */
WINAPI DWORD
RegDeleteKeyA(HKEY hkey,LPCSTR lpszSubKey) {
LPWSTR lpszSubKeyW;
DWORD ret;
dprintf_reg(stddeb,"RegDeleteKeyA(%ld,%s)\n",
hkey,lpszSubKey
);
lpszSubKeyW=strdupA2W(lpszSubKey);
ret=RegDeleteKeyW(hkey,lpszSubKeyW);
free(lpszSubKeyW);
return ret;
}
/* RegDeleteKey [SHELL.4] [KERNEL.219] */
WINAPI DWORD
RegDeleteKey(HKEY hkey,LPCSTR lpszSubKey) {
dprintf_reg(stddeb,"RegDeleteKey(%ld,%s)\n",
hkey,lpszSubKey
);
return RegDeleteKeyA(hkey,lpszSubKey);
}
/*
* Delete registry value
*
* Callpath:
* RegDeleteValue -> RegDeleteValueA -> RegDeleteValueW
*/
/* RegDeleteValueW [ADVAPI32.136] */
WINAPI DWORD
RegDeleteValueW(HKEY hkey,LPWSTR lpszValue) {
DWORD i;
LPKEYSTRUCT lpkey;
LPKEYVALUE val;
dprintf_reg(stddeb,"RegDeleteValueW(%ld,%s)\n",
hkey,W2C(lpszValue,0)
);
lpkey=lookup_hkey(hkey);
if (!lpkey)
return SHELL_ERROR_BADKEY;
if (lpszValue) {
for (i=0;i<lpkey->nrofvalues;i++)
if (!strcmpW(lpkey->values[i].name,lpszValue))
break;
} else {
for (i=0;i<lpkey->nrofvalues;i++)
if (lpkey->values[i].name==NULL)
break;
}
if (i==lpkey->nrofvalues)
return SHELL_ERROR_BADKEY;/*FIXME: correct errorcode? */
val = lpkey->values+i;
if (val->name) free(val->name);
if (val->data) free(val->data);
memcpy(
lpkey->values+i,
lpkey->values+i+1,
sizeof(KEYVALUE)*(lpkey->nrofvalues-i-1)
);
lpkey->values = (LPKEYVALUE)xrealloc(
lpkey->values,
(lpkey->nrofvalues-1)*sizeof(KEYVALUE)
);
lpkey->nrofvalues--;
return SHELL_ERROR_SUCCESS;
}
/* RegDeleteValueA [ADVAPI32.135] */
WINAPI DWORD
RegDeleteValueA(HKEY hkey,LPSTR lpszValue) {
LPWSTR lpszValueW;
DWORD ret;
dprintf_reg(stddeb,"RegDeleteValueA(%ld,%s)\n",
hkey,lpszValue
);
if (lpszValue)
lpszValueW=strdupA2W(lpszValue);
else
lpszValueW=NULL;
ret=RegDeleteValueW(hkey,lpszValueW);
if (lpszValueW)
free(lpszValueW);
return ret;
}
/* RegDeleteValue [KERNEL.222] */
WINAPI DWORD
RegDeleteValue(HKEY hkey,LPSTR lpszValue) {
dprintf_reg(stddeb,"RegDeleteValue(%ld,%s)\n",
hkey,lpszValue
);
return RegDeleteValueA(hkey,lpszValue);
}
/* RegFlushKey [ADVAPI32.143] [KERNEL.227] */
WINAPI DWORD
RegFlushKey(HKEY hkey) {
dprintf_reg(stddeb,"RegFlushKey(%ld), STUB.\n",hkey);
return SHELL_ERROR_SUCCESS;
}
/* FIXME: lpcchXXXX ... is this counting in WCHARS or in BYTEs ?? */
/* RegQueryInfoKeyW [ADVAPI32.153] */
WINAPI DWORD
RegQueryInfoKeyW(
HKEY hkey,
LPWSTR lpszClass,
LPDWORD lpcchClass,
LPDWORD lpdwReserved,
LPDWORD lpcSubKeys,
LPDWORD lpcchMaxSubkey,
LPDWORD lpcchMaxClass,
LPDWORD lpcValues,
LPDWORD lpcchMaxValueName,
LPDWORD lpccbMaxValueData,
LPDWORD lpcbSecurityDescriptor,
FILETIME *ft
) {
LPKEYSTRUCT lpkey,lpxkey;
int nrofkeys,maxsubkey,maxclass,maxvalues,maxvname,maxvdata;
int i;
dprintf_reg(stddeb,"RegQueryInfoKeyW(%lx,......)\n",hkey);
lpkey=lookup_hkey(hkey);
if (!lpkey)
return SHELL_ERROR_BADKEY;
if (lpszClass) {
if (lpkey->class) {
if (strlenW(lpkey->class)*2+2>*lpcchClass) {
*lpcchClass=strlenW(lpkey->class)*2;
return ERROR_MORE_DATA;
}
*lpcchClass=strlenW(lpkey->class)*2;
memcpy(lpszClass,lpkey->class,strlenW(lpkey->class));
} else {
*lpszClass = 0;
*lpcchClass = 0;
}
} else {
if (lpcchClass)
*lpcchClass = strlenW(lpkey->class)*2;
}
lpxkey=lpkey->nextsub;
nrofkeys=maxsubkey=maxclass=maxvalues=maxvname=maxvdata=0;
while (lpxkey) {
nrofkeys++;
if (strlenW(lpxkey->keyname)>maxsubkey)
maxsubkey=strlenW(lpxkey->keyname);
if (lpxkey->class && strlenW(lpxkey->class)>maxclass)
maxclass=strlenW(lpxkey->class);
if (lpxkey->nrofvalues>maxvalues)
maxvalues=lpxkey->nrofvalues;
for (i=0;i<lpxkey->nrofvalues;i++) {
LPKEYVALUE val=lpxkey->values+i;
if (val->name && strlenW(val->name)>maxvname)
maxvname=strlenW(val->name);
if (val->len>maxvdata)
maxvdata=val->len;
}
lpxkey=lpxkey->next;
}
if (!maxclass) maxclass = 1;
if (!maxvname) maxvname = 1;
if (lpcSubKeys)
*lpcSubKeys = nrofkeys;
if (lpcchMaxSubkey)
*lpcchMaxSubkey = maxsubkey*2;
if (lpcchMaxClass)
*lpcchMaxClass = maxclass*2;
if (lpcValues)
*lpcValues = maxvalues;
if (lpcchMaxValueName)
*lpcchMaxValueName= maxvname;
if (lpccbMaxValueData)
*lpccbMaxValueData= maxvdata;
return SHELL_ERROR_SUCCESS;
}
/* RegQueryInfoKeyA [ADVAPI32.152] */
WINAPI DWORD
RegQueryInfoKeyA(
HKEY hkey,
LPSTR lpszClass,
LPDWORD lpcchClass,
LPDWORD lpdwReserved,
LPDWORD lpcSubKeys,
LPDWORD lpcchMaxSubkey,
LPDWORD lpcchMaxClass,
LPDWORD lpcValues,
LPDWORD lpcchMaxValueName,
LPDWORD lpccbMaxValueData,
LPDWORD lpcbSecurityDescriptor,
FILETIME *ft
) {
LPWSTR lpszClassW;
DWORD ret;
dprintf_reg(stddeb,"RegQueryInfoKeyA(%lx,......)\n",hkey);
if (lpszClass) {
*lpcchClass*= 2;
lpszClassW = (LPWSTR)xmalloc(*lpcchClass);
} else
lpszClassW = NULL;
ret=RegQueryInfoKeyW(
hkey,
lpszClassW,
lpcchClass,
lpdwReserved,
lpcSubKeys,
lpcchMaxSubkey,
lpcchMaxClass,
lpcValues,
lpcchMaxValueName,
lpccbMaxValueData,
lpcbSecurityDescriptor,
ft
);
if (ret==ERROR_SUCCESS)
strcpyWA(lpszClass,lpszClassW);
if (lpcchClass)
*lpcchClass/=2;
if (lpcchMaxSubkey)
*lpcchMaxSubkey/=2;
if (lpcchMaxClass)
*lpcchMaxClass/=2;
if (lpcchMaxValueName)
*lpcchMaxValueName/=2;
if (lpszClassW)
free(lpszClassW);
return ret;
}