Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-13 05:15:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Removing obsolete xpcom/remote files.

Browse Source 
Bug #102787 r=igor.kushnirskiy@sun.com
This commit is contained in:
seawood%netscape.com 2001-11-14 04:10:51 +00:00
parent 3e771f6d39
commit 8cd04ee331
72 changed files with 0 additions and 5985 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
xpcom/remote/Makefile
View File

@ -1,35 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../..
topsrcdir = ../..
VPATH = .
srcdir = .
include $(DEPTH)/config/autoconf.mk
DIRS= \
common \
server \
client \
tests \
$(NULL)
include $(topsrcdir)/config/rules.mk

35
xpcom/remote/Makefile.in
View File

@ -1,35 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../..
topsrcdir = @top_srcdir@
VPATH = @srcdir@
srcdir = @srcdir@
include $(DEPTH)/config/autoconf.mk
DIRS= \
common \
server \
client \
tests \
$(NULL)
include $(topsrcdir)/config/rules.mk

28
xpcom/remote/README
View File

@ -1,28 +0,0 @@
This document is under construction.
The main goal of module is to give services for calling xpcom objects across
process boundaries.
Currently we are providing communication between two processes only
1
The reason of this is that this project was started to help blackwood
projects to use oji on solaris.
(Under solaris jvm is running in a separate process.)
In this specific case we need to have only two process communication
(We have one jvm per mozilla running)
------------------------
sources are organized as follows:
server/ - server related
client/ - client related
common/ - related to bough
tests/ - tests for this
-----------------------------------
This code was tested under solaris and linux

17
xpcom/remote/TODO
View File

@ -1,17 +0,0 @@
* Figure out when to free memory allocated for marshaling/demarshaling
(I am going to use my on nsIAllocator for this.
I guess it would be convenient to free all memory allocated by this
allocator)
* Add marshaling for Interfaces.
(It would be done using IMarshalToolkit
We need to implement read/write interface for server and client side
and update code for MarshalToolkitImpl::read/ride Array in order to use
arrays of interfaces)
* Add handling of AddRef, Release and QueryInterface to RemoteObjectProxy
* Implement smarter Dispatcher and RPCChannel.
In order to use it in multi threading environment.

57
xpcom/remote/client/Makefile.in
View File

@ -1,57 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../../..
topsrcdir = ../../..
srcdir = .
VPATH = .
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/config.mk
LIBRARY_NAME = rpcclient
EXPORT_LIBRARY = 1
MODULE = rpcclient
CPPSRCS = \
RPCChannelClientImpl.cpp \
RPCClientService.cpp \
RemoteObjectProxy.cpp \
$(NULL)
INCLUDES += -I../common -I../server
LIBS = \
-lxpcom \
-lxptinfo \
$(NSPR_LIBS) \
$(NULL)
include $(topsrcdir)/config/rules.mk

59
xpcom/remote/client/RPCChannelClientImpl.cpp
View File

@ -1,59 +0,0 @@
/* -*- 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):
*/
#include "nsISupports.h"
#include "RPCChannelClientImpl.h"
#include "prmem.h"
NS_IMPL_ISUPPORTS1(RPCChannelClientImpl, IRPCChannel)
RPCChannelClientImpl::RPCChannelClientImpl(ITransport * _transport) {
NS_INIT_REFCNT();
transport = _transport;
}
RPCChannelClientImpl::~RPCChannelClientImpl() {
NS_IF_RELEASE(transport);
}
NS_IMETHODIMP RPCChannelClientImpl::SendReceive(IRPCall * call) {
//nb temporary implamentation
if(!transport
|| !call) {
return NS_ERROR_NULL_POINTER;
}
void *rawData = NULL;
PRUint32 size = 0;
nsresult rv;
if (NS_FAILED(rv = call->GetRawData(&rawData,&size))) {
return rv;
}
transport->Write(rawData,size);
PR_Free(rawData);
rawData = NULL;
while (!NS_SUCCEEDED(transport->Read(&rawData,&size))) { //nb ugly just for testing
;
}
rv = call->Demarshal(rawData,size);
PR_Free(rawData);
return rv;
}

37
xpcom/remote/client/RPCChannelClientImpl.h
View File

@ -1,37 +0,0 @@
/* -*- 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):
*/
#ifndef __RPCChannelClientImpl_h__
#define __RPCChannelClientImpl_h__
#include "IRPCChannel.h"
#include "ITransport.h"
#include "IRPCall.h"
class RPCChannelClientImpl : public IRPCChannel {
public:
RPCChannelClientImpl(ITransport *transport);
virtual ~RPCChannelClientImpl(void);
NS_DECL_ISUPPORTS
NS_IMETHOD SendReceive(IRPCall * call);
private:
ITransport *transport;
};
#endif __RPCChannelClientImpl_h__

112
xpcom/remote/client/RPCClientService.cpp
View File

@ -1,112 +0,0 @@
/* -*- 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):
*/
#include "RPCClientService.h"
#include "RemoteObjectProxy.h"
#include "RPCChannelClientImpl.h"
#include "RPCallImpl.h"
#include "TransportImpl.h"
#include "IMarshalToolkit.h"
#include "MarshalToolkitImpl.h"
static IMarshalToolkit * marshalToolkit = new MarshalToolkitImpl();
RPCClientService * RPCClientService::instance = NULL;
char * RPCClientService::serverName = NULL;
RPCClientService::RPCClientService(void) {
transport = NULL;
rpcChannel = NULL;
}
RPCClientService::~RPCClientService(void) {
instance = NULL;
NS_IF_RELEASE(rpcChannel);
}
RPCClientService * RPCClientService::GetInstance(void) {
if (!instance) {
instance = new RPCClientService();
}
return instance;
}
void RPCClientService::Initialize(char *_serverName) {
serverName = _serverName;
}
NS_IMETHODIMP RPCClientService::CreateRPCall(IRPCall **result) {
if (!result) {
return NS_ERROR_NULL_POINTER;
}
*result = new RPCallImpl(marshalToolkit);
NS_ADDREF(*result);
return NS_OK;
}
NS_IMETHODIMP RPCClientService::CreateObjectProxy(OID oid, const nsIID &iid, nsISupports **result) {
if (!result) {
return NS_ERROR_NULL_POINTER;
}
*result = new RemoteObjectProxy(oid, iid);
NS_ADDREF(*result);
return NS_OK;
}
NS_IMETHODIMP RPCClientService::GetTransport(ITransport **result) {
if (!result) {
return NS_ERROR_NULL_POINTER;
}
if (!transport) {
transport = new TransportImpl(serverName);
if (!transport) {
return NS_ERROR_FAILURE;
}
}
NS_ADDREF(transport);
*result = transport;
return NS_OK;
}
NS_IMETHODIMP RPCClientService::GetRPCChannel(IRPCChannel **result) {
nsresult rv = NS_OK;
if (!result) {
return NS_ERROR_NULL_POINTER;
}
if (!rpcChannel) {
ITransport * _transport = NULL;
if (NS_FAILED(rv = GetTransport(&_transport))) {
return rv;
}
rpcChannel = new RPCChannelClientImpl(_transport);
if (!rpcChannel) {
return NS_ERROR_FAILURE;
}
NS_ADDREF(rpcChannel); //nb !! it is for future
}
NS_ADDREF(rpcChannel);
*result = rpcChannel;
return NS_OK;
}

44
xpcom/remote/client/RPCClientService.h
View File

@ -1,44 +0,0 @@
/* -*- 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):
*/
#ifndef __RPCClientServoce_h__
#define __RPCClientService_h__
#include "nsISupports.h"
#include "ITransport.h"
#include "IRPCall.h"
#include "IRPCChannel.h"
class RPCClientService {
public:
static RPCClientService * GetInstance(void);
static void Initialize(char *serverName);
~RPCClientService();
NS_IMETHOD GetRPCChannel(IRPCChannel **channel);
NS_IMETHOD CreateRPCall(IRPCall **rcall);
NS_IMETHOD CreateObjectProxy(OID oid, const nsIID &iid, nsISupports **result);
protected:
RPCClientService(void);
NS_IMETHOD GetTransport(ITransport **transport);
static RPCClientService * instance;
ITransport * transport;
IRPCChannel * rpcChannel;
static char * serverName;
};
#endif /* __RPCClientService_h__ */

100
xpcom/remote/client/RemoteObjectProxy.cpp
View File

@ -1,100 +0,0 @@
/* -*- 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):
*/
#include "nsIInterfaceInfoManager.h"
#include "RemoteObjectProxy.h"
#include "IRPCall.h"
#include "IRPCChannel.h"
#include "RPCClientService.h"
NS_IMPL_ISUPPORTS1(RemoteObjectProxy, RemoteObjectProxy)
RemoteObjectProxy::RemoteObjectProxy(OID _oid, REFNSIID _iid ) {
NS_INIT_REFCNT();
oid = _oid;
iid = _iid;
interfaceInfo = NULL;
}
RemoteObjectProxy::~RemoteObjectProxy() {
NS_IF_RELEASE(interfaceInfo);
}
NS_IMETHODIMP RemoteObjectProxy::GetInterfaceInfo(nsIInterfaceInfo** info) {
printf("--RemoteObjectProxy::GetInterfaceInfo\n");
if(!info) {
return NS_ERROR_FAILURE;
}
if (!interfaceInfo) {
nsIInterfaceInfoManager* iimgr;
if(iimgr = XPTI_GetInterfaceInfoManager()) {
if (NS_FAILED(iimgr->GetInfoForIID(&iid, &interfaceInfo))) {
printf("--RemoteObjectProxy::GetInterfaceInfo NS_ERROR_FAILURE 1 \n");
return NS_ERROR_FAILURE;
}
NS_RELEASE(iimgr);
} else {
printf("--RemoteObjectProxy::GetInterfaceInfo NS_ERROR_FAILURE 2 \n");
return NS_ERROR_FAILURE;
}
}
NS_ADDREF(interfaceInfo);
*info = interfaceInfo;
return NS_OK;
}
NS_IMETHODIMP RemoteObjectProxy::CallMethod(PRUint16 methodIndex,
const nsXPTMethodInfo* info,
nsXPTCMiniVariant* params) {
printf("--RemoteObjectProxy::CallMethod methodIndex %d\n", methodIndex);
RPCClientService * rpcService = RPCClientService::GetInstance();
IRPCall * call = NULL;
IRPCChannel *rpcChannel = NULL;
nsresult rv;
if (NS_FAILED(rv = rpcService->GetRPCChannel(&rpcChannel))) {
printf("--RemoteObjectProxy::CallMethod: failed to get channel\n");
return rv;
}
if (NS_FAILED(rv = rpcService->CreateRPCall(&call))) {
printf("--RemoteObjectProxy::CallMethod: failed to create call\n");
NS_IF_RELEASE(rpcChannel);
return rv;
}
if (NS_FAILED(rv = call->Marshal(iid,oid,methodIndex,info,params))) {
printf("--RemoteObjectProxy::CallMethod: failed marshal\n");
NS_IF_RELEASE(call);
NS_IF_RELEASE(rpcChannel);
return rv;
}
rv = rpcChannel->SendReceive(call);
NS_IF_RELEASE(call);
NS_IF_RELEASE(rpcChannel);
return rv;
}

53
xpcom/remote/client/RemoteObjectProxy.h
View File

@ -1,53 +0,0 @@
/* -*- 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):
*/
#ifndef __RemoteObjectProxy_h__
#define __RemoteObjectProxy_h__
#include "xptcall.h"
#include "nsISupports.h"
#include "IRPCChannel.h"
#include "rproxydefs.h"
// {59678963-A52B-11d3-837C-0004AC56C49E}
#define REMOTEOBJECTPROXY_IID \
{ 0x59678963, 0xa52b, 0x11d3, { 0x83, 0x7c, 0x0, 0x4, 0xac, 0x56, 0xc4, 0x9e } }
class RemoteObjectProxy : public nsXPTCStubBase {
public:
NS_DEFINE_STATIC_IID_ACCESSOR(REMOTEOBJECTPROXY_IID)
NS_DECL_ISUPPORTS
RemoteObjectProxy(OID oid, const nsIID &iid );
virtual ~RemoteObjectProxy();
NS_IMETHOD GetInterfaceInfo(nsIInterfaceInfo** info);
// call this method and return result
NS_IMETHOD CallMethod(PRUint16 methodIndex,
const nsXPTMethodInfo* info,
nsXPTCMiniVariant* params);
NS_IMETHOD GetOID(OID *_oid) { *_oid = oid; return NS_OK;}
private:
OID oid;
nsIID iid;
nsIInterfaceInfo * interfaceInfo;
};
#endif /* __RemoteObjectProxy_h__ */

61
xpcom/remote/common/IMarshalToolkit.h
View File

@ -1,61 +0,0 @@
/* -*- 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):
*/
#ifndef __IMarshalToolkit_h__
#define __IMarshalToolkit_h__
#include <iostream.h>
#include "nsISupports.h"
#include "xptcall.h"
#include "nsIAllocator.h"
class IMarshalToolkit : public nsISupports {
public:
/* nsXPTType::T_I8, nsXPTType::T_U8, nsXPTType::T_I16, nsXPTType::T_U16
* nsXPTType::T_I32, nsXPTType::T_U32, nsXPTType::T_I64, nsXPTType::T_U64,
* nsXPTType::T_FLOAT, nsXPTType::T_DOUBLE, nsXPTType::T_BOOL, nsXPTType::T_CHAR, nsXPTType::T_WCHAR,
*/
NS_IMETHOD ReadSimple(istream *in, nsXPTCMiniVariant *value,nsXPTType * type, PRBool isOut, nsIAllocator * allocator = NULL) = 0;
NS_IMETHOD WriteSimple(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut) = 0;
/* nsXPTType::T_IID
*/
NS_IMETHOD ReadIID(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIAllocator * allocator = NULL) = 0;
NS_IMETHOD WriteIID(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut) = 0;
/* case nsXPTType::T_CHAR_STR:
* case nsXPTType::T_WCHAR_STR:
* case nsXPTType::T_PSTRING_SIZE_IS:
* case nsXPTType::T_PWSTRING_SIZE_IS:
*/
NS_IMETHOD ReadString(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIAllocator * allocator = NULL) = 0;
NS_IMETHOD WriteString(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, PRInt32 size = -1) = 0;
/* nsXPTType::T_INTERFACE, nsXPTType::T_INTERFACE_IS
*/
NS_IMETHOD ReadInterface(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIID * iid = NULL,
nsIAllocator * allocator = NULL) = 0;
NS_IMETHOD WriteInterface(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIID * iid = NULL) = 0;
/* nsXPTType::T_ARRAY
*/
NS_IMETHOD ReadArray(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsXPTType * datumType, nsIAllocator * allocator = NULL) = 0;
NS_IMETHOD WriteArray(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsXPTType * datumType, PRUint32 size) = 0;
};
#endif /* __IMarshalToolkit_h__ */

179
xpcom/remote/common/IPCbridge.cpp
View File

@ -1,179 +0,0 @@
/* -*- 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):
*/
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <string.h>
#include "IPCbridge.h"
#define SERVER 1L
#define CLIENT 2L
const char * IPCBridge::PREFIX = "/tmp/.msg";
struct data_info {
long dataId;
size_t dataSize;
int dataBlock;
};
// constructor for both
IPCBridge::IPCBridge( const char* serverName)
{
if (serverName) {
fname = (char *)malloc(strlen(serverName) + strlen(PREFIX) + 1);
sprintf(fname,"%s%s",PREFIX,serverName);
initClient();
} else {
initServer();
}
}
// destructor
IPCBridge::~IPCBridge()
{
switch( this_side )
{
case SERVER:
// remove msg queue
msgctl(msg_handler, IPC_RMID, NULL);
// remove file
unlink(fname);
case CLIENT:
// free memory
free(fname);
break;
}
}
unsigned int IPCBridge::Read( void **data )
{
int status;
void *shmem;
struct data_info di;
/* read message about array */
status = msgrcv(msg_handler, &di, sizeof(struct data_info), other_side, IPC_NOWAIT);
if( status==-1 ) return 0;
/* attach shared memory block */
shmem = shmat(di.dataBlock, NULL, 0);
/* copy array to local memory */
*data = malloc(di.dataSize);
memcpy(*data, shmem, di.dataSize);
/* destroy shared memory block */
shmdt((char *)shmem);
status = shmctl(di.dataBlock, IPC_RMID, NULL);
/* return data */
return di.dataSize;
}
unsigned int IPCBridge::Write( unsigned int size, void *data )
{
int status;
int shm_handler;
void *shmem;
struct data_info di;
/* create and attach shared memory block */
shm_handler = shmget(IPC_PRIVATE, size, IPC_CREAT | 0600);
shmem = shmat(shm_handler, NULL, 0);
/* copy array from local memory */
memcpy(shmem, data, size);
shmdt((char *)shmem);
/* create and send message about array */
di.dataId = this_side;
di.dataSize = size;
di.dataBlock = shm_handler;
status = msgsnd(msg_handler, &di, sizeof(struct data_info), IPC_NOWAIT);
if( status==-1 )
{
shmctl(shm_handler, IPC_RMID, NULL);
return 0;
}
/* return */
return size;
}
int IPCBridge::initServer( void )
{
int status;
int fs;
/* create exchange file */
/* name is /tmp/.mgg<pid_in_hex_mode> */
fname = get_name(getpid());
fs = open(fname, O_RDWR | O_CREAT | O_TRUNC, 0600);
printf("--InitServer %s\n",fname);
/* create message queue */
msg_handler = msgget(IPC_PRIVATE, IPC_CREAT | 0600);
if (msg_handler < 0) {
printf("--IPCBridge::initServer failed. status\n");
perror(NULL);
}
this_side = SERVER;
other_side = CLIENT;
/* wrtie handler into exchange file */
status = write(fs, &msg_handler, sizeof(int));
close(fs);
return status;
}
int IPCBridge::initClient( void )
{
int status;
int fs;
/* create exchange filename */
/* name is /tmp/.msg<parent_pid_in_hex_mode> */
/* get message handler */
fs = open(fname,O_RDONLY);
status = read(fs,&msg_handler,sizeof(int));
this_side = CLIENT;
other_side = SERVER;
close(fs);
return status;
}
char *IPCBridge::get_name( pid_t pid )
{
char * p = (char *)malloc(100);
sprintf(p,"%s%x",PREFIX,pid);
printf("--get_name %s\n",p);
return p;
}

53
xpcom/remote/common/IPCbridge.h
View File

@ -1,53 +0,0 @@
/* -*- 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):
*/
#ifndef __IPCbridge_h__
#define __IPCbridge_h__
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
class IPCBridge {
public:
IPCBridge(const char* serverName = NULL);
~IPCBridge();
unsigned int Read( void** );
unsigned int Write( unsigned int, void* );
private:
const static char * PREFIX;
int msg_handler;
long this_side;
long other_side;
char *fname;
char *get_name( pid_t );
int initServer( void );
int initClient( void );
};
#endif /* __IPCbridge_h__ */

37
xpcom/remote/common/IRPCChannel.h
View File

@ -1,37 +0,0 @@
/* -*- 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):
*/
#ifndef __IRPCChannel_h__
#define __IRPCChannel_h__
#include "nsISupports.h"
#include "IRPCall.h"
// {59678951-A52B-11d3-837C-0004AC56C49E}
#define IRPCCHANNEL_IID \
{ 0x59678951, 0xa52b, 0x11d3, { 0x83, 0x7c, 0x0, 0x4, 0xac, 0x56, 0xc4, 0x9e } }
class IRPCChannel : public nsISupports {
public:
NS_DEFINE_STATIC_IID_ACCESSOR(IRPCCHANNEL_IID)
NS_IMETHOD SendReceive(IRPCall * call) = 0;
};
#endif /* __IRPCChannel_h__ */

45
xpcom/remote/common/IRPCall.h
View File

@ -1,45 +0,0 @@
/* -*- 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):
*/
#ifndef __IRPCall_h__
#define __IRPCall_h__
#include "nsISupports.h"
#include "xptcall.h"
#include "rproxydefs.h"
// {59678952-A52B-11d3-837C-0004AC56C49E}
#define IRPCALL_IID\
{ 0x59678952, 0xa52b, 0x11d3, { 0x83, 0x7c, 0x0, 0x4, 0xac, 0x56, 0xc4, 0x9e } }
class IRPCall : public nsISupports {
public:
NS_DEFINE_STATIC_IID_ACCESSOR(IRPCALL_IID)
NS_IMETHOD Marshal(const nsIID &iid, OID oid, PRUint16 methodIndex,
const nsXPTMethodInfo* info,
nsXPTCMiniVariant* params) = 0;
NS_IMETHOD Marshal() = 0;
NS_IMETHOD Demarshal(void * data, PRUint32 size) = 0;
NS_IMETHOD GetRawData(void ** data, PRUint32 *size) = 0;
//you should not free(params)
NS_IMETHOD GetXPTCData(OID *oid,PRUint32 *methodIndex,
PRUint32 *paramCount, nsXPTCVariant** params, nsresult **result) = 0;
};
#endif /* __IRPCall_h__ */

37
xpcom/remote/common/ITransport.h
View File

@ -1,37 +0,0 @@
/* -*- 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):
*/
#ifndef __ITransport_h__
#define __ITransport_h__
#include "nsISupports.h"
// {59678953-A52B-11d3-837C-0004AC56C49E}
#define ITRANSPORT_IID \
{ 0x59678953, 0xa52b, 0x11d3, { 0x83, 0x7c, 0x0, 0x4, 0xac, 0x56, 0xc4, 0x9e } }
class ITransport : public nsISupports {
public:
NS_DEFINE_STATIC_IID_ACCESSOR(ITRANSPORT_IID)
NS_IMETHOD Read(void** data, PRUint32 * size) = 0;
NS_IMETHOD Write(void* data, PRUint32 size) = 0;
};
#endif /* __ITransport_h__ */

55
xpcom/remote/common/Makefile.in
View File

@ -1,55 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../../..
topsrcdir = ../../..
srcdir = .
VPATH = .
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/config.mk
LIBRARY_NAME = rpccommon
EXPORT_LIBRARY = 1
MODULE = rpccommon
CPPSRCS = \
IPCbridge.cpp \
Queue.cpp \
TransportImpl.cpp \
MarshalToolkitImpl.cpp \
RPCallImpl.cpp \
$(NULL)
LIBS = \
-lxpcom \
-lxptinfo \
$(NSPR_LIBS) \
$(NULL)
include $(topsrcdir)/config/rules.mk

307
xpcom/remote/common/MarshalToolkitImpl.cpp
View File

@ -1,307 +0,0 @@
/* -*- 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):
*/
#include <stdlib.h>
#include <iostream.h>
#include "MarshalToolkitImpl.h"
NS_IMPL_ISUPPORTS0(MarshalToolkitImpl)
MarshalToolkitImpl::MarshalToolkitImpl(void) {
NS_INIT_REFCNT();
}
MarshalToolkitImpl::~MarshalToolkitImpl() {
}
PRInt16 MarshalToolkitImpl::GetSimpleSize(nsXPTType *type) {
PRInt16 size = -1;
switch(type->TagPart()) {
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:
break;
}
return size;
}
NS_IMETHODIMP MarshalToolkitImpl::ReadSimple(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIAllocator * allocator) {
PRInt16 size = GetSimpleSize(type);
if (size <= 0 ) {
return NS_ERROR_FAILURE;
}
void * data = NULL;
if (isOut) {
if (allocator) {
value->val.p = allocator->Alloc(size);
}
data = value->val.p;
} else {
data = value;
}
in->read((char*)data,size);
return NS_OK;
}
NS_IMETHODIMP MarshalToolkitImpl::WriteSimple(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut) {
PRInt16 size = GetSimpleSize(type);
if (size <= 0 ) {
return NS_ERROR_FAILURE;
}
void *data = (isOut)? value->val.p : value;
out->write((const char*)data,size);
return NS_OK;
}
NS_IMETHODIMP MarshalToolkitImpl::ReadIID(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIAllocator * allocator) {
void * data = malloc(sizeof(nsIID)); // nb I guess it is more convinient
if (isOut) {
if (allocator) {
value->val.p = allocator->Alloc(sizeof(void*));
}
memcpy(value->val.p,(void *)&data,sizeof(void*));
} else {
value->val.p = data;
}
in->read((char*)data,sizeof(nsIID));
return NS_OK;
}
NS_IMETHODIMP MarshalToolkitImpl::WriteIID(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut) {
void * data = NULL;
if (isOut) {
memcpy((void *)&data, value->val.p, sizeof(void*));
} else {
data = value->val.p;
}
out->write((const char*)data, sizeof(nsIID));
return NS_OK;
}
NS_IMETHODIMP MarshalToolkitImpl::ReadString(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut,
nsIAllocator * allocator) {
PRUint32 length;
void *data = NULL;
PRBool isStringWithSize = PR_FALSE;
in->read((char*)&length, sizeof(PRUint32)); //length 0 means NULL string
PRUint32 actualLength = 0;
if (length) {
switch (type->TagPart()) {
case nsXPTType::T_CHAR_STR:
case nsXPTType::T_WCHAR_STR:
actualLength = length;
break;
case nsXPTType::T_PSTRING_SIZE_IS:
case nsXPTType::T_PWSTRING_SIZE_IS:
isStringWithSize = PR_TRUE;
actualLength = length - 1 ; //length could not be less than 2. It is impossible to have empty ("") string for this case
break;
default:
return NS_ERROR_FAILURE;
};
data = malloc(actualLength);
}
if (isOut) {
if (allocator) {
value->val.p = allocator->Alloc(sizeof(void*));
}
memcpy(value->val.p,(void *)&data,sizeof(void*));
} else {
value->val.p = data;
}
if (length-1 > 0) {
in->read((char*)data,length-1);
}
if (!isStringWithSize
&& length) {
((char*)data)[length-1]=0;
}
return NS_OK;
}
NS_IMETHODIMP MarshalToolkitImpl::WriteString(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, PRInt32 size) {
void * data = NULL;
if (isOut) {
memcpy((void *)&data, value->val.p, sizeof(void*));
} else {
data = value->val.p;
}
PRUint32 length = 0;
if (!data) {
out->write((const char*)&length,sizeof(PRUint32));
return NS_OK;
}
switch (type->TagPart()) {
case nsXPTType::T_CHAR_STR:
case nsXPTType::T_WCHAR_STR:
length = strlen((char*)data);
break;
case nsXPTType::T_PSTRING_SIZE_IS:
case nsXPTType::T_PWSTRING_SIZE_IS:
length = size;
break;
default:
return NS_ERROR_FAILURE;
};
length++; //0 for NULL, 1 for "", etc.
out->write((const char*)&length,sizeof(PRUint32));
out->write((const char*)data, length-1);
return NS_OK;
}
NS_IMETHODIMP MarshalToolkitImpl::ReadInterface(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIID * iid,
nsIAllocator * allocator) {
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP MarshalToolkitImpl::WriteInterface(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIID * iid) {
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP MarshalToolkitImpl::ReadArray(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsXPTType * datumType, nsIAllocator * allocator) {
PRUint32 length;
in->read((char*)&length,sizeof(PRUint32));
PRInt16 elemSize = GetSimpleSize(datumType);
if(elemSize<0) { //not simple
elemSize = sizeof(void*); //it has to be a pointer
}
void * data = malloc(elemSize*length);
if (isOut) {
if (allocator) {
value->val.p = allocator->Alloc(sizeof(void*));
}
memcpy(value->val.p,(void *)&data,sizeof(void*));
} else {
value->val.p = data;
}
char *current = (char*)data;
nsIID iid;
for (int i = 0; i < length;i++) {
switch(datumType->TagPart()) {
case nsXPTType::T_I8 :
case nsXPTType::T_I16 :
case nsXPTType::T_I32 :
case nsXPTType::T_I64 :
case nsXPTType::T_U8 :
case nsXPTType::T_U16 :
case nsXPTType::T_U32 :
case nsXPTType::T_U64 :
case nsXPTType::T_FLOAT :
case nsXPTType::T_DOUBLE :
case nsXPTType::T_BOOL :
case nsXPTType::T_CHAR :
case nsXPTType::T_WCHAR :
ReadSimple(in,(nsXPTCMiniVariant*)current,datumType,PR_FALSE,allocator);
break;
case nsXPTType::T_IID :
ReadIID(in,(nsXPTCMiniVariant*)current,datumType,PR_FALSE,allocator);
break;
case nsXPTType::T_CHAR_STR :
case nsXPTType::T_WCHAR_STR :
ReadString(in,(nsXPTCMiniVariant*)current,datumType,PR_FALSE,allocator);
break;
case nsXPTType::T_INTERFACE : //nb
break;
default:
return NS_ERROR_FAILURE;
}
current += elemSize;
}
return NS_OK;
}
NS_IMETHODIMP MarshalToolkitImpl::WriteArray(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsXPTType * datumType, PRUint32 length) {
PRInt16 elemSize = GetSimpleSize(datumType);
if(elemSize < 0) { //not simple
elemSize = sizeof(void*); //it has to be a pointer
}
char *current = NULL;
if (isOut) {
memcpy(&current,value->val.p,sizeof(void*));
} else {
current = (char*)value->val.p;
}
out->write((char*)&length,sizeof(PRUint32));
for (int i = 0; i < length;i++) {
switch(datumType->TagPart()) {
case nsXPTType::T_I8 :
case nsXPTType::T_I16 :
case nsXPTType::T_I32 :
case nsXPTType::T_I64 :
case nsXPTType::T_U8 :
case nsXPTType::T_U16 :
case nsXPTType::T_U32 :
case nsXPTType::T_U64 :
case nsXPTType::T_FLOAT :
case nsXPTType::T_DOUBLE :
case nsXPTType::T_BOOL :
case nsXPTType::T_CHAR :
case nsXPTType::T_WCHAR :
WriteSimple(out,(nsXPTCMiniVariant*)current,datumType,PR_FALSE);
break;
case nsXPTType::T_IID :
WriteIID(out,(nsXPTCMiniVariant*)current,datumType,PR_FALSE);
break;
case nsXPTType::T_CHAR_STR :
case nsXPTType::T_WCHAR_STR :
WriteString(out,(nsXPTCMiniVariant*)current,datumType,PR_FALSE);
break;
case nsXPTType::T_INTERFACE : //nb
break;
default:
return NS_ERROR_FAILURE;
}
current += elemSize;
}
return NS_OK;
}

82
xpcom/remote/common/MarshalToolkitImpl.h
View File

@ -1,82 +0,0 @@
/* -*- 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):
*/
#ifndef __MarshalToolkitImpl_h__
#define __MarshalToolkitImpl_h__
#include "nsISupports.h"
#include "xptcall.h"
#include "IMarshalToolkit.h"
class MarshalToolkitImpl : public IMarshalToolkit {
NS_DECL_ISUPPORTS
/* nsXPTType::T_I8, nsXPTType::T_U8, nsXPTType::T_I16, nsXPTType::T_U16
* nsXPTType::T_I32, nsXPTType::T_U32, nsXPTType::T_I64, nsXPTType::T_U64,
* nsXPTType::T_FLOAT, nsXPTType::T_DOUBLE, nsXPTType::T_BOOL, nsXPTType::T_CHAR, nsXPTType::T_WCHAR,
*/
NS_IMETHOD ReadSimple(istream *in, nsXPTCMiniVariant *value,nsXPTType * type, PRBool isOut, nsIAllocator * allocator = NULL);
NS_IMETHOD WriteSimple(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut);
/* nsXPTType::T_IID
*/
NS_IMETHOD ReadIID(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIAllocator * allocator = NULL);
NS_IMETHOD WriteIID(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut);
/* case nsXPTType::T_CHAR_STR:
* case nsXPTType::T_WCHAR_STR:
* case nsXPTType::T_PSTRING_SIZE_IS:
* case nsXPTType::T_PWSTRING_SIZE_IS:
*/
NS_IMETHOD ReadString(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIAllocator * allocator = NULL);
NS_IMETHOD WriteString(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, PRInt32 size = -1);
/* nsXPTType::T_INTERFACE, nsXPTType::T_INTERFACE_IS
*/
NS_IMETHOD ReadInterface(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIID * iid = NULL,
nsIAllocator * allocator = NULL);
NS_IMETHOD WriteInterface(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsIID * iid = NULL);
/* nsXPTType::T_ARRAY
*/
NS_IMETHOD ReadArray(istream *in, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsXPTType * datumType, nsIAllocator * allocator = NULL);
NS_IMETHOD WriteArray(ostream *out, nsXPTCMiniVariant *value, nsXPTType * type, PRBool isOut, nsXPTType * datumType, PRUint32 size);
MarshalToolkitImpl(void);
virtual ~MarshalToolkitImpl();
private:
PRInt16 GetSimpleSize(nsXPTType *type);
};
#endif /* __MarshalToolkitImpl_h__ */

89
xpcom/remote/common/Queue.cpp
View File

@ -1,89 +0,0 @@
/* -*- 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):
*/
#include "Queue.h"
struct QueueEntry {
void * ptr;
QueueEntry *next;
QueueEntry *prev;
QueueEntry(void* _ptr) {
next = prev = NULL;
ptr = _ptr;
}
};
Queue::Queue() {
m_head = NULL;
m_tail = NULL;
m_lock = PR_NewLock();
}
Queue::~Queue() {
while (Get())
;
PR_DestroyLock(m_lock);
}
nsresult Queue::Put(void *ptr) {
PR_Lock(m_lock);
QueueEntry* p = new QueueEntry(ptr);
if (!m_tail) {
m_tail = new QueueEntry(ptr);
}
else {
m_tail->next = new QueueEntry(ptr);
m_tail->next->prev = m_tail;
m_tail = m_tail->next;
}
if (!m_head)
m_head = m_tail;
PR_Unlock(m_lock);
return NS_OK;
}
void * Queue::Get() {
void *res;
PR_Lock(m_lock);
if (!m_head) {
m_tail = NULL;
PR_Unlock(m_lock);
return NULL;
}
QueueEntry* excluded;
excluded = m_head;
if (m_head->next)
m_head = m_head->next, m_head->prev = NULL;
else
m_head = m_tail = NULL;
res = excluded->ptr;
delete excluded;
PR_Unlock(m_lock);
return res;
}

40
xpcom/remote/common/Queue.h
View File

@ -1,40 +0,0 @@
/* -*- 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):
*/
#ifndef __Queue_h__
#define __Queue_h__
#include "nspr.h"
#include "nsError.h"
class QueueEntry;
class Queue {
public:
Queue();
~Queue();
void * Get();
nsresult Put(void *);
private:
QueueEntry * m_head;
QueueEntry * m_tail;
PRLock * m_lock;
};
#endif /* __Queue_h__ */

329
xpcom/remote/common/RPCallImpl.cpp
View File

@ -1,329 +0,0 @@
/* -*- 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):
*/
#include <stdlib.h>
#include <strstream.h>
#include "RPCallImpl.h"
#include "prmem.h"
#include "nsIInterfaceInfoManager.h"
#include "nsIInterfaceInfo.h"
NS_IMPL_ISUPPORTS1(RPCallImpl, IRPCall)
RPCallImpl::RPCallImpl(IMarshalToolkit * _marshalToolkit) {
NS_INIT_REFCNT();
params = NULL;
info = NULL;
oid = 0;
bundle = NULL;
size = 0;
callSide = unDefined;
interfaceInfo = NULL;
result = NS_ERROR_FAILURE;
marshalToolkit = _marshalToolkit;
}
RPCallImpl::~RPCallImpl() {
if (params) {
free(params);
}
if (bundle) {
free(bundle);
}
NS_IF_RELEASE(interfaceInfo);
}
NS_IMETHODIMP RPCallImpl::Marshal(const nsIID &_iid, OID _oid, PRUint16 _methodIndex,
const nsXPTMethodInfo* _info,
nsXPTCMiniVariant* _params) {
if (callSide == unDefined) {
callSide = onClient;
}
iid = _iid;
oid = _oid;
nsIInterfaceInfoManager *iimgr = NULL;
iimgr = XPTI_GetInterfaceInfoManager();
if (!iimgr) {
return NS_ERROR_FAILURE; //nb how are we going to handle critical errors?
}
if (NS_FAILED(iimgr->GetInfoForIID(&iid, &interfaceInfo))) {
NS_IF_RELEASE(iimgr);
printf("--RemoteObjectProxy::GetInterfaceInfo NS_ERROR_FAILURE 1 \n");
return NS_ERROR_FAILURE;
}
NS_IF_RELEASE(iimgr);
methodIndex = _methodIndex;
info = (nsXPTMethodInfo*) _info;
paramCount = info->GetParamCount();
if (paramCount > 0) {
params = (nsXPTCVariant*)malloc(sizeof(nsXPTCVariant) * paramCount);
if (params == nsnull) {
return NS_ERROR_OUT_OF_MEMORY;
}
for (int i = 0; i < paramCount; i++) {
(params)[i].Init(_params[i], info->GetParam(i).GetType());
if (info->GetParam(i).IsOut()) {
params[i].flags |= nsXPTCVariant::PTR_IS_DATA;
params[i].ptr = params[i].val.p = _params[i].val.p;
}
}
}
return Marshal();
}
NS_IMETHODIMP RPCallImpl::Marshal(void) {
ostrstream out;
if (callSide == onClient) {
out.write((const char *)&iid, sizeof(nsIID));
out.write((const char *)&oid, sizeof(OID));
out.write((const char *)&methodIndex, sizeof(PRUint16));
}
for (int i = 0; i < paramCount; i++) {
nsXPTParamInfo param = info->GetParam(i);
nsXPTType type = param.GetType();
PRBool isOut = param.IsOut();
if ((callSide == onClient && !param.IsIn())
|| (callSide == onServer && !param.IsOut())) {
continue;
}
nsXPTCVariant *value = & params[i];
switch(type.TagPart()) {
case nsXPTType::T_I8 :
case nsXPTType::T_I16 :
case nsXPTType::T_I32 :
case nsXPTType::T_I64 :
case nsXPTType::T_U8 :
case nsXPTType::T_U16 :
case nsXPTType::T_U32 :
case nsXPTType::T_U64 :
case nsXPTType::T_FLOAT :
case nsXPTType::T_DOUBLE :
case nsXPTType::T_BOOL :
case nsXPTType::T_CHAR :
case nsXPTType::T_WCHAR :
marshalToolkit->WriteSimple(&out,value,&type,isOut);
break;
case nsXPTType::T_IID :
marshalToolkit->WriteIID(&out,value,&type,isOut);
break;
case nsXPTType::T_CHAR_STR :
case nsXPTType::T_WCHAR_STR :
marshalToolkit->WriteString(&out,value,&type,isOut);
break;
case nsXPTType::T_INTERFACE :
case nsXPTType::T_INTERFACE_IS :
marshalToolkit->WriteInterface(&out,value,&type,isOut,NULL);
break;
case nsXPTType::T_PSTRING_SIZE_IS:
case nsXPTType::T_PWSTRING_SIZE_IS:
case nsXPTType::T_ARRAY:
{
PRUint32 arraySize;
if(!GetArraySizeFromParam(interfaceInfo,info,param,methodIndex,i,params,GET_LENGTH, &arraySize)) {
return NS_ERROR_FAILURE;
}
if (type.TagPart() == nsXPTType::T_ARRAY) {
nsXPTType datumType;
if(NS_FAILED(interfaceInfo->GetTypeForParam(methodIndex, &param, 1,&datumType))) {
return NS_ERROR_FAILURE;
}
marshalToolkit->WriteArray(&out,value,&type,isOut,&datumType,arraySize);
} else {
marshalToolkit->WriteString(&out,value,&type,isOut, arraySize);
}
break;
}
default:
return NS_ERROR_FAILURE;
}
}
if (callSide == onServer) {
out.write((const char*)&result,sizeof(nsresult));
}
size = out.pcount();
bundle = malloc(size);
memcpy(bundle,out.str(),size);
return NS_OK;
}
NS_IMETHODIMP RPCallImpl::Demarshal(void * data, PRUint32 _size) {
if(callSide == unDefined) {
callSide = onServer;
}
istrstream in((const char*)data,_size);
nsIAllocator * allocator = NULL;
if (callSide == onServer) {
in.read((char*)&iid,sizeof(nsIID));
in.read((char*)&oid,sizeof(OID));
in.read((char*)&methodIndex,sizeof(PRUint16));
nsIInterfaceInfoManager *iimgr = NULL;
iimgr = XPTI_GetInterfaceInfoManager();
if (!iimgr) {
return NS_ERROR_FAILURE; //nb how are we going to handle critical errors?
}
if (NS_FAILED(iimgr->GetInfoForIID(&iid, &interfaceInfo))) {
NS_IF_RELEASE(iimgr);
printf("--RemoteObjectProxy::GetInterfaceInfo NS_ERROR_FAILURE 1 \n");
return NS_ERROR_FAILURE;
}
NS_IF_RELEASE(iimgr);
interfaceInfo->GetMethodInfo(methodIndex,(const nsXPTMethodInfo**)&info);
paramCount = info->GetParamCount();
if (paramCount > 0) {
params = (nsXPTCVariant*)malloc(sizeof(nsXPTCVariant) * paramCount);
if (params == nsnull) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
allocator = nsAllocator::GetGlobalAllocator();
}
for (int i = 0; i < paramCount; i++) {
nsXPTParamInfo param = info->GetParam(i);
PRBool isOut = param.IsOut();
nsXPTCMiniVariant tmpValue = params[i]; //we need to set value for client side
nsXPTCMiniVariant * value;
value = &tmpValue;
nsXPTType type = param.GetType();
if ( (callSide == onServer && !param.IsIn()
|| (callSide == onClient && !param.IsOut()))){
if (callSide == onServer) { //we need to allocate memory for out parametr
value->val.p = allocator->Alloc(sizeof(nsXPTCMiniVariant)); // sizeof(nsXPTCMiniVariant) is good
params[i].Init(*value,type);
params[i].ptr = params[i].val.p = value->val.p;
params[i].flags |= nsXPTCVariant::PTR_IS_DATA;
}
continue;
}
switch(type.TagPart()) {
case nsXPTType::T_I8 :
case nsXPTType::T_I16 :
case nsXPTType::T_I32 :
case nsXPTType::T_I64 :
case nsXPTType::T_U8 :
case nsXPTType::T_U16 :
case nsXPTType::T_U32 :
case nsXPTType::T_U64 :
case nsXPTType::T_FLOAT :
case nsXPTType::T_DOUBLE :
case nsXPTType::T_BOOL :
case nsXPTType::T_CHAR :
case nsXPTType::T_WCHAR :
marshalToolkit->ReadSimple(&in,value,&type,isOut,allocator);
break;
case nsXPTType::T_IID :
marshalToolkit->ReadIID(&in,value,&type,isOut,allocator);
break;
case nsXPTType::T_PSTRING_SIZE_IS:
case nsXPTType::T_PWSTRING_SIZE_IS:
case nsXPTType::T_CHAR_STR :
case nsXPTType::T_WCHAR_STR :
marshalToolkit->ReadString(&in,value,&type,isOut,allocator);
break;
case nsXPTType::T_INTERFACE :
case nsXPTType::T_INTERFACE_IS :
marshalToolkit->ReadInterface(&in,value,&type,isOut,NULL,allocator);
break;
case nsXPTType::T_ARRAY:
{
nsXPTType datumType;
if(NS_FAILED(interfaceInfo->GetTypeForParam(methodIndex, &param, 1,&datumType))) {
return NS_ERROR_FAILURE;
}
marshalToolkit->ReadArray(&in,value,&type,isOut,&datumType,allocator);
break;
}
default:
return NS_ERROR_FAILURE;
}
params[i].Init(*value,type);
if (isOut) {
params[i].flags |= nsXPTCVariant::PTR_IS_DATA;
params[i].ptr = params[i].val.p = value->val.p;
}
}
return NS_OK;
}
NS_IMETHODIMP RPCallImpl::GetRawData(void ** data, PRUint32 * _size) {
if (!bundle) {
return NS_ERROR_NULL_POINTER;
}
*data = malloc(size);
*_size = size;
memcpy(*data,bundle,size);
return NS_OK;
}
//you should not free(params)
NS_IMETHODIMP RPCallImpl::GetXPTCData(OID * _oid,PRUint32 *_methodIndex,
PRUint32 *_paramCount, nsXPTCVariant** _params, nsresult ** _result) {
*_oid = oid;
*_methodIndex = methodIndex;
*_paramCount = paramCount;
*_params = params;
*_result = &result;
return NS_OK;
}
PRBool RPCallImpl::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, &param, 0, &argnum);
} else {
rv = interfaceInfo->GetLengthIsArgNumberForParam(methodIndex, &param, 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;
}

68
xpcom/remote/common/RPCallImpl.h
View File

@ -1,68 +0,0 @@
/* -*- 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):
*/
#ifndef __RPCallImpl_h__
#define __RPCallImpl_h__
#include "IRPCall.h"
#include "IMarshalToolkit.h"
class ostream;
class istream;
class nsIInterfaceInfo;
class RPCallImpl : public IRPCall {
public:
NS_DECL_ISUPPORTS
NS_IMETHOD Marshal(const nsIID &iid, OID oid, PRUint16 methodIndex,
const nsXPTMethodInfo* info,
nsXPTCMiniVariant* params);
NS_IMETHOD Marshal(void);
NS_IMETHOD Demarshal(void * data, PRUint32 size);
NS_IMETHOD GetRawData(void ** data, PRUint32 *size);
//you should not free(params)
NS_IMETHOD GetXPTCData(OID *oid,PRUint32 *methodIndex,
PRUint32 *paramCount, nsXPTCVariant** params, nsresult **result);
RPCallImpl(IMarshalToolkit * _marshalToolkit);
virtual ~RPCallImpl();
protected:
enum { unDefined, onServer, onClient } callSide;
enum SizeMode { GET_SIZE, GET_LENGTH } ;
nsIID iid;
OID oid;
PRUint16 methodIndex;
nsXPTMethodInfo* info;
nsXPTCVariant *params;
PRUint32 paramCount;
nsIInterfaceInfo * interfaceInfo;
void *bundle;
PRUint32 size;
nsresult result;
IMarshalToolkit * marshalToolkit;
static PRBool GetArraySizeFromParam( nsIInterfaceInfo *interfaceInfo,
const nsXPTMethodInfo* method,
const nsXPTParamInfo& param,
uint16 methodIndex,
uint8 paramIndex,
nsXPTCVariant* nativeParams,
SizeMode mode,
PRUint32* result);
};
#endif /* __RPCallImpl_h__ */

59
xpcom/remote/common/TransportImpl.cpp
View File

@ -1,59 +0,0 @@
/* -*- 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):
*/
#include "TransportImpl.h"
NS_IMPL_ISUPPORTS1(TransportImpl, ITransport)
NS_IMETHODIMP TransportImpl::Read(void** data, PRUint32 * size) {
if(!bridge) {
return NS_ERROR_FAILURE;
}
*size = bridge->Read(data);
if (*size > 0) {
printf("--TransportImpl::Read size %d\n",*size);
}
return (*size > 0 ) ? NS_OK : NS_ERROR_FAILURE;
}
NS_IMETHODIMP TransportImpl::Write(void* data, PRUint32 size) {
if(!bridge) {
return NS_ERROR_FAILURE;
}
if (!bridge->Write(size,data)) {
return NS_ERROR_FAILURE;
}
printf("--TransportImpl::Write size %d\n",size);
return NS_OK;
}
TransportImpl::TransportImpl(const char* serverName) {
NS_INIT_REFCNT();
bridge = new IPCBridge(serverName);
}
TransportImpl::~TransportImpl() {
if (bridge) {
delete bridge;
}
}

36
xpcom/remote/common/TransportImpl.h
View File

@ -1,36 +0,0 @@
/* -*- 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):
*/
#ifndef __TransportImpl_h__
#define __TransportImpl_h__
#include "ITransport.h"
#include "IPCbridge.h"
class TransportImpl : public ITransport {
NS_DECL_ISUPPORTS
NS_IMETHOD Read(void** data, PRUint32 * size);
NS_IMETHOD Write(void* data, PRUint32 size);
TransportImpl(const char* serverName = NULL);
virtual ~TransportImpl();
protected:
IPCBridge * bridge; //nb temporary
};
#endif /* __TransportImpl_h__ */

27
xpcom/remote/common/rproxydefs.h
View File

@ -1,27 +0,0 @@
/* -*- 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):
*/
#ifndef __rproxydefs_h__
#define __rproxydefs_h__
#include "prtypes.h"
typedef PRInt32 OID;
#endif /* __rproxydefs_h__ */

173
xpcom/remote/server/DispatcherImpl.cpp
View File

@ -1,173 +0,0 @@
/* -*- 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):
*/
#include "DispatcherImpl.h"
#include "RPCServerService.h"
#include "IRPCChannel.h"
#include "xptcall.h"
class ObjectDescription {
public:
nsISupports* p;
OID oid;
public:
ObjectDescription(nsISupports *_p, OID _oid) {
p = _p; oid = _oid;
}
~ObjectDescription() {
}
};
NS_IMPL_ISUPPORTS1(DispatcherImpl, IDispatcher)
DispatcherImpl::DispatcherImpl()
: m_objects(NULL), m_currentOID(0)
{
NS_INIT_REFCNT();
}
DispatcherImpl::~DispatcherImpl() {
PRUint32 size = m_objects->GetSize();
for (PRUint32 i = 0; i < size; i++) {
ObjectDescription* obj = (ObjectDescription*)(*m_objects)[i];
delete obj;
}
delete m_objects;
}
NS_IMETHODIMP DispatcherImpl::Dispatch(IRPCall *call) {
RPCServerService * rpcService = RPCServerService::GetInstance();
IRPCChannel *channel = NULL;
OID oid;
PRUint32 methodIndex;
PRUint32 paramCount;
nsXPTCVariant* params;
nsresult *result;
call->GetXPTCData(&oid,&methodIndex, &paramCount, &params, &result);
nsISupports * p = NULL;
OIDToPointer(&p,oid);
*result = XPTC_InvokeByIndex(p, methodIndex,
paramCount, params);
call->Marshal();
rpcService->GetRPCChannel(&channel);
channel->SendReceive(call);
return NS_OK;
}
NS_IMETHODIMP DispatcherImpl::OIDToPointer(nsISupports **_p,OID _oid) {
PRUint32 size = m_objects->GetSize();
PRUint32 i;
ObjectDescription* desc;
for (i = 0; i < size; i++) {
desc = (ObjectDescription*)(*m_objects)[i];
if (desc->oid == _oid) {
*_p = desc->p;
return NS_OK;
}
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP DispatcherImpl:: PointerToOID(OID *_oid, nsISupports *_p) {
PRUint32 size = m_objects->GetSize();
PRUint32 i;
ObjectDescription* desc;
for (i = 0; i < size; i++) {
desc = (ObjectDescription*)(*m_objects)[i];
if (desc->p == _p) {
*_oid = desc->oid;
return NS_OK;
}
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP DispatcherImpl::RegisterWithOID(nsISupports *_p, OID _oid) {
if (_p == NULL)
return NS_OK;
if (m_objects == NULL) {
m_objects = new nsVector();
if (m_objects == NULL)
return NS_ERROR_OUT_OF_MEMORY;
}
ObjectDescription* desc = new ObjectDescription(_p, _oid);
PRUint32 size = m_objects->GetSize();
PRUint32 i, rv;
rv = -1;
for (i = 0; i < size; i++) {
if ((*m_objects)[i] == NULL) {
fprintf(stderr, "Adding %p to index %d\n", desc, i);
(*m_objects)[i] = desc, rv = i;
break;
}
}
if (i >= size) {
fprintf(stderr, "Adding %p to the end\n", desc);
rv = m_objects->Add(desc);
}
return rv == -1 ? NS_ERROR_FAILURE : NS_OK;
}
NS_IMETHODIMP DispatcherImpl::UnregisterWithOID(nsISupports *_p, OID _oid) {
if (_p == NULL)
return NS_OK;
PRUint32 size = m_objects->GetSize();
PRUint32 i, rv;
rv = -1;
for (i = 0; i < size; i++) {
ObjectDescription* desc = (ObjectDescription*)(*m_objects)[i];
if (desc == NULL) continue;
if (desc->oid == _oid) {
// this is kind of security measure :)
if (desc->p == _p) {
delete desc;
(*m_objects)[i] = NULL;
return NS_OK;
}
return NS_ERROR_FAILURE;
}
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP DispatcherImpl::GetOID(OID *_oid) {
*_oid = --m_currentOID;
return NS_OK;
}

47
xpcom/remote/server/DispatcherImpl.h
View File

@ -1,47 +0,0 @@
/* -*- 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):
*/
#ifndef __DispatcherImpl_h__
#define __DispatcherImpl_h__
#include "nsISupports.h"
#include "IRPCall.h"
#include "IDispatcher.h"
#include "rproxydefs.h"
#include "nsVector.h"
class DispatcherImpl : public IDispatcher {
public :
NS_DECL_ISUPPORTS
NS_IMETHOD Dispatch(IRPCall *call);
NS_IMETHOD OIDToPointer(nsISupports **p,OID oid);
NS_IMETHOD PointerToOID(OID *oid, nsISupports *p);
NS_IMETHOD RegisterWithOID(nsISupports *p, OID oid);
NS_IMETHOD UnregisterWithOID(nsISupports *p, OID oid);
NS_IMETHOD GetOID(OID *oid);
DispatcherImpl();
virtual ~DispatcherImpl();
private:
nsVector* m_objects; // vector of registred objects
OID m_currentOID;
};
#endif /* __DispatcherImpl_h__ */

42
xpcom/remote/server/IDispatcher.h
View File

@ -1,42 +0,0 @@
/* -*- 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):
*/
#ifndef __IDispatcher_h__
#define __IDispatcher_h__
#include "nsISupports.h"
#include "IRPCall.h"
#include "rproxydefs.h"
// {59678955-A52B-11d3-837C-0004AC56C49E}
#define IDISPATCHER_IID \
{ 0x59678955, 0xa52b, 0x11d3, { 0x83, 0x7c, 0x0, 0x4, 0xac, 0x56, 0xc4, 0x9e } }
class IDispatcher : public nsISupports {
public :
NS_DEFINE_STATIC_IID_ACCESSOR(IDISPATCHER_IID)
NS_IMETHOD Dispatch(IRPCall *call) = 0;
NS_IMETHOD OIDToPointer(nsISupports **p,OID oid) = 0;
NS_IMETHOD PointerToOID(OID *oid, nsISupports *p) = 0;
NS_IMETHOD RegisterWithOID(nsISupports *p, OID oid) = 0;
NS_IMETHOD UnregisterWithOID(nsISupports *p, OID oid) = 0;
NS_IMETHOD GetOID(OID *oid) = 0;
};
#endif /* __IDispatcher_h__ */

56
xpcom/remote/server/Makefile.in
View File

@ -1,56 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../../..
topsrcdir = ../../..
srcdir = .
VPATH = .
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/config.mk
LIBRARY_NAME = rpcserver
EXPORT_LIBRARY = 1
MODULE = rpcserver
CPPSRCS = \
DispatcherImpl.cpp \
RPCChannelServerImpl.cpp\
RPCServerService.cpp \
$(NULL)
INCLUDES += -I../common/
LIBS = \
-lxpcom \
-lxptinfo \
$(NSPR_LIBS) \
$(NULL)
include $(topsrcdir)/config/rules.mk

119
xpcom/remote/server/RPCChannelServerImpl.cpp
View File

@ -1,119 +0,0 @@
/* -*- 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):
*/
#include "nsISupports.h"
#include "RPCChannelServerImpl.h"
#include "nsIThread.h"
#include "nsIRunnable.h"
#include "RPCServerService.h"
#include "Queue.h"
#include "IDispatcher.h"
class RPCChannelRunner : public nsIRunnable {
public:
NS_DECL_ISUPPORTS
NS_IMETHOD Run() {
while(1) { //nb
rpcChannel->SendReceive(NULL);
PR_Sleep(100);
}
return NS_OK;
}
RPCChannelRunner(IRPCChannel *_rpcChannel) {
NS_INIT_REFCNT();
rpcChannel = _rpcChannel;
NS_ADDREF(rpcChannel);
}
virtual ~RPCChannelRunner() {
NS_IF_RELEASE(rpcChannel);
}
private:
IRPCChannel * rpcChannel;
};
NS_IMPL_ISUPPORTS1(RPCChannelRunner, nsIRunnable)
NS_IMPL_ISUPPORTS1(RPCChannelServerImpl, IRPCChannel)
RPCChannelServerImpl::RPCChannelServerImpl(ITransport * _transport) {
NS_INIT_REFCNT();
transport = _transport;
queue = new Queue();
rawData = NULL;
dispatcher = NULL;
service = NULL;
NS_NewThread(&thread,new RPCChannelRunner(this));
}
RPCChannelServerImpl::~RPCChannelServerImpl() {
NS_IF_RELEASE(dispatcher);
NS_IF_RELEASE(thread);
NS_IF_RELEASE(transport);
}
NS_IMETHODIMP RPCChannelServerImpl::SendReceive(IRPCall * call) {
if (call) {
queue->Put(call);
} else {
if (!rawData) {
IRPCall * call = (IRPCall*) queue->Get();
if (call) {
call->GetRawData(&rawData,&size);
NS_RELEASE(call);
}
}
if (rawData) {
if (NS_SUCCEEDED(transport->Write(rawData,size))) {
PR_Free(rawData);
rawData = NULL;
}
}
char *data;
PRUint32 s;
if (NS_SUCCEEDED(transport->Read((void**)&data,&s))) {
IRPCall *call = NULL;
if (!service) {
service = RPCServerService::GetInstance();
}
service->CreateRPCall(&call);
call->Demarshal(data,s); //nb error handling
PR_Free(data);
if (!dispatcher) {
service->GetDispatcher(&dispatcher);
}
dispatcher->Dispatch(call);
}
}
return NS_OK;
}

48
xpcom/remote/server/RPCChannelServerImpl.h
View File

@ -1,48 +0,0 @@
/* -*- 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):
*/
#ifndef __RPCChannelServerImpl_h__
#define __RPCChannelServerImpl_h__
#include "IRPCChannel.h"
#include "ITransport.h"
#include "IRPCall.h"
class nsIThread;
class Queue;
class IDispatcher;
class RPCServerService;
class RPCChannelServerImpl : public IRPCChannel {
public:
RPCChannelServerImpl(ITransport *transport);
virtual ~RPCChannelServerImpl(void);
NS_DECL_ISUPPORTS
NS_IMETHOD SendReceive(IRPCall * call);
private:
nsIThread * thread;
ITransport *transport;
IDispatcher *dispatcher;
Queue * queue;
RPCServerService *service;
void * rawData;
PRUint32 size;
};
#endif __RPCChannelServerImpl_h__

108
xpcom/remote/server/RPCServerService.cpp
View File

@ -1,108 +0,0 @@
/* -*- 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):
*/
#include "RPCServerService.h"
#include "RPCallImpl.h"
#include "TransportImpl.h"
#include "DispatcherImpl.h"
#include "RPCChannelServerImpl.h"
#include "MarshalToolkitImpl.h"
static IMarshalToolkit * marshalToolkit = new MarshalToolkitImpl();
RPCServerService * RPCServerService::instance = NULL;
RPCServerService * RPCServerService::GetInstance() {
if (!instance) {
instance = new RPCServerService();
}
return instance;
}
NS_IMETHODIMP RPCServerService::CreateRPCall(IRPCall **result) {
if (!result) {
return NS_ERROR_NULL_POINTER;
}
*result = new RPCallImpl(marshalToolkit);
NS_ADDREF(*result);
return NS_OK;
}
NS_IMETHODIMP RPCServerService::GetTransport(ITransport **result) {
if (!result) {
return NS_ERROR_NULL_POINTER;
}
if (!transport) {
transport = new TransportImpl();
if (!transport) {
return NS_ERROR_FAILURE;
}
}
NS_ADDREF(transport);
*result = transport;
return NS_OK;
}
NS_IMETHODIMP RPCServerService::GetDispatcher(IDispatcher **result) {
if (!result) {
return NS_ERROR_NULL_POINTER;
}
if (!dispatcher) {
dispatcher = new DispatcherImpl();
if (!dispatcher) {
return NS_ERROR_FAILURE;
}
}
NS_ADDREF(dispatcher);
*result = dispatcher;
return NS_OK;
}
NS_IMETHODIMP RPCServerService::GetRPCChannel(IRPCChannel **result) {
nsresult rv = NS_OK;
if (!result) {
return NS_ERROR_NULL_POINTER;
}
if (!rpcChannel) {
ITransport * _transport = NULL;
if (NS_FAILED(rv = GetTransport(&_transport))) {
return rv;
}
rpcChannel = new RPCChannelServerImpl(_transport);
if (!rpcChannel) {
return NS_ERROR_FAILURE;
}
}
NS_ADDREF(rpcChannel);
*result = rpcChannel;
return NS_OK;
}
RPCServerService::RPCServerService() {
transport = NULL;
dispatcher = NULL;
GetRPCChannel(&rpcChannel);
}
RPCServerService::~RPCServerService() {
NS_IF_RELEASE(rpcChannel);
}

46
xpcom/remote/server/RPCServerService.h
View File

@ -1,46 +0,0 @@
/* -*- 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):
*/
#ifndef __RPCServerServoce_h__
#define __RPCServerService_h__
#include "nsISupports.h"
#include "ITransport.h"
#include "IRPCall.h"
#include "IRPCChannel.h"
#include "IDispatcher.h"
class RPCServerService {
public:
static RPCServerService * GetInstance(void);
~RPCServerService();
NS_IMETHOD GetRPCChannel(IRPCChannel **channel);
NS_IMETHOD GetDispatcher(IDispatcher **dispatcher);
NS_IMETHOD CreateRPCall(IRPCall **rcall);
protected:
RPCServerService(void);
NS_IMETHOD GetTransport(ITransport **transport);
static RPCServerService * instance;
ITransport * transport;
IRPCChannel * rpcChannel;
IDispatcher * dispatcher;
};
#endif /* __RPCServerService_h__ */

64
xpcom/remote/tests/Makefile
View File

@ -1,64 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../../..
topsrcdir = ../../..
srcdir = .
VPATH = .
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/config.mk
SIMPLE_PROGRAMS = clientIn serverIn \
clientOut serverOut \
clientInOut serverInOut \
clientComb serverComb
XPIDL_MODULE = rpctest
XPIDLSRCS = nsIRPCTestIn.idl \
nsIRPCTestOut.idl \
nsIRPCTestInOut.idl \
nsIRPCTestComb.idl
INCLUDES += -I../common -I../server -I../client
LIBRARY_NAME = common
CPPSRCS = common.cpp
LIBS = \
-lcommon \
-lxpcom \
-lxptinfo \
-lrpcserver \
-lrpcclient \
-lrpccommon \
$(NSPR_LIBS) \
$(NULL)
include $(topsrcdir)/config/rules.mk

53
xpcom/remote/tests/Makefile.IN.test
View File

@ -1,53 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../../..
topsrcdir = ../../..
srcdir = .
VPATH = .
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/config.mk
SIMPLE_PROGRAMS = clientIn serverIn
XPIDL_MODULE = rpctest
XPIDLSRCS = nsIRPCTestIn.idl
INCLUDES += -I../common -I../server -I../client
LIBS = \
-lxpcom \
-lxptinfo \
-lrpcserver \
-lrpcclient \
-lrpccommon \
$(NSPR_LIBS) \
$(NULL)
include $(topsrcdir)/config/rules.mk

53
xpcom/remote/tests/Makefile.INOUT.test
View File

@ -1,53 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../../..
topsrcdir = ../../..
srcdir = .
VPATH = .
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/config.mk
SIMPLE_PROGRAMS = clientInOut serverInOut
XPIDL_MODULE = rpctest
XPIDLSRCS = nsIRPCTestInOut.idl
INCLUDES += -I../common -I../server -I../client
LIBS = \
-lxpcom \
-lxptinfo \
-lrpcserver \
-lrpcclient \
-lrpccommon \
$(NSPR_LIBS) \
$(NULL)
include $(topsrcdir)/config/rules.mk

53
xpcom/remote/tests/Makefile.OUT.test
View File

@ -1,53 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../../..
topsrcdir = ../../..
srcdir = .
VPATH = .
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/config.mk
SIMPLE_PROGRAMS = clientOut serverOut
XPIDL_MODULE = rpctest
XPIDLSRCS = nsIRPCTestOut.idl
INCLUDES += -I../common -I../server -I../client
LIBS = \
-lxpcom \
-lxptinfo \
-lrpcserver \
-lrpcclient \
-lrpccommon \
$(NSPR_LIBS) \
$(NULL)
include $(topsrcdir)/config/rules.mk

53
xpcom/remote/tests/Makefile.in
View File

@ -1,53 +0,0 @@
#!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 Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
DEPTH = ../..
topsrcdir = ../..
srcdir = .
VPATH = .
include $(DEPTH)/config/autoconf.mk
include $(topsrcdir)/config/config.mk
SIMPLE_PROGRAMS = client server
XPIDL_MODULE = rpctest
XPIDLSRCS = nsIRPCTest.idl
INCLUDES += -I../common -I../server -I../client
LIBS = \
-lxpcom \
-lxptinfo \
-lrpcserver \
-lrpcclient \
-lrpccommon \
$(NSPR_LIBS) \
$(NULL)
include $(topsrcdir)/config/rules.mk

29
xpcom/remote/tests/README
View File

@ -1,29 +0,0 @@
To build the tests,
- Run make or gmake.
To run the tests,
- Run each server and client modules on separate terminals.
- Type the following,
sIn - server for IN parameter tests
cIn - client for IN parameter tests
sOut - server for OUT parameter tests
cOut - client for OUT parameter tests
sIO - server for INOUT parameter tests
cIO - client for INOUT parameter tests
sComb - server for Combinational tests
cComb - client for Combinational tests
Each server and client module writes the values of each
parameter that it sends and/or receive to a result file.
Each has its own result file.
To check the result, the result files of the server and
the client will be compared using the diff tool. Tests
pass if data in both files exactly match; otherwise,
they fail.
chkIn - comparing the IN result files
chkOut - comparing the OUT result files
chkIO - comparing the INOUT result files
chkComb - comparing the Combinational result files

3
xpcom/remote/tests/cComb
View File

@ -1,3 +0,0 @@
rm serverComb.res
rm clientComb.res
clientComb

3
xpcom/remote/tests/cIO
View File

@ -1,3 +0,0 @@
rm serverInOut.res
rm clientInOut.res
clientInOut

3
xpcom/remote/tests/cIn
View File

@ -1,3 +0,0 @@
rm serverIn.res
rm clientIn.res
clientIn

3
xpcom/remote/tests/cOut
View File

@ -1,3 +0,0 @@
rm serverOut.res
rm clientOut.res
clientOut

3
xpcom/remote/tests/chkComb
View File

@ -1,3 +0,0 @@
echo diff clientComb.res serverComb.res
diff clientComb.res serverComb.res

3
xpcom/remote/tests/chkIO
View File

@ -1,3 +0,0 @@
echo diff clientInOut.res serverInOut.res
diff clientInOut.res serverInOut.res

3
xpcom/remote/tests/chkIn
View File

@ -1,3 +0,0 @@
echo diff clientIn.res serverIn.res
diff clientIn.res serverIn.res

3
xpcom/remote/tests/chkOut
View File

@ -1,3 +0,0 @@
echo diff clientOut.res serverOut.res
diff clientOut.res serverOut.res

3
xpcom/remote/tests/clean
View File

@ -1,3 +0,0 @@
#!/usr/bin/sh
ME=`who am i |awk '{print $1}'`
for d in `ipcs -q | grep $ME |awk '{print $2}'`;do ipcrm -q $d;done

42
xpcom/remote/tests/client.cpp
View File

@ -1,42 +0,0 @@
#include <stdio.h>
#include "RPCClientService.h"
#include "nsISupports.h"
#include "nsISample.h"
#include "nsIRPCTest.h"
extern char* transportName;
int main(int argc, char **args) {
PRInt32 i;
if (argc < 2) {
printf("format clinet <server pid>\n");
exit(1);
}
RPCClientService::Initialize(args[1]);
RPCClientService * rpcService = RPCClientService::GetInstance();
nsIID iid;
nsIRPCTest *t1, *t2;
rpcService->CreateObjectProxy(1, NS_GET_IID(nsIRPCTest),(nsISupports**)&t1);
#if 0
i = 1999;
printf("--before call %d\n",i);
t1->Test2(4321,&i);
printf("--after call %d\n",i);
rpcService->CreateObjectProxy(5, NS_GET_IID(nsIRPCTest),(nsISupports**)&t2);
i = 1998;
printf("____________________________________________\n");
printf("--before call %d\n",i);
t2->Test2(4320,&i);
printf("--after call %d\n",i);
printf("---------------------------------------------\n");
char *s1 = "hello";
char *s2 = "world";
t1->Test3(s1,&s2);
printf("s2 %s\n",s2);
#endif
printf("-----------------------------------------------\n");
PRUint32 arrayCount = 2;
char * array[2] = {"Hello","Pic"};
t1->Test4(arrayCount,array);
}

312
xpcom/remote/tests/clientComb.cpp
View File

@ -1,312 +0,0 @@
#include <stdio.h>
#include <stream.h>
#include <fstream.h>
#include <stdlib.h>
#include <string.h>
#include "RPCClientService.h"
#include "nsISupports.h"
#include "nsISample.h"
#include "nsIRPCTestComb.h"
#include "deftest.h"
#include "proto.h"
extern char* transportName;
int main(int argc, char **args)
{
nsIID iid;
nsIRPCTestComb *t1;
PRBool b, b2;
PRUint8 o;
PRInt16 sInt;
PRUint16 usInt, usInt2;
PRInt32 lInt;
double d;
char c;
PRUnichar wc;
char* sio;
char* s;
char spid[20];
getProcessId(COMB_FDATA, &spid[0]);
ofstream f_res(CLIENT_COMB_RES);
if(!f_res) {
cerr << "Cannot open result file.";
}
RPCClientService::Initialize(spid);
RPCClientService * rpcService = RPCClientService::GetInstance();
rpcService->CreateObjectProxy(1, NS_GET_IID(nsIRPCTestComb),(nsISupports**)&t1);
b = PR_TRUE;
c = 'A';
printf("--before call TestComb1 %c\n",c);
t1->TestComb1(b, &c);
printf("--after call TestComb1 %c\n",c);
f_res << form("TestComb1 %c\n",c);
printf("____________________________________________\n");
b = PR_TRUE;
sio = "This is a test.";
printf("--before call TestComb2 %s\n",sio);
t1->TestComb2(b, &sio);
printf("--after call TestComb2 %s\n",sio);
f_res << form("TestComb2 %s\n",sio);
printf("____________________________________________\n");
c = 'A';
sio = "This is a test.";
printf("--before call TestComb3 %c\n",c);
printf("--before call TestComb3 %s\n",sio);
t1->TestComb3(&c, &sio);
printf("--after call TestComb3 %c\n",c);
printf("--after call TestComb3 %s\n",sio);
f_res << form("TestComb3 %c %s\n",c,sio);
printf("____________________________________________\n");
b = PR_TRUE;
c = 'A';
s = "This is a test.";
printf("--before call TestComb4 %c\n",c);
printf("--before call TestComb4 %s\n",s);
t1->TestComb4(&s, b, &c);
printf("--after call TestComb4 %c\n",c);
printf("--after call TestComb4 %s\n",s);
f_res << form("TestComb4 %c %s\n",c,s);
printf("____________________________________________\n");
sInt = 555;
c = 'A';
printf("--before call TestComb5 %c\n",c);
t1->TestComb5(sInt, &c);
printf("--after call TestComb5 %c\n",c);
f_res << form("TestComb5 %c\n",c);
printf("____________________________________________\n");
b = PR_TRUE;
sInt = 555;
printf("--before call TestComb6 %d\n",sInt);
t1->TestComb6(b, &sInt);
printf("--after call TestComb6 %d\n",sInt);
f_res << form("TestComb6 %d\n",sInt);
printf("____________________________________________\n");
b = PR_TRUE;
sInt = 555;
printf("--before call TestComb7 %d\n",sInt);
t1->TestComb7(b, &sInt);
printf("--after call TestComb7 %d\n",sInt);
f_res << form("TestComb7 %d\n",sInt);
printf("____________________________________________\n");
b = PR_TRUE;
sInt = 555;
printf("--before call TestComb8 %d\n",b);
printf("--before call TestComb8 %d\n",sInt);
t1->TestComb8(b, sInt);
f_res << form("TestComb8 %d %d\n",b, sInt);
printf("____________________________________________\n");
b = PR_TRUE;
c = 'a';
printf("--before call TestComb9 %d\n",b);
printf("--before call TestComb9 %c\n",c);
t1->TestComb9(b, c);
printf("--after call TestComb9 %c\n",c);
f_res << form("TestComb9 %d %c\n",b, c);
printf("____________________________________________\n");
b = PR_TRUE;
s = (char *) malloc(sizeof(char) * 50);
strcpy(s,"This is a test.");
t1->TestComb10(b, &s);
printf("--after call TestComb10 %s\n",s);
f_res << form("TestComb10 %s\n", s);
printf("____________________________________________\n");
b = PR_TRUE;
c = 'A';
printf("--before call TestComb11 %c\n",c);
t1->TestComb11(b, &c);
printf("--after call TestComb11 %c\n",c);
f_res << form("TestComb11 %c\n",c);
printf("____________________________________________\n");
b = PR_TRUE;
lInt = 100;
printf("--before call TestComb12 %d\n",lInt);
t1->TestComb12(b, &lInt);
printf("--after call TestComb12 %d\n",lInt);
f_res << form("TestComb12 %d\n",lInt);
printf("____________________________________________\n");
b = PR_TRUE;
lInt = 100;
printf("--before call TestComb13 %d\n",lInt);
t1->TestComb13(b, &lInt);
printf("--after call TestComb13 %d\n",lInt);
f_res << form("TestComb13 %d\n",lInt);
printf("____________________________________________\n");
b = PR_TRUE;
lInt = 100;
printf("--before call TestComb14 %d\n",b);
printf("--before call TestComb14 %d\n",lInt);
t1->TestComb14(b, lInt);
f_res << form("TestComb14 %d %d\n",b, lInt);
printf("____________________________________________\n");
b = PR_TRUE;
d = 100.99;
printf("--before call TestComb15 %d\n",b);
printf("--before call TestComb15 %.50f\n",d);
t1->TestComb15(b, &d);
printf("--after call TestComb15 %.50f\n",d);
f_res << form("TestComb15 %.50f\n",d);
printf("____________________________________________\n");
b = PR_TRUE;
d = 100.99;
printf("--before call TestComb16 %d\n",b);
printf("--before call TestComb16 %.50f\n",d);
t1->TestComb16(b, &d);
printf("--after call TestComb16 %.50f\n",d);
f_res << form("TestComb16 %.50f\n",d);
printf("____________________________________________\n");
b = PR_TRUE;
usInt = 555;
printf("--before call TestComb17 %d\n",b);
printf("--before call TestComb17 %u\n",usInt);
t1->TestComb17(b, &usInt);
printf("--after call TestComb17 %u\n",usInt);
f_res << form("TestComb17 %d\n",usInt);
printf("____________________________________________\n");
b = PR_TRUE;
usInt = 555;
printf("--before call TestComb18 %d\n",b);
printf("--before call TestComb18 %u\n",usInt);
t1->TestComb18(b, &usInt);
printf("--after call TestComb18 %u\n",usInt);
f_res << form("TestComb18 %d\n",usInt);
printf("____________________________________________\n");
b = PR_TRUE;
o = 7;
printf("--before call TestComb19 %d\n",b);
printf("--before call TestComb19 %d\n",o);
t1->TestComb19(b, &o);
printf("--after call TestComb19 %d\n",o);
f_res << form("TestComb19 %o\n",o);
printf("____________________________________________\n");
b = PR_TRUE;
o = 7;
printf("--before call TestComb20 %d\n",b);
printf("--before call TestComb20 %d\n",o);
t1->TestComb20(b, &o);
printf("--after call TestComb20 %d\n",o);
f_res << form("TestComb20 %o\n",o);
printf("____________________________________________\n");
b = PR_TRUE;
o = 7;
printf("--before call TestComb21 %d\n",o);
t1->TestComb21(b, o);
f_res << form("TestComb21 %d %o\n",b,o);
printf("____________________________________________\n");
b = PR_TRUE;
b2 = PR_TRUE;
printf("--before call TestComb22 %d\n",b2);
t1->TestComb22(b, b2);
f_res << form("TestComb22 %d %d\n",b,b2);
printf("____________________________________________\n");
b = PR_TRUE;
b2 = PR_TRUE;
printf("--before call TestComb23 %d\n",b2);
t1->TestComb23(b, &b2);
printf("--after call TestComb23 %d\n",b2);
f_res << form("TestComb23 %d\n",b2);
printf("____________________________________________\n");
b = PR_TRUE;
b2 = PR_TRUE;
printf("--before call TestComb24 %d\n",b2);
t1->TestComb24(b, &b2);
printf("--after call TestComb24 %d\n",b2);
f_res << form("TestComb24 %d\n",b2);
printf("____________________________________________\n");
b = PR_TRUE;
c = 'A';
printf("--before call TestComb25 %d\n",b);
printf("--before call TestComb25 %d\n",c);
t1->TestComb25(&b, &c);
printf("--after call TestComb25 %d\n",b);
printf("--after call TestComb25 %d\n",c);
f_res << form("TestComb25 %d %c\n",b,c);
printf("____________________________________________\n");
b = PR_TRUE;
c = 'A';
printf("--before call TestComb26 %d\n",b);
printf("--before call TestComb26 %d\n",c);
t1->TestComb26(&b, &c);
printf("--after call TestComb26 %d\n",c);
printf("--after call TestComb26 %d\n",b);
f_res << form("TestComb26 %d %c\n",b,c);
printf("____________________________________________\n");
b = PR_TRUE;
wc = 'A';
printf("--before call TestComb27 %c\n",wc);
t1->TestComb27(b, &wc);
printf("--after call TestComb27 %c\n",wc);
f_res << form("TestComb27 %c\n",wc);
printf("____________________________________________\n");
sio = "This is a test.";
s = "This is a second test.";
printf("--before call TestComb30 %s\n",sio);
printf("--before call TestComb30 %s\n",s);
t1->TestComb30(s, &sio);
printf("--after call TestComb30 %s\n",sio);
f_res << form("TestComb30 %s\n",sio);
printf("____________________________________________\n");
o = 55;
usInt = 55;
printf("--before call TestComb31 %o\n",o);
printf("--before call TestComb31 %u\n",usInt);
t1->TestComb31(&o, &usInt);
printf("--after call TestComb31 %o\n",o);
printf("--after call TestComb31 %u\n",usInt);
f_res << form("TestComb31 %o %u\n",o,usInt);
printf("____________________________________________\n");
o = 55;
lInt = 55;
printf("--before call TestComb32 %o\n",o);
printf("--before call TestComb32 %d\n",lInt);
t1->TestComb32(&o, &lInt);
printf("--after call TestComb32 %o\n",o);
printf("--after call TestComb32 %d\n",lInt);
f_res << form("TestComb32 %o %d\n",o,lInt);
printf("____________________________________________\n");
lInt = 55;
usInt2 = 55;
printf("--before call TestComb33 %u\n",usInt2);
printf("--before call TestComb33 %d\n",lInt);
t1->TestComb33(&lInt, &usInt);
printf("--after call TestComb33 %u\n",usInt2);
printf("--after call TestComb33 %d\n",lInt);
f_res << form("TestComb33 %d %u\n",lInt,usInt);
printf("____________________________________________\n");
f_res.close();
}

268
xpcom/remote/tests/clientIn.cpp
View File

@ -1,268 +0,0 @@
#include <stdio.h>
#include <stream.h>
#include <fstream.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>
#include "RPCClientService.h"
#include "nsISupports.h"
#include "nsISample.h"
#include "nsIRPCTestIn.h"
#include "deftest.h"
#include "proto.h"
extern char* transportName;
int main(int argc, char **args) {
nsIID iid;
nsIRPCTestIn *t1;
PRBool b;
PRUint8 o;
PRInt16 sInt;
PRInt32 lInt;
PRInt64 llInt;
PRUint16 usInt;
PRUint32 ulInt;
PRUint64 ullInt;
float f;
double d;
char c;
PRUnichar wc;
char* s;
PRUnichar *ws;
char spid[20];
int i;
getProcessId(IN_FDATA, &spid[0]);
ofstream f_res(CLIENT_IN_RES);
if(!f_res) {
cerr << "Cannot open result file.";
}
RPCClientService::Initialize(spid);
RPCClientService * rpcService = RPCClientService::GetInstance();
rpcService->CreateObjectProxy(1, NS_GET_IID(nsIRPCTestIn),(nsISupports**)&t1);
b = PR_TRUE;
printf("--before call TestIn1 %d\n",b);
t1->TestIn1(b);
f_res << form("TestIn1 %d\n",b);
b = PR_FALSE;
printf("--before call TestIn1 %d\n",b);
t1->TestIn1(b);
f_res << form("TestIn1 %d\n",b);
printf("____________________________________________\n");
o = 0;
printf("--before call TestIn2 %d\n",o);
t1->TestIn2(o);
f_res << form("TestIn2 %o\n",o);
o = 124;
printf("--before call TestIn2 %d\n",o);
t1->TestIn2(o);
f_res << form("TestIn2 %o\n",o);
printf("____________________________________________\n");
sInt = SHRT_MIN;
printf("--before call TestIn3 %d\n",sInt);
t1->TestIn3(sInt);
f_res << form("TestIn3 %d\n",sInt);
sInt = SHRT_MAX;
printf("--before call TestIn3 %d\n",sInt);
t1->TestIn3(sInt);
f_res << form("TestIn3 %d\n",sInt);
printf("____________________________________________\n");
lInt = LONG_MIN;
printf("--before call TestIn4 %d\n",lInt);
t1->TestIn4(lInt);
f_res << form("TestIn4 %d\n",lInt);
lInt = LONG_MAX;
printf("--before call TestIn4 %d\n",lInt);
t1->TestIn4(lInt);
f_res << form("TestIn4 %d\n",lInt);
printf("____________________________________________\n");
llInt = LONG_MIN;
printf("--before call TestIn5 %d\n",llInt);
t1->TestIn5(llInt);
f_res << form("TestIn5 %d\n",llInt);
llInt = LONG_MAX;
printf("--before call TestIn5 %d\n",llInt);
t1->TestIn5(llInt);
f_res << form("TestIn5 %d\n",llInt);
printf("____________________________________________\n");
usInt = 555;
printf("--before call TestIn6 %u\n",usInt);
t1->TestIn6(usInt);
f_res << form("TestIn6 %u\n",usInt);
usInt = USHRT_MAX;
printf("--before call TestIn6 %u\n",usInt);
t1->TestIn6(usInt);
f_res << form("TestIn6 %u\n",usInt);
printf("____________________________________________\n");
ulInt = 555;
printf("--before call TestIn7 %u\n",ulInt);
t1->TestIn7(ulInt);
f_res << form("TestIn7 %u\n",ulInt);
ulInt = ULONG_MAX;
printf("--before call TestIn7 %u\n",ulInt);
t1->TestIn7(ulInt);
f_res << form("TestIn7 %u\n",ulInt);
printf("____________________________________________\n");
ullInt = 555;
printf("--before call TestIn8 %u\n",ullInt);
t1->TestIn8(ullInt);
f_res << form("TestIn8 %u\n",ullInt);
ullInt = ULONG_MAX;
printf("--before call TestIn8 %u\n",ullInt);
t1->TestIn8(ullInt);
f_res << form("TestIn8 %u\n",ullInt);
printf("____________________________________________\n");
f = FLT_MIN;
printf("--before call TestIn9 %.50f\n",f);
t1->TestIn9(f);
f_res << form("TestIn9 %.50f\n",f);
f = FLT_MAX;
printf("--before call TestIn9 %f\n",f);
t1->TestIn9(f);
f_res << form("TestIn9 %.50f\n",f);
printf("____________________________________________\n");
d = DBL_MIN;
printf("--before call TestIn10 %.50f\n",d);
t1->TestIn10(d);
f_res << form("TestIn10 %.50f\n",d);
d = DBL_MAX;
printf("--before call TestIn10 %f\n",d);
t1->TestIn10(d);
f_res << form("TestIn10 %.50f\n",d);
printf("____________________________________________\n");
c = 'A';
printf("--before call TestIn11 %d\n",c);
t1->TestIn11(c);
f_res << form("TestIn11 %c\n",c);
c = 'Z';
printf("--before call TestIn11 %d\n",c);
t1->TestIn11(c);
f_res << form("TestIn11 %c\n",c);
printf("____________________________________________\n");
wc = 'A';
printf("--before call TestIn12 %d\n",wc);
t1->TestIn12(wc);
f_res << form("TestIn12 %c\n",wc);
wc = 'Z';
printf("--before call TestIn12 %d\n",wc);
t1->TestIn12(wc);
f_res << form("TestIn12 %c\n",wc);
printf("____________________________________________\n");
s = "";
printf("--before call TestIn13 %s\n",s);
t1->TestIn13(s);
f_res << form("TestIn13 %s\n",s);
strcpy(s,"This is a test.");
printf("--before call TestIn13 %s\n",s);
t1->TestIn13(s);
f_res << form("TestIn13 %s\n",s);
printf("____________________________________________\n");
/*
ws = new PRUnichar[50];
ws[0] = '\0';
printf("--before call TestIn14 %s\n",ws);
t1->TestIn14(ws);
f_res << form("TestIn14 %s\n",ws);
for (i = 0; i < 10; i++) {
ws[i] = 'z';
}
ws[i] = '\0';
printf("--before call TestIn14 %s\n",ws);
t1->TestIn14(ws);
f_res << form("TestIn14 %s\n",ws);
delete ws;
printf("____________________________________________\n");
*/
PRUint32 arrCount = 3;
const char *array[3] = {"Blackwood","MCD","StarLite"};
printf("--before call TestIn15 data array.\n");
t1->TestIn15(arrCount, array);
f_res << form("TestIn15 count %d\n", arrCount);
for (i = 0; i < arrCount; i++) {
f_res << form("TestIn15 Array[%d]=%s\n",i,array[i]);
}
printf("____________________________________________\n");
PRUint32 arrCount2 = 10;
PRInt32 arrLong[10] = {1111111, 2222222, 3333333, 4444444, 5555555,
6666666, 7777777, 8888888, 9999999, 0};
printf("--before call TestIn16 data array.\n");
t1->TestIn16(arrCount2, &arrLong[0]);
f_res << form("TestIn16 count %d\n", arrCount2);
for (i = 0; i < arrCount2; i++) {
f_res << form("TestIn16 Array[%d]=%d\n",i,arrLong[i]);
}
printf("____________________________________________\n");
b = PR_TRUE;
o = 8;
sInt = 1;
lInt = 2;
llInt = 3;
usInt = 4;
ulInt = 5;
ullInt = 6;
f = 7;
d = 8;
c = 'A';
printf("--before call TestIn17 combination.\n");
t1->TestIn17(b, c, o, sInt, usInt, lInt, ulInt, llInt, ullInt, f, d, s, arrCount2, &arrLong[0]);
f_res << form("TestIn17 PRBool %d\n",b);
f_res << form("TestIn17 PRUint8 %o\n",o);
f_res << form("TestIn17 PRInt16 %d\n",sInt);
f_res << form("TestIn17 PRInt32 %d\n",lInt);
f_res << form("TestIn17 PRInt64 %d\n",llInt);
f_res << form("TestIn17 PRUint16 %u\n",usInt);
f_res << form("TestIn17 PRUint32 %u\n",ulInt);
f_res << form("TestIn17 PRUint64 %u\n",ullInt);
f_res << form("TestIn17 float %.50f\n",f);
f_res << form("TestIn17 double %.50f\n",d);
f_res << form("TestIn17 char %c\n",c);
f_res << form("TestIn17 string %s\n",s);
f_res << form("TestIn17 count %d\n", arrCount2);
for (i = 0; i < arrCount2; i++) {
f_res << form("TestIn17 Array[%d]=%d\n",i,arrLong[i]);
}
printf("____________________________________________\n");
printf("--before call TestIn18 combination.\n");
t1->TestIn18(c, o, sInt, usInt, lInt, ulInt, llInt, ullInt, f, d, s, arrCount2, &arrLong[0]);
f_res << form("TestIn18 PRUint8 %o\n",o);
f_res << form("TestIn18 PRInt16 %d\n",sInt);
f_res << form("TestIn18 PRInt32 %d\n",lInt);
f_res << form("TestIn18 PRInt64 %d\n",llInt);
f_res << form("TestIn18 PRUint16 %u\n",usInt);
f_res << form("TestIn18 PRUint32 %u\n",ulInt);
f_res << form("TestIn18 PRUint64 %u\n",ullInt);
f_res << form("TestIn18 float %.50f\n",f);
f_res << form("TestIn18 double %.50f\n",d);
f_res << form("TestIn18 char %c\n",c);
f_res << form("TestIn18 string %s\n",s);
f_res << form("TestIn18 count %d\n", arrCount2);
for (i = 0; i < arrCount2; i++) {
f_res << form("TestIn18 Array[%d]=%d\n",i,arrLong[i]);
}
printf("____________________________________________\n");
f_res.close();
}

285
xpcom/remote/tests/clientInOut.cpp
View File

@ -1,285 +0,0 @@
#include <stdio.h>
#include <stream.h>
#include <fstream.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>
#include "RPCClientService.h"
#include "nsISupports.h"
#include "nsISample.h"
#include "nsIRPCTestInOut.h"
#include "deftest.h"
#include "proto.h"
extern char* transportName;
int main(int argc, char **args) {
nsIID iid;
nsIRPCTestInOut *t1;
PRBool b;
PRUint8 o;
PRInt16 sInt;
PRInt32 lInt;
PRInt64 llInt;
PRUint16 usInt;
PRUint32 ulInt;
PRUint64 ullInt;
float f;
double d;
char c;
PRUnichar wc;
char* s;
PRUnichar *ws;
char spid[20];
int i;
getProcessId(INOUT_FDATA, &spid[0]);
ofstream f_res(CLIENT_INOUT_RES);
if(!f_res) {
cerr << "Cannot open result file.";
}
RPCClientService::Initialize(spid);
RPCClientService * rpcService = RPCClientService::GetInstance();
rpcService->CreateObjectProxy(1, NS_GET_IID(nsIRPCTestInOut),(nsISupports**)&t1);
b = PR_TRUE;
printf("--before call TestInOut1 %d\n",b);
f_res << form("TestInOut1 before %d\n",b);
t1->TestInOut1(&b);
printf("--after call TestInOut1 %d\n",b);
f_res << form("TestInOut1 after %d\n",b);
printf("____________________________________________\n");
o = 10;
printf("--before call TestInOut2 %o\n",o);
f_res << form("TestInOut2 before %o\n",o);
t1->TestInOut2(&o);
printf("--after call TestInOut2 %o\n",o);
f_res << form("TestInOut2 after %o\n",o);
printf("____________________________________________\n");
sInt = SHRT_MIN;
printf("--before call TestInOut3 %d\n",sInt);
f_res << form("TestInOut3 before %d\n",sInt);
t1->TestInOut3(&sInt);
printf("--after call TestInOut3 %d\n",sInt);
f_res << form("TestInOut3 after %d\n",sInt);
printf("____________________________________________\n");
lInt = LONG_MIN;
printf("--before call TestInOut4 %d\n",lInt);
f_res << form("TestInOut4 before %l\n",lInt);
t1->TestInOut4(&lInt);
printf("--after call TestInOut4 %d\n",lInt);
f_res << form("TestInOut4 after %l\n",lInt);
printf("____________________________________________\n");
llInt = LONG_MIN;
printf("--before call TestInOut5 %d\n",llInt);
f_res << form("TestInOut5 before %l\n",llInt);
t1->TestInOut5(&llInt);
printf("--after call TestInOut5 %d\n",llInt);
f_res << form("TestInOut5 after %l\n",llInt);
printf("____________________________________________\n");
usInt = 555;
printf("--before call TestInOut6 %u\n",usInt);
f_res << form("TestInOut6 before %10u\n",usInt);
t1->TestInOut6(&usInt);
printf("--after call TestInOut6 %u\n",usInt);
f_res << form("TestInOut6 after %10u\n",usInt);
printf("____________________________________________\n");
ulInt = 555;
printf("--before call TestInOut7 %u\n",ulInt);
f_res << form("TestInOut7 before %10u\n",ulInt);
t1->TestInOut7(&ulInt);
printf("--after call TestInOut7 %u\n",ulInt);
f_res << form("TestInOut7 after %10u\n",ulInt);
printf("____________________________________________\n");
ullInt = 555;
printf("--before call TestInOut8 %u\n",ullInt);
f_res << form("TestInOut8 before %10u\n",ullInt);
t1->TestInOut8(&ullInt);
printf("--after call TestInOut8 %u\n",ullInt);
f_res << form("TestInOut8 after %10u\n",ullInt);
printf("____________________________________________\n");
f = FLT_MIN;
printf("--before call TestInOut9 %.50f\n",f);
f_res << form("TestInOut9 before %.50f\n",f);
t1->TestInOut9(&f);
printf("--after call TestInOut9 %.50f\n",f);
f_res << form("TestInOut9 after %.50f\n",f);
printf("____________________________________________\n");
d = DBL_MIN;
printf("--before call TestInOut10 %.50f\n",d);
f_res << form("TestInOut10 before %.50f\n",d);
t1->TestInOut10(&d);
printf("--after call TestInOut10 %.50f\n",d);
f_res << form("TestInOut10 after %.50f\n",d);
printf("____________________________________________\n");
c = 'A';
printf("--before call TestInOut11 %d\n",c);
f_res << form("TestInOut11 before %c\n",c);
t1->TestInOut11(&c);
printf("--after call TestInOut11 %d\n",c);
f_res << form("TestInOut11 after %c\n",c);
printf("____________________________________________\n");
wc = 'A';
printf("--before call TestInOut12 %d\n",wc);
f_res << form("TestInOut12 before %c\n",wc);
t1->TestInOut12(&wc);
printf("--after call TestInOut12 %d\n",wc);
f_res << form("TestInOut12 after %c\n",wc);
printf("____________________________________________\n");
s = "This is a test.";
printf("--before call TestInOut13 %s\n",s);
f_res << form("TestInOut13 before %s\n",s);
t1->TestInOut13(&s);
printf("--before call TestInOut13 %s\n",s);
f_res << form("TestInOut13 after %s\n",s);
printf("____________________________________________\n");
/*
ws = new PRUnichar[50];
for (i = 0; i < 10; i++) {
ws[i] = 'z';
}
ws[i] = '\0';
printf("--before call TestInOut14 %s\n",ws);
f_res << form("TestInOut14 before %s\n",ws);
t1->TestInOut14(&ws);
printf("--before call TestInOut14 %s\n",ws);
f_res << form("TestInOut14 after %s\n",ws);
printf("____________________________________________\n");
*/
PRUint32 arrCount = 0;
char *array = new char [100];
strcpy(array,"Going out... remote ipc test.");
arrCount = strlen(array);
printf("TestInOut15 before count %d\n", arrCount);
f_res << form("TestInOut15 before count %d\n", arrCount);
printf("TestInOut15 before Array=%s\n", array);
f_res << form("TestInOut15 before Array=%s\n",array);
printf("--before call TestInOut15 data array.\n");
t1->TestInOut15(&arrCount, &array);
printf("TestInOut15 after count %d\n", arrCount);
f_res << form("TestInOut15 after count %d\n", arrCount);
printf("TestInOut15 after Array=%s\n", array);
f_res << form("TestInOut15 after Array=%s\n",array);
printf("____________________________________________\n");
printf("--before call TestInOut16 combination.\n");
b = PR_FALSE;
o = 555;
c = 'Z';
sInt = 9;
usInt = 9;
lInt = 9;
ulInt = 9;
llInt = 9;
ullInt = 9;
f = 9;
d = 9;
s = "This is an inout parameter test.";
f_res << form("TestInOut16 before %d\n",b);
f_res << form("TestInOut16 before %d\n",lInt);
f_res << form("TestInOut16 before %d\n",llInt);
f_res << form("TestInOut16 before %u\n",usInt);
f_res << form("TestInOut16 before %u\n",ulInt);
f_res << form("TestInOut16 before %u\n",ullInt);
f_res << form("TestInOut16 before %.50f\n",f);
f_res << form("TestInOut16 before %.50f\n",d);
f_res << form("TestInOut16 before %c\n",c);
f_res << form("TestInOut16 before %s\n",s);
t1->TestInOut16( &b, &c, &usInt, &lInt, &ulInt, &llInt, &ullInt, &f, &d, &s);
printf("After calling TestInOut16.\n");
f_res << form("TestInOut16 after %d\n",b);
f_res << form("TestInOut16 after %d\n",lInt);
f_res << form("TestInOut16 after %d\n",llInt);
f_res << form("TestInOut16 after %u\n",usInt);
f_res << form("TestInOut16 after %u\n",ulInt);
f_res << form("TestInOut16 after %u\n",ullInt);
f_res << form("TestInOut16 after %.50f\n",f);
f_res << form("TestInOut16 after %.50f\n",d);
f_res << form("TestInOut16 after %c\n",c);
f_res << form("TestInOut16 after %s\n",s);
printf("____________________________________________\n");
PRUint32 arrCount2 = 5;
PRInt32 *arrLong = new PRInt32 [arrCount2];
f_res << form("TestInOut17 before count %d\n", arrCount2);
for (i = 0; i < arrCount2; i++) {
arrLong[i] = 11111 + i;
f_res << form("TestInOut17 before Array[%d]=%d\n",i,arrLong[i]);
}
printf("--before call TestInOut17 data array.\n");
t1->TestInOut17(&arrCount2, &arrLong);
f_res << form("TestInOut17 after count %d\n", arrCount2);
for (i = 0; i < arrCount2; i++) {
f_res << form("TestInOut17 after Array[%d]=%d\n",i,arrLong[i]);
}
delete arrLong;
printf("____________________________________________\n");
printf("--before call TestInOut18 combination.\n");
b = PR_FALSE;
o = 555;
c = 'Z';
sInt = 9;
usInt = 9;
lInt = 9;
ulInt = 9;
llInt = 9;
ullInt = 9;
f = 9;
d = 9;
s = "This is an inout parameter test.";
f_res << form("TestInOut18 before %d\n",b);
f_res << form("TestInOut18 before %o\n",o);
f_res << form("TestInOut18 before %d\n",sInt);
f_res << form("TestInOut18 before %d\n",lInt);
f_res << form("TestInOut18 before %d\n",llInt);
f_res << form("TestInOut18 before %u\n",usInt);
f_res << form("TestInOut18 before %u\n",ulInt);
f_res << form("TestInOut18 before %u\n",ullInt);
f_res << form("TestInOut18 before %.50f\n",f);
f_res << form("TestInOut18 before %.50f\n",d);
f_res << form("TestInOut18 before %c\n",c);
f_res << form("TestInOut18 before %s\n",s);
t1->TestInOut18(&b, &c, &o, &sInt, &usInt, &lInt, &ulInt, &llInt, &ullInt, &f, &d, &s);
printf("After calling TestInOut18.\n");
f_res << form("TestInOut18 after %d\n",b);
f_res << form("TestInOut18 after %o\n",o);
f_res << form("TestInOut18 after %d\n",sInt);
f_res << form("TestInOut18 after %d\n",lInt);
f_res << form("TestInOut18 after %d\n",llInt);
f_res << form("TestInOut18 after %u\n",usInt);
f_res << form("TestInOut18 after %u\n",ulInt);
f_res << form("TestInOut18 after %u\n",ullInt);
f_res << form("TestInOut18 after %.50f\n",f);
f_res << form("TestInOut18 after %.50f\n",d);
f_res << form("TestInOut18 after %c\n",c);
f_res << form("TestInOut18 after %s\n",s);
printf("____________________________________________\n");
f_res.close();
}

190
xpcom/remote/tests/clientOut.cpp
View File

@ -1,190 +0,0 @@
#include <stdio.h>
#include <stream.h>
#include <fstream.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>
#include "RPCClientService.h"
#include "nsISupports.h"
#include "nsISample.h"
#include "nsIRPCTestOut.h"
#include "deftest.h"
#include "proto.h"
extern char* transportName;
int main(int argc, char **args) {
nsIID iid;
nsIRPCTestOut *t1;
PRBool b;
PRUint8 o;
PRInt16 sInt;
PRInt32 lInt;
PRInt64 llInt;
PRUint16 usInt;
PRUint32 ulInt;
PRUint64 ullInt;
float f;
double d;
char c;
PRUnichar wc;
char* s;
PRUnichar *ws;
char spid[20];
getProcessId(OUT_FDATA, &spid[0]);
ofstream f_res(CLIENT_OUT_RES);
if(!f_res) {
cerr << "Cannot open result file.";
}
RPCClientService::Initialize(spid);
RPCClientService * rpcService = RPCClientService::GetInstance();
rpcService->CreateObjectProxy(1, NS_GET_IID(nsIRPCTestOut),(nsISupports**)&t1);
b = PR_TRUE;
printf("--before call TestOut1 %d\n",b);
t1->TestOut1(&b);
printf("--after call TestOut1 %d\n",b);
f_res << form("TestOut1 %d\n",b);
printf("____________________________________________\n");
o = 124;
printf("--before call TestOut2 %d\n",o);
t1->TestOut2(&o);
printf("--after call TestOut2 %d\n",o);
f_res << form("TestOut2 %o\n",o);
printf("____________________________________________\n");
sInt = SHRT_MIN;
printf("--before call TestOut3 %d\n",sInt);
t1->TestOut3(&sInt);
printf("--after call TestOut3 %d\n",sInt);
f_res << form("TestOut3 %d\n",sInt);
printf("____________________________________________\n");
lInt = LONG_MIN;
printf("--before call TestOut4 %d\n",lInt);
t1->TestOut4(&lInt);
printf("--after call TestOut4 %d\n",lInt);
f_res << form("TestOut4 %d\n",lInt);
printf("____________________________________________\n");
llInt = LONG_MIN;
printf("--before call TestOut5 %d\n",llInt);
t1->TestOut5(&llInt);
printf("--after call TestOut5 %d\n",llInt);
f_res << form("TestOut5 %d\n",llInt);
printf("____________________________________________\n");
usInt = USHRT_MIN;
printf("--before call TestOut6 %u\n",usInt);
t1->TestOut6(&usInt);
printf("--after call TestOut6 %u\n",usInt);
f_res << form("TestOut6 %u\n",usInt);
printf("____________________________________________\n");
ulInt = ULONG_MIN;
printf("--before call TestOut7 %u\n",ulInt);
t1->TestOut7(&ulInt);
printf("--after call TestOut7 %u\n",ulInt);
f_res << form("TestOut7 %u\n",ulInt);
printf("____________________________________________\n");
ullInt = ULONG_MIN;
printf("--before call TestOut8 %u\n",ullInt);
t1->TestOut8(&ullInt);
printf("--after call TestOut8 %u\n",ullInt);
f_res << form("TestOut8 %u\n",ullInt);
printf("____________________________________________\n");
f = FLT_MIN;
printf("--before call TestOut9 %.38f\n",f);
t1->TestOut9(&f);
printf("--after call TestOut9 %f\n",f);
f_res << form("TestOut9 %.50f\n",f);
printf("____________________________________________\n");
d = DBL_MIN;
printf("--before call TestOut10 %.50f\n",d);
t1->TestOut10(&d);
printf("--after call TestOut10 %f\n",d);
f_res << form("TestOut10 %.50f\n",d);
printf("____________________________________________\n");
c = 'A';
printf("--before call TestOut11 %d\n",c);
t1->TestOut11(&c);
printf("--after call TestOut11 %d\n",c);
f_res << form("TestOut11 %c\n",c);
printf("____________________________________________\n");
wc = 'A';
printf("--before call TestOut12 %d\n",wc);
t1->TestOut12(&wc);
printf("--after call TestOut12 %d\n",wc);
f_res << form("TestOut12 %c\n",wc);
printf("____________________________________________\n");
s = new char[50];
printf("--before call TestOut13 %s\n",s);
t1->TestOut13(&s);
printf("--after call TestOut13 %s\n",s);
f_res << form("TestOut13 %s\n",s);
delete s;
printf("____________________________________________\n");
/*
ws = new PRUnichar[50];
printf("--before call TestOut14 %s\n",ws);
t1->TestOut14(&ws);
printf("--after call TestOut14 %s\n",ws);
f_res << form("TestOut14 %s\n",ws);
delete ws;
printf("____________________________________________\n");
*/
PRUint32 arrCount = 0;
char *array = new char [200];
printf("--before call TestOut15 data array.\n");
t1->TestOut15(&arrCount, &array);
printf("TestOut15 count %d\n", arrCount);
f_res << form("TestOut15 count %d\n", arrCount);
printf("TestOut15 Array=%s\n", array);
f_res << form("TestOut15 Array=%s\n",array);
delete array;
printf("____________________________________________\n");
printf("--before call TestOut16 combination.\n");
t1->TestOut16(&b, &c, &o, &sInt, &usInt, &lInt, &ulInt, &llInt, &ullInt, &f, &d, &s);
printf("After calling TestOut16.\n");
f_res << form("TestOut16 PRBool %d\n",b);
f_res << form("TestOut16 PRUint8 %o\n",o);
f_res << form("TestOut16 PRInt16 %d\n",sInt);
f_res << form("TestOut16 PRInt32 %d\n",lInt);
f_res << form("TestOut16 PRInt64 %d\n",llInt);
f_res << form("TestOut16 PRUint16 %u\n",usInt);
f_res << form("TestOut16 PRUint32 %u\n",ulInt);
f_res << form("TestOut16 PRUint64 %u\n",ullInt);
f_res << form("TestOut16 float %.50f\n",f);
f_res << form("TestOut16 double %.50f\n",d);
f_res << form("TestOut16 char %c\n",c);
f_res << form("TestOut16 string %s\n",s);
printf("____________________________________________\n");
PRUint32 arrCount2 = 0;
PRInt32 *arrLong = new PRInt32 [50];
printf("--before call TestOut17 data array.\n");
t1->TestOut17(&arrCount2, &arrLong);
f_res << form("TestOut17 count %d\n", arrCount2);
for (int i = 0; i < arrCount2; i++) {
f_res << form("TestOut17 Array[%d]=%d\n",i,arrLong[i]);
}
delete arrLong;
printf("____________________________________________\n");
f_res.close();
}

119
xpcom/remote/tests/common.cpp
View File

@ -1,119 +0,0 @@
#include <stdio.h>
#include <stream.h>
#include <fstream.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "proto.h"
/************************************************
* Retrieves the server's process id
* from the data file.
************************************************/
void getProcessId(char *fname, char *s)
{
char ch;
short i = 0;
ifstream f_in(fname);
if (!f_in) {
cerr << "Cannot open file %s.\n" << fname;
exit(1);
}
while(1){
if (f_in.eof()) break;
f_in >> ch;
s[i++] = ch;
}
s[i-1] = '\0';
f_in.close();
}
/***********************************************
* Saves the server's process id
* in to the data file.
***********************************************/
void setProcessId(char *fname)
{
int pid = getpid();
cout << "%x\n" << pid;
ofstream f_out(fname);
if(!f_out) {
cerr << "Cannot open file" << fname;
exit(1);
}
f_out << form("%x",pid);
f_out.close();
}
/***********************************************
* Writes the string into the result data
* file by appending it into the existing data.
***********************************************/
void writeResult(char *fname, char *str) {
char **buf = new char *[500];
int line = readFromFile(fname, buf);
int len = strlen(str);
buf[line] = new char[len];
strcpy(buf[line], str);
writeToFile(fname, line + 1, buf);
for(int i = 0; i < line; i++){
delete buf[i];
}
delete buf;
}
/***********************************************
* Reads the content of the result data file.
*
***********************************************/
int readFromFile(char *fname, char **buf) {
int i = 0;
ifstream f_in(fname);
if (!f_in) {
return i;
}
char *tmpbuf = new char[400];
char ch;
int j = 0;
while(!f_in.eof()) {
f_in.get(ch);
tmpbuf[j++] = ch;
if (ch == '\n') {
tmpbuf[j] = '\0';
buf[i] = new char[strlen(tmpbuf)];
strcpy(buf[i++], tmpbuf);
j = 0;
}
}
delete tmpbuf;
f_in.close();
return i;
}
/***********************************************
* Writes the content of the buffer to the
* of the result data file.
***********************************************/
void writeToFile(char *fname, int numLine, char **buf) {
ofstream f_out(fname);
if (!f_out) {
cerr << "Error in reading file %s.\n" << fname;
exit(1);
}
int i;
for(i = 0; i < numLine; i++) {
f_out << buf[i];
}
f_out.close();
}

18
xpcom/remote/tests/deftest.h
View File

@ -1,18 +0,0 @@
#define BUF_MAX 500
#define BUF_MIN 100
#define SERVER_IN_RES "serverIn.res"
#define CLIENT_IN_RES "clientIn.res"
#define SERVER_OUT_RES "serverOut.res"
#define CLIENT_OUT_RES "clientOut.res"
#define SERVER_INOUT_RES "serverInOut.res"
#define CLIENT_INOUT_RES "clientInOut.res"
#define SERVER_COMB_RES "serverComb.res"
#define CLIENT_COMB_RES "clientComb.res"
#define IN_FDATA "fileIn.dat"
#define OUT_FDATA "fileOut.dat"
#define INOUT_FDATA "fileInOut.dat"
#define COMB_FDATA "fileComb.dat"
#define USHRT_MIN 555
#define ULONG_MIN 555

10
xpcom/remote/tests/nsIRPCTest.idl
View File

@ -1,10 +0,0 @@
#include "nsISupports.idl"
[scriptable, uuid(e7fc2bf4-1dd1-11b2-9253-8efe01a2f0d2)]
interface nsIRPCTest : nsISupports
{
void test1(inout long l);
void test2(in long l1,inout long l2);
void test3(in string s1,inout string s2);
void test4(in PRUint32 count,[array, size_is(count)] in string valueArray);
};

47
xpcom/remote/tests/nsIRPCTestComb.idl
View File

@ -1,47 +0,0 @@
#include "nsISupports.idl"
[scriptable, uuid(89eb8f10-c211-11d3-ad2a-005004159574)]
interface nsIRPCTestComb : nsISupports
{
void testComb1(in boolean bool, out char c);
void testComb2(in boolean bool, inout string str);
void testComb3(out char c, inout string str);
void testComb4(inout string str, in boolean bool, out char c);
void testComb5(in short s, out char c);
void testComb6(in boolean bool, out short s);
void testComb7(in boolean bool, inout short s);
void testComb8(in boolean bool, in short s);
void testComb9(in boolean bool, in char c);
void testComb10(in boolean bool, out string str);
void testComb11(in boolean bool, inout char c);
void testComb12(in boolean bool, out long l);
void testComb13(in boolean bool, inout long l);
void testComb14(in boolean bool, in long l);
void testComb15(in boolean bool, out double d);
void testComb16(in boolean bool, inout double d);
void testComb17(in boolean bool, inout unsigned short us);
void testComb18(in boolean bool, out unsigned short us);
void testComb19(in boolean bool, out octet o);
void testComb20(in boolean bool, inout octet o);
void testComb21(in boolean bool, in octet o);
void testComb22(in boolean bool, in boolean bool2);
void testComb23(in boolean bool, inout boolean bool2);
void testComb24(in boolean bool, out boolean bool2);
void testComb25(out boolean bool, out char c);
void testComb26(inout boolean bool, out char c);
void testComb27(in boolean bool, out wchar wc);
void testComb30(in string s1, out string s2);
void testComb31(out octet o, out unsigned short us);
void testComb32(out octet o, out long l);
void testComb33(out long l, out unsigned short us);
// void testComb36(inout boolean bBool, inout char cChar, inout octet nByte,
// inout short nShort, inout unsigned short nUShort,
// inout long nLong, inout unsigned long nULong,
// inout long long nHyper, inout unsigned long long nUHyper,
// inout float fFloat, inout double fDouble,
// inout wstring aString);
};

38
xpcom/remote/tests/nsIRPCTestIn.idl
View File

@ -1,38 +0,0 @@
#include "nsISupports.idl"
[scriptable, uuid(9cc10d00-b191-11d3-ad1e-005004159574)]
interface nsIRPCTestIn : nsISupports
{
void testIn1(in boolean bool);
void testIn2(in octet oct);
void testIn3(in short s);
void testIn4(in long l);
void testIn5(in long long ll);
void testIn6(in unsigned short us);
void testIn7(in unsigned long ul);
void testIn8(in unsigned long long ull);
void testIn9(in float f);
void testIn10(in double d);
void testIn11(in char c);
void testIn12(in wchar wc);
void testIn13(in string str);
void testIn14(in wstring wstr);
// WONT RUN void testIn15(in long count,[array, size_is(count)] in string valueArray);
void testIn15(in unsigned long count,[array, size_is(count)] in string valueArray);
void testIn16(in unsigned long count, [array, size_is(count)] in long longArray);
void testIn17(in boolean bBool, in char cChar, in octet nByte,
in short nShort, in unsigned short nUShort,
in long nLong, in unsigned long nULong,
in long long nHyper, in unsigned long long nUHyper,
in float fFloat, in double fDouble,
in string aString,
in unsigned long count, [array, size_is(count)] in long longArray);
void testIn18(in char cChar, in octet nByte,
in short nShort, in unsigned short nUShort,
in long nLong, in unsigned long nULong,
in long long nHyper, in unsigned long long nUHyper,
in float fFloat, in double fDouble,
in string aString,
in unsigned long count, [array, size_is(count)] in long longArray);
};

34
xpcom/remote/tests/nsIRPCTestInOut.idl
View File

@ -1,34 +0,0 @@
#include "nsISupports.idl"
[scriptable, uuid(16d17950-cdf5-11d3-ad2e-005004159574)]
interface nsIRPCTestInOut : nsISupports
{
void testInOut1(inout boolean bool);
void testInOut2(inout octet oct);
void testInOut3(inout short s);
void testInOut4(inout long l);
void testInOut5(inout long long ll);
void testInOut6(inout unsigned short us);
void testInOut7(inout unsigned long ul);
void testInOut8(inout unsigned long long ull);
void testInOut9(inout float f);
void testInOut10(inout double d);
void testInOut11(inout char c);
void testInOut12(inout wchar wc);
void testInOut13(inout string str);
void testInOut14(inout wstring wstr);
void testInOut15(inout unsigned long count, [array, size_is(count)] inout char array);
void testInOut16(inout boolean bBool, inout char cChar,
inout unsigned short nUShort,
inout long nLong, inout unsigned long nULong,
inout long long nHyper, inout unsigned long long nUHyper,
inout float fFloat, inout double fDouble,
inout string aString);
void testInOut17(inout unsigned long count, [array, size_is(count)] inout long array);
void testInOut18(inout boolean bBool, inout char cChar, inout octet nByte,
inout short nShort, inout unsigned short nUShort,
inout long nLong, inout unsigned long nULong,
inout long long nHyper, inout unsigned long long nUHyper,
inout float fFloat, inout double fDouble,
inout string aString);
};

28
xpcom/remote/tests/nsIRPCTestOut.idl
View File

@ -1,28 +0,0 @@
#include "nsISupports.idl"
[scriptable, uuid(e284f6a0-b701-11d3-ad26-005004159574)]
interface nsIRPCTestOut : nsISupports
{
void testOut1(out boolean bool);
void testOut2(out octet oct);
void testOut3(out short s);
void testOut4(out long l);
void testOut5(out long long ll);
void testOut6(out unsigned short us);
void testOut7(out unsigned long ul);
void testOut8(out unsigned long long ull);
void testOut9(out float f);
void testOut10(out double d);
void testOut11(out char c);
void testOut12(out wchar wc);
void testOut13(out string str);
void testOut14(out wstring wstr);
void testOut15(out unsigned long count, [array, size_is(count)] out char array);
void testOut16(out boolean bBool, out char cChar, out octet nByte,
out short nShort, out unsigned short nUShort,
out long nLong, out unsigned long nULong,
out long long nHyper, out unsigned long long nUHyper,
out float fFloat, out double fDouble,
out string aString);
void testOut17(out unsigned long count, [array, size_is(count)] out long array);
};

5
xpcom/remote/tests/proto.h
View File

@ -1,5 +0,0 @@
void setProcessId(char *);
void getProcessId(char *, char *s);
void writeResult(char *, char *);
void writeToFile(char *, int, char **);
int readFromFile(char *, char **);

2
xpcom/remote/tests/sComb
View File

@ -1,2 +0,0 @@
clean
serverComb

2
xpcom/remote/tests/sIO
View File

@ -1,2 +0,0 @@
clean
serverInOut

2
xpcom/remote/tests/sIn
View File

@ -1,2 +0,0 @@
clean
serverIn

2
xpcom/remote/tests/sOut
View File

@ -1,2 +0,0 @@
clean
serverOut

59
xpcom/remote/tests/server.cpp
View File

@ -1,59 +0,0 @@
#include <stdio.h>
#include "RPCServerService.h"
#include "nsISupports.h"
#include "nsIJVMManager.h"
#include "nsIRPCTest.h"
#include <unistd.h>
#include "IDispatcher.h"
#include "nsIThread.h"
class nsRPCTestImpl : public nsIRPCTest {
NS_DECL_ISUPPORTS
nsRPCTestImpl() {
NS_INIT_REFCNT();
}
NS_IMETHOD Test1(PRInt32 *l) {
printf("Test1 this=%p\n", this);
printf("--nsRPCTestImpl::Test1 %d\n",*l);
*l = 1234;
printf("--nsRPCTestImpl::Test1 %d\n",*l);
return NS_OK;
}
NS_IMETHOD Test2(PRInt32 l1, PRInt32* l2) {
printf("Test2 this=%p\n", this);
printf("--nsRPCTestImpl::Test2 %d %d\n",l1,*l2);
*l2 = l1;
printf("--nsRPCTestImpl::Test2 %d %d\n",l1,*l2);
return NS_OK;
}
NS_IMETHOD Test3(const char *s1, char **s2) {
printf("Test3 s1 %s s2 %s\n",s1,*s2);
*s2 = "hi";
return NS_OK;
}
NS_IMETHOD Test4(PRUint32 count, const char **valueArray) {
printf("--Test4\n");
printf("count %d\n",count);
for (int i = 0; i < count; i++) {
printf("--valueArray[%d]=%s\n",i,valueArray[i]);
}
return NS_OK;
}
};
NS_IMPL_ISUPPORTS1(nsRPCTestImpl, nsIRPCTest)
int main(int argc, char **args) {
printf("%x\n",getpid());
nsRPCTestImpl * test1 = new nsRPCTestImpl();
nsRPCTestImpl * test2 = new nsRPCTestImpl();
RPCServerService * rpcService = RPCServerService::GetInstance();
IDispatcher *dispatcher;
rpcService->GetDispatcher(&dispatcher);
dispatcher->RegisterWithOID(test1, 1);
dispatcher->RegisterWithOID(test2, 5);
while(1) {
PR_Sleep(100);
}
}

431
xpcom/remote/tests/serverComb.cpp
View File

@ -1,431 +0,0 @@
#include <stdio.h>
#include <stream.h>
#include <fstream.h>
#include <stdlib.h>
#include "RPCServerService.h"
#include "nsISupports.h"
#include "nsIJVMManager.h"
#include "nsIRPCTestComb.h"
#include "IDispatcher.h"
#include "nsIThread.h"
#include "deftest.h"
#include "proto.h"
class nsRPCTestCombImpl : public nsIRPCTestComb {
NS_DECL_ISUPPORTS
nsRPCTestCombImpl() {
NS_INIT_REFCNT();
}
NS_IMETHOD TestComb1(PRBool bool, char *c) {
printf("TestComb1 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test1 %d\n",bool);
printf("Before character assignment.\n");
*c = 'Z';
printf("After character assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb1 %c\n",*c);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb2(PRBool bool, char **s) {
printf("TestComb2 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test2 %d\n",bool);
printf("--nsRPCTestCombImpl::Test2 %s\n",*s);
printf("Before string assignment.\n");
*s = "Remote ipc tests.";
printf("After string assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb2 %s\n",*s);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb3(char *c, char **s) {
printf("TestComb3 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test3 %s\n",*s);
printf("Before character assignment.\n");
*c = 'Z';
printf("After character assignment.\n");
printf("Before string assignment.\n");
*s = "Remote ipc tests.";
printf("After string assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb3 %c %s\n",*c,*s);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb4(char **s, PRBool bool, char *c) {
printf("TestComb4 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test4 %d\n",bool);
printf("--nsRPCTestCombImpl::Test4 %s\n",*s);
printf("Before character assignment.\n");
*c = 'Z';
printf("After character assignment.\n");
printf("Before string assignment.\n");
*s = "Remote ipc tests.";
printf("After string assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb4 %c %s\n",*c,*s);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb5(PRInt16 sInt, char *c) {
printf("TestComb5 this=%p\n", this);
printf("Before character assignment.\n");
*c = 'Z';
printf("After character assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb5 %c\n",*c);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb6(PRBool bool, PRInt16 *sInt) {
printf("TestComb6 this=%p\n", this);
printf("Before short int assignment.\n");
*sInt = 777;
printf("After short int assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb6 %d\n",*sInt);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb7(PRBool bool, PRInt16 *sInt) {
printf("TestComb7 this=%p\n", this);
printf("--nsRPCTestCombInImpl::Test7 %d\n",*sInt);
printf("Before short int assignment.\n");
*sInt = 777;
printf("After short int assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb7 %d\n",*sInt);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb8(PRBool bool, PRInt16 sInt) {
printf("TestComb8 this=%p\n", this);
printf("--nsRPCTestCombInImpl::Test8 %d\n",sInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb8 %d %d\n",bool, sInt);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb9(PRBool bool, char c) {
printf("TestComb9 this=%p\n", this);
printf("--nsRPCTestCombInImpl::Test9 %d\n",c);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb9 %d %c\n",bool, c);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb10(PRBool bool, char **s) {
printf("TestComb10 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test10 %d\n",bool);
printf("Before string assignment.\n");
*s = "Remote ipc tests.";
printf("After string assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb10 %s\n",*s);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb11(PRBool bool, char *c) {
printf("TestComb11 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test11 %d\n",*c);
*c = 'Z';
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb11 %c\n",*c);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb12(PRBool bool, PRInt32 *l) {
printf("TestComb12 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test12 %d\n",bool);
*l = 99999999;
printf("After long integer assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb12 %d\n",*l);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb13(PRBool bool, PRInt32 *l) {
printf("TestComb13 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test13 %d\n",bool);
printf("--nsRPCTestCombImpl::Test13 %d\n",*l);
*l = 99999999;
printf("After long integer assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb13 %d\n",*l);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb14(PRBool bool, PRInt32 l) {
printf("TestComb14 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test14 %d\n",bool);
printf("--nsRPCTestCombImpl::Test14 %d\n",l);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb14 %d %d\n",bool, l);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb15(PRBool bool, double *d) {
printf("TestComb15 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test15 %d\n",bool);
*d = 9999999.9999999;
printf("After long integer assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb15 %.50f\n",*d);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb16(PRBool bool, double *d) {
printf("TestComb16 this=%p\n", this);
printf("--nsRPCTestCombImpl::Test16 %d\n",bool);
printf("--nsRPCTestCombImpl::Test16 %d\n",*d);
*d = 9999999.9999999;
printf("After long integer assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb16 %.50f\n", *d);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb17(PRBool bool, PRUint16 *usInt) {
printf("TestComb17 this=%p\n", this);
printf("--nsRPCTestCombInImpl::Test17 %d\n",*usInt);
printf("Before unsigned short int assignment.\n");
*usInt = 777;
printf("After unsigned short int assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb17 %d\n",*usInt);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb18(PRBool bool, PRUint16 *usInt) {
printf("TestComb18 this=%p\n", this);
printf("Before unsigned short int assignment.\n");
*usInt = 777;
printf("After unsigned short int assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb18 %d\n",*usInt);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb19(PRBool bool, PRUint8 *oct) {
printf("TestComb19 this=%p\n", this);
printf("Before assignment.\n");
*oct = 77;
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb19 %o\n",*oct);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb20(PRBool bool, PRUint8 *oct) {
printf("TestComb20 this=%p\n", this);
printf("--nsRPCTestCombInImpl::Test20 %d\n",*oct);
printf("Before assignment.\n");
*oct = 77;
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb20 %o\n",*oct);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb21(PRBool bool, PRUint8 oct) {
printf("TestComb21 this=%p\n", this);
printf("--nsRPCTestCombInImpl::Test21 %d\n",oct);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb21 %d %o\n",bool,oct);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb22(PRBool bool, PRBool bool2 ) {
printf("TestComb22 this=%p\n", this);
printf("--nsRPCTestCombInImpl::Test22 %d\n",bool2);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb22 %d %d\n",bool,bool2);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb23(PRBool bool, PRBool *bool2 ) {
printf("TestComb23 this=%p\n", this);
printf("--nsRPCTestCombInImpl::Test23 %d\n",*bool2);
printf("Before assignment.\n");
*bool2 = PR_FALSE;
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb23 %d\n",*bool2);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb24(PRBool bool, PRBool *bool2 ) {
printf("TestComb24 this=%p\n", this);
printf("Before assignment.\n");
*bool2 = PR_FALSE;
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb24 %d\n",*bool2);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb25(PRBool *bool, char *c) {
printf("TestComb25 this=%p\n", this);
printf("Before assignment.\n");
*bool = PR_FALSE;
*c = 'Z';
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb25 %d %c\n",*bool,*c);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb26(PRBool *bool, char *c) {
printf("TestComb26 this=%p\n", this);
printf("--nsRPCTestCombInImpl::Test26 %d\n",*bool);
printf("Before assignment.\n");
*bool = PR_FALSE;
*c = 'Z';
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb26 %d %c\n",*bool,*c);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb27(PRBool bool, PRUnichar *wc) {
printf("TestComb27 this=%p\n", this);
printf("Before assignment.\n");
*wc = 'Z';
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb27 %c\n",*wc);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb30(const char *s1, char **s2) {
printf("TestComb30 this=%p\n", this);
printf("Before assignment.\n");
*s2 = "Remote ipc test.";
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb30 %s\n",*s2);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb31(PRUint8 *o, PRUint16 *usInt) {
printf("TestComb31 this=%p\n", this);
printf("Before assignment.\n");
*o = 777;
*usInt = 999;
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb31 %o %u\n",*o,*usInt);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb32(PRUint8 *o, PRInt32 *lInt) {
printf("TestComb32 this=%p\n", this);
printf("Before assignment.\n");
*o = 99;
*lInt = 9999999;
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb32 %o %u\n",*o,*lInt);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestComb33(PRInt32 *lInt, PRUint16 *us) {
printf("TestComb33 this=%p\n", this);
printf("Before assignment.\n");
*us = 777;
*lInt = 9999999;
printf("After assignment.\n");
char *tmpstr = new char[200];
sprintf(tmpstr,"TestComb33 %d %u\n",*lInt,*us);
writeResult(SERVER_COMB_RES,tmpstr);
delete tmpstr;
return NS_OK;
}
};
NS_IMPL_ISUPPORTS1(nsRPCTestCombImpl, nsIRPCTestComb)
int main(int argc, char **args)
{
int i;
const short num = 4;
nsRPCTestCombImpl * test[num];
setProcessId(COMB_FDATA);
for(i = 0; i < num; i++) {
test[i] = new nsRPCTestCombImpl();
}
RPCServerService * rpcService = RPCServerService::GetInstance();
IDispatcher *dispatcher;
rpcService->GetDispatcher(&dispatcher);
for(i = 0; i < num; i++) {
dispatcher->RegisterWithOID(test[i], i + 1);
}
while(1) {
PR_Sleep(100);
}
}

304
xpcom/remote/tests/serverIn.cpp
View File

@ -1,304 +0,0 @@
#include <stdio.h>
#include <stream.h>
#include <fstream.h>
#include <stdlib.h>
#include "RPCServerService.h"
#include "nsISupports.h"
#include "nsIJVMManager.h"
#include "nsIRPCTestIn.h"
#include "IDispatcher.h"
#include "nsIThread.h"
#include "deftest.h"
#include "proto.h"
class nsRPCTestInImpl : public nsIRPCTestIn {
NS_DECL_ISUPPORTS
nsRPCTestInImpl() {
NS_INIT_REFCNT();
}
NS_IMETHOD TestIn1(PRBool bool) {
printf("TestIn1 this=%p\n", this);
printf("--nsRPCTestInImpl::Test1 %d\n",bool);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn1 %d\n",bool);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn2(PRUint8 octet) {
printf("TestIn2 this=%p\n", this);
printf("--nsRPCTestInImpl::Test2 %d\n",octet);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn2 %o\n",octet);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn3(PRInt16 sInt) {
printf("TestIn3 this=%p\n", this);
printf("--nsRPCTestInImpl::Test3 %d\n",sInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn3 %d\n",sInt);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn4(PRInt32 lInt) {
printf("TestIn4 this=%p\n", this);
printf("--nsRPCTestInImpl::Test4 %d\n",lInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn4 %d\n",lInt);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn5(PRInt64 llInt) {
printf("TestIn5 this=%p\n", this);
printf("--nsRPCTestInImpl::Test5 %d\n",llInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn5 %d\n",llInt);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn6(PRUint16 usInt) {
printf("TestIn6 this=%p\n", this);
printf("--nsRPCTestInImpl::Test6 %u\n",usInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn6 %u\n",usInt);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn7(PRUint32 ulInt) {
printf("TestIn7 this=%p\n", this);
printf("--nsRPCTestInImpl::Test7 %u\n",ulInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn7 %u\n",ulInt);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn8(PRUint64 ullInt) {
printf("TestIn8 this=%p\n", this);
printf("--nsRPCTestInImpl::Test8 %u\n",ullInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn8 %u\n",ullInt);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn9(float f) {
printf("TestIn9 this=%p\n", this);
printf("--nsRPCTestInImpl::Test9 %.50f\n",f);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn9 %.50f\n",f);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn10(double d) {
printf("TestIn10 this=%p\n", this);
printf("--nsRPCTestInImpl::Test10 %.50f\n",d);
char *tmpstr = new char[500];
sprintf(tmpstr,"TestIn10 %.50f\n",d);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn11(char c) {
printf("TestIn11 this=%p\n", this);
printf("--nsRPCTestInImpl::Test11 %c\n",c);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn11 %c\n",c);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn12(PRUnichar unic) {
printf("TestIn12 this=%p\n", this);
printf("--nsRPCTestInImpl::Test12 %c\n",unic);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn12 %c\n",unic);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn13(const char* s) {
printf("TestIn13 this=%p\n", this);
printf("--nsRPCTestInImpl::Test13 %s\n",s);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn13 %s\n",s);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn14(const PRUnichar* unis) {
printf("TestIn14 this=%p\n", this);
printf("--nsRPCTestInImpl::Test14 %s\n",unis);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn14 %s\n",unis);
writeResult(SERVER_IN_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn15(PRUint32 count, const char **valueArray) {
printf("--TestIn15\n");
printf("count %d\n",count);
char *tmpstr = new char[200];
sprintf(tmpstr, "TestIn15 count %d\n", count);
writeResult(SERVER_IN_RES, tmpstr);
for (int i = 0; i < count; i++) {
printf("TestIn15 Array[%d]=%s\n",i,valueArray[i]);
sprintf(tmpstr,"TestIn15 Array[%d]=%s\n",i,valueArray[i]);
writeResult(SERVER_IN_RES, tmpstr);
}
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn16(PRUint32 count, PRInt32 *longArray) {
printf("--TestIn16\n");
printf("count %d\n",count);
char *tmpstr = new char[200];
sprintf(tmpstr, "TestIn16 count %d\n", count);
writeResult(SERVER_IN_RES, tmpstr);
for (int i = 0; i < count; i++) {
printf("TestIn16 Array[%d]=%d\n",i,longArray[i]);
sprintf(tmpstr,"TestIn16 Array[%d]=%d\n",i,longArray[i]);
writeResult(SERVER_IN_RES, tmpstr);
}
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn17(PRBool bBool, char cChar, PRUint8 nByte,
PRInt16 nShort, PRUint16 nUShort,
PRInt32 nLong,PRUint32 nULong,
PRInt64 nHyper, PRUint64 nUHyper,
float fFloat, double fDouble, const char *aString,
PRUint32 count, PRInt32 *longArray)
{
printf("TestIn17 this=%p\n", this) ;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn17 PRBool %d\n",bBool);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 PRUint8 %o\n",nByte);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 PRInt16 %d\n",nShort);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 PRInt32 %d\n",nLong);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 PRInt64 %d\n",nHyper);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 PRUint16 %u\n",nUShort);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 PRUint32 %u\n",nULong);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 PRUint64 %u\n",nUHyper);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 float %.50f\n",fFloat);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 double %.50f\n",fDouble);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 char %c\n",cChar);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 string %s\n",aString);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn17 count %d\n", count);
writeResult(SERVER_IN_RES, tmpstr);
for (int i = 0; i < count; i++) {
printf("TestIn17 Array[%d]=%d\n",i,longArray[i]);
sprintf(tmpstr,"TestIn17 Array[%d]=%d\n",i,longArray[i]);
writeResult(SERVER_IN_RES, tmpstr);
}
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestIn18(char cChar, PRUint8 nByte,
PRInt16 nShort, PRUint16 nUShort,
PRInt32 nLong,PRUint32 nULong,
PRInt64 nHyper, PRUint64 nUHyper,
float fFloat, double fDouble, const char *aString,
PRUint32 count, PRInt32 *longArray)
{
printf("TestIn18 this=%p\n", this);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestIn18 PRUint8 %o\n",nByte);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 PRInt16 %d\n",nShort);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 PRInt32 %d\n",nLong);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 PRInt64 %d\n",nHyper);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 PRUint16 %u\n",nUShort);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 PRUint32 %u\n",nULong);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 PRUint64 %u\n",nUHyper);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 float %.50f\n",fFloat);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 double %.50f\n",fDouble);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 char %c\n",cChar);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 string %s\n",aString);
writeResult(SERVER_IN_RES, tmpstr);
sprintf(tmpstr,"TestIn18 count %d\n", count);
writeResult(SERVER_IN_RES, tmpstr);
for (int i = 0; i < count; i++) {
printf("TestIn18 Array[%d]=%d\n",i,longArray[i]);
sprintf(tmpstr,"TestIn18 Array[%d]=%d\n",i,longArray[i]);
writeResult(SERVER_IN_RES, tmpstr);
}
delete tmpstr;
return NS_OK;
}
};
NS_IMPL_ISUPPORTS1(nsRPCTestInImpl, nsIRPCTestIn)
int main(int argc, char **args) {
int i;
const short num = 2;
nsRPCTestInImpl * test[num];
setProcessId(IN_FDATA);
for(i = 0; i < num; i++) {
test[i] = new nsRPCTestInImpl();
}
RPCServerService * rpcService = RPCServerService::GetInstance();
IDispatcher *dispatcher;
rpcService->GetDispatcher(&dispatcher);
for(i = 0; i < num; i++) {
dispatcher->RegisterWithOID(test[i], i + 1);
}
while(1) {
PR_Sleep(100);
}
}

461
xpcom/remote/tests/serverInOut.cpp
View File

@ -1,461 +0,0 @@
#include <stdio.h>
#include <stream.h>
#include <fstream.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>
#include "RPCServerService.h"
#include "nsISupports.h"
#include "nsIJVMManager.h"
#include "nsIRPCTestInOut.h"
#include "IDispatcher.h"
#include "nsIThread.h"
#include "deftest.h"
#include "proto.h"
class nsRPCTestInOutImpl : public nsIRPCTestInOut {
NS_DECL_ISUPPORTS
nsRPCTestInOutImpl() {
NS_INIT_REFCNT();
}
NS_IMETHOD TestInOut1(PRBool *bool) {
printf("TestInOut1 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test1 %d\n",*bool);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut1 before %d\n",*bool);
writeResult(SERVER_INOUT_RES, tmpstr);
*bool = PR_FALSE;
sprintf(tmpstr,"TestInOut1 after %d\n",*bool);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut2(PRUint8 *octet) {
printf("TestInOut2 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test2 %o\n",*octet);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut2 before %o\n",*octet);
writeResult(SERVER_INOUT_RES, tmpstr);
*octet = 88;
sprintf(tmpstr,"TestInOut2 after %o\n",*octet);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut3(PRInt16 *sInt) {
printf("TestInOut3 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test3 %d\n",*sInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut3 before %d\n",*sInt);
writeResult(SERVER_INOUT_RES, tmpstr);
*sInt = SHRT_MAX;
sprintf(tmpstr,"TestInOut3 after %d\n",*sInt);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut4(PRInt32 *lInt) {
printf("TestInOut4 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test4 %d\n",*lInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut4 before %l\n",*lInt);
writeResult(SERVER_INOUT_RES, tmpstr);
*lInt = LONG_MAX;
sprintf(tmpstr,"TestInOut4 after %l\n",*lInt);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut5(PRInt64 *llInt) {
printf("TestInOut5 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test5 %d\n",*llInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut5 before %l\n",*llInt);
writeResult(SERVER_INOUT_RES, tmpstr);
*llInt = LONG_MAX;
sprintf(tmpstr,"TestInOut5 after %l\n",*llInt);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut6(PRUint16 *usInt) {
printf("TestInOut6 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test6 %15u\n",*usInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut6 before %10u\n",*usInt);
writeResult(SERVER_INOUT_RES, tmpstr);
*usInt = USHRT_MAX;
sprintf(tmpstr,"TestInOut6 after %10u\n",*usInt);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut7(PRUint32 *ulInt) {
printf("TestInOut7 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test7 %15u\n",*ulInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut7 before %10u\n",*ulInt);
writeResult(SERVER_INOUT_RES, tmpstr);
*ulInt = ULONG_MAX;
sprintf(tmpstr,"TestInOut7 after %10u\n",*ulInt);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut8(PRUint64 *ullInt) {
printf("TestInOut8 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test8 %15u\n",*ullInt);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut8 before %10u\n",*ullInt);
writeResult(SERVER_INOUT_RES, tmpstr);
*ullInt = ULONG_MAX;
sprintf(tmpstr,"TestInOut8 after %10u\n",*ullInt);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut9(float *f) {
printf("TestInOut9 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test9 %.50f\n",*f);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut9 before %.50f\n",*f);
writeResult(SERVER_INOUT_RES, tmpstr);
*f = FLT_MAX;
sprintf(tmpstr,"TestInOut9 after %.50f\n",*f);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut10(double *d) {
printf("TestInOut10 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test10 %.50f\n",*d);
char *tmpstr = new char[500];
sprintf(tmpstr,"TestInOut10 before %.50f\n",*d);
writeResult(SERVER_INOUT_RES, tmpstr);
*d = DBL_MAX;
sprintf(tmpstr,"TestInOut10 after %.50f\n",*d);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut11(char *c) {
printf("TestInOut11 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test11 %c\n",*c);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut11 before %c\n",*c);
printf("THIS THIS THIS IS A TEST.... %s\n", tmpstr);
writeResult(SERVER_INOUT_RES, tmpstr);
*c = 'G';
sprintf(tmpstr,"TestInOut11 after %c\n",*c);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut12(PRUnichar *unic) {
printf("TestInOut12 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test12 %c\n",*unic);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut12 before %c\n",*unic);
writeResult(SERVER_INOUT_RES, tmpstr);
*unic = 'G';
sprintf(tmpstr,"TestInOut12 after %c\n",*unic);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut13(char **s) {
printf("TestInOut13 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test13 %s\n",*s);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut13 before %s\n",*s);
writeResult(SERVER_INOUT_RES, tmpstr);
*s = "remote ipc";
sprintf(tmpstr,"TestInOut13 after %s\n",*s);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut14(PRUnichar **unis) {
printf("TestInOut14 this=%p\n", this);
printf("--nsRPCTestInOutImpl::Test14 %s\n",*unis);
char *tmpstr = new char[200];
sprintf(tmpstr,"TestInOut14 before %s\n",*unis);
writeResult(SERVER_INOUT_RES, tmpstr);
//*unis = "remote ipc";
for (int i = 0; i < 10; i++) {
(*unis)[i] = 'a' + 1;
}
(*unis)[i] = '\0';
sprintf(tmpstr,"TestInOut14 after %s\n",*unis);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut15(PRUint32 *count, char **valueArray) {
printf("--TestInOut15\n");
char *tmpstr = new char[200];
printf("TestInOut15 before count %d\n", *count);
sprintf(tmpstr, "TestInOut15 before count %d\n", *count);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut15 before valueArray %s\n", *valueArray);
sprintf(tmpstr,"TestInOut15 before Array=%s\n",*valueArray);
writeResult(SERVER_INOUT_RES, tmpstr);
*valueArray = "Going in... remote ipc test.";
*count = strlen(*valueArray);
printf("TestInOut15 after count %d\n", *count);
sprintf(tmpstr, "TestInOut15 after count %d\n", *count);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut15 after valueArray %s\n", *valueArray);
sprintf(tmpstr,"TestInOut15 after Array=%s\n",*valueArray);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut16(PRBool *bBool, char *cChar,
PRUint16 *nUShort,
PRInt32 *nLong,PRUint32 *nULong,
PRInt64 *nHyper, PRUint64 *nUHyper,
float *fFloat, double *fDouble, char **aString)
{
printf("TestInOut16 before this=%p\n", this) ;
char *tmpstr = new char[200];
printf("TestInOut16 before %d\n",*bBool);
sprintf(tmpstr,"TestInOut16 before %d\n",*bBool);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 before %d\n",*nLong);
sprintf(tmpstr,"TestInOut16 before %d\n",*nLong);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 before %d\n",*nHyper);
sprintf(tmpstr,"TestInOut16 before %d\n",*nHyper);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 before %u\n",*nUShort);
sprintf(tmpstr,"TestInOut16 before %u\n",*nUShort);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 before %u\n",*nULong);
sprintf(tmpstr,"TestInOut16 before %u\n",*nULong);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 before %u\n",*nUHyper);
sprintf(tmpstr,"TestInOut16 before %u\n",*nUHyper);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 before %.50f\n",*fFloat);
sprintf(tmpstr,"TestInOut16 before %.50f\n",*fFloat);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 before %.50f\n",*fDouble);
sprintf(tmpstr,"TestInOut16 before %.50f\n",*fDouble);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 before %c\n",*cChar);
sprintf(tmpstr,"TestInOut16 before %c\n",*cChar);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 before %s\n",*aString);
sprintf(tmpstr,"TestInOut16 before %s\n",*aString);
writeResult(SERVER_INOUT_RES, tmpstr);
*bBool = PR_TRUE;
*cChar = 'A';
*nUShort = 2;
*nLong = 3;
*nULong = 4;
*nHyper = 5;
*nUHyper = 6;
*fFloat = 7;
*fDouble = 8;
*aString = "Remote ipc test.";
printf("TestInOut16 after %d\n",*bBool);
sprintf(tmpstr,"TestInOut16 after %d\n",*bBool);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 after %d\n",*nLong);
sprintf(tmpstr,"TestInOut16 after %d\n",*nLong);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 after %d\n",*nHyper);
sprintf(tmpstr,"TestInOut16 after %d\n",*nHyper);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 after %u\n",*nUShort);
sprintf(tmpstr,"TestInOut16 after %u\n",*nUShort);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 after %u\n",*nULong);
sprintf(tmpstr,"TestInOut16 after %u\n",*nULong);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 after %u\n",*nUHyper);
sprintf(tmpstr,"TestInOut16 after %u\n",*nUHyper);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 after %.50f\n",*fFloat);
sprintf(tmpstr,"TestInOut16 after %.50f\n",*fFloat);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 after %.50f\n",*fDouble);
sprintf(tmpstr,"TestInOut16 after %.50f\n",*fDouble);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 after %c\n",*cChar);
sprintf(tmpstr,"TestInOut16 after %c\n",*cChar);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut16 after %s\n",*aString);
sprintf(tmpstr,"TestInOut16 after %s\n",*aString);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut17(PRUint32 *count, PRInt32 **longArray) {
printf("--TestInOut17\n");
char *tmpstr = new char[200];
sprintf(tmpstr, "TestInOut17 before count %d\n", *count);
writeResult(SERVER_INOUT_RES, tmpstr);
for (int i = 0; i < *count; i++) {
printf("TestInOut17 before Array[%d]=%d\n",i,(*longArray)[i]);
sprintf(tmpstr,"TestInOut17 before Array[%d]=%d\n",i,(*longArray)[i]);
writeResult(SERVER_INOUT_RES, tmpstr);
}
*count = 5;
sprintf(tmpstr, "TestInOut17 after count %d\n", *count);
writeResult(SERVER_INOUT_RES, tmpstr);
*longArray = new PRInt32[*count];
for (i = 0; i < *count; i++) {
//longArray[i] = new PRInt32;
(*longArray)[i] = 55555 + i;
printf("TestInOut17 after Array[%d]=%d\n",i,(*longArray)[i]);
sprintf(tmpstr,"TestInOut17 after Array[%d]=%d\n",i,(*longArray)[i]);
writeResult(SERVER_INOUT_RES, tmpstr);
}
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestInOut18(PRBool *bBool, char *cChar, PRUint8 *nByte,
PRInt16 *nShort, PRUint16 *nUShort,
PRInt32 *nLong,PRUint32 *nULong,
PRInt64 *nHyper, PRUint64 *nUHyper,
float *fFloat, double *fDouble, char **aString)
{
printf("TestInOut18 before this=%p\n", this) ;
char *tmpstr = new char[200];
printf("TestInOut18 before %d\n",*bBool);
sprintf(tmpstr,"TestInOut18 before %d\n",*bBool);
writeResult(SERVER_INOUT_RES, tmpstr);
sprintf(tmpstr,"TestInOut18 before %o\n",*nByte);
writeResult(SERVER_INOUT_RES, tmpstr);
sprintf(tmpstr,"TestInOut18 before %d\n",*nShort);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 before %d\n",*nLong);
sprintf(tmpstr,"TestInOut18 before %d\n",*nLong);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 before %d\n",*nHyper);
sprintf(tmpstr,"TestInOut18 before %d\n",*nHyper);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 before %u\n",*nUShort);
sprintf(tmpstr,"TestInOut18 before %u\n",*nUShort);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 before %u\n",*nULong);
sprintf(tmpstr,"TestInOut18 before %u\n",*nULong);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 before %u\n",*nUHyper);
sprintf(tmpstr,"TestInOut18 before %u\n",*nUHyper);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 before %.50f\n",*fFloat);
sprintf(tmpstr,"TestInOut18 before %.50f\n",*fFloat);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 before %.50f\n",*fDouble);
sprintf(tmpstr,"TestInOut18 before %.50f\n",*fDouble);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 before %c\n",*cChar);
sprintf(tmpstr,"TestInOut18 before %c\n",*cChar);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 before %s\n",*aString);
sprintf(tmpstr,"TestInOut18 before %s\n",*aString);
writeResult(SERVER_INOUT_RES, tmpstr);
*bBool = PR_TRUE;
*nByte = 777;
*cChar = 'A';
*nShort = 1;
*nUShort = 2;
*nLong = 3;
*nULong = 4;
*nHyper = 5;
*nUHyper = 6;
*fFloat = 7;
*fDouble = 8;
*aString = "Remote ipc test.";
printf("TestInOut18 after %d\n",*bBool);
sprintf(tmpstr,"TestInOut18 after %d\n",*bBool);
writeResult(SERVER_INOUT_RES, tmpstr);
sprintf(tmpstr,"TestInOut18 after %o\n",*nByte);
writeResult(SERVER_INOUT_RES, tmpstr);
sprintf(tmpstr,"TestInOut18 after %d\n",*nShort);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 after %d\n",*nLong);
sprintf(tmpstr,"TestInOut18 after %d\n",*nLong);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 after %d\n",*nHyper);
sprintf(tmpstr,"TestInOut18 after %d\n",*nHyper);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 after %u\n",*nUShort);
sprintf(tmpstr,"TestInOut18 after %u\n",*nUShort);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 after %u\n",*nULong);
sprintf(tmpstr,"TestInOut18 after %u\n",*nULong);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 after %u\n",*nUHyper);
sprintf(tmpstr,"TestInOut18 after %u\n",*nUHyper);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 after %.50f\n",*fFloat);
sprintf(tmpstr,"TestInOut18 after %.50f\n",*fFloat);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 after %.50f\n",*fDouble);
sprintf(tmpstr,"TestInOut18 after %.50f\n",*fDouble);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 after %c\n",*cChar);
sprintf(tmpstr,"TestInOut18 after %c\n",*cChar);
writeResult(SERVER_INOUT_RES, tmpstr);
printf("TestInOut18 after %s\n",*aString);
sprintf(tmpstr,"TestInOut18 after %s\n",*aString);
writeResult(SERVER_INOUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
};
NS_IMPL_ISUPPORTS1(nsRPCTestInOutImpl, nsIRPCTestInOut)
int main(int argc, char **args) {
int i;
const short num = 2;
nsRPCTestInOutImpl * test[num];
setProcessId(INOUT_FDATA);
for(i = 0; i < num; i++) {
test[i] = new nsRPCTestInOutImpl();
}
RPCServerService * rpcService = RPCServerService::GetInstance();
IDispatcher *dispatcher;
rpcService->GetDispatcher(&dispatcher);
for(i = 0; i < num; i++) {
dispatcher->RegisterWithOID(test[i], i + 1);
}
while(1) {
PR_Sleep(100);
}
}

274
xpcom/remote/tests/serverOut.cpp
View File

@ -1,274 +0,0 @@
#include <stdio.h>
#include <stream.h>
#include <fstream.h>
#include <stdlib.h>
#include <limits.h>
#include <float.h>
#include "RPCServerService.h"
#include "nsISupports.h"
#include "nsIJVMManager.h"
#include "nsIRPCTestOut.h"
#include "IDispatcher.h"
#include "nsIThread.h"
#include "deftest.h"
#include "proto.h"
class nsRPCTestOutImpl : public nsIRPCTestOut {
NS_DECL_ISUPPORTS
nsRPCTestOutImpl () {
NS_INIT_REFCNT();
}
NS_IMETHOD TestOut1(PRBool *bool) {
printf("TestOut1 this=%p\n", this);
*bool = PR_FALSE;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut1 %d\n",*bool);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut2(PRUint8 *octet) {
printf("TestOut2 this=%p\n", this);
*octet = 88;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut2 %o\n",*octet);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut3(PRInt16 *sInt) {
printf("TestOut3 this=%p\n", this);
*sInt = SHRT_MAX;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut3 %d\n",*sInt);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut4(PRInt32 *lInt) {
printf("TestOut4 this=%p\n", this);
*lInt = LONG_MAX;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut4 %d\n",*lInt);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut5(PRInt64 *llInt) {
printf("TestOut5 this=%p\n", this);
*llInt = LONG_MAX;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut5 %d\n",*llInt);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut6(PRUint16 *usInt) {
printf("TestOut6 this=%p\n", this);
*usInt = USHRT_MAX;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut6 %u\n",*usInt);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut7(PRUint32 *ulInt) {
printf("TestOut7 this=%p\n", this);
*ulInt = ULONG_MAX;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut7 %u\n",*ulInt);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut8(PRUint64 *ullInt) {
printf("TestOut8 this=%p\n", this);
*ullInt = ULONG_MAX;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut8 %u\n",*ullInt);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut9(float *f) {
printf("TestOut9 this=%p\n", this);
*f = FLT_MAX;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut9 %.50f\n",*f);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut10(double *d) {
printf("TestOut10 this=%p\n", this);
*d = DBL_MAX;
char *tmpstr = new char[500];
sprintf(tmpstr,"TestOut10 %.50f\n",*d);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut11(char *c) {
printf("TestOut11 this=%p\n", this);
*c = 'G';
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut11 %c\n",*c);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut12(PRUnichar *unic) {
printf("TestOut12 this=%p\n", this);
*unic = 'G';
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut12 %c\n",*unic);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut13(char **s) {
printf("TestOut13 this=%p\n", this);
*s = "remote ipc";
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut13 %s\n",*s);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut14(PRUnichar **unis) {
printf("TestOut14 this=%p\n", this);
//*unis = "remote ipc";
*unis = new PRUnichar[50];
for (int i = 0; i < 10; i++) {
(*unis)[i] = 'a' + 1;
}
(*unis)[i] = '\0';
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut14 %s\n",*unis);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut15(PRUint32 *count, char **valueArray) {
printf("--TestOut15\n");
*valueArray = "This is a remote ipc test.";
*count = strlen(*valueArray);
char *tmpstr = new char[200];
printf("TestOut15 count %d\n", *count);
sprintf(tmpstr, "TestOut15 count %d\n", *count);
writeResult(SERVER_OUT_RES, tmpstr);
printf("TestOut15 valueArray %s\n", *valueArray);
sprintf(tmpstr,"TestOut15 Array=%s\n",*valueArray);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut16(PRBool *bBool, char *cChar, PRUint8 *nByte,
PRInt16 *nShort, PRUint16 *nUShort,
PRInt32 *nLong,PRUint32 *nULong,
PRInt64 *nHyper, PRUint64 *nUHyper,
float *fFloat, double *fDouble, char **aString)
{
*bBool = PR_TRUE;
*nByte = 777;
*cChar = 'A';
*nShort = 1;
*nUShort = 2;
*nLong = 3;
*nULong = 4;
*nHyper = 5;
*nUHyper = 6;
*fFloat = 7;
*fDouble = 8;
*aString = "Remote ipc test.";
printf("TestOut16 this=%p\n", this) ;
char *tmpstr = new char[200];
sprintf(tmpstr,"TestOut16 PRBool %d\n",*bBool);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 PRUint8 %o\n",*nByte);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 PRInt16 %d\n",*nShort);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 PRInt32 %d\n",*nLong);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 PRInt64 %d\n",*nHyper);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 PRUint16 %u\n",*nUShort);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 PRUint32 %u\n",*nULong);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 PRUint64 %u\n",*nUHyper);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 float %.50f\n",*fFloat);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 double %.50f\n",*fDouble);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 char %c\n",*cChar);
writeResult(SERVER_OUT_RES, tmpstr);
sprintf(tmpstr,"TestOut16 string %s\n",*aString);
writeResult(SERVER_OUT_RES, tmpstr);
delete tmpstr;
return NS_OK;
}
NS_IMETHOD TestOut17(PRUint32 *count, PRInt32 **longArray) {
printf("--TestOut17\n");
char *tmpstr = new char[200];
*count = 5;
sprintf(tmpstr, "TestOut17 count %d\n", *count);
writeResult(SERVER_OUT_RES, tmpstr);
*longArray = new PRInt32[*count];
for (int i = 0; i < *count; i++) {
(*longArray)[i] = 55555 + i;
printf("TestOut17 Array[%d]=%d\n",i,(*longArray)[i]);
sprintf(tmpstr,"TestOut17 Array[%d]=%d\n",i,(*longArray)[i]);
writeResult(SERVER_OUT_RES, tmpstr);
}
delete tmpstr;
return NS_OK;
}
};
NS_IMPL_ISUPPORTS1(nsRPCTestOutImpl, nsIRPCTestOut)
int main(int argc, char **args) {
int i;
const short num = 5;
nsRPCTestOutImpl * test[num];
setProcessId(OUT_FDATA);
for(i = 0; i < num; i++) {
test[i] = new nsRPCTestOutImpl();
}
RPCServerService * rpcService = RPCServerService::GetInstance();
IDispatcher *dispatcher;
rpcService->GetDispatcher(&dispatcher);
for(i = 0; i < num; i++) {
dispatcher->RegisterWithOID(test[i], i + 1);
}
while(1) {
PR_Sleep(100);
}
}