tcpcomm_proxy.c

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

    {
	CMPIStatus rc;
	CMPIArray *r;
	rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
	r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
	close(socket);
	remove_context(ctxid);
	socketcomm_array2result(r, result);
	return rc;
    };
};


static CMPIStatus TCPCOMM_MethodMI_invokeMethod(provider_address * addr,
			      RemoteCMPIMethodMI * cThis,
			      CONST CMPIContext * context,
			      CONST CMPIResult * result, CONST CMPIObjectPath * cop,
			      const char *method, CONST CMPIArgs * in,
			      CMPIArgs * out)
{
    int socket;
    unsigned long int ctxid = save_context(context);
    TRACE_NORMAL(("Executing remote MI call."));
    CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
    socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
			   __FUNCTION__, context, cop);
    if (socket < 0)
	CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
    (__sft)->serialize_string(socket, method);
    (__sft)->serialize_CMPIArgs(socket, in);
    {
	CMPIStatus rc;
	CMPIArray *r;
	rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
	r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
	{
	    CMPIArgs *a =
		(__sft)->deserialize_CMPIArgs(socket, cThis->broker);
	    socketcomm_copy_args(a, (out));
	}
	close(socket);
	remove_context(ctxid);
	socketcomm_array2result(r, result);
	return rc;
    };
};


static CMPIStatus TCPCOMM_PropertyMI_setProperty(provider_address * addr,
			       RemoteCMPIPropertyMI * cThis,
			       CONST CMPIContext * context,
			       CONST CMPIResult * result,
			       CONST CMPIObjectPath * cop, const char *name,
			       CONST CMPIData data)
{
    int socket;
    unsigned long int ctxid = save_context(context);
    TRACE_NORMAL(("Executing remote MI call."));
    CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
    socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
			   __FUNCTION__, context, cop);
    if (socket < 0)
	CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
    (__sft)->serialize_string(socket, name);
    (__sft)->serialize_CMPIData(socket, data);
    {
	CMPIStatus rc;
	CMPIArray *r;
	rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
	r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
	close(socket);
	remove_context(ctxid);
	socketcomm_array2result(r, result);
	return rc;
    };
}

static CMPIStatus TCPCOMM_PropertyMI_getProperty(provider_address * addr,
			       RemoteCMPIPropertyMI * cThis,
			       CONST CMPIContext * context,
			       CONST CMPIResult * result,
			       CONST CMPIObjectPath * cop, const char *name)
{
    int socket;
    unsigned long int ctxid = save_context(context);
    TRACE_NORMAL(("Executing remote MI call."));
    CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
    socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
			   __FUNCTION__, context, cop);
    if (socket < 0)
	CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
    (__sft)->serialize_string(socket, name);
    {
	CMPIStatus rc;
	CMPIArray *r;
	rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
	r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
	close(socket);
	remove_context(ctxid);
	socketcomm_array2result(r, result);
	return rc;
    };
};


#ifdef CMPI_VER_100
static CMPIStatus TCPCOMM_IndicationMI_authorizeFilter(provider_address * addr,
				     RemoteCMPIIndicationMI * cThis,
				     const CMPIContext * context,
				     const CMPISelectExp * filter,
				     const char *indType,
				     const CMPIObjectPath * cop,
				     const char *owner)
#else
static CMPIStatus TCPCOMM_IndicationMI_authorizeFilter(provider_address * addr,
				     RemoteCMPIIndicationMI * cThis,
				     CMPIContext * context,
				     CMPIResult * result,
				     CMPIObjectPath * cop,
				     CMPISelectExp * filter,
				     const char *indType, const char *owner)
#endif
{
    int socket;
    unsigned long int ctxid = save_context(context);
    TRACE_NORMAL(("Executing remote MI call."));
    CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
    socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
			   __FUNCTION__, context, cop);
    if (socket < 0)
	CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
    (__sft)->serialize_CMPISelectExp(socket, filter,
                                     PEGASUS_INDICATION_GLOBAL_CONTEXT );
    (__sft)->serialize_string(socket, indType);
    (__sft)->serialize_string(socket, owner);
    {
	CMPIStatus rc;
	CMPIArray *r;
	rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
#ifndef CMPI_VER_100
	r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
#endif
	close(socket);
	remove_context(ctxid);
#ifndef CMPI_VER_100
	socketcomm_array2result(r, result);
#endif
	return rc;
    };
}


#ifdef CMPI_VER_100
static CMPIStatus TCPCOMM_IndicationMI_mustPoll(provider_address * addr,
			      RemoteCMPIIndicationMI * cThis,
			      const CMPIContext * context,
			      const CMPISelectExp * filter,
			      const char *indType,
			      const CMPIObjectPath * cop)
#else
static CMPIStatus TCPCOMM_IndicationMI_mustPoll(provider_address * addr,
			      RemoteCMPIIndicationMI * cThis,
			      CMPIContext * context,
			      CMPIResult * result, CMPIObjectPath * cop,
			      CMPISelectExp * filter, const char *indType)
#endif
{
    int socket;
    unsigned long int ctxid = save_context(context);
    TRACE_NORMAL(("Executing remote MI call."));
    CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
    socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
			   __FUNCTION__, context, cop);
    if (socket < 0)
	CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
    (__sft)->serialize_CMPISelectExp(socket, filter,
                                     PEGASUS_INDICATION_GLOBAL_CONTEXT);
    (__sft)->serialize_string(socket, indType);
    {
	CMPIStatus rc;
	CMPIArray *r;
	rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
#ifndef CMPI_VER_100
	r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
#endif
	close(socket);
	remove_context(ctxid);
#ifndef CMPI_VER_100
	socketcomm_array2result(r, result);
#endif
	return rc;
    };
}

#ifdef CMPI_VER_100
static CMPIStatus TCPCOMM_IndicationMI_activateFilter(provider_address * addr,
				    RemoteCMPIIndicationMI * cThis,
				    const CMPIContext * context,
				    const CMPISelectExp * filter,
				    const char *indType,
				    const CMPIObjectPath * cop,
				    CMPIBoolean firstActivation)
#else
static CMPIStatus TCPCOMM_IndicationMI_activateFilter(provider_address * addr,
				    RemoteCMPIIndicationMI * cThis,
				    CMPIContext * context,
				    CMPIResult * result,
				    CMPIObjectPath * cop,
				    CMPISelectExp * filter,
				    const char *indType,
				    CMPIBoolean firstActivation)
#endif

{
    int socket;
    unsigned long int ctxid = save_context(context);
    TRACE_NORMAL(("Executing remote MI call."));
    CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
    socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
			   __FUNCTION__, context, cop);
    if (socket < 0)
	CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
    (__sft)->serialize_CMPISelectExp(socket, filter,
                                             PEGASUS_INDICATION_GLOBAL_CONTEXT);
    (__sft)->serialize_string(socket, indType);
    (__sft)->serialize_UINT8(socket, firstActivation);
    {
	CMPIStatus rc;
	CMPIArray *r;
	rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
#ifndef CMPI_VER_100
	r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
#endif
	close(socket);
	remove_context(ctxid);
#ifndef CMPI_VER_100
	socketcomm_array2result(r, result);
#endif
	return rc;
    };
}

#ifdef CMPI_VER_100
static CMPIStatus TCPCOMM_IndicationMI_deActivateFilter(provider_address * addr,
				      RemoteCMPIIndicationMI * cThis,
				      const CMPIContext * context,
				      const CMPISelectExp * filter,
				      const char *indType,
				      const CMPIObjectPath * cop,
				      CMPIBoolean lastActivation)
#else
static CMPIStatus TCPCOMM_IndicationMI_deActivateFilter(provider_address * addr,
				      RemoteCMPIIndicationMI * cThis,
				      CMPIContext * context,
				      CMPIResult * result,
				      CMPIObjectPath * cop,
				      CMPISelectExp * filter,
				      const char *indType,
				      CMPIBoolean lastActivation)
#endif
{
    int socket;
    unsigned long int ctxid = save_context(context);
    TRACE_NORMAL(("Executing remote MI call."));
    CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
    socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
			   __FUNCTION__, context, cop);

    if (socket < 0)
	CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
    (__sft)->serialize_CMPISelectExp(socket, filter,
                                             PEGASUS_INDICATION_GLOBAL_CONTEXT);
    (__sft)->serialize_string(socket, indType);
    (__sft)->serialize_UINT8(socket, lastActivation);
    {
	CMPIStatus rc;
	CMPIArray *r;
	rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
#ifndef CMPI_VER_100
	r = (__sft)->deserialize_CMPIArray(socket, cThis->broker);
#endif
	close(socket);
	remove_context(ctxid);
#ifndef CMPI_VER_100
	socketcomm_array2result(r, result);
#endif
	return rc;
    };
};

#ifdef CMPI_VER_100
static CMPIStatus TCPCOMM_IndicationMI_enableIndications(provider_address * addr,
                                      RemoteCMPIIndicationMI * cThis,
                                      const CMPIContext * context)
#else
static CMPIStatus TCPCOMM_IndicationMI_enableIndications(provider_address * addr,
                                      RemoteCMPIIndicationMI * cThis);
#endif
{
    int socket;
    unsigned long int ctxid = save_context(context);
    CMPIObjectPath *cop = NULL;
    TRACE_NORMAL(("Executing remote MI call."));
    CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
    socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
                           __FUNCTION__, context, cop);
    if (socket < 0)
        CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
    {
        CMPIStatus rc;
        CMPIArray *r;
        rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
        close(socket);
        remove_context(ctxid);
        return rc;
    };
};


#ifdef CMPI_VER_100
static CMPIStatus TCPCOMM_IndicationMI_disableIndications(provider_address * addr,
                                      RemoteCMPIIndicationMI * cThis,
                                      const CMPIContext * context)
#else
static CMPIStatus TCPCOMM_IndicationMI_disableIndications(provider_address * addr,
                                      RemoteCMPIIndicationMI * cThis);
#endif
{
    int socket;
    unsigned long int ctxid = save_context(context);
    CMPIObjectPath *cop = NULL;
    TRACE_NORMAL(("Executing remote MI call."));

    CMAddContextEntry(context, RCMPI_CTX_ID, &ctxid, CMPI_uint32);
    socket = __provider_connect(addr, cThis->provider, &cThis->ticket,
                           __FUNCTION__, context, cop);
    if (socket < 0)
        CMReturnWithString(CMPI_RC_ERR_FAILED,connect_error(addr));
    {
        CMPIStatus rc;
        CMPIArray *r;
        rc = (__sft)->deserialize_CMPIStatus(socket, cThis->broker);
        close(socket);
        remove_context(ctxid);
        return rc;
    };
};


static CMPIStatus
TCPCOMM_cleanup()
{
	CMPIStatus rc = {CMPI_RC_OK,NULL};

    TRACE_NORMAL(("Closing connections."));
	rc.rc = close_connection(CIMOM_LISTEN_PORT);
	cleanup_context();
	return rc;
}

//! Initializes this communication layer.
/*!
  This method, if called by the proxy provider sets up the daemon thread
  to listen for MB calls, then returns a provider_comm to receive MI
  requests.

  \param broker the CMPIBroker requesting this service.
  \param ctx the context of the requesting caller.
 */
provider_comm *CMPIRTCPComm_InitCommLayer(CONST CMPIBroker * broker,
					  CONST CMPIContext * ctx)
{
   static provider_comm comm = {
        "TCPComm",
        TCPCOMM_InstanceMI_enumInstanceNames,
        TCPCOMM_InstanceMI_enumInstances,
        TCPCOMM_InstanceMI_getInstance,
        TCPCOMM_InstanceMI_createInstance,
        TCPCOMM_InstanceMI_setInstance,
        TCPCOMM_InstanceMI_deleteInstance,
        TCPCOMM_InstanceMI_execQuery,
        TCPCOMM_AssociationMI_associators,
        TCPCOMM_AssociationMI_associatorNames,
        TCPCOMM_AssociationMI_references,
        TCPCOMM_AssociationMI_referenceNames,
        TCPCOMM_MethodMI_invokeMethod,
        TCPCOMM_PropertyMI_setProperty,
        TCPCOMM_PropertyMI_getProperty,
        TCPCOMM_IndicationMI_authorizeFilter,
        TCPCOMM_IndicationMI_mustPoll,
        TCPCOMM_IndicationMI_activateFilter,
        TCPCOMM_IndicationMI_deActivateFilter,
		TCPCOMM_cleanup,
	TCPCOMM_IndicationMI_enableIndications,
	TCPCOMM_IndicationMI_disableIndications,
        NULL,
	NULL
   };
#ifndef PEGASUS_PLATFORM_ZOS_ZSERIES
    static int  __once = 0;
#else
		pthread_once_t __once = PTHREAD_ONCE_INIT;
#endif

     __init_broker = broker;
     __init_context = ctx;

     CMPI_BrokerExt_Ftab->threadOnce(&__once, __launch_proxy_daemon);

     return &comm;
}


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

/*** Local Variables:  ***/
/*** mode: C           ***/
/*** c-basic-offset: 8 ***/
/*** End:              ***/