tcpcomm_remote.c

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

    close(socket);
    return result;
}

#endif /* CMPI_VER_200 */

CMPIBoolean TCPCOMM_selExp_evaluate (CONST CMPISelectExp* se,
                              CONST CMPIInstance *inst,
                              CMPIStatus *rc)
{
        CMPIStatus __rc ;
        CMPIContext *context;
        CMPIBroker *broker;
        CMPIBoolean res;
        int socket;

        broker = tool_mm_get_broker((void**)&context);
        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 0;
        };
        (__sft)->serialize_CMPISelectExp (socket, se, PEGASUS_INDICATION_GLOBAL_CONTEXT);
        (__sft)->serialize_CMPIInstance (socket, inst);
        res = (__sft)->deserialize_UINT8(socket);
        if (rc)
        {
            rc->rc = res ? CMPI_RC_OK : CMPI_RC_ERR_FAILED;
            rc->msg = NULL;
        }
        close(socket);

        return res;
}



CMPISelectCond * TCPCOMM_selExp_getDOC ( CONST CMPISelectExp * exp, CMPIStatus * rc )
{
    if (rc)
    {
        rc->rc = CMPI_RC_ERR_NOT_SUPPORTED;
        rc->msg = NULL;
    }

    return NULL;
}


CMPISelectCond * TCPCOMM_selExp_getCOD ( CONST CMPISelectExp * exp, CMPIStatus * rc )
{
    if (rc)
    {
        rc->rc = CMPI_RC_ERR_NOT_SUPPORTED;
        rc->msg = NULL;
    }

    return NULL;
}

CMPIBoolean TCPCOMM_selExp_evaluateUsingAccessor (CONST CMPISelectExp* se,
        CMPIAccessor *accessor, void *parm, CMPIStatus* rc)
{
    if (rc)
    {
        rc->rc = CMPI_RC_ERR_NOT_SUPPORTED;
        rc->msg = NULL;
    }

    return 0;
}

CMPISelectExp* TCPCOMM_selExp_clone (CONST CMPISelectExp* se, CMPIStatus* rc)
{
    CMPIStatus __rc ;
    CMPIContext *context;
    CMPIBroker *broker;
    CMPISelectExp *res;
    int socket;

    broker = tool_mm_get_broker((void**)&context);
    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;
    }
    (__sft)->serialize_CMPISelectExp (socket, se,
                                      PEGASUS_INDICATION_GLOBAL_CONTEXT);
    {
        CMPIStatus __rc = (__sft)->deserialize_CMPIStatus (socket, broker);
        if ((rc))
            *(rc) = __rc;
    }
    res = (__sft)->deserialize_CMPISelectExp (socket, broker,
                           PEGASUS_INDICATION_GLOBAL_CONTEXT);
    close(socket);

    return res;
}

CMPIString* TCPCOMM_selExp_getString (CONST CMPISelectExp* se, CMPIStatus* rc)
{
    CMPIStatus __rc ;
    CMPIContext *context;
    CMPIBroker *broker;
    CMPIString *str;
    int socket;

    broker = tool_mm_get_broker((void**)&context);
    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;
    }
    (__sft)->serialize_CMPISelectExp (socket, se, PEGASUS_INDICATION_GLOBAL_CONTEXT);
    {
        CMPIStatus __rc = (__sft)->deserialize_CMPIStatus (socket, broker);
        if ((rc))
            *(rc) = __rc;
    }
    str = (__sft)->deserialize_CMPIString (socket, broker);
    close(socket);

    return str;
}

CMPIStatus TCPCOMM_selExp_release (CONST CMPISelectExp* se)
{
    CMPIStatus __rc ;
    CMPIContext *context;
    CMPIBroker *broker;
    int socket;

    broker = tool_mm_get_broker((void**)&context);
    socket = __broker_connect(broker, context, __FUNCTION__);
    TRACE_NORMAL(("Executing remote MB call."));
    if (socket < 0)
    {
        __rc.rc = CMPI_RC_ERR_FAILED;
        __rc.msg = CMNewString((broker), "cannot connect to CIMOM", NULL);
        TRACE_CRITICAL(("up-call connect to broker failed."));
    }
    else
    {
        (__sft)->serialize_CMPISelectExp (socket, se,
                                          PEGASUS_INDICATION_GLOBAL_CONTEXT);
        __rc = (__sft)->deserialize_CMPIStatus(socket, broker);
        if (__rc.rc == CMPI_RC_OK)
        {
            native_release_CMPISelectExp (se);
        }
        close(socket);
    }

    return __rc;
}

CMPISelectExp *TCPCOMM_selExp_newSelExp (const char * queryString,
                                         const char * language,
                                         CMPIArray ** projection,
                                         CMPIStatus * rc )

{
    CMPIStatus __rc ;
    CMPIContext *context;
    CMPIBroker *broker;
    CMPISelectExp *res;
    int socket;

    broker = tool_mm_get_broker((void**)&context);
    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;
    }
    (__sft)->serialize_string (socket, queryString);
    (__sft)->serialize_string (socket, language);

    {
        CMPIStatus __rc = (__sft)->deserialize_CMPIStatus(socket, broker);
        if ((rc))
            *(rc) = __rc;
    }
    // This CMPISelectExp is added to current thread memory management
    // -V 5245
    res = (__sft)->deserialize_CMPISelectExp (socket, broker,
                                   PEGASUS_INDICATION_LOCAL_CONTEXT);
    *projection = (__sft)->deserialize_CMPIArray (socket, broker);
    close(socket);

    return res;
}

static NativeCMPIBrokerFT(tcpcomm_brokerFT) = {
        {       0, 0,
	        "TCPCOMM_REMOTE_BROKER",
	        TCPCOMM_prepareAttachThread,
	        TCPCOMM_attachThread,
	        TCPCOMM_detachThread,
	        TCPCOMM_deliverIndication,
	        TCPCOMM_enumInstanceNames,
	        TCPCOMM_getInstance,
	        TCPCOMM_createInstance,
	        TCPCOMM_setInstance,
	        TCPCOMM_deleteInstance,
	        TCPCOMM_execQuery,
	        TCPCOMM_enumInstances,
	        TCPCOMM_associators,
	        TCPCOMM_associatorNames,
	        TCPCOMM_references,
	        TCPCOMM_referenceNames,
	        TCPCOMM_invokeMethod,
	        TCPCOMM_setProperty,
	        TCPCOMM_getProperty
	},
#ifndef CMPI_VER_100
	TCPCOMM_getKeyNames,
#endif
	TCPCOMM_getMessage,
#ifdef CMPI_VER_100
	TCPCOMM_logMessage,
	TCPCOMM_trace,
#endif
	TCPCOMM_classPathIsA,
    // These are added for Remote CMPI support for Indications
    // We are not implemented the below functionalities on remote
    // side instead we make UP calls to MB. -V 5245
    TCPCOMM_selExp_evaluate,
    TCPCOMM_selExp_getDOC,
    TCPCOMM_selExp_getCOD,
    TCPCOMM_selExp_evaluateUsingAccessor,
    TCPCOMM_selExp_clone,
    TCPCOMM_selExp_getString,
    TCPCOMM_selExp_release,
    TCPCOMM_selExp_newSelExp
#ifdef CMPI_VER_200
    ,
    TCPCOMM_newCMPIError,
    TCPCOMM_openMessageFile,
    TCPCOMM_closeMessageFile,
    TCPCOMM_getMessage2
#endif
};



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


//! Establishes a broker connection.
/*!
  Opens a new connection to the broker address stored in the remote broker
  handle that is hidden behind the regular CMPIBroker. Once the
  connection has been established the proxy ticket, the RCMPI_CTX_ID, and
  the context itself are sent.

  \param broker the remote broker.
  \param ctx the context to be sent.
  \param function the MB call function name.

  \return the connection socket.
 */
static int __broker_connect(CONST CMPIBroker * broker,
			    CONST CMPIContext * ctx, const char *function)
{
    remote_broker *rb = CMPIBroker2remote_broker(broker);
    char *broker_address = RBGetBrokerAddress(rb);
    comm_ticket *ticket = RBGetTicket(rb);

    CMPIData d;
    int socket = open_connection ( broker_address, CIMOM_LISTEN_PORT,
                                   PEGASUS_PRINT_ERROR_MESSAGE);

    if (socket < 0)
	return -1;

    io_write_fixed_length(socket, ticket, sizeof(comm_ticket));

    d = CMGetContextEntry(ctx, RCMPI_CTX_ID, NULL);
    __sft->serialize_UINT32(socket, d.value.uint32);
    __sft->serialize_string(socket, function);
    socketcomm_serialize_context(socket, __sft, ctx);

    return socket;
}

static void __handle_daemon_stop_request()
{
    // TODO: need to close all active connections ???
    // Don't send any response, remote-end already closed the connection.
    exit(0);
}

static void __handle_daemon_is_running_request(int socket)
{
    //As of now do nothing, Don't send any response,
    //remote end already closed the connection...
    close(socket);

    return;
}

//! Sets up the minimal environment for handling an MI request.
/*!
  The function reads initial data such as function name, ticket, provider
  and provider module, resolves the broker address and looks up the
  handler function.

  \param socket the connection socket.

  \sa __mi_functions
*/
static void __handle_MI_call(int socket)
{
    static CMPIBroker __broker = {
	NULL,
	NULL,
	&native_brokerEncFT,
	NULL, // CMPI_BrokerExt_Ftab
        NULL  // CMPI_BrokerMem_Ftab
    };

    char *provider, *provider_module, *function, broker_address[256];
    comm_ticket ticket;
    remote_broker *rb;
    unsigned int i;

    TRACE_VERBOSE(("entered function."));

    get_peer_address(socket, broker_address);

    TRACE_NORMAL(("Handling MI request from: %s", broker_address));
    provider = __sft->deserialize_string(socket, &__broker);

    // PEGASUS_CMPIR_DAEMON_STOP, PEGASUS_CMPIR_DAEMON_IS_RUNNING are not
    // really provider-names. These are the messages sent to daemon.
    // Filter these messages out and handle them.
    if (!strcmp (provider, PEGASUS_CMPIR_DAEMON_STOP) )
    {
        __handle_daemon_stop_request ();
        return; // we should never reach here...
    }
    if (!strcmp (provider, PEGASUS_CMPIR_DAEMON_IS_RUNNING) )
    {
        __handle_daemon_is_running_request (socket);
        return;
    }

    provider_module = __sft->deserialize_string(socket, &__broker);
    io_read_fixed_length(socket, &ticket, sizeof(comm_ticket));
    function = __sft->deserialize_string(socket, &__broker);

    rb = find_remote_broker("TCPComm",
			    broker_address,
			    provider,
			    provider_module, &ticket,
			    &tcpcomm_brokerFT.brokerFt);
    for (i = 0;
	 i < sizeof(__mi_functions) / sizeof(struct socket_mi_function); i++) {

	if (strcmp(function, __mi_functions[i].name) == 0) {

	    CMPIBroker *b = remote_broker2CMPIBroker(rb);
	    CMPIContext *ctx = native_new_CMPIContext(TOOL_MM_ADD);
	    CMPIObjectPath *cop;

	    socketcomm_deserialize_context(socket, __sft, b, ctx);
	    cop = __sft->deserialize_CMPIObjectPath(socket, b);

	    __mi_functions[i].function(socket, b, ctx, cop);

	    RBReleaseMI(rb);
	    close(socket);

	    TRACE_VERBOSE(("leaving function."));
	    return;
	}
    }
    close(socket);
    TRACE_CRITICAL(("Invalid MI call requested: %s", function));
}


//! Waits on incoming MI requests.
/*!
  This function is to be run in a separate thread. There it waits for incoming
  MI calls. These are passed on to __handle_MI_call().

  \sa accept_connections()
 */

static void *__start_remote_daemon(void* parm)
{
    accept_connections(REMOTE_LISTEN_PORT, __handle_MI_call, 1);
    ret