tcpcomm_proxy.c

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

	break;
    case 3:
        result = broker->eft->getMessage(broker, msgId, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint);
	break;
    case 4:
        result = broker->eft->getMessage(broker, msgId, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint);
    case 5:
        result = broker->eft->getMessage(broker, msgId, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint);
	break;
    case 6:
        result = broker->eft->getMessage(broker, msgId, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint);
	break;
    case 7:
        result = broker->eft->getMessage(broker, msgId, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint,
	   type[6],value[6].uint);
	break;
     case 8:
        result = broker->eft->getMessage(broker, msgId, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint,
	   type[6],value[6].uint, type[7],value[7].uint);
	break;
     case 9:
        result = broker->eft->getMessage(broker, msgId, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint,
	   type[6],value[6].uint, type[7],value[7].uint, type[8],value[8].uint);
	break;
     default:
        result = broker->eft->getMessage(broker, msgId, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint,
	   type[6],value[6].uint, type[7],value[7].uint, type[8],value[8].uint,
	   type[9],value[9].uint);
   }

    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIString(socket, result);
}

static void TCPCOMM_logMessage (int socket, CONST CMPIBroker * broker,
		    CONST CMPIContext * context)
{
    CMPIUint32 severity;
    char *id,*text;
    CMPIString *string;
    CMPIStatus rc = { CMPI_RC_OK,NULL };

    severity = (__sft)->deserialize_UINT32(socket);
    id = (__sft)->deserialize_string(socket, broker);
    text = (__sft)->deserialize_string(socket, broker);
    string = (__sft)->deserialize_CMPIString(socket, broker);
    rc = broker->eft->logMessage(broker,severity,id,text,string);
    (__sft)->serialize_CMPIStatus(socket, &rc);
}

static void TCPCOMM_trace (int socket, CONST CMPIBroker * broker,
		    CONST CMPIContext * context)
{
    CMPIUint32 level;
    char *component,*text;
    CMPIString *string;
    CMPIStatus rc = { CMPI_RC_OK,NULL };

    level = (__sft)->deserialize_UINT32(socket);
    component = (__sft)->deserialize_string(socket, broker);
    text = (__sft)->deserialize_string(socket, broker);
    string = (__sft)->deserialize_CMPIString(socket, broker);
    rc = broker->eft->trace(broker,level,component,text,string);
    (__sft)->serialize_CMPIStatus(socket, &rc);
}

static void TCPCOMM_classPathIsA (int socket, CONST CMPIBroker * broker,
		    CONST CMPIContext * context)
{
//  ( CMPIBroker * broker,
//        CMPIObjectPath * cop, const char * type, CMPIStatus * rc );
    CMPIStatus rc;
    CMPIObjectPath *cop;
    char *type;
    CMPIBoolean result;

    cop = (__sft)->deserialize_CMPIObjectPath(socket, broker);
    type= (__sft)->deserialize_string(socket, broker);
    result = broker->eft->classPathIsA(broker, cop, type, &rc);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_UINT8(socket, (unsigned char)result);
};


#ifdef CMPI_VER_200

static void TCPCOMM_newCMPIError (int socket, CONST CMPIBroker * broker,
		    CONST CMPIContext * context)
{
    char *owner,*msgID,*msg;
    CMPIErrorSeverity sev;
    CMPIErrorProbableCause pc;
    CMPIrc cimStatusCode;
    CMPIError *resError;
    CMPIStatus rc = { CMPI_RC_OK, NULL };

    owner = (__sft)->deserialize_string(socket, broker);
    msgID = (__sft)->deserialize_string(socket, broker);
    msg = (__sft)->deserialize_string(socket, broker);
    sev = (__sft)->deserialize_CMPIErrorSeverity(socket, broker);
    pc = (__sft)->deserialize_CMPIErrorProbableCause(socket, broker);
    cimStatusCode = (__sft)->deserialize_CMPIrc(socket, broker);
    resError = broker->eft->newCMPIError(
        broker, owner, msgID, msg, sev, pc, cimStatusCode, &rc);
    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIError(socket, resError);
}

static void TCPCOMM_openMessageFile (int socket, CONST CMPIBroker * broker,
		    CONST CMPIContext * context)
{
    char *msgFile;
    CMPIMsgFileHandle msgFileHandle;
    CMPIStatus rc = { CMPI_RC_OK,NULL };

    msgFile = (__sft)->deserialize_string(socket, broker);
    rc = broker->eft->openMessageFile(broker, msgFile, &msgFileHandle);
    (__sft)->serialize_CMPIStatus(socket, &rc);
	(__sft)->serialize_CMPIMsgFileHandle(socket, msgFileHandle);
}

static void TCPCOMM_closeMessageFile (int socket, CONST CMPIBroker * broker,
		    CONST CMPIContext * context)
{
    CMPIMsgFileHandle msgFileHandle;
    CMPIStatus rc = { CMPI_RC_OK,NULL };

    msgFileHandle = (__sft)->deserialize_CMPIMsgFileHandle(socket, broker);
    rc = broker->eft->closeMessageFile(broker, msgFileHandle);
    (__sft)->serialize_CMPIStatus(socket, &rc);
}

static void TCPCOMM_getMessage2 (int socket, CONST CMPIBroker * broker,
		    CONST CMPIContext * context)
{
    union {
      CMPIUint32  uint;
      CMPIBoolean blean;
      CMPIString  *str;
      CMPIReal64  r64;
      CMPIUint64  u64;
    } value[10];
    CMPIType type[10];

    CMPIStatus rc = { CMPI_RC_OK, NULL };
    CMPIString *result;
    char *msgId,*defMsg;
    CMPIMsgFileHandle msgFileHandle;
    CMPIUint32 count,i;
    msgId = (__sft)->deserialize_string(socket, broker);
    msgFileHandle = (__sft)->deserialize_CMPIMsgFileHandle(socket, broker);
    defMsg = (__sft)->deserialize_string(socket, broker);
    count = (__sft)->deserialize_UINT32(socket);

    for (i=0; i<count; i++) {
       type[i]=(__sft)->deserialize_CMPIType(socket);
       switch (type[i]) {
       case CMPI_uint32:
       case CMPI_sint32:
          value[i].uint=(__sft)->deserialize_UINT32(socket);
	  break;
       case CMPI_boolean:
          value[i].blean=(CMPIBoolean)(__sft)->deserialize_UINT32(socket);
 	  break;
       case CMPI_uint64:
       case CMPI_sint64:
          value[i].u64=(CMPIBoolean)(__sft)->deserialize_UINT64(socket);
 	  break;
       case CMPI_real64: {
             char * real_str;
             real_str = (__sft)->deserialize_string ( socket, broker );
             sscanf ( real_str, "%le", (double *) &value[i].r64 );
          }
	  break;
       case CMPI_string:
          value[i].str = (__sft)->deserialize_CMPIString ( socket, broker );
	  break;
       }
    }


    switch (count) {
    case 0:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count);
	break;
    case 1:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint);
	break;
    case 2:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint);
	break;
    case 3:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint);
	break;
    case 4:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint);
    case 5:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint);
	break;
    case 6:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint);
	break;
    case 7:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint,
	   type[6],value[6].uint);
	break;
     case 8:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint,
	   type[6],value[6].uint, type[7],value[7].uint);
	break;
     case 9:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint,
	   type[6],value[6].uint, type[7],value[7].uint, type[8],value[8].uint);
	break;
     default:
        result = broker->eft->getMessage2(broker, msgId, msgFileHandle, defMsg, &rc, count,
	   type[0],value[0].uint, type[1],value[1].uint, type[2],value[2].uint,
	   type[3],value[3].uint, type[4],value[4].uint, type[5],value[5].uint,
	   type[6],value[6].uint, type[7],value[7].uint, type[8],value[8].uint,
	   type[9],value[9].uint);
   }

    (__sft)->serialize_CMPIStatus(socket, &rc);
    (__sft)->serialize_CMPIString(socket, result);
}

#endif

//! Up-call function identifiers.
/*!
  This array holds all possible broker service request names issued by
  remote providers and the appropriate function pointers.
 */
static struct socket_mb_function __mb_functions[] = {
    { "TCPCOMM_prepareAttachThread",    TCPCOMM_prepareAttachThread },
    { "TCPCOMM_detachThread",           TCPCOMM_detachThread },
    { "TCPCOMM_attachThread",           TCPCOMM_attachThread},
    { "TCPCOMM_deliverIndication",      TCPCOMM_deliverIndication },
    { "TCPCOMM_enumInstanceNames",      TCPCOMM_enumInstanceNames },
    { "TCPCOMM_getInstance",            TCPCOMM_getInstance },
    { "TCPCOMM_createInstance",         TCPCOMM_createInstance },
    { "TCPCOMM_setInstance",            TCPCOMM_setInstance },
    { "TCPCOMM_deleteInstance",         TCPCOMM_deleteInstance },
    { "TCPCOMM_execQuery",              TCPCOMM_execQuery },
    { "TCPCOMM_enumInstances",          TCPCOMM_enumInstances },
    { "TCPCOMM_associators",            TCPCOMM_associators },
    { "TCPCOMM_associatorNames",        TCPCOMM_associatorNames },
    { "TCPCOMM_references",             TCPCOMM_references },
    { "TCPCOMM_referenceNames",         TCPCOMM_referenceNames },
    { "TCPCOMM_invokeMethod",           TCPCOMM_invokeMethod },
    { "TCPCOMM_setProperty",            TCPCOMM_setProperty },
    { "TCPCOMM_getProperty",            TCPCOMM_getProperty },
#ifndef CMPI_VER_100
    { "TCPCOMM_getKeyNames",            TCPCOMM_getKeyNames },
#endif
    { "TCPCOMM_classPathIsA",           TCPCOMM_classPathIsA },
    { "TCPCOMM_getMessage",             TCPCOMM_getMessage },
    { "TCPCOMM_logMessage",             TCPCOMM_logMessage },
    { "TCPCOMM_trace",                  TCPCOMM_trace }
#ifdef CMPI_VER_200
    ,
    { "TCPCOMM_newCMPIError",           TCPCOMM_newCMPIError },
    { "TCPCOMM_openMessageFile",        TCPCOMM_openMessageFile },
    { "TCPCOMM_closeMessageFile",       TCPCOMM_closeMessageFile },
    { "TCPCOMM_getMessage2",            TCPCOMM_getMessage2 }
#endif /* CMPI_VER_200 */
};
/****************************************************************************/

//! Dispatches the broker service request handler.
/*!
  This function is running in a separate thread and sets up the environment
  for the actual request handler before calling it. This comprises reading
  the function name and deserializing the calling context.

  \param athread contains socket, broker and context handles.

  \sa __mb_functions
  \sa __handle_MB_call
 */
static void __dispatch_MB_function(struct accept_thread *athread)
{
    char *function;
    unsigned int i;

    TRACE_VERBOSE(("entered function."));
    TRACE_NORMAL(("dispatching broker service function request."));

    CBAttachThread(athread->broker, athread->context);
    function =
	__sft->deserialize_string(athread->socket, athread->broker);
    socketcomm_deserialize_context(athread->socket,  __sft, athread->broker,
				   athread->context);

    for (i = 0;
	 i < sizeof(__mb_functions) / sizeof(struct socket_mb_function);
	 i++) {

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

	    TRACE_INFO(("calling %s to handle request.",
			__mb_functions[i].name));
	    __mb_functions[i].function(athread->socket, athread->broker,
				       athread->context);
	    break;
	}
    }

    // Now check for CMPISelectExp functions. -V 5245
    for (i = 0; i < SOCKET_SELECT_EXP_FUNCTIONS_SIZE ; i++) {

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

            TRACE_INFO(("calling %s to handle request.",
                        select_exp_functions[i].name));
            select_exp_functions[i].function(athread->socket, athread->broker,
                                       athread->context, athread->ctx_id);
            break;
        }
    }

    CBDetachThread(athread->broker, athread->context);
    close(athread->socket);
    free(athread);

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


//! Sets up the minimal environment for a broker service request thread.
/*!
  The function evaluates the up-call context id to set up
  the basic entities broker and context, before actually
  spawning a separate thread to handle the request.

  \param socket the connection socket.
  \param broker the broker to forward the request to.

  \sa __dispatch_MB_function
  \sa __verify_MB_call
 */
static void __handle_MB_call(int socket, CONST CMPIBroker * broker)
{
    CONST CMPIContext *ctx;
    CMPIUint32 ctx_id;

    struct accept_thread *athread = (struct accept_thread *)
	malloc(sizeof(struct accept_thread));

    TRACE_VERBOSE(("entered function."));
    TRACE_NORMAL(("handling incoming broker service request."));

    // This ctx_id is used to create indication objects for a
    // particular context. -V 5245
    ctx_id = __sft->deserialize_UINT32 (socket);
    ctx = get_context (ctx_id);

    athread->socket = socket;
    athread->broker = broker;
    athread->context = CBPrepareAttachThread(broker, ctx);
    athread->ctx_id = ctx_id;

    CMPI_BrokerExt_Ftab->newThread((void*(*)(void*))__dispatch_MB_function,athread,1);

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


//! Verifies an incoming MB call's ticket.
/*!
  The function evaluates the up-call ticket, retrieves the appropriate
  broker handle, and passes on the request to __handle_MB_call(), if
  successful.

  \param socket the connection socket.
 */
static void __verify_MB_call(int socket)
{
    comm_ticket ticket;
    CONST CMPIBroker *broker;

    TRACE_VERBOSE(("entered function."));
    TRACE_NORMAL(("handling incoming broker service request."));

    io_read_fixed_length(socket, &ticket, sizeof(comm_ticket));
    broker = verify_ticket(&ticket);

    if (broker == NULL) {

	TRACE_CRITICAL(("ticket invalid, could not obtain a broker"
			" handle."));