tcpcomm_remote.c

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

					  CONST CMPIObjectPath * cop)
{
    char *method = (__sft)->deserialize_string(socket, broker);
    CMPIArgs *in = (__sft)->deserialize_CMPIArgs(socket, broker);
    CMPIArgs *out = CMNewArgs(broker, NULL);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIMethodMI *mi = RBGetMethodMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if(mi)
    {
        rc = mi->ft->invokeMethod(mi, ctx, result, cop, method, in, out);
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
    (__sft)->serialize_CMPIArgs(socket, out);
};



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


static void TCPCOMM_PropertyMI_setProperty(int socket, CONST CMPIBroker * broker,
					     CONST CMPIContext * ctx,
					     CONST CMPIObjectPath * cop)
{
    char *name = (__sft)->deserialize_string(socket, broker);
    CMPIData data = (__sft)->deserialize_CMPIData(socket, broker);
    CMPIStatus rc;
    CMPIArray *r;
    CMPIResult *result = native_new_CMPIResult(NULL);
    CMPIPropertyMI *mi = RBGetPropertyMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (mi)
    {
        rc = mi->ft->setProperty(mi, ctx, result, cop, name, data);
    }
    else
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIArray(socket, r);;
};



static void TCPCOMM_IndicationMI_authorizeFilter(int socket,
						 CONST CMPIBroker * broker,
						 CONST CMPIContext * ctx,
						 CONST CMPIObjectPath * cop)
{
    CMPISelectExp *filter = (__sft)->deserialize_CMPISelectExp(socket, broker,
                                            PEGASUS_INDICATION_GLOBAL_CONTEXT);
    char *indType = (__sft)->deserialize_string(socket, broker);
    char *owner = (__sft)->deserialize_string(socket, broker);
    CMPIStatus rc;
    CMPIArray *r;
#ifndef CMPI_VER_100
    CMPIResult *result = native_new_CMPIResult(NULL);
#endif
    CMPIIndicationMI *mi =
	RBGetIndicationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
#ifdef CMPI_VER_100
    if (mi)
    {
        rc = mi->ft->authorizeFilter(mi, ctx, filter, indType, cop, owner);
    }
#else
    if (mi)
    {
        rc = mi->ft->authorizeFilter(mi, ctx, result, filter, indType, cop, owner);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIArray(socket, r);;
#endif
    if (!mi)
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    (__sft)->serialize_CMPIStatus(socket, &rc);
}


static void TCPCOMM_IndicationMI_mustPoll(int socket, CONST CMPIBroker * broker,
					    CONST CMPIContext * ctx,
					    CONST CMPIObjectPath * cop)
{
    CMPISelectExp *filter = (__sft)->deserialize_CMPISelectExp(socket, broker,
                                       PEGASUS_INDICATION_GLOBAL_CONTEXT);
    char *indType = (__sft)->deserialize_string(socket, broker);
    CMPIStatus rc;
    CMPIArray *r;
#ifndef CMPI_VER_100
    CMPIResult *result = native_new_CMPIResult(NULL);
#endif
    CMPIIndicationMI *mi =
	RBGetIndicationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
#ifdef CMPI_VER_100
    if (mi)
    {
        rc = mi->ft->mustPoll(mi, ctx,  filter, indType, cop);
    }
#else
    if (mi)
    {
        rc = mi->ft->mustPoll(mi, ctx, result, filter, indType, cop);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIArray(socket, r);
#endif
    if (!mi)
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    (__sft)->serialize_CMPIStatus(socket, &rc);
}


static void TCPCOMM_IndicationMI_activateFilter(int socket,
						  CONST CMPIBroker * broker,
						  CONST CMPIContext * ctx,
						  CONST CMPIObjectPath * cop)
{
    // This filter is not deleted when the current thread is finished
    // execution. This is the persistent filter on MB side.
    // Delete this filter in deactiveFilter -V 5245
    CMPISelectExp *filter = (__sft)->deserialize_CMPISelectExp(socket, broker,
                                     PEGASUS_INDICATION_GLOBAL_CONTEXT);
    char *indType = (__sft)->deserialize_string(socket, broker);
    CMPIBoolean firstActivation = (__sft)->deserialize_UINT8(socket);
    CMPIStatus rc;
    CMPIArray *r;

#ifndef CMPI_VER_100
    CMPIResult *result = native_new_CMPIResult(NULL);
#endif
    CMPIIndicationMI *mi =
	RBGetIndicationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
#ifdef CMPI_VER_100
    if (mi)
    {
        rc = mi->ft->activateFilter(mi, ctx, filter, indType, cop,
				    firstActivation);;
    }
#else
    if (mi)
    {
        rc = mi->ft->activateFilter(mi, ctx, result, filter, indType, cop,
				    firstActivation);;
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIArray(socket, r);
#endif
    if (!mi)
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    (__sft)->serialize_CMPIStatus(socket, &rc);
}


static void TCPCOMM_IndicationMI_deActivateFilter(int socket,
						    CONST CMPIBroker * broker,
						    CONST CMPIContext * ctx,
						    CONST CMPIObjectPath * cop)
{
    CMPISelectExp *filter = (__sft)->deserialize_CMPISelectExp(socket, broker,
                                  PEGASUS_INDICATION_GLOBAL_CONTEXT);
    char *indType = (__sft)->deserialize_string(socket, broker);
    CMPIBoolean lastActivation = (__sft)->deserialize_UINT8(socket);
    CMPIStatus rc;
    CMPIArray *r;
#ifndef CMPI_VER_100
    CMPIResult *result = native_new_CMPIResult(NULL);
#endif
    CMPIIndicationMI *mi =
	RBGetIndicationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
#ifdef CMPI_VER_100
    if (mi)
    {
        rc = mi->ft->deActivateFilter(mi, ctx,  filter, indType, cop,
				      lastActivation);
    }
#else
    if (mi)
    {
        rc = mi->ft->deActivateFilter(mi, ctx, result, filter, indType, cop,
				      lastActivation);
    }
    r = native_result2array(result);
    (__sft)->serialize_CMPIArray(socket, r);
#endif
    if (!mi)
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    // Now delete the original filter we got in activateFilter. -V 5245
    native_release_CMPISelectExp (filter);
    (__sft)->serialize_CMPIStatus(socket, &rc);
};

static void TCPCOMM_IndicationMI_enableIndications (int socket,
                                                      CONST CMPIBroker * broker,
                                                      CONST CMPIContext * ctx,
                                                      CONST CMPIObjectPath * cop)
{
    CMPIStatus rc = { CMPI_RC_OK , NULL };

    CMPIIndicationMI *mi =
        RBGetIndicationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (!mi)
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    // To make compatibilty with old providers it was decided to discard the
    // returned CMPIStatus here. This will prevent us from breaking existing
    // CMPI Indication providers. -V 5886
#ifdef CMPI_VER_100
    mi->ft->enableIndications(mi, ctx);
#else
    mi->ft->enableIndications(mi);
#endif
    (__sft)->serialize_CMPIStatus(socket, &rc);
}

static void TCPCOMM_IndicationMI_disableIndications (int socket,
                                                      CONST CMPIBroker * broker,
                                                      CONST CMPIContext * ctx,
                                                      CONST CMPIObjectPath * cop)
{
    CMPIStatus rc = { CMPI_RC_OK, NULL };
    CMPIIndicationMI *mi =
        RBGetIndicationMI(CMPIBroker2remote_broker((broker)));
    TRACE_NORMAL(("Executing remote MI request."));
    tool_mm_set_broker((CMPIBroker *)broker, (CMPIContext *)ctx);
    START_DEBUGGER;
    if (!mi)
    {
        SET_STATUS_INIT_FAILED(rc);
    }
    // To make compatibilty with old providers it was decided to discard the
    // returned CMPIStatus here. This will prevent us from breaking existing
    // CMPI Indication providers. -V 5886
#ifdef CMPI_VER_100
    mi->ft->disableIndications(mi, ctx);
#else
    mi->ft->disableIndications(mi);
#endif
    (__sft)->serialize_CMPIStatus(socket, &rc);
}

static struct socket_mi_function __mi_functions[] = {
        {"TCPCOMM_InstanceMI_enumInstanceNames",        TCPCOMM_InstanceMI_enumInstanceNames},
        {"TCPCOMM_InstanceMI_enumInstances",            TCPCOMM_InstanceMI_enumInstances},
        {"TCPCOMM_InstanceMI_getInstance",              TCPCOMM_InstanceMI_getInstance},
        {"TCPCOMM_InstanceMI_createInstance",           TCPCOMM_InstanceMI_createInstance},
        {"TCPCOMM_InstanceMI_setInstance",              TCPCOMM_InstanceMI_setInstance},
        {"TCPCOMM_InstanceMI_deleteInstance",           TCPCOMM_InstanceMI_deleteInstance},
        {"TCPCOMM_InstanceMI_execQuery",                TCPCOMM_InstanceMI_execQuery},
        {"TCPCOMM_AssociationMI_associators",           TCPCOMM_AssociationMI_associators},
        {"TCPCOMM_AssociationMI_associatorNames",       TCPCOMM_AssociationMI_associatorNames},
        {"TCPCOMM_AssociationMI_references",            TCPCOMM_AssociationMI_references},
        {"TCPCOMM_AssociationMI_referenceNames",        TCPCOMM_AssociationMI_referenceNames},
        {"TCPCOMM_MethodMI_invokeMethod",               TCPCOMM_MethodMI_invokeMethod},
        {"TCPCOMM_PropertyMI_getProperty",              TCPCOMM_PropertyMI_getProperty},
        {"TCPCOMM_PropertyMI_setProperty",              TCPCOMM_PropertyMI_setProperty},
        {"TCPCOMM_IndicationMI_authorizeFilter",        TCPCOMM_IndicationMI_authorizeFilter},
        {"TCPCOMM_IndicationMI_mustPoll",               TCPCOMM_IndicationMI_mustPoll},
        {"TCPCOMM_IndicationMI_activateFilter",         TCPCOMM_IndicationMI_activateFilter},
        {"TCPCOMM_IndicationMI_deActivateFilter",       TCPCOMM_IndicationMI_deActivateFilter},
        {"TCPCOMM_IndicationMI_enableIndications",      TCPCOMM_IndicationMI_enableIndications},
        {"TCPCOMM_IndicationMI_disableIndications",     TCPCOMM_IndicationMI_disableIndications}
};

static CMPIContext *TCPCOMM_prepareAttachThread(CONST CMPIBroker * broker,
						CONST CMPIContext * context)
{
    CMPIStatus *rc = NULL;
    CMPIContext *r = native_new_CMPIContext(TOOL_MM_NO_ADD);
    int socket = __broker_connect(broker, context, __FUNCTION__);
    TRACE_NORMAL(("Executing remote MB call."));
    if (socket < 0) {
	if ((rc)) {
	    (rc)->rc = CMPI_RC_ERR_FAILED;
	    (rc)->msg = CMNewString((broker), "cannot connect to CIMOM", NULL);
	}
	TRACE_CRITICAL(("up-call connect to broker failed."));
	return (NULL);
    };
    socketcomm_deserialize_context(socket, (__sft), broker, r);
    close(socket);
    return r;
}



static CMPIStatus TCPCOMM_attachThread(CONST CMPIBroker * broker,
				       CONST CMPIContext * context)
{
    // Add the current thread to memory Management. -V 5245
    tool_mm_set_broker( (CMPIBroker*)broker, (CMPIContext*)context);
    CMReturn(CMPI_RC_OK);
}



static CMPIStatus TCPCOMM_detachThread(CONST CMPIBroker * broker,
					 CONST CMPIContext * context)
{
    CMPIStatus __rc, *rc = &__rc;
    int socket = __broker_connect(broker, context, __FUNCTION__);
    TRACE_NORMAL(("Executing remote MB call."));
    if (socket < 0) {
	if ((rc)) {
	    (rc)->rc = CMPI_RC_ERR_FAILED;
	    (rc)->msg = CMNewString((broker), "cannot connect to CIMOM", NULL);
	}
	TRACE_CRITICAL(("up-call connect to broker failed."));
	return (__rc);
    }; {
	CMPIStatus __rc = (__sft)->deserialize_CMPIStatus(socket, broker);
	if ((rc))
	    *(rc) = __rc;
    };
    close(socket);
    native_release_CMPIContext(context);
    return __rc;
}



static CMPIStatus TCPCOMM_deliverIndication(CONST CMPIBroker * broker,
					    CONST CMPIContext * context, const char *ns,
					    CONST CMPIInstance * ind)
{
    CMPIStatus __rc, *rc = &__rc;
    int socket = __broker_connect(broker, context, __FUNCTION__);
    TRACE_NORMAL(("Executing remote MB call."));
    if (socket < 0) {
	if ((rc)) {
	    (rc)->rc = CMPI_RC_ERR_FAILED;
	    (rc)->msg = CMNewString((broker), "cannot connect to CIMOM", NULL);
	}
	TRACE_CRITICAL(("up-call connect to broker failed."));
	return (__rc);
    };
    (__sft)->serialize_string(socket, ns);
    (__sft)->serialize_CMPIInstance(socket, ind); {
	CMPIStatus __rc = (__sft)->deserialize_CMPIStatus(socket, broker);
	if ((rc))
	    *(rc) = __rc;
    };
    close(socket);
    return __rc;
}



static CMPIEnumeration *TCPCOMM_enumInstanceNames(CONST CMPIBroker * broker,
						  CONST CMPIContext * context,
						  CONST CMPIObjectPath * cop,
						  CMPIStatus * rc)
{
    CMPIArray *r;
    int socket = __broker_connect(broker, context, __FUNCTION__);
    TRACE_NORMAL(("Executing remote MB call."));
    if (socket < 0) {
	if ((rc)) {
	    (rc)->rc = CMPI_RC_ERR_FAILED;
	    (rc)->msg = CMNewString((broker), "cannot connect to CIMOM", NULL);