diff --git a/mozilla/java/xpcom/urp/src/Makefile b/mozilla/java/xpcom/urp/src/Makefile index 39068ae0223..3bbcea4cbc1 100644 --- a/mozilla/java/xpcom/urp/src/Makefile +++ b/mozilla/java/xpcom/urp/src/Makefile @@ -18,7 +18,8 @@ # Rights Reserved. # # Contributor(s): -# Igor Kushnirskiy +# Serge Pikalev +# # DEPTH = ../../../../ topsrcdir = $(DEPTH) @@ -33,18 +34,19 @@ include $(DEPTH)/config/autoconf.mk include $(topsrcdir)/config/config.mk -DIRS = transport test +DIRS = transport test loader -CXXFLAGS += -I$(CONNECT_SRC)/public -I$(topsrcdir)/java/xpcom/xpcom -Itransport +CXXFLAGS += -I$(CONNECT_SRC)/public -I$(topsrcdir)/java/xpcom/xpcom -Itransport CPPSRCS = \ + urpMarshalToolkit.cpp \ urpManager.cpp \ urpStub.cpp \ $(NULL) EXPORTS = \ + urpMarshalToolkit.h \ urpStub.h \ urpManager.h \ - $(NULL) LIBS = \ -lxpcom \ diff --git a/mozilla/java/xpcom/urp/src/Makefile.in b/mozilla/java/xpcom/urp/src/Makefile.in index 39068ae0223..3bbcea4cbc1 100644 --- a/mozilla/java/xpcom/urp/src/Makefile.in +++ b/mozilla/java/xpcom/urp/src/Makefile.in @@ -18,7 +18,8 @@ # Rights Reserved. # # Contributor(s): -# Igor Kushnirskiy +# Serge Pikalev +# # DEPTH = ../../../../ topsrcdir = $(DEPTH) @@ -33,18 +34,19 @@ include $(DEPTH)/config/autoconf.mk include $(topsrcdir)/config/config.mk -DIRS = transport test +DIRS = transport test loader -CXXFLAGS += -I$(CONNECT_SRC)/public -I$(topsrcdir)/java/xpcom/xpcom -Itransport +CXXFLAGS += -I$(CONNECT_SRC)/public -I$(topsrcdir)/java/xpcom/xpcom -Itransport CPPSRCS = \ + urpMarshalToolkit.cpp \ urpManager.cpp \ urpStub.cpp \ $(NULL) EXPORTS = \ + urpMarshalToolkit.h \ urpStub.h \ urpManager.h \ - $(NULL) LIBS = \ -lxpcom \ diff --git a/mozilla/java/xpcom/urp/src/loader/Makefile.in b/mozilla/java/xpcom/urp/src/loader/Makefile.in new file mode 100644 index 00000000000..079c33ada9b --- /dev/null +++ b/mozilla/java/xpcom/urp/src/loader/Makefile.in @@ -0,0 +1,50 @@ +#!gmake +# +# The contents of this file are subject to the Netscape Public +# License Version 1.1 (the "License"); you may not use this file +# except in compliance with the License. You may obtain a copy of +# the License at http://www.mozilla.org/NPL/ +# +# Software distributed under the License is distributed on an "AS +# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or +# implied. See the License for the specific language governing +# rights and limitations under the License. +# +# The Original Code is mozilla.org code. +# +# The Initial Developer of the Original Code is Sun Microsystems, +# Inc. Portions created by Sun are +# Copyright (C) 1999 Sun Microsystems, Inc. All +# Rights Reserved. +# +# Contributor(s): +# Sergey Lunegov +# + +DEPTH = ../../../../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +include $(DEPTH)/config/autoconf.mk +include $(topsrcdir)/config/config.mk + +MODULE = urploader +LIBRARY_NAME = urploader +IS_COMPONENT = 1 + +CPPSRCS = \ + urpComponentLoader.cpp \ + urpComponentFactory.cpp \ + $(NULL) + +EXTRA_DSO_LDOPTS += \ + ../transport/llTransport.o ../transport/urpPacket.o \ + ../transport/urpTransport.o \ + ../urpStub.o \ + ../urpMarshalToolkit.o \ + ../urpManager.o + +CXXFLAGS += -I../transport/ $(MOZ_TOOLKIT_REGISTRY_CFLAGS) -D_REENTRANT -DOJI_DISABLE -I$(CONNECT_SRC)/public + +include $(topsrcdir)/config/rules.mk diff --git a/mozilla/java/xpcom/urp/src/loader/urpComponentFactory.cpp b/mozilla/java/xpcom/urp/src/loader/urpComponentFactory.cpp new file mode 100644 index 00000000000..cf9b0a6a2ed --- /dev/null +++ b/mozilla/java/xpcom/urp/src/loader/urpComponentFactory.cpp @@ -0,0 +1,99 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is Sun Microsystems, + * Inc. Portions created by Sun are + * Copyright (C) 1999 Sun Microsystems, Inc. All + * Rights Reserved. + * + * Contributor(s): + * Sergey Lunegov + */ +#include "nsIServiceManager.h" +#include "nsCRT.h" +#include "urpComponentFactory.h" +#include "bcIXPCOMStubsAndProxies.h" +#include "bcXPCOMStubsAndProxiesCID.h" +#include "bcIORBComponent.h" +#include "bcORBComponentCID.h" + +#include "urpStub.h" + +static NS_DEFINE_CID(kXPCOMStubsAndProxies,BC_XPCOMSTUBSANDPROXIES_CID); +static NS_DEFINE_CID(kORBComponent,BC_ORBCOMPONENT_CID); + +NS_IMPL_THREADSAFE_ISUPPORTS1(urpComponentFactory, nsIFactory) + +static nsISupports* compM = nsnull; + +urpComponentFactory::urpComponentFactory(const char *_location, const nsCID &aCID) { + NS_INIT_ISUPPORTS(); + location = nsCRT::strdup(_location); + aClass = aCID; +} + +urpComponentFactory::~urpComponentFactory() { + nsCRT::free((char*)location); +} + +/* void CreateInstance (in nsISupports aOuter, in nsIIDRef iid, [iid_is (iid), retval] out nsQIResult result); +*/ +NS_IMETHODIMP urpComponentFactory::CreateInstance(nsISupports *aOuter, const nsIID & iid, void * *result) { + printf("--urpComponentFactory::CreateInstance\n"); + nsresult r; + if(!compM) { + NS_WITH_SERVICE(bcIXPCOMStubsAndProxies, xpcomStubsAndProxies, kXPCOMStubsAndProxies, &r); + if (NS_FAILED(r)) { + printf("--urpComponentFactory::CreateInstance xpcomStubsAndProxies failed \n"); + return r; + } + NS_WITH_SERVICE(bcIORBComponent, _orb, kORBComponent, &r); + if (NS_FAILED(r)) { + printf("--urpComponentFactory::CreateInstance bcORB failed \n"); + return r; + } + bcIORB *orb; + _orb->GetORB(&orb); + bcOID oid; + urpTransport* transport = new urpConnector(); + PRStatus status = transport->Open("socket,host=indra,port=20009"); + if(status != PR_SUCCESS) { + printf("Error during opening connection\n"); + exit(-1); + } + bcIStub *stub = new urpStub(transport->GetConnection()); + oid = orb->RegisterStub(stub); + printf("--urpComponentFactory::CreateInstance after GetOID\n"); + nsISupports *proxy; + printf("--[c++]urpComponentFactory::CreateInstance iid:%s cid:%s\n",iid.ToString(), aClass.ToString()); + xpcomStubsAndProxies->GetProxy(oid, NS_GET_IID(nsIComponentManager), orb, &proxy); + compM = proxy; + } + ((nsIComponentManager*)(compM))->CreateInstance(aClass, nsnull, iid, result); + printf("--urpComponentFactory::CreateInstance end\n"); + return NS_OK; +} + +/* void LockFactory (in PRBool lock); */ +NS_IMETHODIMP urpComponentFactory::LockFactory(PRBool lock) +{ + return NS_ERROR_NOT_IMPLEMENTED; +} + + + + + + + + diff --git a/mozilla/java/xpcom/urp/src/loader/urpComponentFactory.h b/mozilla/java/xpcom/urp/src/loader/urpComponentFactory.h new file mode 100644 index 00000000000..3cc22221238 --- /dev/null +++ b/mozilla/java/xpcom/urp/src/loader/urpComponentFactory.h @@ -0,0 +1,39 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is Sun Microsystems, + * Inc. Portions created by Sun are + * Copyright (C) 1999 Sun Microsystems, Inc. All + * Rights Reserved. + * + * Contributor(s): + * Sergey Lunegov + */ +#ifndef __urpComponentFactory_h +#define __urpComponentFactory_h +#include "nsIFactory.h" + +class urpComponentFactory : public nsIFactory { +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIFACTORY + urpComponentFactory(const char *location, const nsCID &aCID); + virtual ~urpComponentFactory(); +private: + char *location; + nsCID aClass; +}; + +#endif + + diff --git a/mozilla/java/xpcom/urp/src/loader/urpComponentLoader.cpp b/mozilla/java/xpcom/urp/src/loader/urpComponentLoader.cpp new file mode 100644 index 00000000000..f9a2e541eb4 --- /dev/null +++ b/mozilla/java/xpcom/urp/src/loader/urpComponentLoader.cpp @@ -0,0 +1,441 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is Sun Microsystems, + * Inc. Portions created by Sun are + * Copyright (C) 1999 Sun Microsystems, Inc. All + * Rights Reserved. + * + * Contributor(s): + * Sergey Lunegov + */ + +/* + A bunch of stuff was copied from mozJSComponentLoader.cpp + */ +#include +#include "nsICategoryManager.h" +#include "urpComponentLoader.h" +#include "urpComponentFactory.h" +#include "nsCOMPtr.h" +#include "nsIModule.h" +#include "nsIGenericFactory.h" +#include "nsXPIDLString.h" +#include "nsCRT.h" + + + +const char urpComponentTypeName[] = URPCOMPONENTTYPENAME; + +/* XXX export properly from libxpcom, for now this will let Mac build */ +#ifdef RHAPSODY +extern const char fileSizeValueName[]; // = "FileSize"; +extern const char lastModValueName[]; // = "LastModTimeStamp"; +extern const char xpcomKeyName[]; // = "Software/Mozilla/XPCOM"; +#else +const char fileSizeValueName[] = "FileSize"; +const char lastModValueName[] = "LastModTimeStamp"; +const char xpcomKeyName[] = "software/mozilla/XPCOM/components"; +#endif + +NS_IMPL_THREADSAFE_ISUPPORTS(urpComponentLoader,NS_GET_IID(nsIComponentLoader)); + +urpComponentLoader::urpComponentLoader() + : mCompMgr(NULL), + + mXPCOMKey(0) +{ + NS_INIT_REFCNT(); + printf("--urpComponentLoader::urpComponentLoader \n"); +} + +urpComponentLoader::~urpComponentLoader() { //nb + printf("--urpComponentLoader::~urpComponentLoader \n"); +} + + +/** + * Get the factory for a given component. + */ +/* nsIFactory getFactory (in nsIIDRef aCID, in string aLocation, in string aType); */ +NS_IMETHODIMP urpComponentLoader::GetFactory(const nsIID & aCID, const char *aLocation, const char *aType, nsIFactory **_retval) { + printf("--urpComponentLoader::GetFactory \n"); + if (!_retval) + return NS_ERROR_NULL_POINTER; +#ifdef DEBUG + char *cidString = aCID.ToString(); + fprintf(stderr, "--urpComponentLoader::GetFactory(%s,%s,%s)\n", cidString, aLocation, aType); + delete [] cidString; +#endif + nsIFactory *f = new urpComponentFactory(aLocation, aCID); + *_retval = f; + return NS_OK; +} + +/** + * Initialize the loader. + * + * We use nsISupports here because nsIRegistry isn't IDLized yet. + */ +/* void init (in nsIComponentManager aCompMgr, in nsISupports aRegistry); */ +NS_IMETHODIMP urpComponentLoader::Init(nsIComponentManager *aCompMgr, nsISupports *aReg) { + printf("--urpComponentLoader::Init \n"); + nsresult rv; + mCompMgr = aCompMgr; + mRegistry = do_QueryInterface(aReg, &rv); + if (NS_SUCCEEDED(rv)) { + rv = mRegistry->GetSubtree(nsIRegistry::Common, xpcomKeyName, + &mXPCOMKey); + if (NS_FAILED(rv)) + /* if we can't get the XPCOM key, just skip all registry ops */ + mRegistry = nsnull; + } + return NS_OK; +} + +/** + * Called when a component of the appropriate type is registered, + * to give the component loader an opportunity to do things like + * annotate the registry and such. + */ +/* void onRegister (in nsIIDRef aCID, in string aType, in string aClassName, in string aContractID, in string aLocation, in boolean aReplace, in boolean aPersist); */ +NS_IMETHODIMP urpComponentLoader::OnRegister(const nsIID & aCID, const char *aType, const char *aClassName, const char *aContractID, const char *aLocation, PRBool aReplace, PRBool aPersist) { //nb + printf("--urpComponentLoader::OnRegister \n"); + return NS_OK; +} + +/** + * AutoRegister components in the given directory. + */ +NS_IMETHODIMP urpComponentLoader::AutoRegisterComponents(PRInt32 aWhen, nsIFile *aDirectory) { + printf("--urpComponentLoader::AutoRegisterComponents \n"); + return RegisterComponentsInDir(aWhen,aDirectory); +} + +NS_IMETHODIMP urpComponentLoader::AutoUnregisterComponent(PRInt32 when, + nsIFile *component, + PRBool *unregistered) { + //nb need to impelement + return NS_OK; +} + +nsresult urpComponentLoader::RegisterComponentsInDir(PRInt32 when, nsIFile *dir) +{ + nsresult rv; + PRBool isDir; + + if (NS_FAILED(rv = dir->IsDirectory(&isDir))) + return rv; + + if (!isDir) + return NS_ERROR_INVALID_ARG; + + // Create a directory iterator + nsCOMPtr dirIterator; + rv = dir->GetDirectoryEntries(getter_AddRefs(dirIterator)); + + if (NS_FAILED(rv)) return rv; + + // whip through the directory to register every file + nsIFile *dirEntry = NULL; + PRBool more = PR_FALSE; + + rv = dirIterator->HasMoreElements(&more); + if (NS_FAILED(rv)) return rv; + while (more == PR_TRUE) + { + rv = dirIterator->GetNext((nsISupports**)&dirEntry); + if (NS_SUCCEEDED(rv)) + { + rv = dirEntry->IsDirectory(&isDir); + if (NS_SUCCEEDED(rv)) + { + if (isDir == PR_TRUE) + { + // This is a directory. Grovel for components into the directory. + rv = RegisterComponentsInDir(when, dirEntry); + } + else + { + PRBool registered; + // This is a file. Try to register it. + rv = AutoRegisterComponent(when, dirEntry, ®istered); + } + } + NS_RELEASE(dirEntry); + } + rv = dirIterator->HasMoreElements(&more); + if (NS_FAILED(rv)) return rv; + } + + return NS_OK; +} + +/** + * AutoRegister the given component. + * + * Returns true if the component was registered, false if it couldn't + * attempt to register the component (wrong type) and ``throws'' an + * NS_FAILED code if there was an error during registration. + */ +/* boolean autoRegisterComponent (in long aWhen, in nsIFile aComponent); */ + +/* copied from mozJSComponentLoader.cpp */ +NS_IMETHODIMP urpComponentLoader::AutoRegisterComponent(PRInt32 when, nsIFile *component, PRBool *registered) { + //printf("--urpComponentLoader::AutoRegisterComponent \n"); + nsresult rv; + if (!registered) + return NS_ERROR_NULL_POINTER; + + const char javaExtension[] = ".urp.info"; + int javaExtensionLen = 9; + nsXPIDLCString leafName; + + *registered = PR_FALSE; + + /* we only do files */ + PRBool isFile = PR_FALSE; + if (NS_FAILED(rv = component->IsFile(&isFile)) || !isFile) + return rv; + + if (NS_FAILED(rv = component->GetLeafName(getter_Copies(leafName)))) + return rv; + int len = PL_strlen(leafName); + + /* if it's not javaExtension return now */ + if (len < javaExtensionLen || // too short + PL_strcasecmp(leafName + len - javaExtensionLen, javaExtension)) + return NS_OK; + + printf("--urpComponentLoader: registering urpComponent component %s\n",(const char *)leafName); + rv = AttemptRegistration(component, PR_FALSE); + if (NS_SUCCEEDED(rv)) + printf("registered module %s\n", (const char *)leafName); + else if (rv == NS_ERROR_FACTORY_REGISTER_AGAIN) + printf("deferred module %s\n", (const char *)leafName); + else + printf("failed to register %s\n", (const char *)leafName); + *registered = (PRBool) NS_SUCCEEDED(rv); + return NS_OK; + +} + + +nsresult urpComponentLoader::AttemptRegistration(nsIFile *component, + PRBool deferred) { + nsXPIDLCString registryLocation; + nsresult rv; + nsIModule *module; + + rv = mCompMgr->RegistryLocationForSpec(component, + getter_Copies(registryLocation)); + nsXPIDLCString str; + component->GetPath(getter_Copies(str)); + const char* location = nsCRT::strdup(str); + ifstream in(location); + char cidStr[500], contractid[1000], desc[1000]; + in.getline(cidStr,1000); + in.getline(contractid,1000); + in.getline(desc,1000); + printf("%s %s %s", cidStr, contractid, desc); + nsCID cid; + cid.Parse((const char *)cidStr); + mCompMgr->RegisterComponentWithType(cid, desc, contractid, component, registryLocation, PR_TRUE, PR_TRUE, urpComponentTypeName); + if (NS_FAILED(rv)) + return rv; + + /* no need to check registry data on deferred reg */ + SetRegistryInfo(registryLocation, component); + return rv; +} + +nsresult urpComponentLoader::SetRegistryInfo(const char *registryLocation, + nsIFile *component) +{ + if (!mRegistry.get()) + return NS_OK; // silent failure + + nsresult rv; + nsRegistryKey key; + + rv = mRegistry->AddSubtreeRaw(mXPCOMKey, registryLocation, &key); + if (NS_FAILED(rv)) + return rv; + + PRInt64 modDate; + + if (NS_FAILED(rv = component->GetLastModificationDate(&modDate)) || + NS_FAILED(rv = mRegistry->SetLongLong(key, lastModValueName, &modDate))) + return rv; + + PRInt64 fileSize; + if (NS_FAILED(rv = component->GetFileSize(&fileSize)) || + NS_FAILED(rv = mRegistry->SetLongLong(key, fileSizeValueName, &fileSize))) + return rv; + printf("SetRegistryInfo(%s) => (%d,%d)\n", registryLocation, + (int)modDate, (int)fileSize); + return NS_OK; +} + + +PRBool urpComponentLoader::HasChanged(const char *registryLocation, nsIFile *component) { + /* if we don't have a registry handle, force registration of component */ + if (!mRegistry) + return PR_TRUE; + + nsRegistryKey key; + if (NS_FAILED(mRegistry->GetSubtreeRaw(mXPCOMKey, registryLocation, &key))) + return PR_TRUE; + + /* check modification date */ + PRInt64 regTime, lastTime; + if (NS_FAILED(mRegistry->GetLongLong(key, lastModValueName, ®Time))) + return PR_TRUE; + + if (NS_FAILED(component->GetLastModificationDate(&lastTime)) || LL_NE(lastTime, regTime)) + return PR_TRUE; + + /* check file size */ + PRInt64 regSize; + if (NS_FAILED(mRegistry->GetLongLong(key, fileSizeValueName, ®Size))) + return PR_TRUE; + PRInt64 size; + if (NS_FAILED(component->GetFileSize(&size)) || LL_NE(size,regSize) ) + return PR_TRUE; + + return PR_FALSE; +} + +/** + * Register any deferred (NS_ERROR_FACTORY_REGISTER_AGAIN) components. + * Return registered-any-components? + */ +/* boolean registerDeferredComponents (in long aWhen); */ +NS_IMETHODIMP urpComponentLoader::RegisterDeferredComponents(PRInt32 aWhen, PRBool *aRegistered) { + printf("--urpComponentLoader::RegisterDeferredComponents \n"); + nsresult rv; + *aRegistered = PR_FALSE; + PRUint32 count; + rv = mDeferredComponents.Count(&count); + printf("mJCL: registering deferred (%d)\n", count); + if (NS_FAILED(rv) || !count) + return NS_OK; + + for (PRUint32 i = 0; i < count; i++) { + nsCOMPtr supports; + nsCOMPtr component; + + rv = mDeferredComponents.GetElementAt(i, getter_AddRefs(supports)); + if (NS_FAILED(rv)) + continue; + + component = do_QueryInterface(supports, &rv); + if (NS_FAILED(rv)) + continue; + + rv = AttemptRegistration(component, PR_TRUE /* deferred */); + if (rv != NS_ERROR_FACTORY_REGISTER_AGAIN) { + if (NS_SUCCEEDED(rv)) + *aRegistered = PR_TRUE; + mDeferredComponents.RemoveElementAt(i); + } + } + rv = mDeferredComponents.Count(&count); + if (NS_SUCCEEDED(rv)) { + if (*aRegistered) + printf("mJCL: registered deferred, %d left\n", count); + else + printf("mJCL: didn't register any components, %d left\n", count); + } + /* are there any fatal errors? */ + return NS_OK; +} + + +/** + * Unload all components that are willing. + */ +/* void unloadAll (in long aWhen); */ +NS_IMETHODIMP urpComponentLoader::UnloadAll(PRInt32 aWhen) { //nb + printf("--urpComponentLoader::UnloadAll \n"); + return NS_OK; +} + + + +//--------------------------------------------------------------------------------------------------- + +/* XXX this should all be data-driven, via NS_IMPL_GETMODULE_WITH_CATEGORIES */ +static NS_METHOD +RegisterRemoteLoader(nsIComponentManager *aCompMgr, nsIFile *aPath, + const char *registryLocation, const char *componentType, const nsModuleComponentInfo *info) +{ + nsresult rv; + nsCOMPtr catman = + do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv); + printf("--URPLoader got registered\n"); + if (NS_FAILED(rv)) return rv; + nsXPIDLCString previous; + rv = catman->AddCategoryEntry("component-loader", urpComponentTypeName, + URP_COMPONENTLOADER_ContractID, + PR_TRUE, PR_TRUE, getter_Copies(previous)); + if(NS_FAILED(rv)) + printf("Adding of remote-comp-loader is failed\n"); + else + printf("Adding of remote-comp-loader is succeseded\n"); + nsXPIDLCString urpLoader; + rv = catman->GetCategoryEntry("component-loader", urpComponentTypeName, + getter_Copies(urpLoader)); + if (NS_FAILED(rv)) + printf("didn't got category entry\n"); + else + printf("got category entry\n"); + + return rv; + +} + +static NS_METHOD +UnregisterRemoteLoader(nsIComponentManager *aCompMgr, nsIFile *aPath, + const char *registryLocation, const nsModuleComponentInfo *info) +{ + nsresult rv; + nsCOMPtr catman = + do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv); + if (NS_FAILED(rv)) return rv; + nsXPIDLCString urpLoader; + rv = catman->GetCategoryEntry("component-loader", urpComponentTypeName, + getter_Copies(urpLoader)); + if (NS_FAILED(rv)) return rv; + + // only unregister if we're the current JS component loader + if (!strcmp(urpLoader, URP_COMPONENTLOADER_ContractID)) { + return catman->DeleteCategoryEntry("component-loader", + urpComponentTypeName, PR_TRUE, + getter_Copies(urpLoader)); + } + return NS_OK; +} + +NS_GENERIC_FACTORY_CONSTRUCTOR(urpComponentLoader); +static nsModuleComponentInfo components[] = { + { "URP component loader", URP_COMPONENTLOADER_CID, + URP_COMPONENTLOADER_ContractID, + urpComponentLoaderConstructor, + RegisterRemoteLoader, UnregisterRemoteLoader } +}; + +NS_IMPL_NSGETMODULE("URP component loader", components); + + + diff --git a/mozilla/java/xpcom/urp/src/loader/urpComponentLoader.h b/mozilla/java/xpcom/urp/src/loader/urpComponentLoader.h new file mode 100644 index 00000000000..4c1720ec156 --- /dev/null +++ b/mozilla/java/xpcom/urp/src/loader/urpComponentLoader.h @@ -0,0 +1,65 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is Sun Microsystems, + * Inc. Portions created by Sun are + * Copyright (C) 1999 Sun Microsystems, Inc. All + * Rights Reserved. + * + * Contributor(s): + * Sergey Lunegov + */ +#ifndef _urpComponentLoader_h +#define _urpComponentLoader_h +#include "nsIComponentLoader.h" +#include "nsIModule.h" +#include "nsHashtable.h" +#include "nsCOMPtr.h" +#include "nsIFileSpec.h" +#include "nsIFile.h" +#include "nsIRegistry.h" +#include "nsSupportsArray.h" + +#define URP_COMPONENTLOADER_ContractID \ +"@mozilla.org/blackwood/starconnect/remote-component-loader;1" + +/* 0d6b5198-1dd2-11b2-b2f0-ed49ba755db8 */ +#define URP_COMPONENTLOADER_CID \ + { 0xdcc5322f, 0x06e5, 0x4a3f, \ + {0x92, 0xe8, 0xde, 0xe6, 0x8f, 0x26, 0x0d, 0x8f }} + +#define URPCOMPONENTTYPENAME "application/remote-component" + +class urpComponentLoader : public nsIComponentLoader { + NS_DECL_ISUPPORTS + NS_DECL_NSICOMPONENTLOADER + + urpComponentLoader(); + virtual ~urpComponentLoader(); + protected: + nsCOMPtr mRegistry; + nsCOMPtr mCompMgr; + nsRegistryKey mXPCOMKey; + nsSupportsArray mDeferredComponents; + + nsresult RegisterComponentsInDir(PRInt32 when, nsIFile *dir); + nsresult AttemptRegistration(nsIFile *component, PRBool deferred); + PRBool HasChanged(const char *registryLocation, nsIFile *component); + nsresult SetRegistryInfo(const char *registryLocation, nsIFile *component); + +}; +#endif + + + + diff --git a/mozilla/java/xpcom/urp/src/test/Makefile.in b/mozilla/java/xpcom/urp/src/test/Makefile.in index 78ab5a57a79..6458ecbffce 100644 --- a/mozilla/java/xpcom/urp/src/test/Makefile.in +++ b/mozilla/java/xpcom/urp/src/test/Makefile.in @@ -30,6 +30,8 @@ include $(DEPTH)/config/autoconf.mk include $(topsrcdir)/config/config.mk +DIRS = client + LIBRARY_NAME = urpTest MODULE = urpTest IS_COMPONENT = 1 @@ -41,24 +43,23 @@ CXXFLAGS += -I$(topsrcdir)/java/xpcom/xpcom -I../transport -I$(JDKHOME)/ CPPSRCS = \ urpTestImpl.cpp \ + urpTestImplFactory.cpp \ server.cpp \ $(NULL) -EXTRA_DSO_LIBS += \ - bcorb bcxpcomstubs \ - $(NULL) - -LIBS = -L./ -L$(DIST)/bin/components/ $(XPCOM_LIBS) $(NSPR_LIBS) $(EXTRA_DSO_LIBS) \ +LIBS = -L./ $(XPCOM_LIBS) $(NSPR_LIBS) $(EXTRA_DSO_LIBS) \ ../urpStub.o \ + ../urpMarshalToolkit.o \ ../urpManager.o \ ../transport/llTransport.o ../transport/urpPacket.o \ ../transport/urpTransport.o \ - -L../../java/src \ + -L../../java/src EXTRA_DSO_LDOPTS += \ ../transport/llTransport.o ../transport/urpPacket.o \ ../transport/urpTransport.o \ ../urpStub.o \ + ../urpMarshalToolkit.o \ ../urpManager.o \ $(NULL) diff --git a/mozilla/java/xpcom/urp/src/test/README b/mozilla/java/xpcom/urp/src/test/README new file mode 100644 index 00000000000..e1c0bbac44d --- /dev/null +++ b/mozilla/java/xpcom/urp/src/test/README @@ -0,0 +1,7 @@ +1. cd in $(MOZILLA_FIVE_HOME)/java/xpcom/urp/src; run 'gmake' + +2. for server running : cd $(MOZILLA_FIVE_HOME)/dist/bin; + run 'server socket,host=YourHost,port=YourPort' + +6. for client running: cd $(MOZILLA_FIVE_HOME)/dist/bin; + run 'client socket,host=YourHost,port=YourPort' diff --git a/mozilla/java/xpcom/urp/src/test/Simple_Server.cpp b/mozilla/java/xpcom/urp/src/test/Simple_Server.cpp new file mode 100644 index 00000000000..737dfb1ee99 --- /dev/null +++ b/mozilla/java/xpcom/urp/src/test/Simple_Server.cpp @@ -0,0 +1,101 @@ +#include "nsIServiceManager.h" +#include "nsIComponentManager.h" + +#include "nsIURI.h" +#include "nsNetUtil.h" +#include "nsIPref.h" +#include "plevent.h" +#include "prmem.h" +#include "prnetdb.h" +#include "prthread.h" + +#include "urpManager.h" +#include "urpTransport.h" + +#include "urpITest.h" +#include "bcIORBComponent.h" +#include "bcORBComponentCID.h" +#include "urpTestImpl.h" +#include + +#include "nsIModule.h" + +#include "bcIXPCOMStubsAndProxies.h" +#include "bcXPCOMStubsAndProxiesCID.h" + +static NS_DEFINE_CID(kXPCOMStubsAndProxies,BC_XPCOMSTUBSANDPROXIES_CID); +static NS_DEFINE_CID(kORBCIID,BC_ORBCOMPONENT_CID); + +struct localThreadArg { + urpManager *mgr; + urpConnection *conn; + localThreadArg( urpManager *mgr, urpConnection *conn ) { + this->mgr = mgr; + this->conn = conn; + } +}; + +void thread_start_server( void *arg ) +{ + urpManager *manager = ((localThreadArg *)arg)->mgr; + urpConnection *connection = ((localThreadArg *)arg)->conn; + nsresult rv = manager->ReadMessage( connection, PR_FALSE ); +} + +int main( int argc, char *argv[] ) { + + char *connectString = "socket,host=localhost,port=2009"; + if( argc == 2 ) connectString = argv[1]; + + nsresult rv = NS_InitXPCOM(NULL, NULL); + NS_ASSERTION( NS_SUCCEEDED(rv), "NS_InitXPCOM failed" ); + + NS_WITH_SERVICE(bcIORBComponent, _orb, kORBCIID, &rv); + if (NS_FAILED(rv)) { +printf("NS_WITH_SERVICE(bcXPC in Marshal failed\n"); + } + + NS_WITH_SERVICE(bcIXPCOMStubsAndProxies, xpcomStubsAndProxies, kXPCOMStubsAndProxies, &rv); + if (NS_FAILED(rv)) { + printf("bcXPCOMStubsAndProxie failed\n"); + return -1; + } + + bcIORB *orb; + _orb->GetORB(&orb); + bcIStub *stub = nsnull; + urpITest *object = new urpTestImpl(); + object->AddRef(); + urpITest *proxy = nsnull; + xpcomStubsAndProxies->GetStub((nsISupports*)object, &stub); + bcOID oid = orb->RegisterStub(stub); + + urpTransport* trans = new urpAcceptor(); + PRStatus status = trans->Open(connectString); + if(status == PR_SUCCESS) printf("succes %ld\n",oid); + else printf("failed\n"); + object->AddRef(); + urpManager* mngr = new urpManager(PR_FALSE, orb, nsnull); + rv = NS_OK; + while(NS_SUCCEEDED(rv)) { + // rv = mngr->HandleRequest(trans->GetConnection()); + urpConnection *conn = trans->GetConnection(); + if( conn != NULL ) { + // handle request in new thread + localThreadArg *arg = new localThreadArg( mngr, conn ); + PRThread *thr = PR_CreateThread( PR_USER_THREAD, + thread_start_server, + arg, + PR_PRIORITY_NORMAL, + PR_GLOBAL_THREAD, + PR_UNJOINABLE_THREAD, + 0); + if( thr == nsnull ) { + rv = NS_ERROR_FAILURE; + } + } else { + rv = NS_ERROR_FAILURE; + } + } + return 1; +} diff --git a/mozilla/java/xpcom/urp/src/test/With_Comp_Man_And_Load_Server.cpp b/mozilla/java/xpcom/urp/src/test/With_Comp_Man_And_Load_Server.cpp new file mode 100644 index 00000000000..2e030f26cf5 --- /dev/null +++ b/mozilla/java/xpcom/urp/src/test/With_Comp_Man_And_Load_Server.cpp @@ -0,0 +1,106 @@ +#include "nsIServiceManager.h" +#include "nsIComponentManager.h" + +#include "nsIURI.h" +#include "nsNetUtil.h" +#include "nsIPref.h" +#include "plevent.h" +#include "prmem.h" +#include "prnetdb.h" +#include "prthread.h" + +#include "urpManager.h" +#include "urpTransport.h" + +#include "urpITest.h" +#include "bcIORBComponent.h" +#include "bcORBComponentCID.h" +#include "urpTestImpl.h" +#include + +#include "nsIModule.h" + +#include "bcIXPCOMStubsAndProxies.h" +#include "bcXPCOMStubsAndProxiesCID.h" + +static NS_DEFINE_CID(kXPCOMStubsAndProxies,BC_XPCOMSTUBSANDPROXIES_CID); +static NS_DEFINE_CID(kORBCIID,BC_ORBCOMPONENT_CID); +static NS_DEFINE_CID(compManag, NS_COMPONENTMANAGER_CID); + +struct localThreadArg { + urpManager *mgr; + urpConnection *conn; + localThreadArg( urpManager *mgr, urpConnection *conn ) { + this->mgr = mgr; + this->conn = conn; + } +}; + +void thread_start_server( void *arg ) +{ + urpManager *manager = ((localThreadArg *)arg)->mgr; + urpConnection *connection = ((localThreadArg *)arg)->conn; + nsresult rv = manager->ReadMessage( connection, PR_FALSE ); +} + +int main( int argc, char *argv[] ) { + + char *connectString = "socket,host=localhost,port=2009"; + if( argc == 2 ) connectString = argv[1]; + + nsresult rv = NS_InitXPCOM(NULL, NULL); + NS_ASSERTION( NS_SUCCEEDED(rv), "NS_InitXPCOM failed" ); + + (void) nsComponentManager::AutoRegister(nsIComponentManager::NS_Startup, nsnull); + + NS_WITH_SERVICE(bcIORBComponent, _orb, kORBCIID, &rv); + if (NS_FAILED(rv)) { +printf("NS_WITH_SERVICE(bcXPC in Marshal failed\n"); + } + + NS_WITH_SERVICE(bcIXPCOMStubsAndProxies, xpcomStubsAndProxies, kXPCOMStubsAndProxies, &rv); + if (NS_FAILED(rv)) { + printf("bcXPCOMStubsAndProxie failed\n"); + return -1; + } + + bcIORB *orb; + _orb->GetORB(&orb); + bcIStub *stub = nsnull; + NS_WITH_SERVICE(nsIComponentManager, mComp, compManag, &rv); + if (NS_FAILED(rv)) { + printf("compManager failed\n"); + return -1; + } + urpITest *proxy = nsnull; + xpcomStubsAndProxies->GetStub((nsISupports*)mComp, &stub); + bcOID oid = orb->RegisterStub(stub); + + urpTransport* trans = new urpAcceptor(); + PRStatus status = trans->Open(connectString); + if(status == PR_SUCCESS) printf("succes %ld\n",oid); + else printf("failed\n"); + urpManager* mngr = new urpManager(PR_FALSE, orb, nsnull); + rv = NS_OK; + while(NS_SUCCEEDED(rv)) { + // rv = mngr->HandleRequest(trans->GetConnection()); + urpConnection *conn = trans->GetConnection(); + if( conn != NULL ) { + // handle request in new thread + localThreadArg *arg = new localThreadArg( mngr, conn ); + PRThread *thr = PR_CreateThread( PR_USER_THREAD, + thread_start_server, + arg, + PR_PRIORITY_NORMAL, + PR_GLOBAL_THREAD, + PR_UNJOINABLE_THREAD, + 0); + if( thr == nsnull ) { + rv = NS_ERROR_FAILURE; + } + } else { + rv = NS_ERROR_FAILURE; + } + } + return 1; +} diff --git a/mozilla/java/xpcom/urp/src/test/client/Makefile.in b/mozilla/java/xpcom/urp/src/test/client/Makefile.in index 0b5ded663b6..29bce42d183 100644 --- a/mozilla/java/xpcom/urp/src/test/client/Makefile.in +++ b/mozilla/java/xpcom/urp/src/test/client/Makefile.in @@ -41,12 +41,12 @@ CPPSRCS = \ client.cpp \ $(NULL) -LIBS = -L./ -L$(DIST)/bin/components/ $(XPCOM_LIBS) $(NSPR_LIBS) $(EXTRA_DSO_LIBS) \ +LIBS = -L./ $(XPCOM_LIBS) $(NSPR_LIBS) $(EXTRA_DSO_LIBS) \ ../../urpStub.o \ + ../../urpMarshalToolkit.o \ ../../urpManager.o \ - ../urpTestImpl.o \ ../../transport/llTransport.o ../../transport/urpPacket.o \ - ../../transport/urpTransport.o + ../../transport/urpTransport.o \ include $(topsrcdir)/config/rules.mk diff --git a/mozilla/java/xpcom/urp/src/test/client/client.cpp b/mozilla/java/xpcom/urp/src/test/client/client.cpp index 314c048b57d..187719c2366 100644 --- a/mozilla/java/xpcom/urp/src/test/client/client.cpp +++ b/mozilla/java/xpcom/urp/src/test/client/client.cpp @@ -22,7 +22,7 @@ #include #include -#include "urpTestImpl.h" +#include "urpManager.h" #include "nsIInterfaceInfo.h" #include "nsIInterfaceInfoManager.h" @@ -41,6 +41,7 @@ #include "bcORBComponentCID.h" #include "bcIStub.h" #include "urpStub.h" +#include "urpITest.h" static NS_DEFINE_CID(kORBCIID,BC_ORBCOMPONENT_CID); static NS_DEFINE_CID(kXPCOMStubsAndProxies,BC_XPCOMSTUBSANDPROXIES_CID); @@ -75,12 +76,18 @@ nsIInterfaceInfo *interfaceInfo; bcIORB *orb; _orb->GetORB(&orb); bcIStub *stub = NULL; - urpITest *object = new urpTestImpl(); - object->AddRef(); +// urpITest *object = new urpTestImpl(); +// object->AddRef(); urpITest *proxy = NULL; - stub = new urpStub(connectString); + urpTransport* transport = new urpConnector(); + PRStatus status = transport->Open(connectString); + if(status != PR_SUCCESS) { + printf("Error during opening connection\n"); + exit(-1); + } + stub = new urpStub(transport->GetConnection()); bcOID oid = orb->RegisterStub(stub); - printf("---urpTestImpl iid=%s\n",NS_GET_IID(urpITest).ToString()); + printf("---urpTestImpl oid=%ld iid=%s\n",oid, NS_GET_IID(urpITest).ToString()); r = xpcomStubsAndProxies->GetProxy(oid,NS_GET_IID(urpITest),orb,(nsISupports**)&proxy); if (NS_FAILED(r)) { printf("--urpTestImpl test failed\n"); @@ -97,7 +104,7 @@ nsIInterfaceInfo *interfaceInfo; PRInt32 l1 = 1999; PRInt32 ret; PRInt32 rt; - object->Test1(&l1); +// object->Test1(&l1); l1 = 1999; proxy->Test1(&l1); printf("--urpTestImpl after Test1 l=%d %d\n",l1,ret); @@ -124,7 +131,7 @@ nsIInterfaceInfo *interfaceInfo; for (unsigned int i = 0; i < 4; i++) { printf("valueArray[%d]=%s\n",i,(*valueArray2)[i]); } - object->Test5(4,valueArray2); +// object->Test5(4,valueArray2); printf("after calling object\n"); for (unsigned int i = 0; i < 4; i++) { printf("valueArray[%d]=%s\n",i,(*valueArray2)[i]); @@ -138,7 +145,7 @@ nsIInterfaceInfo *interfaceInfo; } /*********************************************/ - proxy->Test6(object); +// proxy->Test6(object); /*********************************************/ { urpITest *p1; @@ -152,9 +159,11 @@ nsIInterfaceInfo *interfaceInfo; if (NS_SUCCEEDED(p1->QueryInterface(NS_GET_IID(urpITest),(void**)&p3))) { l=2000; p3->Test1(&l); + printf("l in client after test1 %ld\n",l); } } +// trans->Close(); } diff --git a/mozilla/java/xpcom/urp/src/test/server.cpp b/mozilla/java/xpcom/urp/src/test/server.cpp index 533ccb7cc73..737dfb1ee99 100644 --- a/mozilla/java/xpcom/urp/src/test/server.cpp +++ b/mozilla/java/xpcom/urp/src/test/server.cpp @@ -7,6 +7,7 @@ #include "plevent.h" #include "prmem.h" #include "prnetdb.h" +#include "prthread.h" #include "urpManager.h" #include "urpTransport.h" @@ -25,6 +26,22 @@ static NS_DEFINE_CID(kXPCOMStubsAndProxies,BC_XPCOMSTUBSANDPROXIES_CID); static NS_DEFINE_CID(kORBCIID,BC_ORBCOMPONENT_CID); +struct localThreadArg { + urpManager *mgr; + urpConnection *conn; + localThreadArg( urpManager *mgr, urpConnection *conn ) { + this->mgr = mgr; + this->conn = conn; + } +}; + +void thread_start_server( void *arg ) +{ + urpManager *manager = ((localThreadArg *)arg)->mgr; + urpConnection *connection = ((localThreadArg *)arg)->conn; + nsresult rv = manager->ReadMessage( connection, PR_FALSE ); +} + int main( int argc, char *argv[] ) { char *connectString = "socket,host=localhost,port=2009"; @@ -46,22 +63,39 @@ printf("NS_WITH_SERVICE(bcXPC in Marshal failed\n"); bcIORB *orb; _orb->GetORB(&orb); - bcIStub *stub = NULL; + bcIStub *stub = nsnull; urpITest *object = new urpTestImpl(); object->AddRef(); - urpITest *proxy = NULL; + urpITest *proxy = nsnull; xpcomStubsAndProxies->GetStub((nsISupports*)object, &stub); bcOID oid = orb->RegisterStub(stub); urpTransport* trans = new urpAcceptor(); PRStatus status = trans->Open(connectString); - if(status == PR_SUCCESS) printf("succes\n"); + if(status == PR_SUCCESS) printf("succes %ld\n",oid); else printf("failed\n"); object->AddRef(); - urpManager* mngr = new urpManager(trans, orb); + urpManager* mngr = new urpManager(PR_FALSE, orb, nsnull); rv = NS_OK; while(NS_SUCCEEDED(rv)) { - rv = mngr->HandleRequest(trans->GetConnection()); + // rv = mngr->HandleRequest(trans->GetConnection()); + urpConnection *conn = trans->GetConnection(); + if( conn != NULL ) { + // handle request in new thread + localThreadArg *arg = new localThreadArg( mngr, conn ); + PRThread *thr = PR_CreateThread( PR_USER_THREAD, + thread_start_server, + arg, + PR_PRIORITY_NORMAL, + PR_GLOBAL_THREAD, + PR_UNJOINABLE_THREAD, + 0); + if( thr == nsnull ) { + rv = NS_ERROR_FAILURE; + } + } else { + rv = NS_ERROR_FAILURE; + } } return 1; } diff --git a/mozilla/java/xpcom/urp/src/test/urpITest.idl b/mozilla/java/xpcom/urp/src/test/urpITest.idl index 763990a0efb..ec03aefaefc 100644 --- a/mozilla/java/xpcom/urp/src/test/urpITest.idl +++ b/mozilla/java/xpcom/urp/src/test/urpITest.idl @@ -35,3 +35,15 @@ interface urpITest : nsISupports void test7(out urpITest o); }; +%{ C++ +#define URPTEST_CID \ +{ /*70ef013d-bca9-4226-bdd4-42a92cf6930d*/ \ + 0x70ef013d, \ + 0xbca9, \ + 0x4226, \ + {0xbd, 0xd4, 0x42, 0xa9, 0x2c, 0xf6, 0x93, 0x0d} \ +} + +#define URPTEST_PROGID "urpTest" + +%} diff --git a/mozilla/java/xpcom/urp/src/test/urpTestImpl.cpp b/mozilla/java/xpcom/urp/src/test/urpTestImpl.cpp index 90235273d66..a3c07a1f16d 100644 --- a/mozilla/java/xpcom/urp/src/test/urpTestImpl.cpp +++ b/mozilla/java/xpcom/urp/src/test/urpTestImpl.cpp @@ -29,6 +29,16 @@ static char * className = "urpTestImpl"; +NS_IMPL_ISUPPORTS1(urpTestImpl, urpITest); + +urpTestImpl::urpTestImpl() { + NS_INIT_REFCNT(); +} + +urpTestImpl::~urpTestImpl() { +} + +/* nsrefcnt urpTestImpl::AddRef(void) { static const char * methodName="AddRef"; printf("--%s::%s this=%p",className, methodName,this); @@ -62,7 +72,7 @@ NS_IMETHODIMP urpTestImpl::QueryInterface(REFNSIID aIID, void** aInstancePtr) { } } - +*/ /*void test1(inout long l);*/ NS_IMETHODIMP urpTestImpl::Test1(PRInt32 *l) { @@ -159,147 +169,3 @@ NS_IMETHODIMP urpTestImpl::Test7(urpITest **o) { return NS_OK; } -/****************************************************/ - -#include "nsIModule.h" -#include "nsIServiceManager.h" -#include "bcIXPCOMStubsAndProxies.h" -#include "bcXPCOMStubsAndProxiesCID.h" -#include "bcIORBComponent.h" -#include "bcORBComponentCID.h" -#include "bcIStub.h" -#include "urpStub.h" - -static NS_DEFINE_CID(kORBCIID,BC_ORBCOMPONENT_CID); -static NS_DEFINE_CID(kXPCOMStubsAndProxies,BC_XPCOMSTUBSANDPROXIES_CID); - -static void test(void) { - -nsIInterfaceInfo *interfaceInfo; - nsIInterfaceInfoManager* iimgr; - bcIID iid = NS_GET_IID(urpITest); - if( (iimgr = XPTI_GetInterfaceInfoManager()) ) { - if (NS_FAILED(iimgr->GetInfoForIID(&iid, &interfaceInfo))) { -printf("zdes ploho\n"); - return; //nb exception handling - } - NS_RELEASE(iimgr); - } else { -printf("ne tak zdes\n"); - return; - } - nsresult r; - NS_WITH_SERVICE(bcIORBComponent, _orb, kORBCIID, &r); - if (NS_FAILED(r)) { - printf("--urpTestImpl test failed\n"); - return; - } - - NS_WITH_SERVICE(bcIXPCOMStubsAndProxies, xpcomStubsAndProxies, kXPCOMStubsAndProxies, &r); - if (NS_FAILED(r)) { - printf("--urpTestImpl test failed\n"); - return; - } - bcIORB *orb; - _orb->GetORB(&orb); - bcIStub *stub = NULL; - urpITest *object = new urpTestImpl(); - object->AddRef(); - urpITest *proxy = NULL; -// xpcomStubsAndProxies->GetStub((nsISupports*)object, &stub); - stub = new urpStub("socket,host=shiva,port=2009"); -printf("yatatatata\n"); - bcOID oid = orb->RegisterStub(stub); - printf("---urpTestImpl iid=%s\n",NS_GET_IID(urpITest).ToString()); - r = xpcomStubsAndProxies->GetProxy(oid,NS_GET_IID(urpITest),orb,(nsISupports**)&proxy); - if (NS_FAILED(r)) { - printf("--urpTestImpl test failed\n"); - return; - } - - /*******************************************/ - char ** valueArray = (char **)malloc(sizeof(char*)*4); - valueArray[0] = "hi"; - valueArray[1] = "there"; - valueArray[2] = "a"; - valueArray[3] = "b"; - - PRInt32 l1 = 1999; - PRInt32 ret; - PRInt32 rt; - object->Test1(&l1); - l1 = 1999; - proxy->Test1(&l1); - printf("--urpTestImpl after Test1 l=%d %d\n",l1,ret); - /*******************************************/ - PRInt32 l2 = 2000; - l1 = 1999; - proxy->Test2(l1,&l2); - printf("--urpTestImpl after Test2 l2=%d\n",l2); - - /*******************************************/ - const char * s1 = "s1"; - char * s2 = "s2"; - proxy->Test3(s1,&s2); - printf("--urpTestImpl after Test3 s2=%s\n",s2); - /*******************************************/ - - - proxy->Test4(4,(const char **)valueArray); - /*******************************************/ - - char ***valueArray2 = &valueArray; - - printf("call object\n"); - for (unsigned int i = 0; i < 4; i++) { - printf("valueArray[%d]=%s\n",i,(*valueArray2)[i]); - } - object->Test5(4,valueArray2); - printf("after calling object\n"); - for (unsigned int i = 0; i < 4; i++) { - printf("valueArray[%d]=%s\n",i,(*valueArray2)[i]); - } - - - valueArray2 = (char ***)&valueArray; - proxy->Test5(4,valueArray2); - for (unsigned int i = 0; i < 4; i++) { - printf("valueArray[%d]=%s\n",i,(*valueArray2)[i]); - } - - /*********************************************/ - proxy->Test6(object); - /*********************************************/ - { - urpITest *p1; - proxy->Test7(&p1); - printf("p1=%p",p1); - PRInt32 l = 1234; - PRInt32 r; - p1->Test1(&l); - urpITest *p3; - printf("--before QueryInterface calling \n"); - if (NS_SUCCEEDED(p1->QueryInterface(NS_GET_IID(urpITest),(void**)&p3))) { - l=2000; - p3->Test1(&l); - } - - - } -} - -static int counter = 0; //we do not need to call it on unload time; -extern "C" NS_EXPORT nsresult NSGetModule(nsIComponentManager *compMgr, - nsIFile *location, - nsIModule** result) //I am using it for runnig test *only* -{ - if (counter == 0) { - counter ++; - test(); - } - return NS_ERROR_FAILURE; -} - - - - diff --git a/mozilla/java/xpcom/urp/src/test/urpTestImpl.h b/mozilla/java/xpcom/urp/src/test/urpTestImpl.h index ac584de2607..ba40370c741 100644 --- a/mozilla/java/xpcom/urp/src/test/urpTestImpl.h +++ b/mozilla/java/xpcom/urp/src/test/urpTestImpl.h @@ -26,23 +26,23 @@ class urpTestImpl : public urpITest { NS_DECL_ISUPPORTS - urpTestImpl() { - NS_INIT_REFCNT(); - } + NS_DECL_URPITEST + urpTestImpl(); + virtual ~urpTestImpl(); /*void test1(inout long l);*/ - NS_IMETHOD Test1(PRInt32 *l); +// NS_IMETHOD Test1(PRInt32 *l); /*void test2(in long l1,inout long l2);*/ - NS_IMETHOD Test2(PRInt32 l1, PRInt32* l2); +// NS_IMETHOD Test2(PRInt32 l1, PRInt32* l2); /*void test3(in string s1,inout string s2);*/ - NS_IMETHOD Test3(const char *s1, char **s2); +// NS_IMETHOD Test3(const char *s1, char **s2); /*void test4(in PRUint32 count,[array, size_is(count)] in string valueArray);*/ - NS_IMETHOD Test4(PRUint32 count, const char **valueArray); +// NS_IMETHOD Test4(PRUint32 count, const char **valueArray); /*void test5(in PRUint32 count,[array, size_is(count)] inout string valueArray);*/ - NS_IMETHOD Test5(PRUint32 count, char ***valueArray); +// NS_IMETHOD Test5(PRUint32 count, char ***valueArray); /*void test6(in urpITest o);*/ - NS_IMETHOD Test6(class urpITest *o); +// NS_IMETHOD Test6(class urpITest *o); /* void test7 (out urpITest o); */ - NS_IMETHOD Test7(urpITest **o); +// NS_IMETHOD Test7(urpITest **o); }; #endif /* __urpTestImpl_h */ diff --git a/mozilla/java/xpcom/urp/src/test/urpTestImplFactory.cpp b/mozilla/java/xpcom/urp/src/test/urpTestImplFactory.cpp new file mode 100644 index 00000000000..99ea38a92ec --- /dev/null +++ b/mozilla/java/xpcom/urp/src/test/urpTestImplFactory.cpp @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + + The contents of this file are subject to the Mozilla Public + License Version 1.1 (the "License"); you may not use this file + except in compliance with the License. You may obtain a copy of + the License at http://www.mozilla.org/MPL/ + + Software distributed under the License is distributed on an "AS + IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + implied. See the License for the specific language governing + rights and limitations under the License. + + The Original Code is mozilla.org code. + + The Initial Developer of the Original Code is Sun Microsystems, + Inc. Portions created by Sun are + Copyright (C) 1999 Sun Microsystems, Inc. All + Rights Reserved. + + Contributor(s): + Client QA Team, St. Petersburg, Russia +*/ + +#include "nsIGenericFactory.h" + +#include "urpTestImpl.h" + +NS_GENERIC_FACTORY_CONSTRUCTOR(urpTestImpl) + +static nsModuleComponentInfo components[] = +{ + { "URP Test Component", URPTEST_CID, URPTEST_PROGID, urpTestImplConstructor, + NULL /* NULL if you dont need one */, + NULL /* NULL if you dont need one */ + } +}; + +NS_IMPL_NSGETMODULE("urpITestFactory", components) diff --git a/mozilla/java/xpcom/urp/src/transport/llTransport.cpp b/mozilla/java/xpcom/urp/src/transport/llTransport.cpp index 515b817668b..97df4303259 100644 --- a/mozilla/java/xpcom/urp/src/transport/llTransport.cpp +++ b/mozilla/java/xpcom/urp/src/transport/llTransport.cpp @@ -229,3 +229,11 @@ PRStatus llPipeTransport::Open( char *name, llSideType type ) return PR_FAILURE; } + +PRStatus llPipeTransport::Close( void ) +{ + PRNetAddr addr; + PR_GetSockName( fd, &addr ); + PR_Delete( addr.local.path ); + return PR_Close( fd ); +} diff --git a/mozilla/java/xpcom/urp/src/transport/llTransport.h b/mozilla/java/xpcom/urp/src/transport/llTransport.h index ee9fdea3e8e..4f2ce99d827 100644 --- a/mozilla/java/xpcom/urp/src/transport/llTransport.h +++ b/mozilla/java/xpcom/urp/src/transport/llTransport.h @@ -61,13 +61,14 @@ protected: PRNetAddr addr; // only for client needs public: PRStatus Open( char *name, llSideType type ); - PRStatus Close( void ); + virtual PRStatus Close( void ); llConnection * ProvideConnection( void ); }; class llPipeTransport : public llTCPTransport { public: PRStatus Open( char *name, llSideType type ); + PRStatus Close( void ); }; #endif // llTransport_included diff --git a/mozilla/java/xpcom/urp/src/transport/urpTransport.h b/mozilla/java/xpcom/urp/src/transport/urpTransport.h index 659db69b011..c98583fe65a 100644 --- a/mozilla/java/xpcom/urp/src/transport/urpTransport.h +++ b/mozilla/java/xpcom/urp/src/transport/urpTransport.h @@ -49,9 +49,9 @@ protected: llTransport *trans; llSideType type; -public: urpTransport(); +public: PRBool IsClient( void ); PRBool IsServer( void ); diff --git a/mozilla/java/xpcom/urp/src/urpManager.cpp b/mozilla/java/xpcom/urp/src/urpManager.cpp index 05aa5db0a69..1930603c8f2 100644 --- a/mozilla/java/xpcom/urp/src/urpManager.cpp +++ b/mozilla/java/xpcom/urp/src/urpManager.cpp @@ -23,54 +23,85 @@ #include "prmem.h" #include "nsIInterfaceInfo.h" #include "nsIInterfaceInfoManager.h" -#include "nsIAllocator.h" #include "nsCOMPtr.h" #include "xptcall.h" #include "nsCRT.h" #include "urpManager.h" #include +#include "urpStub.h" +#include "urpMarshalToolkit.h" + #include "nsIModule.h" -#include "bcIXPCOMStubsAndProxies.h" -#include "bcXPCOMStubsAndProxiesCID.h" -static NS_DEFINE_CID(kXPCOMStubsAndProxies,BC_XPCOMSTUBSANDPROXIES_CID); - -class urpAllocator : public bcIAllocator { //nb make is smarter. It should deallocate allocated memory. +class threadHashKey : public nsHashKey { public: - urpAllocator(nsIAllocator *_allocator) { - allocator = _allocator; - } - virtual ~urpAllocator() {} - virtual void * Alloc(size_t size) { - return allocator->Alloc(size); - } - virtual void Free(void *ptr) { - allocator->Free(ptr); - } - virtual void * Realloc(void* ptr, size_t size) { - return allocator->Realloc(ptr,size); - } + threadHashKey(bcTID thrdID) : threadID(thrdID) {} + + virtual PRUint32 HashCode(void) const + { + return PRUint32(threadID); + } + + virtual PRBool Equals(const nsHashKey *aKey) const + { + return ((threadHashKey*)aKey)->threadID == threadID; + } + + virtual nsHashKey *Clone(void) const + { + return new threadHashKey(threadID); + } + private: - nsCOMPtr allocator; + bcTID threadID; }; -urpManager::urpManager(urpTransport* trans) { - broker = NULL; - connection = NULL; - transport = trans; - nsresult r; +struct localThreadArg { + urpManager *mgr; + urpConnection *conn; + PRBool isClnt; + localThreadArg( urpManager *mgr, urpConnection *conn, PRBool ic ) { + this->mgr = mgr; + this->conn = conn; + this->isClnt = ic; + } +}; + +void thread_start( void *arg ) +{ + urpManager *manager = ((localThreadArg *)arg)->mgr; + urpConnection *connection = ((localThreadArg *)arg)->conn; + PRBool ic = ((localThreadArg *)arg)->isClnt; + nsresult rv = manager->ReadMessage( connection, ic ); } -urpManager::urpManager(urpTransport* trans, bcIORB *orb) { +urpManager::urpManager(PRBool IsClient, bcIORB *orb, urpConnection* conn) { broker = orb; - connection = NULL; - transport = trans; + connection = conn; + connTable = nsnull; + if(IsClient) { +//then + localThreadArg *arg = new localThreadArg( this, conn, PR_TRUE ); + PRThread *thr = PR_CreateThread( PR_USER_THREAD, + thread_start, + arg, + PR_PRIORITY_NORMAL, + PR_GLOBAL_THREAD, + PR_UNJOINABLE_THREAD, + 0); + if(thr == nsnull) { + printf("Error couldn't run listener\n"); + exit(-1); + } + } } urpManager::~urpManager() { + if(connTable) + delete connTable; } @@ -78,10 +109,13 @@ urpManager::~urpManager() { void urpManager::SendUrpRequest(bcOID oid, bcIID iid, PRUint16 methodIndex, nsIInterfaceInfo* interfaceInfo, - bcICall *call, nsXPTCVariant* params, + bcICall *call, PRUint32 paramCount, const nsXPTMethodInfo* info) { printf("this is method sendUrpRequest and mid is %x\n",methodIndex); - connection = transport->GetConnection(); + if(connection == nsnull) { + printf("Connection is NULL in SendUrpRequest\n"); + exit(-1); + } long size = 0; long messagesCount = 0; urpPacket* message = new urpPacket(); @@ -122,520 +156,95 @@ void urpManager::SendUrpRequest(bcOID oid, bcIID iid, else message->WriteByte((char)methodIndex); } -printf("header is written\n"); - WriteType(iid, message); -printf("Type is written\n"); - WriteOid(oid, message); -printf("OID is written\n"); - WriteThreadID(1000, message); + urpMarshalToolkit* mt = new urpMarshalToolkit(PR_TRUE); + mt->WriteType(iid, message); + mt->WriteOid(oid, message); + bcTID thrID = (bcTID)PR_GetCurrentThread(); +printf("OID is written %ld\n", thrID); + mt->WriteThreadID(thrID, message); broker = call->GetORB(); - WriteParams(params, paramCount, info, interfaceInfo, message, methodIndex); -printf("params are written\n"); + mt->WriteParams(call, paramCount, info, interfaceInfo, message, methodIndex); + delete mt; connection->Write(message); delete message; -printf("package is written\n"); } void urpManager::TransformMethodIDAndIID() { printf("this is method transformMethodIDAndIID\n"); } -void -urpManager::WriteType(bcIID iid, urpPacket* message) { - - short cache_index; - - char typeClass = INTERFACE; - int found = 0; - - if(0) //here should be checking on whether class is simple or not - printf("class is simple\n"); - else { - if(0) { // here should be checking on whether cache is used - printf("cache is used\n"); - cache_index = 0x0; - } - else - cache_index = (short)0xffff; - - message->WriteByte((char)typeClass | (found ? 0x0 : 0x80)); -printf("write type is %x\n",(char)typeClass | (found ? 0x0 : 0x80)); - message->WriteShort(cache_index); -printf("write type is %x\n",cache_index); - - if(!found) { - char* iidStr = iid.ToString(); - message->WriteString(iidStr, strlen(iidStr)); - PR_Free(iidStr); - } - } -} - -bcIID -urpManager::ReadType(urpPacket* message) { - - char byte = (char)message->ReadByte(); - char typeClassValue = byte & 0xff; - - short cache_index = message->ReadShort(); - - int& size = 0; - nsIID iid; - char* name = message->ReadString(size); - iid.Parse(name); - PR_Free(name); - return iid; -} - -void -urpManager::WriteOid(bcOID oid, urpPacket* message) { - short cache_index; - int found = 0; - - if(0) { // here should be checking on whether cache is used - printf("cache is used\n"); - cache_index = 0x0; - } - else - cache_index = (short)0xffff; - - char* str = (char*)calloc(100, sizeof(char)); - sprintf(str,"%ld",oid); - message->WriteString(str, strlen(str)); - free(str); - message->WriteShort(cache_index); -} - -bcOID -urpManager::ReadOid(urpPacket* message) { - int& size = 0; - bcOID result; - - char* str = message->ReadString(size); - short cache_index = message->ReadShort(); - result = (bcOID)atol(str); - PR_Free(str); - return result; -} - -void -urpManager::WriteThreadID(bcTID tid, urpPacket* message) { - short cache_index; - int found = 0; - - char realTID[5] = {0x54, 0x14, 0x78, 0x71, 0x27}; - - if(0) { // here should be checking on whether cache is used - printf("cache is used\n"); - cache_index = 0x0; - } - else - cache_index = (short)0xffff; - - message->WriteOctetStream(realTID, 5); - message->WriteShort(cache_index); -} - -bcTID -urpManager::ReadThreadID(urpPacket* message) { - int& size = 0; - bcTID result; - char* array = message->ReadOctetStream(size); - short cache_index = message->ReadShort(); - result= (bcTID)array[0]; - PR_Free(array); - return result; -} - nsresult -urpManager::MarshalElement(void *data, nsXPTParamInfo * param, uint8 type, uint8 ind, - nsIInterfaceInfo* interfaceInfo, urpPacket* message, - PRUint16 methodIndex, const nsXPTMethodInfo *info, - nsXPTCVariant* params) { - nsresult r = NS_OK; - switch(type) { - case nsXPTType::T_IID : -printf("Marshalim T_IID\n"); - data = *(char**)data; - message->WriteString((char*)data, strlen((char*)data)); - break; - case nsXPTType::T_I8 : - message->WriteByte(*(char*)data); - break; - case nsXPTType::T_I16 : - message->WriteShort(*(short*)data); - break; - case nsXPTType::T_I32 : - message->WriteInt(*(int*)data); - break; - case nsXPTType::T_I64 : - message->WriteLong(*(long*)data); - break; - case nsXPTType::T_U8 : - message->WriteByte(*(char*)data); - break; - case nsXPTType::T_U16 : - message->WriteShort(*(short*)data); - break; - case nsXPTType::T_U32 : - message->WriteInt(*(int*)data); - break; - case nsXPTType::T_U64 : - message->WriteLong(*(long*)data); - break; - case nsXPTType::T_FLOAT : - message->WriteFloat(*(float*)data); - break; - case nsXPTType::T_DOUBLE : - message->WriteDouble(*(double*)data); - break; - case nsXPTType::T_CHAR_STR : - case nsXPTType::T_WCHAR_STR : - { - data = *(char **)data; - size_t length = 0; - if (type == nsXPTType::T_WCHAR_STR) { - length = nsCRT::strlen((const PRUnichar*)data); - length *= 2; - length +=2; - for (int i = 0; i < length && type == nsXPTType::T_WCHAR_STR; i++) { - char c = ((char*)data)[i]; - } - } else { - length = nsCRT::strlen((const char*)data); - length+=1; - } - message->WriteString((char*)data,length); - break; - } - case nsXPTType::T_INTERFACE : - case nsXPTType::T_INTERFACE_IS : - { - nsIID *iid; - if (type == nsXPTType::T_INTERFACE) { - if(NS_FAILED(r = interfaceInfo->GetIIDForParam(methodIndex, param, &iid))) { - return r; - } - } else { - uint8 argnum; - if (NS_FAILED(r = interfaceInfo->GetInterfaceIsArgNumberForParam(methodIndex, param, &argnum))) { - return r; - } - const nsXPTParamInfo& arg_param = info->GetParam(argnum); - const nsXPTType& arg_type = arg_param.GetType(); - if(arg_type.IsPointer() && - arg_type.TagPart() == nsXPTType::T_IID) { - if(arg_param.IsOut()) - iid =*((nsID**)params[argnum].val.p); - else - iid = (nsID*)params[argnum].val.p; - } - } - bcOID oid = 0; - if (*(char**)data != NULL) { - NS_WITH_SERVICE(bcIXPCOMStubsAndProxies, xpcomStubsAndProxies, kXPCOMStubsAndProxies, &r); - if (NS_FAILED(r)) { -printf("NS_WITH_SERVICE(bcXPC in Marshal failed\n"); - return r; - } - xpcomStubsAndProxies->GetOID(*(nsISupports**)data, broker,&oid); - } - WriteOid(oid, message); - bcIID biid = *(iid); - WriteType(biid, message); - break; - } - case nsXPTType::T_PSTRING_SIZE_IS: - case nsXPTType::T_PWSTRING_SIZE_IS: - case nsXPTType::T_ARRAY: //nb array of interfaces [to do] - { - PRUint32 arraySize; - if (!GetArraySizeFromParam(interfaceInfo,info, *param,methodIndex, - ind,params,GET_LENGTH, &arraySize)) { - return r; - } - if (type == nsXPTType::T_ARRAY) { - nsXPTType datumType; - if(NS_FAILED(interfaceInfo->GetTypeForParam(methodIndex, param, 1,&datumType))) { - return r; - } - message->WriteInt(arraySize); - PRInt16 elemSize = GetSimpleSize(datumType); - char *current = *(char**)data; - for (unsigned int i = 0; i < arraySize; i++, current+=elemSize) - { - r = MarshalElement(current,param,datumType.TagPart(),0, - interfaceInfo, message, methodIndex, info, params); - if(NS_FAILED(r)) return r; - } - } else { - size_t length = 0; - if (type == nsXPTType::T_PWSTRING_SIZE_IS) { - length = arraySize * sizeof(PRUnichar); - } else { - length = arraySize; - } - message->WriteString((char*)data, length); - } - break; - } - default: - return r; - } - return r; -} - -nsresult -urpManager::WriteParams(nsXPTCVariant* params, PRUint32 paramCount, const nsXPTMethodInfo *info, nsIInterfaceInfo* interfaceInfo, urpPacket* message, PRUint16 methodIndex) { - int i; - nsresult rv = NS_OK; - for(i=0;iGetParam(i); - PRBool isOut = param.IsOut(); - if ((transport->IsClient() && !param.IsIn()) || - (transport->IsServer() && !param.IsOut())) { - continue; - } - nsXPTCVariant *value = & params[i]; - void *data; - data = (isOut) ? value->val.p : value; - rv = MarshalElement(data, ¶m,param.GetType().TagPart(), i, interfaceInfo, message, methodIndex, info, params); - if(NS_FAILED(rv)) return rv; - - -/* - if(0) //here should be checking on whether class is simple or not - printf("class is simple\n"); - else { - if(0) { // here should be checking on whether cache is used - printf("cache is used\n"); - cache_index = 0x0; - } - else - cache_index = (short)0xffff; - - message->writeByte((char)typeClass | (found ? 0x0 : 0x80)); - message->writeShort(cache_index); - - if(!found) - message->writeString("com.sun.star.uno.XNamingService", 31); - } -*/ - } - return rv; -} - -nsresult -urpManager::UnMarshal(void *data, nsXPTParamInfo * param, uint8 type, - nsIInterfaceInfo* interfaceInfo, urpPacket* message, - PRUint16 methodIndex, bcIAllocator * allocator) { - nsresult r = NS_OK; - switch(type) { - case nsXPTType::T_IID : - { -printf("Unmarsahalim T_IID\n"); -/* - *(char**)data = (char*)new nsIID(); - data = *(char**)data; -*/ - int& size = 0; - *(char**)data = message->ReadString(size); - break; - } - case nsXPTType::T_I8 : - *(char*)data = message->ReadByte(); - break; - case nsXPTType::T_I16 : - *(short*)data = message->ReadShort(); - break; - case nsXPTType::T_I32 : - *(int*)data = message->ReadInt(); - break; - case nsXPTType::T_I64 : - *(long*)data = message->ReadLong(); - break; - case nsXPTType::T_U8 : - *(char*)data = message->ReadByte(); - break; - case nsXPTType::T_U16 : - *(short*)data = message->ReadShort(); - break; - case nsXPTType::T_U32 : - *(int*)data = message->ReadInt(); - break; - case nsXPTType::T_U64 : - *(long*)data = message->ReadLong(); - break; - case nsXPTType::T_FLOAT : - *(float*)data = message->ReadFloat(); - break; - case nsXPTType::T_DOUBLE : - *(double*)data = message->ReadDouble(); - break; - case nsXPTType::T_PSTRING_SIZE_IS: - case nsXPTType::T_PWSTRING_SIZE_IS: - case nsXPTType::T_CHAR_STR : - case nsXPTType::T_WCHAR_STR : - { - int& size = 0; - *(char**)data = message->ReadString(size); - break; - } - case nsXPTType::T_INTERFACE : - case nsXPTType::T_INTERFACE_IS : - { - bcOID oid = ReadOid(message); - nsIID iid = ReadType(message); - nsISupports *proxy = NULL; - if (oid != 0) { - NS_WITH_SERVICE(bcIXPCOMStubsAndProxies, xpcomStubsAndProxies, - kXPCOMStubsAndProxies, &r); - if (NS_FAILED(r)) { -printf("NS_WITH_SERVICE(bcXPCOMStubsAndProxies, xp failed\n"); - return r; - } - xpcomStubsAndProxies->GetProxy(oid, iid, broker,&proxy); - } - *(nsISupports**)data = proxy; - break; - } - case nsXPTType::T_ARRAY: - { - nsXPTType datumType; - if(NS_FAILED(interfaceInfo->GetTypeForParam(methodIndex, param, 1,&datumType))) { - return r; - } - PRUint32 arraySize; - PRInt16 elemSize = GetSimpleSize(datumType); - arraySize = message->ReadInt(); - - char * current; - *(char**)data = current = (char *) allocator->Alloc(elemSize*arraySize); - //nb what about arraySize=0? - for (unsigned int i = 0; i < arraySize; i++, current+=elemSize) { - r = UnMarshal(current, param, datumType.TagPart(), interfaceInfo, message, methodIndex, allocator); - if(NS_FAILED(r)) return r; - } - break; - } - default: - return r; - } - return r; -} - -nsresult -urpManager::ReadParams(nsXPTCVariant* params, PRUint32 paramCount, const nsXPTMethodInfo *info, urpPacket* message, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex) { - bcIAllocator * allocator = new urpAllocator(nsAllocator::GetGlobalAllocator()); - int i; - nsresult rv = NS_OK; - for(i=0;iGetParam(i); - PRBool isOut = param.IsOut(); - nsXPTCMiniVariant tmpValue = params[i]; //we need to set value for client side - nsXPTCMiniVariant * value; - value = &tmpValue; - if (transport->IsServer() && param.IsOut()) { - value->val.p = allocator->Alloc(sizeof(nsXPTCMiniVariant)); // sizeof(nsXPTCMiniVariant) is good - params[i].Init(*value,param.GetType(),0); - params[i].ptr = params[i].val.p = value->val.p; - params[i].flags |= nsXPTCVariant::PTR_IS_DATA; - } - - if ((transport->IsServer() && !param.IsIn()) || - (transport->IsClient() && !param.IsOut())) { - continue; - } - - void *data; - data = (isOut) ? value->val.p : value; - rv = UnMarshal(data, ¶m, param.GetType().TagPart(), interfaceInfo, - message, methodIndex, allocator); - if(NS_FAILED(rv)) return rv; - - params[i].Init(*value,param.GetType(),0); - -/* - if(0) //here should be checking on whether class is simple or not - printf("class is simple\n"); - else { - if(0) { // here should be checking on whether cache is used - printf("cache is used\n"); - cache_index = 0x0; - } - else - cache_index = (short)0xffff; - - message->writeByte((char)typeClass | (found ? 0x0 : 0x80)); - message->writeShort(cache_index); - - if(!found) - message->writeString("com.sun.star.uno.XNamingService", 31); - } -*/ - } - delete allocator; - return rv; -} - -nsresult -urpManager::ReadReply(nsXPTCVariant* params, PRUint32 paramCount, const nsXPTMethodInfo *info, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex) { - nsresult rv = NS_OK; - printf("this is method readReply\n"); - urpPacket* message = connection->Read(); - char header = message->ReadByte(); -printf("header in reply is %x %x %x\n",header, BIG_HEADER, header & BIG_HEADER); - if((header & BIG_HEADER) != 0) { // full header? - if((header & REQUEST) != 0) // a request ? - printf("long request\n"); - else // reply - rv = ParseReply(message, header, params, paramCount, - info, interfaceInfo, methodIndex); - } - else - printf("short request header\n"); - delete connection; - delete message; -// transport->close(); - return rv; -} - -nsresult -urpManager::ParseReply(urpPacket* message, char header, - nsXPTCVariant* params, PRUint32 paramCount, +urpManager::ReadReply(urpPacket* message, char header, + bcICall* call, PRUint32 paramCount, const nsXPTMethodInfo *info, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex) { nsresult rv = NS_OK; + printf("this is method readReply\n"); + urpMarshalToolkit* mt = new urpMarshalToolkit(PR_TRUE); if((header & NEWTID) != 0) { // new thread id ? printf("new threadID\n"); - bcTID tid = ReadThreadID(message); + bcTID tid = mt->ReadThreadID(message); } else printf("old threadID\n"); - rv = ReadParams(params, paramCount, info, message, interfaceInfo, methodIndex); + rv = mt->ReadParams(paramCount, info, message, interfaceInfo, methodIndex, call, broker, connection); + delete mt; return rv; } nsresult -urpManager::HandleRequest(urpConnection* conn) { -printf("method handleRequest\n"); - connection = conn; - urpPacket* message = connection->Read(); +urpManager::ReadMessage(urpConnection* conn, PRBool isClient) { nsresult rv = NS_OK; - char header = message->ReadByte(); - bcTID tid; - if((header & BIG_HEADER) != 0) { // full header? - if((header & REQUEST) != 0) // a request ? - rv = ReadLongRequest(header, message); - else // a reply - printf("Error: here should be request\n"); - } - else // only a short request header - rv = ReadShortRequest(header, message); - delete message; + if(!isClient) { + if(connTable == nsnull) + connTable = new nsHashtable(20); + bcTID thrID = (bcTID)PR_GetCurrentThread(); + threadHashKey thrHK(thrID); + connTable->Put(&thrHK, conn); + } + while(conn->GetStatus() == urpSuccess) { + urpPacket* message = conn->Read(); + char header = message->ReadByte(); + bcTID tid; + if((header & BIG_HEADER) != 0) { // full header? + if((header & REQUEST) != 0) // a request ? + rv = ReadLongRequest(header, message); + else { // a reply + bcIID iid; bcOID oid; bcMID mid; + call->GetParams(&iid, &oid, &mid); + nsIInterfaceInfo *interfaceInfo; + nsIInterfaceInfoManager* iimgr; + if( (iimgr = XPTI_GetInterfaceInfoManager()) ) { + if (NS_FAILED(iimgr->GetInfoForIID(&iid, &interfaceInfo))) { + printf("Error in ReadMessage\n"); + return NS_ERROR_FAILURE; //nb exception handling + } + NS_RELEASE(iimgr); + } else { + printf("Error in ReadMessage in second place\n"); + return NS_ERROR_FAILURE; + } + + nsXPTMethodInfo* info; + interfaceInfo->GetMethodInfo(mid, (const nsXPTMethodInfo **)&info); + PRUint32 paramCount = info->GetParamCount(); + ReadReply(message, header, call, paramCount, info, interfaceInfo, mid); + PR_EnterMonitor(mon); + PR_Notify(mon); + PR_ExitMonitor(mon); + mon = NULL; + } + } + else // only a short request header + rv = ReadShortRequest(header, message); + delete message; + } + if(!isClient) { + bcTID thrID = (bcTID)PR_GetCurrentThread(); + threadHashKey thrHK(thrID); + connTable->Remove(&thrHK); + } return rv; } @@ -648,7 +257,7 @@ urpManager::ReadShortRequest(char header, urpPacket* message) { } nsresult -urpManager::SendReply(bcTID tid, nsXPTCVariant *params, PRUint32 paramCount, +urpManager::SendReply(bcTID tid, bcICall* call, PRUint32 paramCount, const nsXPTMethodInfo* info, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex) { nsresult rv = NS_OK; @@ -656,13 +265,19 @@ urpManager::SendReply(bcTID tid, nsXPTCVariant *params, PRUint32 paramCount, header |= NEWTID; urpPacket* message = new urpPacket(); message->WriteByte(header); - WriteThreadID(tid, message); - rv = WriteParams(params, paramCount, info, interfaceInfo, message, + urpMarshalToolkit* mt = new urpMarshalToolkit(PR_FALSE); + mt->WriteThreadID(tid, message); + rv = mt->WriteParams(call, paramCount, info, interfaceInfo, message, methodIndex); + delete mt; if(NS_FAILED(rv)) return rv; + if(connTable) { + bcTID thrID = (bcTID)PR_GetCurrentThread(); + threadHashKey thrHK(thrID); + connection = (urpConnection*)connTable->Get(&thrHK); + } connection->Write(message); delete message; - delete connection; return rv; } @@ -679,16 +294,17 @@ urpManager::ReadLongRequest(char header, urpPacket* message) { else methodId = message->ReadByte(); + urpMarshalToolkit* mt = new urpMarshalToolkit(PR_FALSE); if((header & NEWTYPE) != 0) - iid = ReadType(message); + iid = mt->ReadType(message); if((header & NEWOID) != 0) // new oid? - oid = ReadOid(message); + oid = mt->ReadOid(message); if((header & NEWTID) != 0) // new thread id ? - tid = ReadThreadID(message); + tid = mt->ReadThreadID(message); -printf("method readLongRequest: tid %ld\n",tid); +printf("method readLongRequest: tid %ld %ld\n",tid,oid); char ignore_cache = ((header & IGNORECACHE) != 0); // do not use cache for this request? char mustReply; @@ -706,116 +322,32 @@ printf("method readLongRequest: tid %ld\n",tid); nsIInterfaceInfoManager* iimgr; if( (iimgr = XPTI_GetInterfaceInfoManager()) ) { if (NS_FAILED(iimgr->GetInfoForIID(&iid, &interfaceInfo))) { -printf("here oblomalis\n"); + delete mt; return NS_ERROR_FAILURE; //nb exception handling } NS_RELEASE(iimgr); } else { -printf("zdesia oblom\n"); + delete mt; return NS_ERROR_FAILURE; } char* name; interfaceInfo->GetName(&name); printf("in handleRequest interface name is %s\n",name); - nsXPTCVariant *params; nsXPTMethodInfo* info; interfaceInfo->GetMethodInfo(methodId,(const nsXPTMethodInfo **)&info); PRUint32 paramCount = info->GetParamCount(); - if (paramCount > 0) { - params = (nsXPTCVariant *) PR_Malloc(sizeof(nsXPTCVariant)*paramCount); - } - ReadParams(params, paramCount, info, message, interfaceInfo, methodId); -nsXPTCMiniVariant* tempVari = (nsXPTCMiniVariant *) PR_Malloc(sizeof(nsXPTCMiniVariant)*paramCount); - for(int ii =0; iiCreateCall(&iid, &oid, methodId); - bcIMarshaler *marshaler = call->GetMarshaler(); - bcXPCOMMarshalToolkit * mt = new bcXPCOMMarshalToolkit(methodId, interfaceInfo, tempVari,broker); - mt->Marshal(marshaler); + mt->ReadParams(paramCount, info, message, interfaceInfo, methodId, call, broker, connection); + delete mt; + //nb return value; excepion handling broker->SendReceive(call); - bcIUnMarshaler * unmarshaler = call->GetUnMarshaler(); - mt->UnMarshal(unmarshaler); - delete call; delete marshaler; delete unmarshaler; delete mt; - rv = SendReply(tid, params, paramCount, info, interfaceInfo, methodId); - PR_Free(tempVari); - PR_Free(params); + rv = SendReply(tid, call, paramCount, info, interfaceInfo, methodId); return rv; } -nsresult urpManager::GetArraySizeFromParam( nsIInterfaceInfo *_interfaceInfo, - const nsXPTMethodInfo* method, - const nsXPTParamInfo& param, - uint16 _methodIndex, - uint8 paramIndex, - nsXPTCVariant* nativeParams, - SizeMode mode, - PRUint32* result) { - //code borrowed from mozilla/js/src/xpconnect/src/xpcwrappedjsclass.cpp - uint8 argnum; - nsresult rv; - if(mode == GET_SIZE) { - rv = _interfaceInfo->GetSizeIsArgNumberForParam(_methodIndex, ¶m, 0, &argnum); - } else { - rv = _interfaceInfo->GetLengthIsArgNumberForParam(_methodIndex, ¶m, 0, &argnum); - } - if(NS_FAILED(rv)) { - return PR_FALSE; - } - const nsXPTParamInfo& arg_param = method->GetParam(argnum); - const nsXPTType& arg_type = arg_param.GetType(); - - // XXX require PRUint32 here - need to require in compiler too! - if(arg_type.IsPointer() || arg_type.TagPart() != nsXPTType::T_U32) - return PR_FALSE; - - if(arg_param.IsOut()) - *result = *(PRUint32*)nativeParams[argnum].val.p; - else - *result = nativeParams[argnum].val.u32; - - return PR_TRUE; +nsresult +urpManager::SetCall(bcICall* call, PRMonitor *m) { + this->call = call; + this->mon = m; + return NS_OK; } - - -PRInt16 urpManager::GetSimpleSize(uint8 type) { - PRInt16 size = -1; - switch(type) { - case nsXPTType::T_I8: - case nsXPTType::T_U8: - size = sizeof(PRInt8); - break; - case nsXPTType::T_I16: - case nsXPTType::T_U16: - size = sizeof(PRInt16); - break; - case nsXPTType::T_I32: - case nsXPTType::T_U32: - size = sizeof(PRInt32); - break; - case nsXPTType::T_I64: - case nsXPTType::T_U64: - size = sizeof(PRInt64); - break; - case nsXPTType::T_FLOAT: - size = sizeof(float); - break; - case nsXPTType::T_DOUBLE: - size = sizeof(double); - break; - case nsXPTType::T_BOOL: - size = sizeof(PRBool); - break; - case nsXPTType::T_CHAR: - size = sizeof(char); - break; - case nsXPTType::T_WCHAR: - size = sizeof(PRUnichar); - break; - default: - size = sizeof(void*); - } - return size; -} - diff --git a/mozilla/java/xpcom/urp/src/urpManager.h b/mozilla/java/xpcom/urp/src/urpManager.h index b39f6530859..5d2dd44d3bb 100644 --- a/mozilla/java/xpcom/urp/src/urpManager.h +++ b/mozilla/java/xpcom/urp/src/urpManager.h @@ -3,9 +3,11 @@ #include "nsIInterfaceInfo.h" #include "xptinfo.h" +#include "bcDefs.h" #include "urpTransport.h" -#include "bcXPCOMMarshalToolkit.h" +#include "bcIORB.h" +#include "nsHashtable.h" #define BIG_HEADER 0x80 #define REQUEST 0x40 @@ -29,54 +31,34 @@ class urpManager { public: - urpManager(urpTransport* trans); - urpManager(urpTransport* trans, bcIORB *orb); + urpManager(PRBool IsClient, bcIORB *orb, urpConnection* connection); ~urpManager(); - nsresult HandleRequest(urpConnection* conn); void SendUrpRequest(bcOID oid, bcIID iid, PRUint16 methodIndex, nsIInterfaceInfo* interfaceInfo, - bcICall *call, nsXPTCVariant* params, + bcICall *call, PRUint32 paramCount, const nsXPTMethodInfo* info); - nsresult ReadReply(nsXPTCVariant* params, PRUint32 paramCount, const nsXPTMethodInfo *info, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex); + nsresult ReadMessage(urpConnection* conn, PRBool ic); + nsresult SetCall(bcICall* call, PRMonitor *m); private: + nsHashtable* connTable; bcIORB *broker; - enum SizeMode { GET_SIZE, GET_LENGTH }; urpConnection* connection; - urpTransport* transport; + PRMonitor *mon; +/* for ReadReply */ + bcICall* call; + PRUint32 paramCount; + nsXPTMethodInfo* info; + bcMID mid; + nsIInterfaceInfo *interfaceInfo; void TransformMethodIDAndIID(); - void WriteType(bcIID iid, urpPacket* message); - bcIID ReadType(urpPacket* message); - void WriteOid(bcOID oid, urpPacket* message); - bcOID ReadOid(urpPacket* message); - void WriteThreadID(long tid, urpPacket* message); - bcTID ReadThreadID(urpPacket* message); - nsresult WriteParams(nsXPTCVariant* params, PRUint32 paramCount, const nsXPTMethodInfo * info, nsIInterfaceInfo* interfaceInfo, urpPacket* message, - PRUint16 methodIndex); - nsresult ReadParams(nsXPTCVariant* params, PRUint32 paramCount, const nsXPTMethodInfo *info, urpPacket* message, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex); - nsresult ParseReply(urpPacket* message, char header, - nsXPTCVariant* params, PRUint32 paramCount, const nsXPTMethodInfo *info, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex); + nsresult ReadReply(urpPacket* message, char header, + bcICall* call, PRUint32 paramCount, const nsXPTMethodInfo *info, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex); nsresult ReadLongRequest(char header, urpPacket* message); nsresult ReadShortRequest(char header, urpPacket* message); - nsresult SendReply(bcTID tid, nsXPTCVariant *params, PRUint32 paramCount, + nsresult SendReply(bcTID tid, bcICall* call, PRUint32 paramCount, const nsXPTMethodInfo* info, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex); - nsresult MarshalElement(void *data, nsXPTParamInfo * param, uint8 type, uint8 ind, - nsIInterfaceInfo* interfaceInfo, urpPacket* message, - PRUint16 methodIndex, const nsXPTMethodInfo* info, - nsXPTCVariant* params); - nsresult GetArraySizeFromParam( nsIInterfaceInfo *interfaceInfo, - const nsXPTMethodInfo* method, - const nsXPTParamInfo& param, - uint16 methodIndex, - uint8 paramIndex, - nsXPTCVariant* nativeParams, - SizeMode mode, - PRUint32* result); - PRInt16 GetSimpleSize(uint8 type); - nsresult UnMarshal(void *data, nsXPTParamInfo * param, uint8 type, - nsIInterfaceInfo* interfaceInfo, urpPacket* message, - PRUint16 methodIndex, bcIAllocator * allocator); }; #endif diff --git a/mozilla/java/xpcom/urp/src/urpMarshalToolkit.cpp b/mozilla/java/xpcom/urp/src/urpMarshalToolkit.cpp new file mode 100644 index 00000000000..1b1d1841e3a --- /dev/null +++ b/mozilla/java/xpcom/urp/src/urpMarshalToolkit.cpp @@ -0,0 +1,597 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is Sun Microsystems, + * Inc. Portions created by Sun are + * Copyright (C) 1999 Sun Microsystems, Inc. All + * Rights Reserved. + * + * Contributor(s): + * Sergey Lunegov + */ + +#include "prmem.h" +#include "nsIInterfaceInfo.h" +#include "nsIInterfaceInfoManager.h" +#include "nsIAllocator.h" +#include "nsCOMPtr.h" +#include "xptcall.h" +#include "nsCRT.h" +#include "urpMarshalToolkit.h" +#include +#include "urpStub.h" + + +#include "nsIModule.h" + + +class urpAllocator : public bcIAllocator { //nb make is smarter. It should deallocate allocated memory. +public: + urpAllocator(nsIAllocator *_allocator) { + allocator = _allocator; + } + virtual ~urpAllocator() {} + virtual void * Alloc(size_t size) { + return allocator->Alloc(size); + } + virtual void Free(void *ptr) { + allocator->Free(ptr); + } + virtual void * Realloc(void* ptr, size_t size) { + return allocator->Realloc(ptr,size); + } +private: + nsCOMPtr allocator; +}; + + +urpMarshalToolkit::urpMarshalToolkit(PRBool isclnt) { + isClient = isclnt; +} + + +urpMarshalToolkit::~urpMarshalToolkit() { +} + +nsresult +urpMarshalToolkit::WriteElement(bcIUnMarshaler *um, nsXPTParamInfo * param, uint8 type, uint8 ind, + nsIInterfaceInfo* interfaceInfo, urpPacket* message, + PRUint16 methodIndex, const nsXPTMethodInfo *info, + bcIAllocator * allocator) { + void* data = allocator->Alloc(sizeof(void*)); + nsresult r = NS_OK; + switch(type) { + case nsXPTType::T_IID : + data = (char*)new nsIID(); + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteString((char*)data, strlen((char*)data)); + break; + case nsXPTType::T_I8 : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteByte(*(char*)data); + break; + case nsXPTType::T_I16 : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteShort(*(short*)data); + break; + case nsXPTType::T_I32 : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteInt(*(int*)data); + break; + case nsXPTType::T_I64 : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteLong(*(long*)data); + break; + case nsXPTType::T_U8 : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteByte(*(char*)data); + break; + case nsXPTType::T_U16 : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteShort(*(short*)data); + break; + case nsXPTType::T_U32 : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteInt(*(int*)data); + break; + case nsXPTType::T_U64 : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteLong(*(long*)data); + break; + case nsXPTType::T_FLOAT : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteFloat(*(float*)data); + break; + case nsXPTType::T_DOUBLE : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteDouble(*(double*)data); + break; + case nsXPTType::T_CHAR : + case nsXPTType::T_WCHAR : + um->ReadSimple(data,XPTType2bcXPType(type)); + message->WriteByte(*(char*)data); + break; + case nsXPTType::T_CHAR_STR : + case nsXPTType::T_WCHAR_STR : + { + size_t size; + um->ReadString(data,&size,allocator); + { + char *str = *(char**)data; + for (int i = 0; i < size && type == nsXPTType::T_WCHAR_STR; i++) { + char c = str[i]; + } + } + data = *(char **)data; + size_t length = 0; + if (type == nsXPTType::T_WCHAR_STR) { + length = nsCRT::strlen((const PRUnichar*)data); + length *= 2; + length +=2; + for (int i = 0; i < length && type == nsXPTType::T_WCHAR_STR; i++) { + char c = ((char*)data)[i]; + } + } else { + length = nsCRT::strlen((const char*)data); + length+=1; + } + message->WriteString((char*)data,length); + break; + } + case nsXPTType::T_INTERFACE : + case nsXPTType::T_INTERFACE_IS : + { + nsIID iid; + bcOID oid; + um->ReadSimple(&oid,XPTType2bcXPType(type)); + um->ReadSimple(&iid,bc_T_IID); + WriteOid(oid, message); + WriteType(iid, message); + break; + } + case nsXPTType::T_PSTRING_SIZE_IS: + case nsXPTType::T_PWSTRING_SIZE_IS: + case nsXPTType::T_ARRAY: //nb array of interfaces [to do] + { + size_t size; + nsXPTType datumType; + if(type != nsXPTType::T_ARRAY) { + um->ReadString(data,&size,allocator); + { + char *str = *(char**)data; + for (int i = 0; i < size && type == nsXPTType::T_WCHAR_STR; i++) { + char c = str[i]; + } + } + } else { + if(NS_FAILED(interfaceInfo->GetTypeForParam(methodIndex, param, 1,&datumType))) { + allocator->Free(data); + return NS_ERROR_FAILURE; + } + PRUint32 arraySize; + PRInt16 elemSize = GetSimpleSize(datumType); + um->ReadSimple(&arraySize,bc_T_U32); + message->WriteInt(arraySize); + for (unsigned int i = 0; i < arraySize; i++) { + r = WriteElement(um,param,datumType.TagPart(),0, + interfaceInfo, message, methodIndex, info, allocator); + if(NS_FAILED(r)) { + allocator->Free(data); + return r; + } + } + } + if (type != nsXPTType::T_ARRAY) { + size_t length = 0; + if (type == nsXPTType::T_PWSTRING_SIZE_IS) { + length = size * sizeof(PRUnichar); + } else { + length = size; + } + message->WriteString((char*)data, length); + } + break; + } + default: + allocator->Free(data); + return r; + } + allocator->Free(data); + return r; +} + +nsresult +urpMarshalToolkit::WriteParams(bcICall *call, PRUint32 paramCount, const nsXPTMethodInfo *info, nsIInterfaceInfo* interfaceInfo, urpPacket* message, PRUint16 methodIndex) { + int i; + nsresult rv = NS_OK; + bcIAllocator * allocator = new urpAllocator(nsAllocator::GetGlobalAllocator()); + bcIUnMarshaler *um = call->GetUnMarshaler(); + for(i=0;iGetParam(i); + PRBool isOut = param.IsOut(); + if ((isClient && !param.IsIn()) || + (!isClient && !param.IsOut())) { + continue; + } + rv = WriteElement(um, ¶m,param.GetType().TagPart(), i, interfaceInfo, message, methodIndex, info, allocator); + if(NS_FAILED(rv)) { + delete allocator; + delete um; + return rv; + } + + + } + delete allocator; + delete um; + return rv; +} + +nsresult +urpMarshalToolkit::ReadElement(nsXPTParamInfo * param, uint8 type, + nsIInterfaceInfo* interfaceInfo, urpPacket* message, + PRUint16 methodIndex, bcIAllocator* allocator, + bcIMarshaler* m, bcIORB *broker, urpConnection* conn) { + void* data = allocator->Alloc(sizeof(void*)); + nsresult r = NS_OK; + switch(type) { + case nsXPTType::T_IID : + { + int& size = 0; + data = message->ReadString(size); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + } + case nsXPTType::T_I8 : + *(char*)data = message->ReadByte(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_I16 : + *(short*)data = message->ReadShort(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_I32 : + *(int*)data = message->ReadInt(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_I64 : + *(long*)data = message->ReadLong(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_U8 : + *(char*)data = message->ReadByte(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_U16 : + *(short*)data = message->ReadShort(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_U32 : + *(int*)data = message->ReadInt(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_U64 : + *(long*)data = message->ReadLong(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_FLOAT : + *(float*)data = message->ReadFloat(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_DOUBLE : + *(double*)data = message->ReadDouble(); + m->WriteSimple(data, XPTType2bcXPType(type)); + break; + case nsXPTType::T_CHAR_STR : + case nsXPTType::T_WCHAR_STR : + { + int& size = 0; + *(char**)data = message->ReadString(size); + data = *(char **)data; + size_t length = 0; + if (type == nsXPTType::T_WCHAR_STR) { + length = nsCRT::strlen((const PRUnichar*)data); + length *= 2; + length +=2; + for (int i = 0; i < length && type == nsXPTType::T_WCHAR_STR; i++) { + char c = ((char*)data)[i]; + } + } else { + length = nsCRT::strlen((const char*)data); + length+=1; + } + m->WriteString(data,length); + break; + } + case nsXPTType::T_INTERFACE : + case nsXPTType::T_INTERFACE_IS : + { + bcOID oid = ReadOid(message); + nsIID iid = ReadType(message); + nsISupports *proxy = NULL; + if (oid != 0) { + urpStub* stub = new urpStub(conn); + broker->RegisterStubWithOID(stub, &oid); + } + m->WriteSimple(&oid, XPTType2bcXPType(type)); + m->WriteSimple(&iid,bc_T_IID); + break; + } + case nsXPTType::T_PSTRING_SIZE_IS: + case nsXPTType::T_PWSTRING_SIZE_IS: + case nsXPTType::T_ARRAY: + { + nsXPTType datumType; + if(NS_FAILED(interfaceInfo->GetTypeForParam(methodIndex, param, 1,&datumType))) { + allocator->Free(data); + return r; + } + PRUint32 arraySize; + PRInt16 elemSize = GetSimpleSize(datumType); + arraySize = message->ReadInt(); + + if(type == nsXPTType::T_ARRAY) { + m->WriteSimple(&arraySize,bc_T_U32); + char *current = *(char**)data; + for (int i = 0; i < arraySize; i++) { + ReadElement(param,datumType.TagPart(),interfaceInfo, message, methodIndex, allocator, m, broker, conn); + } + } else { + size_t length = 0; + if (type == nsXPTType::T_PWSTRING_SIZE_IS) { + length = arraySize * sizeof(PRUnichar); + } else { + length = arraySize; + } + m->WriteString(data, length); + } + + break; + } + default: + allocator->Free(data); + return r; + } + allocator->Free(data); + return r; +} + +nsresult +urpMarshalToolkit::ReadParams(PRUint32 paramCount, const nsXPTMethodInfo *info, urpPacket* message, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex, bcICall* call, bcIORB *orb, urpConnection* conn) { + bcIAllocator * allocator = new urpAllocator(nsAllocator::GetGlobalAllocator()); + bcIMarshaler* m = call->GetMarshaler(); + int i; + nsresult rv = NS_OK; + for(i=0;iGetParam(i); + PRBool isOut = param.IsOut(); + + if ((!isClient && !param.IsIn()) || + (isClient && !param.IsOut())) { + continue; + } + + rv = ReadElement(¶m, param.GetType().TagPart(), interfaceInfo, + message, methodIndex, allocator, m, orb, conn); + if(NS_FAILED(rv)) { + delete allocator; + delete m; + return rv; + } + + + } + delete allocator; + delete m; + return rv; +} + +PRInt16 urpMarshalToolkit::GetSimpleSize(uint8 type) { + PRInt16 size = -1; + switch(type) { + case nsXPTType::T_I8: + case nsXPTType::T_U8: + size = sizeof(PRInt8); + break; + case nsXPTType::T_I16: + case nsXPTType::T_U16: + size = sizeof(PRInt16); + break; + case nsXPTType::T_I32: + case nsXPTType::T_U32: + size = sizeof(PRInt32); + break; + case nsXPTType::T_I64: + case nsXPTType::T_U64: + size = sizeof(PRInt64); + break; + case nsXPTType::T_FLOAT: + size = sizeof(float); + break; + case nsXPTType::T_DOUBLE: + size = sizeof(double); + break; + case nsXPTType::T_BOOL: + size = sizeof(PRBool); + break; + case nsXPTType::T_CHAR: + size = sizeof(char); + break; + case nsXPTType::T_WCHAR: + size = sizeof(PRUnichar); + break; + default: + size = sizeof(void*); + } + return size; +} + +bcXPType urpMarshalToolkit::XPTType2bcXPType(uint8 type) { + switch(type) { + case nsXPTType::T_I8 : + return bc_T_I8; + case nsXPTType::T_U8 : + return bc_T_U8; + case nsXPTType::T_I16 : + return bc_T_I16; + case nsXPTType::T_U16 : + return bc_T_U16; + case nsXPTType::T_I32 : + return bc_T_I32; + case nsXPTType::T_U32 : + return bc_T_U32; + case nsXPTType::T_I64 : + return bc_T_I64; + case nsXPTType::T_U64 : + return bc_T_U64; + case nsXPTType::T_FLOAT : + return bc_T_FLOAT; + case nsXPTType::T_DOUBLE : + return bc_T_DOUBLE; + case nsXPTType::T_BOOL : + return bc_T_BOOL; + case nsXPTType::T_CHAR : + return bc_T_CHAR; + case nsXPTType::T_WCHAR : + return bc_T_WCHAR; + case nsXPTType::T_IID : + return bc_T_IID; + case nsXPTType::T_CHAR_STR : + case nsXPTType::T_PSTRING_SIZE_IS: + return bc_T_CHAR_STR; + case nsXPTType::T_WCHAR_STR : + case nsXPTType::T_PWSTRING_SIZE_IS: + return bc_T_WCHAR_STR; + case nsXPTType::T_INTERFACE : + case nsXPTType::T_INTERFACE_IS : + return bc_T_INTERFACE; + case nsXPTType::T_ARRAY: + return bc_T_ARRAY; + default: + return bc_T_UNDEFINED; + + } +} +void +urpMarshalToolkit::WriteType(bcIID iid, urpPacket* message) { + + short cache_index; + + char typeClass = INTERFACE; + int found = 0; + + if(0) //here should be checking on whether class is simple or not + printf("class is simple\n"); + else { + if(0) { // here should be checking on whether cache is used + printf("cache is used\n"); + cache_index = 0x0; + } + else + cache_index = (short)0xffff; + + message->WriteByte((char)typeClass | (found ? 0x0 : 0x80)); +printf("write type is %x\n",(char)typeClass | (found ? 0x0 : 0x80)); + message->WriteShort(cache_index); +printf("write type is %x\n",cache_index); + + if(!found) { + char* iidStr = iid.ToString(); + message->WriteString(iidStr, strlen(iidStr)); + PR_Free(iidStr); + } + } +} + +bcIID +urpMarshalToolkit::ReadType(urpPacket* message) { + + char byte = (char)message->ReadByte(); + char typeClassValue = byte & 0xff; + + short cache_index = message->ReadShort(); + + int& size = 0; + nsIID iid; + char* name = message->ReadString(size); + iid.Parse(name); + PR_Free(name); + return iid; +} + +void +urpMarshalToolkit::WriteOid(bcOID oid, urpPacket* message) { + short cache_index; + int found = 0; + + if(0) { // here should be checking on whether cache is used + printf("cache is used\n"); + cache_index = 0x0; + } + else + cache_index = (short)0xffff; + + char* str = (char*)calloc(100, sizeof(char)); + sprintf(str,"%ld",oid); + message->WriteString(str, strlen(str)); + free(str); + message->WriteShort(cache_index); +} + +bcOID +urpMarshalToolkit::ReadOid(urpPacket* message) { + int& size = 0; + bcOID result; + + char* str = message->ReadString(size); + short cache_index = message->ReadShort(); + result = (bcOID)atol(str); + PR_Free(str); + return result; +} + +void +urpMarshalToolkit::WriteThreadID(bcTID tid, urpPacket* message) { + short cache_index; + int found = 0; + + char realTID[4]; /* this is hack: I know that bcTID is PRUint32 + so it is represented by four bytes */ + realTID[0] = tid>>24 & 0xff; + realTID[1] = (tid>>16) & 0xff; + realTID[2] = (tid>>8) & 0xff; + realTID[3] = tid & 0xff; + + if(0) { // here should be checking on whether cache is used + printf("cache is used\n"); + cache_index = 0x0; + } + else + cache_index = (short)0xffff; + + message->WriteOctetStream(realTID, 4); + message->WriteShort(cache_index); +} + +bcTID +urpMarshalToolkit::ReadThreadID(urpPacket* message) { + int& size = 0; + bcTID result; + char* array = message->ReadOctetStream(size); + short cache_index = message->ReadShort(); + result = ((unsigned char)array[0]<<24) + ((unsigned char)array[1]<<16) + ((unsigned char)array[2]<<8) + ((unsigned char)array[3]&0xff); + PR_Free(array); + return result; +} diff --git a/mozilla/java/xpcom/urp/src/urpMarshalToolkit.h b/mozilla/java/xpcom/urp/src/urpMarshalToolkit.h new file mode 100644 index 00000000000..3aeb456ed41 --- /dev/null +++ b/mozilla/java/xpcom/urp/src/urpMarshalToolkit.h @@ -0,0 +1,61 @@ +#ifndef URP_MARSHALTOOLKIT +#define URP_MARSHALTOOLKIT + +#include "nsIInterfaceInfo.h" +#include "xptinfo.h" +#include "bcDefs.h" +#include "urpTransport.h" +#include "bcIORB.h" + +#include "nsHashtable.h" + +#define BIG_HEADER 0x80 +#define REQUEST 0x40 +#define NEWTYPE 0x20 +#define NEWOID 0x10 +#define NEWTID 0x08 +#define LONGMETHODID 0x04 +#define IGNORECACHE 0x02 +#define MOREFLAGS 0x01 + +#define MUSTREPLY 0x80 +#define SYNCHRONOUSE 0x40 + +#define DIR_MID 0x40 +#define EXCEPTION 0x20 + +#define INTERFACE 22 +#define INTERFACE_STRING "com.sun.star.uno.XInterface" + + +class urpMarshalToolkit { + +public: + urpMarshalToolkit(PRBool isClient); + ~urpMarshalToolkit(); + + nsresult ReadParams(PRUint32 paramCount, const nsXPTMethodInfo *info, urpPacket* message, nsIInterfaceInfo *interfaceInfo, PRUint16 methodIndex, bcICall* call, bcIORB *orb, urpConnection* conn); + nsresult WriteParams(bcICall *call, PRUint32 paramCount, const nsXPTMethodInfo * info, nsIInterfaceInfo* interfaceInfo, urpPacket* message, + PRUint16 methodIndex); + void WriteType(bcIID iid, urpPacket* message); + bcIID ReadType(urpPacket* message); + void WriteOid(bcOID oid, urpPacket* message); + bcOID ReadOid(urpPacket* message); + void WriteThreadID(long tid, urpPacket* message); + bcTID ReadThreadID(urpPacket* message); + +private: + PRBool isClient; + nsresult WriteElement(bcIUnMarshaler * um, nsXPTParamInfo * param, uint8 type, uint8 ind, + nsIInterfaceInfo* interfaceInfo, urpPacket* message, + PRUint16 methodIndex, const nsXPTMethodInfo* info, + bcIAllocator * allocator); + PRInt16 GetSimpleSize(uint8 type); + nsresult ReadElement(nsXPTParamInfo * param, uint8 type, + nsIInterfaceInfo* interfaceInfo, urpPacket* message, + PRUint16 methodIndex, bcIAllocator * allocator, + bcIMarshaler* m, bcIORB *orb, urpConnection* conn); + bcXPType XPTType2bcXPType(uint8 type); +}; + +#endif diff --git a/mozilla/java/xpcom/urp/src/urpStub.cpp b/mozilla/java/xpcom/urp/src/urpStub.cpp index 7ea650a7b07..f166737a005 100644 --- a/mozilla/java/xpcom/urp/src/urpStub.cpp +++ b/mozilla/java/xpcom/urp/src/urpStub.cpp @@ -29,22 +29,14 @@ #include "urpManager.h" -urpStub::urpStub(char* conStr) { - transport = new urpConnector(); - PRStatus status = transport->Open(conStr); - if(status != NS_OK) { - fprintf(stderr,"Error in opening of remote server on client side\n"); - exit(-1); - } - manager = new urpManager(transport); + +urpStub::urpStub(urpConnection* conn) { + manager = new urpManager(PR_TRUE, nsnull, conn); +//here zavodim condWait i peredaem v urpManager } urpStub::~urpStub() { - if(transport) { - transport->Close(); - delete transport; - } if(manager) delete manager; } @@ -72,25 +64,17 @@ void urpStub::Dispatch(bcICall *call) { interfaceInfo->GetMethodInfo(mid, (const nsXPTMethodInfo **)&info); PRUint32 paramCount = info->GetParamCount(); printf("ThreadID is written %d\n",paramCount); - nsXPTCVariant* params; - bcXPCOMMarshalToolkit* mt = NULL; - if (paramCount > 0) { - params = (nsXPTCVariant*)malloc(sizeof(nsXPTCVariant) * paramCount); - mt = new bcXPCOMMarshalToolkit(mid, interfaceInfo, params, call->GetORB()); - bcIUnMarshaler * um = call->GetUnMarshaler(); - mt->UnMarshal(um); - if (params == nsnull) { - return; - } - } - - manager->SendUrpRequest(oid, iid, mid, interfaceInfo, call, params, paramCount, + PRMonitor* mon = PR_NewMonitor(); + PR_EnterMonitor(mon); + manager->SetCall(call, mon); + manager->SendUrpRequest(oid, iid, mid, interfaceInfo, call, paramCount, info); - manager->ReadReply(params, paramCount, info, interfaceInfo, mid); - if (mt != NULL) { //nb to do what about nsresult ? - bcIMarshaler * m = call->GetMarshaler(); - mt->Marshal(m); - } + if(NS_FAILED(PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT))) { + printf("Can't wait on cond var\n"); + exit(-1); + } + PR_ExitMonitor(mon); + PR_DestroyMonitor(mon); } diff --git a/mozilla/java/xpcom/urp/src/urpStub.h b/mozilla/java/xpcom/urp/src/urpStub.h index a8e7693f558..d3b5d5f5a5c 100644 --- a/mozilla/java/xpcom/urp/src/urpStub.h +++ b/mozilla/java/xpcom/urp/src/urpStub.h @@ -30,11 +30,10 @@ class urpStub : public bcIStub { public: - urpStub(char* cStr); + urpStub(urpConnection* conn); virtual ~urpStub(); virtual void Dispatch(bcICall *call) ; private: - urpTransport* transport; urpManager* manager; };