tcpcomm_remote.c

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; Symantec Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

/*!
  \file tcpcomm_remote.c
  \brief TCP/IP communication layer (remote side module).

  This module implements the remote side functionality to support TCP/IP
  driven remote providers. This comprises setting up a daemon listening
  for MI requests.

  \author Frank Scheffler

  \sa tcpcomm_proxy.c
  \sa remote_broker.c
  \sa socketcomm.h
*/

#include <stdio.h>
#include <stdlib.h>
#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
  #include <error.h>
#endif
#include <errno.h>
#include <netinet/in.h>

#include "tcpcomm.h"
#include "ip.h"
#include "remote.h"
#include "serialization.h"
#include "io.h"
#include "mm.h"
#include "native.h"
#include "debug.h"
#include "socketcomm.h"
#include "indication_objects.h"

#include <Pegasus/Provider/CMPI/cmpidt.h>

#ifdef PEGASUS_PLATFORM_WIN32_IX86_MSVC
#define lloonngg __int64
#else
#define lloonngg long long int
#endif

int nativeSide=1;

/****************************************************************************/

static int __broker_connect(CONST CMPIBroker *, CONST CMPIContext *, const char *);

static const struct BinarySerializerFT *__sft = &binarySerializerFT;

/****************************************************************************/

#define GET_INSTANCE_MI(broker,ctx) \
        RBGetInstanceMI ( CMPIBroker2remote_broker ( (broker) ) )
#define GET_ASSOCIATION_MI(broker,ctx) \
        RBGetAssociationMI ( CMPIBroker2remote_broker ( (broker) ) )
#define GET_METHOD_MI(broker,ctx) \
        RBGetMethodMI ( CMPIBroker2remote_broker ( (broker) ) )
#define GET_PROPERTY_MI(broker,ctx) \
        RBGetPropertyMI ( CMPIBroker2remote_broker ( (broker) ) )
#define GET_INDICATION_MI(broker,ctx) \
        RBGetIndicationMI ( CMPIBroker2remote_broker ( (broker) ) )

#define NOCLEAN(mi,ctx)

static const char* mierrMsg = "ProviderInitFailure: Error initializing the API's _Create<mi-type>MI";
#define SET_STATUS_INIT_FAILED(rc) \
        rc.msg = native_new_CMPIString (mierrMsg, NULL); \
        rc.rc = CMPI_RC_ERR_FAILED; \
        TRACE_CRITICAL((mierrMsg));

static void TCPCOMM_InstanceMI_enumInstanceNames(int socket,
						 CONST CMPIBroker * broker,
						 CONST CMPIContext * ctx,
						 CONST CMPIObjectPath * cop)
{
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIInstanceMI *mi = RBGetInstanceMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->enumInstanceNames(mi, ctx, result, cop);;
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
}


static void TCPCOMM_InstanceMI_enumInstances(int socket, CONST CMPIBroker * broker,
					       CONST CMPIContext * ctx,
					       CONST CMPIObjectPath * cop)
{
    char **props = socketcomm_deserialize_props(socket, (__sft), broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIInstanceMI *mi = RBGetInstanceMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->enumInstances(mi, ctx, result, cop, (CONST char **)props);
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
    free(props);
}


static void TCPCOMM_InstanceMI_getInstance(int socket, CONST CMPIBroker * broker,
					     CONST CMPIContext * ctx,
					     CONST CMPIObjectPath * cop)
{
    char **props = socketcomm_deserialize_props(socket, (__sft), broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIInstanceMI *mi = RBGetInstanceMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->getInstance(mi, ctx, result, cop, (CONST char **)props);
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
    free(props);
}


static void TCPCOMM_InstanceMI_createInstance(int socket, CONST CMPIBroker * broker,
						CONST CMPIContext * ctx,
						CONST CMPIObjectPath * cop)
{
    CMPIInstance *inst = (__sft)->deserialize_CMPIInstance(socket, broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIInstanceMI *mi = RBGetInstanceMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->createInstance(mi, ctx, result, cop, inst);;
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
}


static void TCPCOMM_InstanceMI_setInstance(int socket, CONST CMPIBroker * broker,
					     CONST CMPIContext * ctx,
					     CONST CMPIObjectPath * cop)
{
    CMPIInstance *inst = (__sft)->deserialize_CMPIInstance(socket, broker);
    char **props = socketcomm_deserialize_props(socket, (__sft), broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIInstanceMI *mi = RBGetInstanceMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
#ifdef CMPI_VER_100
    rc = mi->ft->modifyInstance(mi, ctx, result, cop, inst, (const char **)props);
#else
    rc = mi->ft->setInstance(mi, ctx, result, cop, inst, (CONST char **)props);
#endif
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
    free(props);
}


static void TCPCOMM_InstanceMI_deleteInstance(int socket,CONST  CMPIBroker * broker,
						CONST CMPIContext * ctx,
						CONST CMPIObjectPath * cop)
{
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIInstanceMI *mi = RBGetInstanceMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker,(CMPIContext *) ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->deleteInstance(mi, ctx, result, cop);;
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
}


static void TCPCOMM_InstanceMI_execQuery(int socket, CONST CMPIBroker * broker,
					   CONST CMPIContext * ctx,
					   CONST CMPIObjectPath * cop)
{
    char *lang = (__sft)->deserialize_string(socket, broker);
    char *query = (__sft)->deserialize_string(socket, broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIInstanceMI *mi = RBGetInstanceMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->execQuery(mi, ctx, result, cop, lang, query);;
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
};


static void TCPCOMM_AssociationMI_associators(int socket, CONST CMPIBroker * broker,
					      CONST CMPIContext * ctx,
					      CONST CMPIObjectPath * cop)
{
    char *assocclass = (__sft)->deserialize_string(socket, broker);
    char *resultclass = (__sft)->deserialize_string(socket, broker);
    char *role = (__sft)->deserialize_string(socket, broker);
    char *resultrole = (__sft)->deserialize_string(socket, broker);
    char **props = socketcomm_deserialize_props(socket, (__sft), broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIAssociationMI *mi =
	RBGetAssociationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->associators(mi, ctx, result, cop, assocclass, resultclass,
			         role, resultrole, (CONST char **)props);
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
    free(props);
}


static void TCPCOMM_AssociationMI_associatorNames(int socket,
						    CONST CMPIBroker * broker,
						    CONST CMPIContext * ctx,
						    CONST CMPIObjectPath * cop)
{
    char *assocclass = (__sft)->deserialize_string(socket, broker);
    char *resultclass = (__sft)->deserialize_string(socket, broker);
    char *role = (__sft)->deserialize_string(socket, broker);
    char *resultrole = (__sft)->deserialize_string(socket, broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIAssociationMI *mi =
	RBGetAssociationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->associatorNames(mi, ctx, result, cop, assocclass, resultclass,
				     role, resultrole);
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
}


static void TCPCOMM_AssociationMI_references(int socket, CONST CMPIBroker * broker,
					       CONST CMPIContext * ctx,
					       CONST CMPIObjectPath * cop)
{
    char *assocclass = (__sft)->deserialize_string(socket, broker);
    char *role = (__sft)->deserialize_string(socket, broker);
    char **props = socketcomm_deserialize_props(socket, (__sft), broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIAssociationMI *mi =
	RBGetAssociationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->references(mi, ctx, result, cop, assocclass, role, (CONST char **)props);
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
    free(props);
}


static void TCPCOMM_AssociationMI_referenceNames(int socket,
						   CONST CMPIBroker * broker,
						   CONST CMPIContext * ctx,
						   CONST CMPIObjectPath * cop)
{
    char *assocclass = (__sft)->deserialize_string(socket, broker);
    char *role = (__sft)->deserialize_string(socket, broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIAssociationMI *mi =
	RBGetAssociationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->referenceNames(mi, ctx, result, cop, assocclass, role);
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
};



static void TCPCOMM_MethodMI_invokeMethod(int socket, CONST CMPIBroker * broker,
					  CONST CMPIContext * ctx,