tcpcomm_proxy.c

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

	// return bad status.
	close(socket);

    } else
	__handle_MB_call(socket, broker);

    TRACE_VERBOSE(("leaving function."));
}


//! Establishes the remote daemon connection.
/*!
  Opens a connection to the given address on port REMOTE_LISTEN_PORT, and
  sends the broker ticket, provider name and module, MI function name,
  context, and object path.

  \param addr the provider address.
  \param provider the remote provider name.
  \param ticket the ticket as issued by the broker.
  \param function the MI function call name.
  \param ctx the context for this MI call.
  \param cop the object path for this call.

  \return the connection socket.
 */
static int
__provider_connect(provider_address * addr,
		   char *provider,
		   comm_ticket * ticket,
		   const char *function, CONST CMPIContext * ctx,
		   CONST CMPIObjectPath * cop)
{
    int socket = open_connection ( addr->dst_address,
				   REMOTE_LISTEN_PORT,
				   PEGASUS_PRINT_ERROR_MESSAGE);
    char *pnp;

    if (socket < 0)
	return -1;
    if ((pnp = strchr(provider, ':')))
	__sft->serialize_string(socket, pnp + 1);
    else __sft->serialize_string(socket, provider);
    __sft->serialize_string(socket, addr->provider_module);
    io_write_fixed_length(socket, ticket, sizeof(comm_ticket));
    __sft->serialize_string(socket, function);

    socketcomm_serialize_context(socket, __sft, ctx);
    __sft->serialize_CMPIObjectPath(socket, cop);

    return socket;
}

CMPIString *connect_error(provider_address * addr)
{
   CMPIString *str;
   char msg[512]="Unable to connect to ";

   strcat(msg,addr->dst_address);
   str=CMNewString(__init_broker,msg,NULL);
   return str;
}

//! Waits on incoming broker service requests.
/*!
  This function is to be run in a separate thread. There it attaches itself
  to the given context and waits for incoming MB calls. These are passed on
  to __verify_MB_call().

  \param ctx the CMPIContext to attach to.

  \sa accept_connections()
 */
static void __start_proxy_daemon(CMPIContext * ctx)
{
    if (ctx != NULL) {
		CBAttachThread(__init_broker, ctx);
	}
    accept_connections(CIMOM_LISTEN_PORT, __verify_MB_call, 0);
    CBDetachThread(__init_broker, ctx);
}


//! Launches __start_proxy_daemon() in a separate thread.
/*!
  The function prepares a context for the MB listen thread and launches it.
 */
static void __launch_proxy_daemon()
{
    CMPIContext *ctx = CBPrepareAttachThread(__init_broker, __init_context);
    if (!(__init_context && __init_broker))
	{
		CMRelease(ctx);
		ctx = NULL;
	}
    CMPI_BrokerExt_Ftab->newThread((void*(*)(void*))__start_proxy_daemon,ctx,1);
}

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

static CMPIStatus TCPCOMM_InstanceMI_enumInstanceNames(provider_address * addr,
				     RemoteCMPIInstanceMI * cThis,
				     CONST CMPIContext * context,
				     CONST CMPIResult * result,
				     CONST CMPIObjectPath * cop)
{
    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));
    {
	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_InstanceMI_enumInstances(provider_address * addr,
				 RemoteCMPIInstanceMI * cThis,
				 CONST CMPIContext * context,
				 CONST CMPIResult * result,
				 CONST CMPIObjectPath * cop, CONST char **props)
{
    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));
    socketcomm_serialize_props(socket, (__sft), (char **)props);
    {
	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_InstanceMI_getInstance(provider_address * addr,
			       RemoteCMPIInstanceMI * cThis,
			       CONST CMPIContext * context,
			       CONST CMPIResult * result,
			       CONST CMPIObjectPath * cop,
						 CONST char **props)
{
    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));
    socketcomm_serialize_props(socket, (__sft), (char **)props);
    {
	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_InstanceMI_createInstance(provider_address * addr,
				  RemoteCMPIInstanceMI * cThis,
				  CONST CMPIContext * context,
				  CONST CMPIResult * result,
				  CONST CMPIObjectPath * cop,
				  CONST CMPIInstance * inst)
{
    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_CMPIInstance(socket, inst);
    {
	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_InstanceMI_setInstance(provider_address * addr,
			       RemoteCMPIInstanceMI * cThis,
			       CONST CMPIContext * context,
			       CONST CMPIResult * result,
			       CONST CMPIObjectPath * cop,
			       CONST CMPIInstance * inst,
						 CONST char **props)
{
    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_CMPIInstance(socket, inst);
    socketcomm_serialize_props(socket, (__sft), (char **)props);
    {
	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_InstanceMI_deleteInstance(provider_address * addr,
				  RemoteCMPIInstanceMI * cThis,
				  CONST CMPIContext * context,
				  CONST CMPIResult * result,
				  CONST CMPIObjectPath * cop)
{
    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));
    {
	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_InstanceMI_execQuery(provider_address * addr,
			     RemoteCMPIInstanceMI * cThis,
			     CONST CMPIContext * context,
					       CONST CMPIResult * result,
			     CONST CMPIObjectPath * cop, CONST char *lang,
			     CONST char *query)
{
    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, lang);
    (__sft)->serialize_string(socket, query);
    {
	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_AssociationMI_associators(provider_address * addr,
				  RemoteCMPIAssociationMI * cThis,
				  CONST CMPIContext * context,
				  CONST CMPIResult * result,
				  CONST CMPIObjectPath * cop,
				  const char *assocclass,
				  const char *resultclass,
				  const char *role,
                                  const char *resultrole,
				  CONST char **props)
{
    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, assocclass);
    (__sft)->serialize_string(socket, resultclass);
    (__sft)->serialize_string(socket, role);
    (__sft)->serialize_string(socket, resultrole);
    socketcomm_serialize_props(socket, (__sft), (char **)props);
    {
	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_AssociationMI_associatorNames(provider_address * addr,
				      RemoteCMPIAssociationMI * cThis,
				      CONST CMPIContext * context,
				      CONST CMPIResult * result,
				      CONST CMPIObjectPath * cop,
				      const char *assocclass,
				      const char *resultclass,
				      const char *role,
				      const char *resultrole)
{
    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, assocclass);
    (__sft)->serialize_string(socket, resultclass);
    (__sft)->serialize_string(socket, role);
    (__sft)->serialize_string(socket, resultrole);
    {
	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_AssociationMI_references(provider_address * addr,
				 RemoteCMPIAssociationMI * cThis,
				 CONST CMPIContext * context,
				 CONST CMPIResult * result,
				 CONST CMPIObjectPath * cop,
                                 const char *assocclass,
				 const char *role,
                                 CONST char **props)
{
    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, assocclass);
    (__sft)->serialize_string(socket, role);
    socketcomm_serialize_props(socket, (__sft), (char **)props);
    {
	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_AssociationMI_referenceNames(provider_address * addr,
				     RemoteCMPIAssociationMI * cThis,
				     CONST CMPIContext * context,
				     CONST CMPIResult * result,
				     CONST CMPIObjectPath * cop,
				     const char *assocclass, const char *role)
{
    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, assocclass);
    (__sft)->serialize_string(socket, role);