From 2250ea126ca68448a88f050f6de2f196d054c3bf Mon Sep 17 00:00:00 2001 From: "ssu%netscape.com" Date: Thu, 13 May 1999 22:59:00 +0000 Subject: [PATCH] initial checkin for install.WinReg object files git-svn-id: svn://10.0.0.236/trunk@31490 18797224-902f-48f8-a5cc-f745e15eee43 --- mozilla/xpinstall/src/nsJSWinReg.cpp | 526 ++++++++++++++++++++++++ mozilla/xpinstall/src/nsJSWinReg.h | 25 ++ mozilla/xpinstall/src/nsWinReg.cpp | 414 +++++++++++++++++++ mozilla/xpinstall/src/nsWinReg.h | 109 +++++ mozilla/xpinstall/src/nsWinRegItem.cpp | 259 ++++++++++++ mozilla/xpinstall/src/nsWinRegItem.h | 82 ++++ mozilla/xpinstall/src/nsWinRegValue.cpp | 24 ++ mozilla/xpinstall/src/nsWinRegValue.h | 56 +++ 8 files changed, 1495 insertions(+) create mode 100644 mozilla/xpinstall/src/nsJSWinReg.cpp create mode 100644 mozilla/xpinstall/src/nsJSWinReg.h create mode 100644 mozilla/xpinstall/src/nsWinReg.cpp create mode 100644 mozilla/xpinstall/src/nsWinReg.h create mode 100644 mozilla/xpinstall/src/nsWinRegItem.cpp create mode 100644 mozilla/xpinstall/src/nsWinRegItem.h create mode 100644 mozilla/xpinstall/src/nsWinRegValue.cpp create mode 100644 mozilla/xpinstall/src/nsWinRegValue.h diff --git a/mozilla/xpinstall/src/nsJSWinReg.cpp b/mozilla/xpinstall/src/nsJSWinReg.cpp new file mode 100644 index 00000000000..151e51bd582 --- /dev/null +++ b/mozilla/xpinstall/src/nsJSWinReg.cpp @@ -0,0 +1,526 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#include "jsapi.h" +//#include "nsJSUtils.h" +#include "nscore.h" +#include "nsIScriptContext.h" + +#include "nsString.h" +#include "nsInstall.h" +#include "nsWinReg.h" +#include "nsJSWinReg.h" + +//extern JSClass WinRegClass; +// extern JSClass WinProfileClass; + +static void PR_CALLBACK WinRegCleanup(JSContext *cx, JSObject *obj); + +extern void nsCvrtJSValToStr(nsString& aString, + JSContext* aContext, + jsval aValue); + +extern void nsCvrtStrToJSVal(const nsString& aProp, + JSContext* aContext, + jsval* aReturn); + +extern PRBool nsCvrtJSValToBool(PRBool* aProp, + JSContext* aContext, + jsval aValue); + +extern PRBool nsCvrtJSValToObj(nsISupports** aSupports, + REFNSIID aIID, + const nsString& aTypeName, + JSContext* aContext, + jsval aValue); + + +static void PR_CALLBACK WinRegCleanup(JSContext *cx, JSObject *obj) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + delete nativeThis; +} + +/***********************************************************************************/ +// Native mothods for WinReg functions + +// +// Native method SetRootKey +// +PR_STATIC_CALLBACK(JSBool) +WinRegSetRootKey(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + JSBool rBool = JS_FALSE; + PRInt32 b0; + + *rval = JSVAL_NULL; + + // If there's no private data, this must be the prototype, so ignore + if(nsnull == nativeThis) + { + return JS_TRUE; + } + + if(argc >= 1) + { + // public int setRootKey(PRInt32 key); + + if(!JS_ValueToInt32(cx, argv[0], (int32 *)&b0)) + { + JS_ReportError(cx, "Parameter must be a number"); + return JS_FALSE; + } + + if(NS_OK != nativeThis->setRootKey(b0)) + { + return JS_FALSE; + } + + *rval = JSVAL_VOID; + } + else + { + JS_ReportError(cx, "Function SetRootKey requires 1 parameters"); + return JS_FALSE; + } + + return JS_TRUE; +} + + +// +// Native method CreateKey +// +PR_STATIC_CALLBACK(JSBool) +WinRegCreateKey(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + PRInt32 nativeRet; + nsAutoString b0; + nsAutoString b1; + + *rval = JSVAL_NULL; + + // If there's no private data, this must be the prototype, so ignore + if(nsnull == nativeThis) + { + return JS_TRUE; + } + + if(argc >= 2) + { + // public int createKey ( String subKey, + // String className); + + nsCvrtJSValToStr(b0, cx, argv[0]); + nsCvrtJSValToStr(b1, cx, argv[1]); + + if(NS_OK != nativeThis->createKey(b0, b1, &nativeRet)) + { + return JS_FALSE; + } + + *rval = INT_TO_JSVAL(nativeRet); + } + else + { + JS_ReportError(cx, "WinReg.CreateKey() parameters error"); + return JS_FALSE; + } + + return JS_TRUE; +} + +// +// Native method DeleteKey +// +PR_STATIC_CALLBACK(JSBool) +WinRegDeleteKey(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + PRInt32 nativeRet; + nsAutoString b0; + + *rval = JSVAL_NULL; + + // If there's no private data, this must be the prototype, so ignore + if(nsnull == nativeThis) + { + return JS_TRUE; + } + + if(argc >= 1) + { + // public int deleteKey ( String subKey); + + nsCvrtJSValToStr(b0, cx, argv[0]); + + if(NS_OK != nativeThis->deleteKey(b0, &nativeRet)) + { + return JS_FALSE; + } + + *rval = INT_TO_JSVAL(nativeRet); + } + else + { + JS_ReportError(cx, "WinReg.DeleteKey() parameters error"); + return JS_FALSE; + } + + return JS_TRUE; +} + + +// +// Native method DeleteValue +// +PR_STATIC_CALLBACK(JSBool) +WinRegDeleteValue(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + PRInt32 nativeRet; + nsString b0; + nsString b1; + + *rval = JSVAL_NULL; + + // If there's no private data, this must be the prototype, so ignore + if(nsnull == nativeThis) + { + return JS_TRUE; + } + + if(argc >= 2) + { + // public int deleteValue ( String subKey, + // String valueName); + + nsCvrtJSValToStr(b0, cx, argv[0]); + nsCvrtJSValToStr(b1, cx, argv[1]); + + if(NS_OK != nativeThis->deleteValue(b0, b1, &nativeRet)) + { + return JS_FALSE; + } + + *rval = INT_TO_JSVAL(nativeRet); + } + else + { + JS_ReportError(cx, "WinReg.DeleteValue() parameters error"); + return JS_FALSE; + } + + return JS_TRUE; +} + +// +// Native method SetValueString +// +PR_STATIC_CALLBACK(JSBool) +WinRegSetValueString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + PRInt32 nativeRet; + nsAutoString b0; + nsAutoString b1; + nsAutoString b2; + + *rval = JSVAL_NULL; + + // If there's no private data, this must be the prototype, so ignore + if(nsnull == nativeThis) + { + return JS_TRUE; + } + + if(argc >= 3) + { + // public int setValueString ( String subKey, + // String valueName, + // String value); + + nsCvrtJSValToStr(b0, cx, argv[0]); + nsCvrtJSValToStr(b1, cx, argv[1]); + nsCvrtJSValToStr(b2, cx, argv[2]); + + if(NS_OK != nativeThis->setValueString(b0, b1, b2, &nativeRet)) + { + return JS_FALSE; + } + + *rval = INT_TO_JSVAL(nativeRet); + } + else + { + JS_ReportError(cx, "WinReg.SetValueString() parameters error"); + return JS_FALSE; + } + + return JS_TRUE; +} + +// +// Native method GetValueString +// +PR_STATIC_CALLBACK(JSBool) +WinRegGetValueString(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + nsString* nativeRet; + nsAutoString b0; + nsAutoString b1; + + *rval = JSVAL_NULL; + + // If there's no private data, this must be the prototype, so ignore + if(nsnull == nativeThis) + { + return JS_TRUE; + } + + if(argc >= 2) + { + // public int getValueString ( String subKey, + // String valueName); + + nsCvrtJSValToStr(b0, cx, argv[0]); + nsCvrtJSValToStr(b1, cx, argv[1]); + + if(NS_OK != nativeThis->getValueString(b0, b1, &nativeRet)) + { + return JS_FALSE; + } + + *rval = INT_TO_JSVAL(nativeRet); + } + else + { + JS_ReportError(cx, "WinReg.GetValueString() parameters error"); + return JS_FALSE; + } + + return JS_TRUE; +} + +// +// Native method SetValue +// +PR_STATIC_CALLBACK(JSBool) +WinRegSetValue(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + PRInt32 nativeRet; + nsAutoString b0; + nsAutoString b1; +// nsWinRegItem *b2; + + *rval = JSVAL_NULL; + + // If there's no private data, this must be the prototype, so ignore + if(nsnull == nativeThis) + { + return JS_TRUE; + } + + if(argc >= 3) + { + // public int setValue ( String subKey, + // String valueName, + // nsWinRegItem *value); + + nsCvrtJSValToStr(b0, cx, argv[0]); + nsCvrtJSValToStr(b1, cx, argv[1]); + + // fix: this parameter is an object, not a string. + // A way needs to be figured out to convert the JSVAL to this object type +// nsCvrtJSValToStr(b2, cx, argv[2]); + +// if(NS_OK != nativeThis->setValue(b0, b1, b2, &nativeRet)) +// { +// return JS_FALSE; +// } + + *rval = INT_TO_JSVAL(nativeRet); + } + else + { + JS_ReportError(cx, "WinReg.SetValue() parameters error"); + return JS_FALSE; + } + + return JS_TRUE; +} + +// +// Native method GetValue +// +PR_STATIC_CALLBACK(JSBool) +WinRegGetValue(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + nsWinRegValue *nativeRet; + nsAutoString b0; + nsAutoString b1; + + *rval = JSVAL_NULL; + + // If there's no private data, this must be the prototype, so ignore + if(nsnull == nativeThis) + { + return JS_TRUE; + } + + if(argc >= 2) + { + // public int getValue ( String subKey, + // String valueName); + + nsCvrtJSValToStr(b0, cx, argv[0]); + nsCvrtJSValToStr(b1, cx, argv[1]); + + if(NS_OK != nativeThis->getValue(b0, b1, &nativeRet)) + { + return JS_FALSE; + } + + *rval = INT_TO_JSVAL(nativeRet); + } + else + { + JS_ReportError(cx, "WinReg.GetValue() parameters error"); + return JS_FALSE; + } + + return JS_TRUE; +} + +// +// Native method InstallObject +// +PR_STATIC_CALLBACK(JSBool) +WinRegInstallObject(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + nsWinReg *nativeThis = (nsWinReg*)JS_GetPrivate(cx, obj); + nsInstall *nativeRet; + nsAutoString b0; + nsAutoString b1; + + *rval = JSVAL_NULL; + + // If there's no private data, this must be the prototype, so ignore + if(nsnull == nativeThis) + { + return JS_TRUE; + } + + // public int installObject (); + + nativeRet = nativeThis->installObject(); + + *rval = INT_TO_JSVAL(nativeRet); + return JS_TRUE; +} + +// +// WinReg constructor +// +PR_STATIC_CALLBACK(JSBool) +WinReg(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + return JS_FALSE; +} + +// +// WinProfile constructor +// +PR_STATIC_CALLBACK(JSBool) +WinProfile(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) +{ + return JS_FALSE; +} + +/***********************************************************************/ +// +// class for WinReg +// +JSClass WinRegClass = { + "WinReg", + JSCLASS_HAS_PRIVATE, + JS_PropertyStub, + JS_PropertyStub, + JS_PropertyStub, + JS_PropertyStub, + JS_EnumerateStub, + JS_ResolveStub, + JS_ConvertStub, + WinRegCleanup +}; + +static JSConstDoubleSpec winreg_constants[] = +{ + { nsWinReg::HKEY_CLASSES_ROOT, "HKEY_CLASSES_ROOT" }, + { nsWinReg::HKEY_CURRENT_USER, "HKEY_CURRENT_USER" }, + { nsWinReg::HKEY_LOCAL_MACHINE, "HKEY_LOCAL_MACHINE" }, + { nsWinReg::HKEY_USERS, "HKEY_USERS" }, + {0} +}; + +// +// WinReg class methods +// +static JSFunctionSpec WinRegMethods[] = +{ + {"setRootKey", WinRegSetRootKey, 1}, + {"createKey", WinRegCreateKey, 2}, + {"deleteKey", WinRegDeleteKey, 1}, + {"deleteValue", WinRegDeleteValue, 2}, + {"setValueString", WinRegSetValueString, 3}, + {"getValueString", WinRegGetValueString, 2}, + {"setValue", WinRegSetValue, 3}, + {"getValue", WinRegGetValue, 2}, + {"installObject", WinRegInstallObject, 0}, + {0} +}; + +PRInt32 +InitWinRegPrototype(JSContext *jscontext, JSObject *global, JSObject **winRegPrototype) +{ + *winRegPrototype = JS_InitClass( jscontext, // context + global, // global object + nsnull, // parent proto + &WinRegClass, // JSClass + nsnull, // JSNative ctor + 0, // ctor args + nsnull, // proto props + nsnull, // proto funcs + nsnull, // ctor props (static) + WinRegMethods); // ctor funcs (static) + + if(nsnull == *winRegPrototype) + { + return NS_ERROR_FAILURE; + } + + if(PR_FALSE == JS_DefineConstDoubles(jscontext, *winRegPrototype, winreg_constants)) + return NS_ERROR_FAILURE; + + return NS_OK; +} diff --git a/mozilla/xpinstall/src/nsJSWinReg.h b/mozilla/xpinstall/src/nsJSWinReg.h new file mode 100644 index 00000000000..036acbebeac --- /dev/null +++ b/mozilla/xpinstall/src/nsJSWinReg.h @@ -0,0 +1,25 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef __NS_JSWINREG_H__ +#define __NS_JSWINREG_H__ + +PRInt32 +InitWinRegPrototype(JSContext *jscontext, JSObject *global, JSObject **winRegPrototype); + +#endif diff --git a/mozilla/xpinstall/src/nsWinReg.cpp b/mozilla/xpinstall/src/nsWinReg.cpp new file mode 100644 index 00000000000..a8a424fe0e4 --- /dev/null +++ b/mozilla/xpinstall/src/nsWinReg.cpp @@ -0,0 +1,414 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#include "nsWinReg.h" +#include "nsWinRegItem.h" +#include /* is this needed? */ + +/* Public Methods */ + +nsWinReg::nsWinReg(nsInstall* suObj) +{ + su = suObj; + +// principal = suObj->GetPrincipal(); +// privMgr = nsPrivilegeManager::getPrivilegeManager(); +// impersonation = nsTarget::findTarget(IMPERSONATOR); +// target = (nsUserTarget*)nsTarget::findTarget(INSTALL_PRIV); +} + +PRInt32 +nsWinReg::setRootKey(PRInt32 key) +{ + rootkey = key; + return NS_OK; +} + +PRInt32 +nsWinReg::createKey(nsString subkey, nsString classname, PRInt32* aReturn) +{ +// resolvePrivileges(); + + nsWinRegItem* wi = new nsWinRegItem(this, rootkey, NS_WIN_REG_CREATE, subkey, classname, "null"); + if(wi == nsnull) + { +// return (-1); +// *aReturn = SaveError( result ); + return NS_OK; + } + su->ScheduleForInstall(wi); + return 0; +} + +PRInt32 +nsWinReg::deleteKey(nsString subkey, PRInt32* aReturn) +{ +// resolvePrivileges(); + + nsWinRegItem* wi = new nsWinRegItem(this, rootkey, NS_WIN_REG_DELETE, subkey, "null", "null"); + if(wi == nsnull) + { +// return (-1); +// *aReturn = SaveError( result ); + return NS_OK; + } + su->ScheduleForInstall(wi); + return 0; +} + +PRInt32 +nsWinReg::deleteValue(nsString subkey, nsString valname, PRInt32* aReturn) +{ +// resolvePrivileges(); + + nsWinRegItem* wi = new nsWinRegItem(this, rootkey, NS_WIN_REG_DELETE_VAL, subkey, valname, "null"); + if(wi == nsnull) + { +// return (-1); +// *aReturn = SaveError( result ); + return NS_OK; + } + su->ScheduleForInstall(wi); + return 0; +} + +PRInt32 +nsWinReg::setValueString(nsString subkey, nsString valname, nsString value, PRInt32* aReturn) +{ +// resolvePrivileges(); + + nsWinRegItem* wi = new nsWinRegItem(this, rootkey, NS_WIN_REG_SET_VAL_STRING, subkey, valname, value); + if(wi == nsnull) + { +// return (-1); +// *aReturn = SaveError( result ); + return NS_OK; + } + su->ScheduleForInstall(wi); + return 0; +} + +PRInt32 +nsWinReg::getValueString(nsString subkey, nsString valname, nsString** aReturn) +{ +// resolvePrivileges(); + +// return nativeGetValueString(subkey, valname); + return NS_OK; +} + +PRInt32 +nsWinReg::setValue(nsString subkey, nsString valname, nsWinRegValue* value, PRInt32* aReturn) +{ +// resolvePrivileges(); + + // fix: need to figure out what to do with nsWinRegValue class. + // nsWinRegItem* wi = new nsWinRegItem(this, rootkey, NS_WIN_REG_SET_VAL, subkey, valname, (nsWinRegValue*)value); + // if(wi == nsnull) + // { +// return (-1); +// *aReturn = SaveError(-1); + // return NS_OK; + // } + // su->ScheduleForInstall(wi); + return 0; +} + +PRInt32 +nsWinReg::getValue(nsString subkey, nsString valname, nsWinRegValue** aReturn) +{ +// resolvePrivileges(); + +// return nativeGetValue(subkey, valname); + return NS_OK; +} + +nsInstall* nsWinReg::installObject() +{ + return su; +} + +PRInt32 +nsWinReg::finalCreateKey(PRInt32 root, nsString subkey, nsString classname, PRInt32* aReturn) +{ + setRootKey(root); + *aReturn = nativeCreateKey(subkey, classname); + return NS_OK; +} + +PRInt32 +nsWinReg::finalDeleteKey(PRInt32 root, nsString subkey, PRInt32* aReturn) +{ + setRootKey(root); + *aReturn = nativeDeleteKey(subkey); + return NS_OK; +} + +PRInt32 +nsWinReg::finalDeleteValue(PRInt32 root, nsString subkey, nsString valname, PRInt32* aReturn) +{ + setRootKey(root); + *aReturn = nativeDeleteValue(subkey, valname); + return NS_OK; +} + +PRInt32 +nsWinReg::finalSetValueString(PRInt32 root, nsString subkey, nsString valname, nsString value, PRInt32* aReturn) +{ + setRootKey(root); + *aReturn = nativeSetValueString(subkey, valname, value); + return NS_OK; +} + +PRInt32 +nsWinReg::finalSetValue(PRInt32 root, nsString subkey, nsString valname, nsWinRegValue* value, PRInt32* aReturn) +{ + setRootKey(root); + *aReturn = nativeSetValue(subkey, valname, value); + return NS_OK; +} + + +/* Private Methods */ + +PRInt32 +nsWinReg::nativeCreateKey(nsString subkey, nsString classname) +{ + HKEY root, newkey; + LONG result; + ULONG disposition; + char* subkeyCString = subkey.ToNewCString(); + char* classnameCString = classname.ToNewCString(); + +#ifdef WIN32 + root = (HKEY)rootkey; + result = RegCreateKeyEx(root, subkeyCString, 0, classnameCString, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, nsnull, &newkey, &disposition); + + if(ERROR_SUCCESS == result) + { + RegCloseKey( newkey ); + } +#endif + + delete [] subkeyCString; + delete [] classnameCString; + + return result; +} + +PRInt32 +nsWinReg::nativeDeleteKey(nsString subkey) +{ + HKEY root; + LONG result; + char* subkeyCString = subkey.ToNewCString(); + +#ifdef WIN32 + root = (HKEY) rootkey; + result = RegDeleteKey( root, subkeyCString ); +#endif + + delete [] subkeyCString; + + return result; +} + +PRInt32 +nsWinReg::nativeDeleteValue(nsString subkey, nsString valname) +{ +#if defined (WIN32) || defined (XP_OS2) + HKEY root, newkey; + LONG result; + char* subkeyCString = subkey.ToNewCString(); + char* valnameCString = valname.ToNewCString(); + + root = (HKEY) rootkey; + result = RegOpenKeyEx( root, subkeyCString, 0, KEY_WRITE, &newkey); + + if ( ERROR_SUCCESS == result ) + { + result = RegDeleteValue( newkey, valnameCString ); + RegCloseKey( newkey ); + } + + delete [] subkeyCString; + delete [] valnameCString; + + return result; +#else + return ERROR_INVALID_PARAMETER; +#endif +} + +PRInt32 +nsWinReg::nativeSetValueString(nsString subkey, nsString valname, nsString value) +{ + HKEY root; + HKEY newkey; + LONG result; + DWORD length; + + char* subkeyCString = subkey.ToNewCString(); + char* valnameCString = valname.ToNewCString(); + char* valueCString = value.ToNewCString(); + + length = subkey.Length(); + +#ifdef WIN32 + root = (HKEY) rootkey; + result = RegOpenKeyEx( root, subkeyCString, 0, KEY_ALL_ACCESS, &newkey); + + if(ERROR_SUCCESS == result) + { + result = RegSetValueEx( newkey, valnameCString, 0, REG_SZ, (unsigned char*)valueCString, length ); + RegCloseKey( newkey ); + } +#endif + + delete [] subkeyCString; + delete [] valnameCString; + delete [] valueCString; + + return result; +} + +#define STRBUFLEN 255 + +nsString* +nsWinReg::nativeGetValueString(nsString subkey, nsString valname) +{ + unsigned char valbuf[STRBUFLEN]; + HKEY root; + HKEY newkey; + LONG result; + DWORD type = REG_SZ; + DWORD length = STRBUFLEN; + nsString* value; + char* subkeyCString = subkey.ToNewCString(); + char* valnameCString = valname.ToNewCString(); + + +#ifdef WIN32 + root = (HKEY) rootkey; + result = RegOpenKeyEx( root, subkeyCString, 0, KEY_ALL_ACCESS, &newkey ); + + if ( ERROR_SUCCESS == result ) { + result = RegQueryValueEx( newkey, valnameCString, nsnull, &type, valbuf, &length ); + + RegCloseKey( newkey ); + } + + if(ERROR_SUCCESS == result && type == REG_SZ) + { + value = new nsString((char*)valbuf); + } +#endif + + delete [] subkeyCString; + delete [] valnameCString; + + return value; +} + + +PRInt32 +nsWinReg::nativeSetValue(nsString subkey, nsString valname, nsWinRegValue* value) +{ +#if defined (WIN32) || defined (XP_OS2) + HKEY root; + HKEY newkey; + LONG result; + DWORD length; + DWORD type; + unsigned char* data; + char* subkeyCString = subkey.ToNewCString(); + char* valnameCString = valname.ToNewCString(); + + + root = (HKEY) rootkey; + result = RegOpenKeyEx( root, subkeyCString, 0, KEY_ALL_ACCESS, &newkey ); + + if(ERROR_SUCCESS == result) + { + type = (DWORD)value->type; + data = (unsigned char*)value->data; + length = (DWORD)value->data_length; + + result = RegSetValueEx( newkey, valnameCString, 0, type, data, length); + RegCloseKey( newkey ); + } + + delete [] subkeyCString; + delete [] valnameCString; + + return result; +#else + return ERROR_INVALID_PARAMETER; +#endif +} + +nsWinRegValue* +nsWinReg::nativeGetValue(nsString subkey, nsString valname) +{ +#if defined (WIN32) || defined (XP_OS2) + unsigned char valbuf[STRBUFLEN]; + HKEY root; + HKEY newkey; + LONG result; + DWORD length=STRBUFLEN; + DWORD type; + nsString* data; + nsWinRegValue* value = nsnull; + char* subkeyCString = subkey.ToNewCString(); + char* valnameCString = valname.ToNewCString(); + + root = (HKEY) rootkey; + result = RegOpenKeyEx( root, subkeyCString, 0, KEY_ALL_ACCESS, &newkey ); + + if(ERROR_SUCCESS == result) + { + result = RegQueryValueEx( newkey, valnameCString, nsnull, &type, valbuf, &length ); + + if ( ERROR_SUCCESS == result ) { + data = new nsString((char*)valbuf); + length = data->Length(); + value = new nsWinRegValue(type, (void*)data, length); + } + + RegCloseKey( newkey ); + } + + delete [] subkeyCString; + delete [] valnameCString; + + return value; +#else + return nsnull; +#endif +} + +// PRBool +// nsWinReg::resolvePrivileges() +// { +// if(privMgr->enablePrivilege(impersonation, 1) && +// privMgr->enablePrivilege(target, principal, 1)) +// return TRUE; +// else +// return FALSE; +// } + diff --git a/mozilla/xpinstall/src/nsWinReg.h b/mozilla/xpinstall/src/nsWinReg.h new file mode 100644 index 00000000000..5f8c0acfd48 --- /dev/null +++ b/mozilla/xpinstall/src/nsWinReg.h @@ -0,0 +1,109 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#ifndef __NS_WINREG_H__ +#define __NS_WINREG_H__ + +//#include "prtypes.h" +#include "nsSoftUpdateEnums.h" +#include "nsWinRegValue.h" + +//#include "nsPrincipal.h" +//#include "nsPrivilegeManager.h" +//#include "nsTarget.h" +//#include "nsUserTarget.h" + +#include "nscore.h" +#include "nsISupports.h" + +#include "jsapi.h" + +#include "plevent.h" + +#include "nsString.h" +#include "nsFileSpec.h" +#include "nsVector.h" +#include "nsHashtable.h" + +#include "nsSoftwareUpdate.h" + +#include "nsInstallObject.h" +#include "nsInstallVersion.h" +#include "nsInstall.h" + +class nsWinReg +{ + public: + + enum + { + HKEY_CLASSES_ROOT = 0x80000000, + HKEY_CURRENT_USER = 0x80000001, + HKEY_LOCAL_MACHINE = 0x80000002, + HKEY_USERS = 0x80000003 + }; + + /* Public Fields */ + + /* Public Methods */ + + nsWinReg(nsInstall* suObj); + + PRInt32 setRootKey(PRInt32 key); + PRInt32 createKey(nsString subkey, nsString classname, PRInt32* aReturn); + PRInt32 deleteKey(nsString subkey, PRInt32* aReturn); + PRInt32 deleteValue(nsString subkey, nsString valname, PRInt32* aReturn); + PRInt32 setValueString(nsString subkey, nsString valname, nsString value, PRInt32* aReturn); + PRInt32 getValueString(nsString subkey, nsString valname, nsString** aReturn); + PRInt32 setValue(nsString subkey, nsString valname, nsWinRegValue* value, PRInt32* aReturn); + PRInt32 getValue(nsString subkey, nsString valname, nsWinRegValue** aReturn); + + nsInstall* installObject(void); + + PRInt32 finalCreateKey(PRInt32 root, nsString subkey, nsString classname, PRInt32* aReturn); + PRInt32 finalDeleteKey(PRInt32 root, nsString subkey, PRInt32* aReturn); + PRInt32 finalDeleteValue(PRInt32 root, nsString subkey, nsString valname, PRInt32* aReturn); + PRInt32 finalSetValueString(PRInt32 root, nsString subkey, nsString valname, nsString value, PRInt32* aReturn); + PRInt32 finalSetValue(PRInt32 root, nsString subkey, nsString valname, nsWinRegValue* value, PRInt32* aReturn); + + + private: + + /* Private Fields */ + PRInt32 rootkey; +// nsPrincipal* principal; +// nsPrivilegeManager* privMgr; +// nsTarget* impersonation; + nsInstall* su; + +// nsUserTarget* target; + + /* Private Methods */ + PRInt32 nativeCreateKey(nsString subkey, nsString classname); + PRInt32 nativeDeleteKey(nsString subkey); + PRInt32 nativeDeleteValue(nsString subkey, nsString valname); + + PRInt32 nativeSetValueString(nsString subkey, nsString valname, nsString value); + nsString* nativeGetValueString(nsString subkey, nsString valname); + + PRInt32 nativeSetValue(nsString subkey, nsString valname, nsWinRegValue* value); + nsWinRegValue* nativeGetValue(nsString subkey, nsString valname); +// PRBool resolvePrivileges(); +}; + +#endif /* __NS_WINREG_H__ */ diff --git a/mozilla/xpinstall/src/nsWinRegItem.cpp b/mozilla/xpinstall/src/nsWinRegItem.cpp new file mode 100644 index 00000000000..56a7cabaf53 --- /dev/null +++ b/mozilla/xpinstall/src/nsWinRegItem.cpp @@ -0,0 +1,259 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public License + * Version 1.0 (the "NPL"); you may not use this file except in + * compliance with the NPL. You may obtain a copy of the NPL at + * http://www.mozilla.org/NPL/ + * + * Software distributed under the NPL is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL + * for the specific language governing rights and limitations under the + * NPL. + * + * The Initial Developer of this code under the NPL is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All Rights + * Reserved. + */ + +#include "nsWinRegItem.h" +#include "nspr.h" + +#ifdef WIN32 +#include /* is this needed? */ +#endif + +/* Public Methods */ + +nsWinRegItem::nsWinRegItem(nsWinReg* regObj, PRInt32 root, PRInt32 action, nsString sub, nsString valname, nsString val) +: nsInstallObject(regObj->installObject()) +{ + reg = regObj; + command = action; + rootkey = root; + + /* I'm assuming we need to copy these */ + subkey = new nsString(sub); + name = new nsString(valname); + value = new nsString(val); +} + +nsWinRegItem::~nsWinRegItem() +{ + if(subkey != nsnull) + delete subkey; + + if(name != nsnull) + delete name; + + if(value != nsnull) + delete value; +} + +PRInt32 nsWinRegItem::Complete() +{ + PRInt32 aReturn; + + switch (command) + { + case NS_WIN_REG_CREATE: + reg->finalCreateKey(rootkey, *subkey, *name, &aReturn); + break; + case NS_WIN_REG_DELETE: + reg->finalDeleteKey(rootkey, *subkey, &aReturn); + break; + case NS_WIN_REG_DELETE_VAL: + reg->finalDeleteValue(rootkey, *subkey, *name, &aReturn); + break; + case NS_WIN_REG_SET_VAL_STRING: + reg->finalSetValueString(rootkey, *subkey, *name, *(nsString*)value, &aReturn); + break; + case NS_WIN_REG_SET_VAL: + reg->finalSetValue(rootkey, *subkey, *name, (nsWinRegValue*)value, &aReturn); + break; + } + return aReturn; +} + +float nsWinRegItem::GetInstallOrder() +{ + return 3; +} + +#define kCRK "Create Registry Key " +#define kDRK "Delete Registry key " +#define kDRV "Delete Registry value " +#define kSRV "Store Registry value " +#define kUNK "Unknown " + +char* nsWinRegItem::toString() +{ + nsString* keyString; + nsString* result; + char* resultCString; + + switch(command) + { + case NS_WIN_REG_CREATE: + keyString = keystr(rootkey, subkey, nsnull); + result = new nsString(kCRK); + result->Append(*keyString); + resultCString = result->ToNewCString(); + delete [] keyString; + delete [] result; + return resultCString; + case NS_WIN_REG_DELETE: + keyString = keystr(rootkey, subkey, nsnull); + result = new nsString(kDRK); + result->Append(*keyString); + resultCString = result->ToNewCString(); + delete [] keyString; + delete [] result; + return resultCString; + case NS_WIN_REG_DELETE_VAL: + keyString = keystr(rootkey, subkey, name); + result = new nsString(kDRV); + result->Append(*keyString); + resultCString = result->ToNewCString(); + delete [] keyString; + delete [] result; + return resultCString; + case NS_WIN_REG_SET_VAL_STRING: + keyString = keystr(rootkey, subkey, name); + result = new nsString(kSRV); + result->Append(*keyString); + resultCString = result->ToNewCString(); + delete [] keyString; + delete [] result; + return resultCString; + case NS_WIN_REG_SET_VAL: + keyString = keystr(rootkey, subkey, name); + result = new nsString(kSRV); + result->Append(*keyString); + resultCString = result->ToNewCString(); + delete [] keyString; + delete [] result; + return resultCString; + default: + keyString = keystr(rootkey, subkey, name); + result = new nsString(kUNK); + result->Append(*keyString); + resultCString = result->ToNewCString(); + delete [] keyString; + delete [] result; + return resultCString; + } +} + +PRInt32 nsWinRegItem::Prepare() +{ + return NULL; +} + +void nsWinRegItem::Abort() +{ +} + +/* Private Methods */ + +nsString* nsWinRegItem::keystr(PRInt32 root, nsString* subkey, nsString* name) +{ + nsString* rootstr; + nsString* finalstr; + char* istr; + + switch(root) + { + case (int)(HKEY_CLASSES_ROOT) : + rootstr = new nsString("\\HKEY_CLASSES_ROOT\\"); + break; + case (int)(HKEY_CURRENT_USER) : + rootstr = new nsString("\\HKEY_CURRENT_USER\\"); + break; + case (int)(HKEY_LOCAL_MACHINE) : + rootstr = new nsString("\\HKEY_LOCAL_MACHINE\\"); + break; + case (int)(HKEY_USERS) : + rootstr = new nsString("\\HKEY_USERS\\"); + break; + default: + istr = itoa(root); + rootstr = new nsString("\\#"); + rootstr->Append(istr); + rootstr->Append("\\"); + PR_DELETE(istr); + break; + } + + finalstr = new nsString(*rootstr); + if(name != nsnull) + { + finalstr->Append(*subkey); + finalstr->Append(" ["); + finalstr->Append(*name); + finalstr->Append("]"); + } + delete [] rootstr; + return finalstr; +} + + +char* nsWinRegItem::itoa(PRInt32 n) +{ + char* s; + int i, sign; + if((sign = n) < 0) + n = -n; + i = 0; + + s = (char*)PR_CALLOC(sizeof(char)); + + do + { + s = (char*)PR_REALLOC(s, (i+1)*sizeof(char)); + s[i++] = n%10 + '0'; + s[i] = '\0'; + } while ((n/=10) > 0); + + if(sign < 0) + { + s = (char*)PR_REALLOC(s, (i+1)*sizeof(char)); + s[i++] = '-'; + } + s[i] = '\0'; + reverseString(s); + return s; +} + +void nsWinRegItem::reverseString(char* s) +{ + int c, i, j; + + for(i=0, j=strlen(s)-1; i