diff options
Diffstat (limited to 'servercomm/manager.cc')
| -rw-r--r-- | servercomm/manager.cc | 1885 |
1 files changed, 1885 insertions, 0 deletions
diff --git a/servercomm/manager.cc b/servercomm/manager.cc new file mode 100644 index 0000000..8177919 --- /dev/null +++ b/servercomm/manager.cc @@ -0,0 +1,1885 @@ +/* +* This file is part of rasdaman community. +* +* Rasdaman community is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* Rasdaman community is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with rasdaman community. If not, see <http://www.gnu.org/licenses/>. +* +* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann / +rasdaman GmbH. +* +* For more information please see <http://www.rasdaman.org> +* or contact Peter Baumann via <baumann@rasdaman.com>. +/ +/** + * SOURCE: manager.cc + * + * MODULE: servercomm + * CLASS: - + * + * COMMENTS: + * No Comments +*/ + +#include "mymalloc/mymalloc.h" +static const char rcsid[] = "@(#)manager, ServerComm: $Id: manager.cc,v 1.92 2005/09/03 21:05:14 rasdev Exp $"; + +#include <iostream> +using namespace std; + +#include <string.h> // for strcat() +#include <time.h> // for time() +#include <malloc.h> + +// server option for switching off garbageCollection (Formerly there were problems +// because of illegal functions called in signal handler, see man 5 attributes; +// these are no longer relevant since the introduction of the CallBackManager) +extern int noTimeOut; + + +// Put it in front of any typedef bool ... because o2 is using bool as a variable. +// #include "o2template_CC.hxx" + +#include <signal.h> // for signal() +#include <unistd.h> // for alarm() + +#ifndef SOLARIS + #define PORTMAP // define to use function declarations for old interfaces + #include <rpc/rpc.h> +#else // HPUX + #include <rpc/rpc.h> +#endif + +#ifndef _RPCIF_ + #define _RPCIF_ + #include "clientcomm/rpcif.h" +#endif + +#include "raslib/rmdebug.hh" +#include "raslib/minterval.hh" +#include "raslib/oid.hh" +#include "raslib/endian.hh" + +#include "servercomm/servercomm.hh" + + +extern "C" { +void garbageCollection( int ); +void garbageCollectionDummy ( int ); +} + + +// +// Section for global variables pointing to RPC return data. +// +static GetExtendedErrorInfo rpcExtendedErrorInfo = { 0, 0}; +static ServerVersionRes rpcServerVersionRes = { 0, 0}; +static u_short rpcDummy = 0; +static OpenDBRes rpcOpenDBRes = { 0, 0}; + +static ServerStatRes rpcServerStatRes = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, { 0, 0 } }; +static ExecuteQueryRes rpcExecuteQueryRes = { 0, 0, 0, 0, 0, 0, 0 }; +static GetMDDRes rpcGetMDDRes = { 0, 0, 0, 0, 0 }; +static GetElementRes rpcGetElementRes = { 0, { 0, 0 } }; +static GetTileRes rpcGetTileRes = { 0, 0 }; +static ExecuteUpdateRes rpcExecuteUpdateRes = { 0, 0, 0, 0, 0 }; +static GetCollRes rpcGetCollRes = { 0, 0, 0, 0, 0 }; +static GetCollOIdsRes rpcGetCollOidsRes = { 0, 0, 0, 0, 0, { 0, 0 } }; +static OIdRes rpcOidRes = { 0, 0 }; +static GetTypeStructureRes rpcGetTypeStructureRes = { 0, 0 }; +static ObjectTypeRes procResult = { 0, 0 }; + +extern char *secureResultBufferForRPC; + +void freeDynamicRPCData() +{ + // rpcserverstat + if( rpcServerStatRes.clientTable.clientTable_len ) + { + for( int i=0; i<rpcServerStatRes.clientTable.clientTable_len; i++ ) + { + free( rpcServerStatRes.clientTable.clientTable_val[i].clientIdText ); + free( rpcServerStatRes.clientTable.clientTable_val[i].userName ); + free( rpcServerStatRes.clientTable.clientTable_val[i].baseName ); + } + + free( rpcServerStatRes.clientTable.clientTable_val ); + + rpcServerStatRes.clientTable.clientTable_len = 0; + rpcServerStatRes.clientTable.clientTable_val = 0; + } + + // rpcexecutequery + if( rpcExecuteQueryRes.token ) free( rpcExecuteQueryRes.token ); + if( rpcExecuteQueryRes.typeName ) free( rpcExecuteQueryRes.typeName ); + if( rpcExecuteQueryRes.typeStructure ) free( rpcExecuteQueryRes.typeStructure ); + rpcExecuteQueryRes.token = 0; + rpcExecuteQueryRes.status = 0; + rpcExecuteQueryRes.errorNo = 0; + rpcExecuteQueryRes.lineNo = 0; + rpcExecuteQueryRes.columnNo = 0; + rpcExecuteQueryRes.typeName = 0; + rpcExecuteQueryRes.typeStructure = 0; + + // rpcgetnextmdd, rpcgetmddbyoid + if( rpcGetMDDRes.domain ) free( rpcGetMDDRes.domain ); + if( rpcGetMDDRes.typeName ) free( rpcGetMDDRes.typeName ); + if( rpcGetMDDRes.typeStructure ) free( rpcGetMDDRes.typeStructure ); + if( rpcGetMDDRes.oid ) free( rpcGetMDDRes.oid ); + rpcGetMDDRes.typeStructure = 0; + rpcGetMDDRes.typeName = 0; + rpcGetMDDRes.domain = 0; + rpcGetMDDRes.oid = 0; + + // rpcgetnextelement + if( rpcGetElementRes.data.confarray_val ) free( rpcGetElementRes.data.confarray_val ); + rpcGetElementRes.data.confarray_val = 0; + + // rpcgetnexttile + if( rpcGetTileRes.marray ) + { + if( rpcGetTileRes.marray->domain ) free( rpcGetTileRes.marray->domain ); + // if( rpcGetTileRes.marray->data ) free( rpcGetTileRes.marray->data ); + free( rpcGetTileRes.marray ); + rpcGetTileRes.marray = 0; + } + + // rpcexecuteupdate + if( rpcExecuteUpdateRes.token ) free( rpcExecuteUpdateRes.token ); + rpcExecuteUpdateRes.token = 0; + rpcExecuteUpdateRes.status = 0; + rpcExecuteUpdateRes.errorNo = 0; + rpcExecuteUpdateRes.lineNo = 0; + rpcExecuteUpdateRes.columnNo = 0; + + // rpcgetcollbyname, rpcgetcollbyoid + if( rpcGetCollRes.typeName ) free( rpcGetCollRes.typeName ); + if( rpcGetCollRes.typeStructure ) free( rpcGetCollRes.typeStructure ); + if( rpcGetCollRes.oid ) free( rpcGetCollRes.oid ); + if( rpcGetCollRes.collName ) free( rpcGetCollRes.collName ); + rpcGetCollRes.oid = 0; + rpcGetCollRes.typeStructure = 0; + rpcGetCollRes.typeName = 0; + rpcGetCollRes.collName = 0; + + // rpcgetcolloidsbyname, rpcgetcolloidsbyoid + if( rpcGetCollOidsRes.typeName ) free( rpcGetCollOidsRes.typeName ); + if( rpcGetCollOidsRes.typeStructure ) free( rpcGetCollOidsRes.typeStructure ); + if( rpcGetCollOidsRes.oid ) free( rpcGetCollOidsRes.oid ); + if( rpcGetCollOidsRes.collName ) free( rpcGetCollOidsRes.collName ); + rpcGetCollOidsRes.oid = 0; + rpcGetCollOidsRes.typeStructure = 0; + rpcGetCollOidsRes.typeName = 0; + rpcGetCollOidsRes.collName = 0; + + if( rpcGetCollOidsRes.oidTable.oidTable_len ) + { + for( int i=0; i<rpcGetCollOidsRes.oidTable.oidTable_len; i++ ) + free( rpcGetCollOidsRes.oidTable.oidTable_val[i].oid ); + + free( rpcGetCollOidsRes.oidTable.oidTable_val ); + + rpcGetCollOidsRes.oidTable.oidTable_len = 0; + rpcGetCollOidsRes.oidTable.oidTable_val = 0; + } + + // rpcgetnewoid + if( rpcOidRes.oid ) free( rpcOidRes.oid ); + rpcOidRes.oid = 0; + + // rpcgettypestructure + if( rpcGetTypeStructureRes.typeStructure ) free( rpcGetTypeStructureRes.typeStructure ); + rpcGetTypeStructureRes.typeStructure = 0; + + // execute all pending callbacks. Redirect alarm signal first to make sure no + // reentrancy is possible! + signal( SIGALRM, garbageCollectionDummy ); + ServerComm::actual_servercomm->callback_mgr.executePending(); + signal( SIGALRM, garbageCollection ); +} + + +/************************************************************* + * + * + * SOURCE: manager.cc + * + * MODULE: servercomm + * + * + * COMMENTS: + * + ************************************************************/ + +#ifdef LINUX +#define RPCFUNCTIONDEF(name, param) name##_svc( param, struct svc_req* ) +#define RPCFUNCTIONDEFP(name, param) *name##_svc( param, struct svc_req* ) +#else +#define RPCFUNCTIONDEF(name, param) name##_svc( param, struct svc_req* ) +#define RPCFUNCTIONDEFP(name, param) *name##_svc( param, struct svc_req* ) +#endif + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/** + The global remote procedure \Ref{rpcgetserverversion_1} is called by a client to determine + version numbers of the server. +*/ + +ServerVersionRes* +RPCFUNCTIONDEF( rpcgetserverversion_1, int* ) +{ + freeDynamicRPCData(); + + rpcServerVersionRes.serverVersionNo = RMANVERSION / 1000.0; + rpcServerVersionRes.rpcInterfaceVersionNo = RPCVERSION / 1000.0; + + return &rpcServerVersionRes; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/** + The global remote procedure \Ref{rpcshutdown_1} is called by a client to shut + down the server. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcshutdown_1, int* ) +{ + rpcDummy = 0; + freeDynamicRPCData(); + // we don't allow the client to shut down the server. This is done thru rasmgr + // may be is would be better to redesign this server interface and drop several + // functions + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/** + The global remote procedure \Ref{rpcServerStat_1} is called by a clientcomm + object on the client system to display server statistics. +*/ + +ServerStatRes* +RPCFUNCTIONDEF( rpcserverstat_1, int* ) +{ + secureResultBufferForRPC = (char*)&rpcServerStatRes; + + freeDynamicRPCData(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // log server status +#ifdef RMANDEBUG + sc->printServerStatus( RMInit::dbgOut ); +#endif + + // get server status + sc->getServerStatus( rpcServerStatRes ); + + return &rpcServerStatRes; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/** + The global remote procedure \Ref{rpckilltableentry_1} is called by a clientcomm + object on the client system to kill a specific client table entry on the server. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpckilltableentry_1, unsigned long* killId ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + rpcDummy = 0; + unsigned long kId = *killId; + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + RMInit::logOut << " Kill specific table entry request received for client ID " << kId << "." << endl; + + if( sc && !sc->clientTbl.empty() ) + { + + list<ServerComm::ClientTblElt*>::iterator iter; + iter = sc->clientTbl.begin(); + + while ( *iter != NULL ) + { + if( (*iter)->clientId == kId ) + { + RMInit::logOut << "ID " << (*iter)->clientId << " found, deleting..." << endl; + + sc->deleteClientTblEntry( (*iter)->clientId ); + + // if this dead client has locked the transaction semaphor, unlock it + if( sc->transactionActive == kId ) + sc->transactionActive = 0; + + // client IDs are unique, so this was the only one... + break; + } + else + iter++; + } + // The following is a necessary dummy command for ONC RPC for not + // misinterpreting the above break command as a return + iter = sc->clientTbl.begin(); + } +return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/** +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcalive_1, unsigned long* callingClientId ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + rpcDummy = 0; + unsigned long cci = *callingClientId; + + freeDynamicRPCData(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->aliveSignal( cci ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcopendb_1()} is called by a clientcomm + object on the client system to open a database on a RasDaMan server. +*/ + +OpenDBRes* +RPCFUNCTIONDEF( rpcopendb_1, OpenDBParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcOpenDBRes; + + unsigned long* clientId = new unsigned long; + + freeDynamicRPCData(); + + char client[256]; + client[0] = '\0'; + strcat( client, "unknown" ); + + const char* dbName = params->dbName; + const char* userName = params->userName; + + RMInit::logOut << "Client called ... "; + + // + // Create a new entry in the client table (should be moved to ServerComm): + // + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Create a new client table element and initialize it. + ServerComm::ClientTblElt* contextStore; + contextStore = new ServerComm::ClientTblElt( client, ++(sc->clientCount) ); + + // give the client id back to to client via the pointer variable + *clientId = sc->clientCount; + // Put the context information in the static control list + sc->clientTbl.push_back( contextStore ); + + // RMInit::logOut << "assigned id " << *clientId << endl; + + // check acces permission + + rpcOpenDBRes.status=accessControl.crunchCapability(params->capability); + // + // Open the database: (only if acces control is OK) + // + if(rpcOpenDBRes.status==0) + rpcOpenDBRes.status = sc->openDB( *clientId, dbName, userName ); + + rpcOpenDBRes.clientID = *clientId; + delete clientId; + + // If database is not successfully opened, the client table entry is deleted again. + if( rpcOpenDBRes.status != 0 ) + sc->deleteClientTblEntry( rpcOpenDBRes.clientID ); + + return &rpcOpenDBRes; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcclosedb_1()} is called by a clientcomm + object on the client system to close a database on a RasDaMan server. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcclosedb_1, unsigned long* callingClientId ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long cci; + cci = *callingClientId; + + freeDynamicRPCData(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->closeDB( cci ); + + if( rpcDummy == 0 ) + sc->deleteClientTblEntry( cci ); + + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpccreatedb_1()} is called by a clientcomm + object on the client system to create a database on a RasDaMan server. +*/ +unsigned short* +RPCFUNCTIONDEF( rpccreatedb_1, char** name ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + char* dbname = *name; + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. (createDB doesn't actually return something + // other than 0, so this can be used in later extensions) + rpcDummy = sc->createDB( dbname ); + + // Return the result + return &rpcDummy; +} + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcdestroydb_1()} is called by a clientcomm + object on the client system to destroy a database on a RasDaMan server. +*/ +unsigned short* +RPCFUNCTIONDEF( rpcdestroydb_1, char** name ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + char* dbname = *name; + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. (createDB doesn't actually return something + // other than 0, so this can be used in later extensions) + rpcDummy = sc->destroyDB( dbname ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcBeginTA()} is called by a clientcomm + object on the client system to begin a new transaction in a session with + a RasDaMan server. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcbeginta_1, BeginTAParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + freeDynamicRPCData(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // check acces permission + rpcDummy = accessControl.crunchCapability(params->capability); + + // Call the corresponding method. (only if acces control is OK) + if(rpcDummy==0) + rpcDummy = sc->beginTA( params->clientID, params->readOnly ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcCommitTA()} is called by a clientcomm + object on the client system to commit the current transaction in a session with + a RasDaMan server. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpccommitta_1, unsigned long* callingClientId ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long cci; + cci = *callingClientId; + + freeDynamicRPCData(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->commitTA( cci ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcAbortTA()} is called by a clientcomm + object on the client system to abort the current transaction in a session with + a RasDaMan server. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcabortta_1, unsigned long* callingClientId ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long cci; + cci = *callingClientId; + + freeDynamicRPCData(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->abortTA( cci ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcexecutequery_1()} is called by a clientcomm + object on the client system to initiate a retrieval query execution on a RasDaMan + server. +*/ + +ExecuteQueryRes* +RPCFUNCTIONDEF( rpcexecutequery_1, ExecuteQueryParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcExecuteQueryRes; + + unsigned short returnValue; + unsigned long callingClientId = params->clientID; + const char* query = params->query; + + freeDynamicRPCData(); + + // prevent RPC from NULL pointers in case of exceptions + char *prev1 = strdup(""); + char *prev2 = strdup(""); + char *prev3 = strdup(""); + rpcExecuteQueryRes.token = prev1; + rpcExecuteQueryRes.typeName = prev2; + rpcExecuteQueryRes.typeStructure = prev3; + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + returnValue = sc->executeQuery( callingClientId, (const char*) query, rpcExecuteQueryRes ); + + // if no exception was thrown we are here, first check if the pointers have changed + if( rpcExecuteQueryRes.token != prev1 ) free(prev1); + if( rpcExecuteQueryRes.typeName != prev2 ) free(prev2); + if( rpcExecuteQueryRes.typeStructure != prev3 ) free(prev3); + + // than check if the pointers are NULL + if( !rpcExecuteQueryRes.token ) rpcExecuteQueryRes.token = strdup(""); + if( !rpcExecuteQueryRes.typeName ) rpcExecuteQueryRes.typeName = strdup(""); + if( !rpcExecuteQueryRes.typeStructure ) rpcExecuteQueryRes.typeStructure = strdup(""); + + // set missing parts of return structure + rpcExecuteQueryRes.status = returnValue; + + + return &rpcExecuteQueryRes; +} + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcgetnextmdd_1()} is called by a clientcomm + object on the client system to transmit the next element of a MDD collection + from a RasDaMan server. +*/ + +GetMDDRes* +RPCFUNCTIONDEF( rpcgetnextmdd_1, unsigned long* callingClientId ) +{ + RMDBGENTER(2, RMDebug::module_servercomm, "Manager", "rpcgetnextmdd_1" ) + + secureResultBufferForRPC = (char*)&rpcGetMDDRes; + + r_Minterval mddDomain; + r_OId oid; + + freeDynamicRPCData(); + + // prevent RPC from NULL pointers + char *prev1 = strdup(""); + char *prev2 = strdup(""); + char *prev3 = strdup(""); + char *prev4 = strdup(""); + + rpcGetMDDRes.typeName = prev1; + rpcGetMDDRes.typeStructure = prev2; + rpcGetMDDRes.domain = prev3; + rpcGetMDDRes.oid = prev4; + + accessControl.wantToRead(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method and return the result + rpcGetMDDRes.status = sc->getNextMDD( *callingClientId, mddDomain, + rpcGetMDDRes.typeName, + rpcGetMDDRes.typeStructure, oid, + rpcGetMDDRes.currentFormat ); + rpcGetMDDRes.domain = mddDomain.get_string_representation(); + rpcGetMDDRes.oid = oid.get_string_representation() ? strdup( oid.get_string_representation() ) : strdup(""); + + // if no exceptions... + if( rpcGetMDDRes.typeName != prev1 ) free(prev1); + if( rpcGetMDDRes.typeStructure != prev2 ) free(prev2); + if( rpcGetMDDRes.domain != prev3 ) free(prev3); + if( rpcGetMDDRes.oid != prev4 ) free(prev4); + + // prevent RPC from NULL pointers + if( !rpcGetMDDRes.typeName ) rpcGetMDDRes.typeName = strdup(""); + if( !rpcGetMDDRes.typeStructure ) rpcGetMDDRes.typeStructure = strdup(""); + // the other 2 are not null + + RMDBGEXIT(2, RMDebug::module_servercomm, "Manager", "rpcgetnextmdd_1" ) + return &rpcGetMDDRes; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcgetnextelement_1()} is called by a clientcomm + object on the client system to transmit the next element of a non-MDD collection + from a RasDaMan server. +*/ + +GetElementRes* +RPCFUNCTIONDEF( rpcgetnextelement_1, unsigned long* callingClientId ) +{ + RMDBGENTER(2, RMDebug::module_servercomm, "Manager", "rpcgetnextelement_1" ) + + secureResultBufferForRPC = (char*)&rpcGetElementRes; + + freeDynamicRPCData(); + + accessControl.wantToRead(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method and return the result + rpcGetElementRes.status = sc->getNextElement( *callingClientId, rpcGetElementRes.data.confarray_val, + rpcGetElementRes.data.confarray_len ); + + RMDBGEXIT(2, RMDebug::module_servercomm, "Manager", "rpcgetnextelement_1" ) + return &rpcGetElementRes; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure \Ref{rpcgetmddbyoid_1} is called by a clientcomm + object on the client system to receive an MDD by its oid. +*/ + +GetMDDRes* +RPCFUNCTIONDEF( rpcgetmddbyoid_1, OIdSpecParams* params ) +{ + RMDBGENTER(2, RMDebug::module_servercomm, "Manager", "rpcgetmddbyoid_1" ) + + secureResultBufferForRPC = (char*)&rpcGetMDDRes; + + r_Minterval mddDomain; + r_OId oid( params->oid ); + + freeDynamicRPCData(); + // prevent RPC from NULL pointers if exception occur + char *prev1 = strdup(""); + char *prev2 = strdup(""); + char *prev3 = strdup(""); + char *prev4 = strdup(""); + + rpcGetMDDRes.typeName = prev1; + rpcGetMDDRes.typeStructure = prev2; + rpcGetMDDRes.domain = prev3; + rpcGetMDDRes.oid = prev4; + + accessControl.wantToRead(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method and return the result + rpcGetMDDRes.status = sc->getMDDByOId( params->clientID, oid, mddDomain, + rpcGetMDDRes.typeName, + rpcGetMDDRes.typeStructure, + rpcGetMDDRes.currentFormat ); + rpcGetMDDRes.domain = mddDomain.get_string_representation(); + rpcGetMDDRes.oid = oid.get_string_representation() ? strdup( oid.get_string_representation() ) : strdup(""); + + // prevent RPC from NULL pointers + if( rpcGetMDDRes.typeName != prev1) free(prev1); + if( rpcGetMDDRes.typeStructure != prev2) free(prev2); + if( rpcGetMDDRes.domain != prev3 ) free(prev3); + if( rpcGetMDDRes.oid != prev4 ) free(prev4); + + if( !rpcGetMDDRes.typeName ) rpcGetMDDRes.typeName = strdup(""); + if( !rpcGetMDDRes.typeStructure ) rpcGetMDDRes.typeStructure = strdup(""); + // the other 2 are not null + + RMDBGEXIT(2, RMDebug::module_servercomm, "Manager", "rpcgetmddbyoid_1" ) + return &rpcGetMDDRes; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcgetnexttile_1()} is called by a clientcomm + object on the client system to transmit the next element of a MDD collection + from a RasDaMan server. +*/ + +GetTileRes* +RPCFUNCTIONDEF( rpcgetnexttile_1, unsigned long* callingClientId ) +{ + RMDBGENTER(2, RMDebug::module_servercomm, "Manager", "rpcgetnexttile_1" ) + + secureResultBufferForRPC = (char*)&rpcGetTileRes; + + freeDynamicRPCData(); + + // fake data for security + RPCMarray *secureRpcMarray = (RPCMarray*)mymalloc(sizeof(RPCMarray)); + secureRpcMarray->domain = strdup(""); + secureRpcMarray->cellTypeLength = 1; + secureRpcMarray->currentFormat = 1; + secureRpcMarray->storageFormat = 1; + secureRpcMarray->data.confarray_len = 1; + secureRpcMarray->data.confarray_val = strdup(""); + + rpcGetTileRes.marray = secureRpcMarray; + + RPCMarray *tempRpcMarray; + + accessControl.wantToRead(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method and return the result + rpcGetTileRes.status = sc->getNextTile( *callingClientId, &tempRpcMarray); //&rpcGetTileRes.marray ); + // if this throws, secure... is nice initialized + + rpcGetTileRes.marray = tempRpcMarray; + + free(secureRpcMarray->data.confarray_val); + free(secureRpcMarray->domain); + free(secureRpcMarray); + + RMDBGEXIT(2, RMDebug::module_servercomm, "Manager", "rpcgetnexttile_1" ) + return &rpcGetTileRes; +} + + + +#ifdef LINUX +extern "C" +#endif +//@ManMemo: Module: {\bf servercomm} + +/** +*/ +unsigned short* +RPCFUNCTIONDEF( rpcendtransfer_1, unsigned long* callingClientId ) +{ + unsigned long cci = *callingClientId; + + secureResultBufferForRPC = (char*)&rpcDummy; + + freeDynamicRPCData(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->endTransfer( cci ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif +//@ManMemo: Module: {\bf servercomm} + +/** +*/ +unsigned short* +RPCFUNCTIONDEF( rpcinitexecuteupdate_1, unsigned long* callingClientId ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long cci; + cci = *callingClientId; + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->initExecuteUpdate( cci ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcexecuteupdate_1()} is called by a clientcomm + object on the client system to initiate an update query execution on a RasDaMan + server. +*/ + +ExecuteUpdateRes* +RPCFUNCTIONDEF( rpcexecuteupdate_1, ExecuteQueryParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcExecuteUpdateRes; + + unsigned short returnValue; + unsigned long callingClientId = params->clientID; + const char* query = params->query; + + freeDynamicRPCData(); + + // prevent RPC from NULL pointers + char *prev1 = strdup(""); + rpcExecuteUpdateRes.token = prev1; + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + returnValue = sc->executeUpdate( callingClientId, (const char*) query, rpcExecuteUpdateRes ); + + // set missing parts of return structure + rpcExecuteUpdateRes.status = returnValue; + + // prevent RPC from NULL pointers + if( rpcExecuteUpdateRes.token != prev1 ) free(prev1); + + if( !rpcExecuteUpdateRes.token ) rpcExecuteUpdateRes.token = strdup(""); + + return &rpcExecuteUpdateRes; +} + + + +#ifdef LINUX +extern "C" +#endif +//@ManMemo: Module: {\bf servercomm} + +/** +*/ +unsigned short* +RPCFUNCTIONDEF( rpcstartinserttransmdd_1, InsertTransMDDParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long callingClientId = params->clientID; + // const char* collName = params->collName; // not used + const char* typeName = params->typeName; + unsigned long typeLength = params->typeLength; + r_Minterval mddDomain( params->domain ); + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->startInsertTransMDD( callingClientId, mddDomain, typeLength, typeName ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif +//@ManMemo: Module: {\bf servercomm} + +/** +*/ +unsigned short* +RPCFUNCTIONDEF( rpcstartinsertpersmdd_1, InsertPersMDDParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long callingClientId = params->clientID; + const char* collName = params->collName; + const char* typeName = params->typeName; + unsigned long typeLength = params->typeLength; + r_Minterval mddDomain( params->domain ); + r_OId oid( params->oid ); + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->startInsertPersMDD( callingClientId, (const char*) collName, mddDomain, typeLength, typeName, oid ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif +//@ManMemo: Module: {\bf servercomm} + +/** +*/ +unsigned short* +RPCFUNCTIONDEF( rpcinserttile_1, InsertTileParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->insertTile( params->clientID, params->isPersistent, params->marray ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/** +*/ +unsigned short* +RPCFUNCTIONDEF( rpcendinsertmdd_1, EndInsertMDDParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->endInsertMDD( params->clientID, params->isPersistent ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcInsertMDD()} is called by a clientcomm + object on the client system to insert a MDD object in an existing MDD + collection on a RasDaMan server. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcinsertmdd_1, InsertMDDParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long callingClientId = params->clientID; + const char* collName = params->collName; + const char* typeName = params->typeName; + RPCMarray* rpcMarray = params->marray; + + r_OId oid( params->oid ); + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->insertMDD( callingClientId, collName, rpcMarray, typeName, oid ); + + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcgetcollbyname_1()} is called by a clientcomm + object on the client system to initiate the lookup of a MDD collection by its name + on a RasDaMan server. +*/ + +GetCollRes* +RPCFUNCTIONDEF( rpcgetcollbyname_1, NameSpecParams* params ) +{ + RMDBGENTER(2, RMDebug::module_servercomm, "Manager", "rpcgetcollbyname_1" ) + + secureResultBufferForRPC = (char*)&rpcGetCollRes; + + r_OId oid; + + freeDynamicRPCData(); + + char *prev1 = strdup(""); + char *prev2 = strdup(""); + char *prev3 = strdup(""); + char *prev4 = strdup(""); + rpcGetCollRes.typeName = prev1; + rpcGetCollRes.typeStructure = prev2; + rpcGetCollRes.oid = prev3; + rpcGetCollRes.collName = prev4; + + accessControl.wantToRead(); + + unsigned long callingClientId = params->clientID; + const char* collName = params->name; + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcGetCollRes.status = sc->getCollByName( callingClientId, collName, + rpcGetCollRes.typeName, + rpcGetCollRes.typeStructure, oid ); + + rpcGetCollRes.oid = oid.get_string_representation() ? strdup( oid.get_string_representation() ) : strdup(""); + rpcGetCollRes.collName = params->name ? strdup( params->name ) : strdup(""); + + // prevent RPC from NULL pointers + if( rpcGetCollRes.typeName != prev1) free(prev1); + if( rpcGetCollRes.typeStructure != prev2) free(prev2); + if( rpcGetCollRes.oid != prev3) free(prev3); + if( rpcGetCollRes.collName != prev4) free(prev4); + + if( !rpcGetCollRes.typeName ) rpcGetCollRes.typeName = strdup(""); + if( !rpcGetCollRes.typeStructure ) rpcGetCollRes.typeStructure = strdup(""); + + // Return the result + RMDBGEXIT(2, RMDebug::module_servercomm, "Manager", "rpcgetcollbyname_1" ) + return &rpcGetCollRes; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcgetcollbyoid_1()} is called by a clientcomm + object on the client system to initiate the lookup of a MDD collection by its oid + on a RasDaMan server. +*/ + +GetCollRes* +RPCFUNCTIONDEF( rpcgetcollbyoid_1, OIdSpecParams* params ) +{ + RMDBGENTER(2, RMDebug::module_servercomm, "Manager", "rpcgetcollbyoid_1" ) + + secureResultBufferForRPC = (char*)&rpcGetCollRes; + + r_OId oid( params->oid ); + + freeDynamicRPCData(); + // prevent RPC from NULL pointers + char *prev1 = strdup(""); + char *prev2 = strdup(""); + char *prev3 = strdup(""); + char *prev4 = strdup(""); + rpcGetCollRes.typeName = prev1; + rpcGetCollRes.typeStructure = prev2; + rpcGetCollRes.collName = prev3; + rpcGetCollRes.oid = prev4; + + accessControl.wantToRead(); + + unsigned long callingClientId = params->clientID; + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcGetCollRes.status = sc->getCollByOId( callingClientId, oid, rpcGetCollRes.typeName, + rpcGetCollRes.typeStructure, rpcGetCollRes.collName ); + + rpcGetCollRes.oid = oid.get_string_representation() ? strdup( oid.get_string_representation() ) : strdup(""); + + // prevent RPC from NULL pointers + if( rpcGetCollRes.typeName != prev1) free(prev1); + if( rpcGetCollRes.typeStructure != prev2) free(prev2); + if( rpcGetCollRes.collName != prev3) free(prev3); + if( rpcGetCollRes.oid != prev4) free(prev4); + + if( !rpcGetCollRes.typeName ) rpcGetCollRes.typeName = strdup(""); + if( !rpcGetCollRes.typeStructure ) rpcGetCollRes.typeStructure = strdup(""); + if( !rpcGetCollRes.collName ) rpcGetCollRes.collName = strdup(""); + // oid is not null, + + // Return the result + RMDBGEXIT(2, RMDebug::module_servercomm, "Manager", "rpcgetcollbyoid_1" ) + return &rpcGetCollRes; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcgetcolloidsbyname_1()} is called by a clientcomm + object on the client system to retrieve the collection of oids by the collection's name. +*/ + +GetCollOIdsRes* +RPCFUNCTIONDEF( rpcgetcolloidsbyname_1, NameSpecParams* params ) +{ + RMDBGENTER(2, RMDebug::module_servercomm, "Manager", "rpcgetcolloidsbyname_1" ) + + secureResultBufferForRPC = (char*)&rpcGetCollOidsRes; + + r_OId oid; + + freeDynamicRPCData(); + + char *prev1 = strdup(""); + char *prev2 = strdup(""); + char *prev3 = strdup(""); + char *prev4 = strdup(""); + rpcGetCollOidsRes.typeName = prev1; + rpcGetCollOidsRes.typeStructure = prev2; + rpcGetCollOidsRes.collName = prev3; + rpcGetCollRes.oid = prev4; + + accessControl.wantToRead(); + + unsigned long callingClientId = params->clientID; + const char* collName = params->name; + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcGetCollOidsRes.status = sc->getCollOIdsByName( callingClientId, collName, rpcGetCollOidsRes.typeName, + rpcGetCollOidsRes.typeStructure, oid, + rpcGetCollOidsRes.oidTable.oidTable_val, rpcGetCollOidsRes.oidTable.oidTable_len ); + + rpcGetCollOidsRes.oid = oid.get_string_representation() ? strdup( oid.get_string_representation() ) : strdup(""); + rpcGetCollOidsRes.collName = params->name ? strdup( params->name ) : strdup(""); + + // prevent RPC from NULL pointers + if( rpcGetCollOidsRes.typeName != prev1 ) free(prev1); + if( rpcGetCollOidsRes.typeStructure != prev2 ) free(prev2); + if( rpcGetCollOidsRes.collName != prev3 ) free(prev3); + if( rpcGetCollRes.oid != prev4) free(prev4); + + if( !rpcGetCollOidsRes.typeName ) rpcGetCollOidsRes.typeName = strdup(""); + if( !rpcGetCollOidsRes.typeStructure ) rpcGetCollOidsRes.typeStructure = strdup(""); + if( !rpcGetCollOidsRes.collName ) rpcGetCollOidsRes.collName = strdup(""); + // oid is not null + + // Return the result + RMDBGEXIT(2, RMDebug::module_servercomm, "Manager", "rpcgetcolloidsbyname_1" ) + return &rpcGetCollOidsRes; +} + + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcgetcolloidsbyoid_1()} is called by a clientcomm + object on the client system to retrieve the collection of oids by the collection's oid. +*/ + +GetCollOIdsRes* +RPCFUNCTIONDEF( rpcgetcolloidsbyoid_1, OIdSpecParams* params ) +{ + RMDBGENTER(2, RMDebug::module_servercomm, "Manager", "rpcgetcolloidsbyname_1" ) + + secureResultBufferForRPC = (char*)&rpcGetCollOidsRes; + + r_OId oid( params->oid ); + + freeDynamicRPCData(); + + char *prev1 = strdup(""); + char *prev2 = strdup(""); + char *prev3 = strdup(""); + char *prev4 = strdup(""); + rpcGetCollOidsRes.typeName = prev1; + rpcGetCollOidsRes.typeStructure = prev2; + rpcGetCollOidsRes.collName = prev3; + rpcGetCollRes.oid = prev4; + + accessControl.wantToRead(); + + unsigned long callingClientId = params->clientID; + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcGetCollOidsRes.status = sc->getCollOIdsByOId( callingClientId, oid, + rpcGetCollOidsRes.typeName, + rpcGetCollOidsRes.typeStructure, + rpcGetCollOidsRes.oidTable.oidTable_val, + rpcGetCollOidsRes.oidTable.oidTable_len, + rpcGetCollOidsRes.collName ); + + rpcGetCollOidsRes.oid = oid.get_string_representation() ? strdup( oid.get_string_representation() ) : strdup(""); + + // prevent RPC from NULL pointers + if( rpcGetCollOidsRes.typeName != prev1 ) free(prev1); + if( rpcGetCollOidsRes.typeStructure != prev2 ) free(prev2); + if( rpcGetCollOidsRes.collName != prev3 ) free(prev3); + if( rpcGetCollRes.oid != prev4) free(prev4); + + if( !rpcGetCollOidsRes.typeName ) rpcGetCollOidsRes.typeName = strdup(""); + if( !rpcGetCollOidsRes.typeStructure ) rpcGetCollOidsRes.typeStructure = strdup(""); + if( !rpcGetCollOidsRes.collName ) rpcGetCollOidsRes.collName = strdup(""); + + // Return the result + RMDBGEXIT(2, RMDebug::module_servercomm, "Manager", "rpcgetcolloidsbyname_1" ) + return &rpcGetCollOidsRes; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcinsertcoll_1()} is called by a clientcomm + object on the client system to create a MDD collection for further use on + a RasDaMan server. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcinsertcoll_1, InsertCollParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long callingClientId = params->clientID; + const char* collName = params->collName; + const char* typeName = params->typeName; + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + r_OId oid( params->oid ); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->insertColl( callingClientId, collName, typeName, oid ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcdeletecollbyname_1()} is called by a clientcomm + object on the client system to delete a existing MDD collection. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcdeletecollbyname_1, NameSpecParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long callingClientId = params->clientID; + const char* collName = params->name; + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->deleteCollByName( callingClientId, collName ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcdeleteobjbyoid_1()} is called by a clientcomm + object on the client system to delete an object specified by oid. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcdeleteobjbyoid_1, OIdSpecParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long callingClientId = params->clientID; + r_OId oid( params->oid ); + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->deleteObjByOId( callingClientId, oid ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: + The global remote procedure {\tt rpcremoveobjfromcoll_1()} is called by a clientcomm + object on the client system to delete an object from a collection. +*/ + +unsigned short* +RPCFUNCTIONDEF( rpcremoveobjfromcoll_1, RemoveObjFromCollParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + unsigned long callingClientId = params->clientID; + const char* collName = params->collName; + r_OId oid( params->oid ); + + freeDynamicRPCData(); + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcDummy = sc->removeObjFromColl( callingClientId, collName, oid ); + + // Return the result + return &rpcDummy; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: +*/ + +ObjectTypeRes* +RPCFUNCTIONDEF( rpcgetobjecttype_1, OIdSpecParams* params ) +{ + secureResultBufferForRPC = (char*)&procResult; + + freeDynamicRPCData(); + + accessControl.wantToRead(); + + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + r_OId oid( params->oid ); + + procResult.status = sc->getObjectType( params->clientID, oid, procResult.objType ); + + // Return the result + return &procResult; +} + + + +#ifdef LINUX +extern "C" +#endif + +//@ManMemo: Module: {\bf servercomm} + +/*@Doc: +*/ + +OIdRes* +RPCFUNCTIONDEF( rpcgetnewoid_1, NewOIdParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcOidRes; + + freeDynamicRPCData(); + + char *prev1 = strdup(""); + rpcOidRes.oid = prev1; + + accessControl.wantToWrite(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + r_OId oid; + + rpcOidRes.status = sc->getNewOId( params->clientID, params->objType, oid ); + rpcOidRes.oid = oid.get_string_representation() ? strdup( oid.get_string_representation() ) : strdup(""); + free(prev1); + + // Return the result + return &rpcOidRes; +} + + +// Callback for callback manager, performs actual garbage collection. +// The context points to the ServerComm object (see registering call in +// garbageCollection() ) +static void callback_garbage_collection(void *context) +{ + ServerComm *sc = (ServerComm*)context; + + if( sc && !sc->clientTbl.empty() ) + { + RMInit::dbgOut << "Garbage Collection ... " << flush; + +#ifdef RMANDEBUG + sc->printServerStatus( RMInit::dbgOut ); +#endif + + if (!noTimeOut) + { + list<ServerComm::ClientTblElt*>::iterator iter; + iter = sc->clientTbl.begin(); + unsigned long now = time( NULL ); + + RMDBGONCE(2, RMDebug::module_servercomm, "Manager", "checking " << sc->clientTbl.size() << " clients..." ); + while ( iter != sc->clientTbl.end() ) + { + if( now - (*iter)->lastActionTime >= sc->clientTimeout ) + { + RMInit::logOut << "Message: Found timed-out client with id " << (*iter)->clientId + << " (" << (*iter)->clientIdText << ", " + << now - (*iter)->lastActionTime << "s)..." << flush; + + if( sc->deleteClientTblEntry( (*iter)->clientId ) == 0 ) + { + RMInit::logOut << "deleted." << endl; + + sc->informRasMGR(SERVER_AVAILABLE); + // reset the iterator (otherwise, it would skip one object + // because one was deleted) + iter = sc->clientTbl.begin(); + } + else + { + RMInit::logOut << "deletion postponed." << endl; + iter++; + } + } + else + iter++; + } + } + RMInit::dbgOut << "garbage collection done." << endl; + } +} + + +#ifdef LINUX +extern "C" +#endif +void +garbageCollection( int ) +{ + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + /* + * Just register the callbacks because we're not allowed to do any + * mallocs or prints in the alarm handler environment. The pending + * callbacks will be executed whenever there's RPC activity. + */ + sc->callback_mgr.registerUniqueCallback(callback_garbage_collection, (void*)sc); + + // Re-initialize the signal handler to point to this function + signal( SIGALRM, garbageCollection); + + // Reset the alarm + alarm( (unsigned int)sc->garbageCollectionInterval ); +} + + +#ifdef LINUX +extern "C" +#endif +void +garbageCollectionDummy( int ) +{ + /* Dummy garbage collection function for avoiding reentrance of the callback manager. + Does nothing but reinstall the signal. */ + signal( SIGALRM, garbageCollection); + alarm( (unsigned int)(ServerComm::actual_servercomm->garbageCollectionInterval) ); +} + + +#ifdef LINUX +extern "C" +#endif +GetTypeStructureRes* +RPCFUNCTIONDEF( rpcgettypestructure_1, GetTypeStructureParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcGetTypeStructureRes; + + freeDynamicRPCData(); + + char *prev1 = strdup(""); + rpcGetTypeStructureRes.typeStructure = prev1; + + accessControl.wantToRead(); + + // Get a pointer to the actual servercomm object. + ServerComm* sc = ServerComm::actual_servercomm; + + // Call the corresponding method. + rpcGetTypeStructureRes.status = sc->getTypeStructure( params->clientID, params->typeName, + params->typeType, rpcGetTypeStructureRes.typeStructure ); + + // prevent RPC from NULL pointers + if( rpcGetTypeStructureRes.typeStructure != prev1 ) free(prev1); + + if( !rpcGetTypeStructureRes.typeStructure ) rpcGetTypeStructureRes.typeStructure = strdup(""); + + // Return the result + return &rpcGetTypeStructureRes; +} + + + +#ifdef LINUX +extern "C" +#endif +int* +RPCFUNCTIONDEF( rpcgetserverendian_1, int * ) +{ + freeDynamicRPCData(); + + static int result; + +#ifdef LITTLE_ENDIAN + result = 1; +#else + result = 0; +#endif + + return &result; +} + + +#ifdef LINUX +extern "C" +#endif +unsigned short* +RPCFUNCTIONDEF( rpcsetservertransfer_1, SetServerTransferParams* params ) +{ + freeDynamicRPCData(); + secureResultBufferForRPC = (char*)&rpcDummy; + + ServerComm* sc = ServerComm::actual_servercomm; + + rpcDummy = (unsigned short)(sc->setTransferMode( params->clientID, params->format, params->formatParams )); + + return &rpcDummy; +} + + +#ifdef LINUX +extern "C" +#endif +GetExtendedErrorInfo * +RPCFUNCTIONDEF( rpcgeterrorinfo_1, void * params ) +{ + freeDynamicRPCData(); + + ServerComm* sc = ServerComm::actual_servercomm; + + rpcExtendedErrorInfo.errorText = (char*) sc->getExtendedErrorInfo(); + + return &rpcExtendedErrorInfo; +} + +#ifdef LINUX +extern "C" +#endif +unsigned short* +RPCFUNCTIONDEF( rpcsetserverstorage_1, SetServerTransferParams* params ) +{ + secureResultBufferForRPC = (char*)&rpcDummy; + + freeDynamicRPCData(); + + ServerComm* sc = ServerComm::actual_servercomm; + + rpcDummy = (unsigned short)(sc->setStorageMode(params->clientID, params->format, params->formatParams )); + + return &rpcDummy; +} + |