binarymessagehandler.cpp

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

            case CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE:
                    myself->handleEnumerateInstanceNamesResponse(
                        op, (CIMEnumerateInstanceNamesResponseMessage*)legacy);
                    break;
            case CIM_EXEC_QUERY_RESPONSE_MESSAGE:
                    myself->handleExecQueryResponse(
                        op, (CIMExecQueryResponseMessage*)legacy);
                    break;
            case CIM_ASSOCIATORS_RESPONSE_MESSAGE:
                    myself->handleAssociatorsResponse(
                        op, (CIMAssociatorsResponseMessage*)legacy);
                    break;
            case CIM_ASSOCIATOR_NAMES_RESPONSE_MESSAGE:
                    myself->handleAssociatorNamesResponse(
                        op, (CIMAssociatorNamesResponseMessage*)legacy);
                    break;
            case CIM_REFERENCES_RESPONSE_MESSAGE:
                    myself->handleReferencesResponse(
                        op, (CIMReferencesResponseMessage*)legacy);
                    break;
            case CIM_REFERENCE_NAMES_RESPONSE_MESSAGE:
                    myself->handleReferenceNamesResponse(
                        op, (CIMReferenceNamesResponseMessage*)legacy);
                    break;
            case CIM_GET_PROPERTY_RESPONSE_MESSAGE:
                    myself->handleGetPropertyResponse(
                        op, (CIMGetPropertyResponseMessage*)legacy);
                    break;
            case CIM_SET_PROPERTY_RESPONSE_MESSAGE:
                    myself->handleSetPropertyResponse(
                        op, (CIMSetPropertyResponseMessage*)legacy);
                    break;
            case CIM_GET_QUALIFIER_RESPONSE_MESSAGE:
                    myself->handleGetQualifierResponse(
                        op, (CIMGetQualifierResponseMessage*)legacy);
                    break;
            case CIM_SET_QUALIFIER_RESPONSE_MESSAGE:
                    myself->handleSetQualifierResponse(
                        op, (CIMSetQualifierResponseMessage*)legacy);
                    break;
            case CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE:
                    myself->handleDeleteQualifierResponse(
                        op, (CIMDeleteQualifierResponseMessage*)legacy);
                    break;
            case CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE:
                    myself->handleEnumerateQualifiersResponse(
                        op, (CIMEnumerateQualifiersResponseMessage*)legacy);
                    break;
            case CIM_INVOKE_METHOD_RESPONSE_MESSAGE:
                    myself->handleInvokeMethodResponse(
                        op, (CIMInvokeMethodResponseMessage*)legacy);
                    break;

            // unexpected requests
            case CIM_PROCESS_INDICATION_REQUEST_MESSAGE:
            case CIM_HANDLE_INDICATION_REQUEST_MESSAGE:
            case CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE:
            case CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE:
            case CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE:
            case CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE:
            case CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE:
            case CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE:
            case CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE:
            case CIM_DISABLE_MODULE_REQUEST_MESSAGE:
            case CIM_ENABLE_MODULE_REQUEST_MESSAGE:

            case CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE:

            case CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE:

            case CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE:
            case CIM_GET_CLASS_REQUEST_MESSAGE:
            case CIM_GET_INSTANCE_REQUEST_MESSAGE:
            case CIM_EXPORT_INDICATION_REQUEST_MESSAGE:
            case CIM_DELETE_CLASS_REQUEST_MESSAGE:
            case CIM_DELETE_INSTANCE_REQUEST_MESSAGE:
                PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
                    "Received Unexpected legacy request message.");
                myself->_handleRequest(op, legacy);
                break;

            // unexpected replies
            case CIM_PROCESS_INDICATION_RESPONSE_MESSAGE:
            case CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE:
            case CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE:
            case CIM_HANDLE_INDICATION_RESPONSE_MESSAGE:
            case CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE:
            case CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE:
            case CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE:
            case CIM_SUBSCRIPTION_INIT_COMPLETE_RESPONSE_MESSAGE:
            case CIM_DISABLE_MODULE_RESPONSE_MESSAGE:
            case CIM_ENABLE_MODULE_RESPONSE_MESSAGE:
            case CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE:
            case CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE:
            case CIM_INITIALIZE_PROVIDER_RESPONSE_MESSAGE:
            case CIM_NOTIFY_CONFIG_CHANGE_RESPONSE_MESSAGE:
                break;
            case CIM_EXPORT_INDICATION_RESPONSE_MESSAGE:
            default:
                PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
                    "Received Unexpected legacy response message.");
                myself->_handleResponse(op, legacy);
                break;
            }
        }
        else
        {
            PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
                "Damaged or uninitialized AsyncOpNode received.");
        }
    }
    catch (const Exception& e)
    {
        PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
            "Caught exception: \"" + e.getMessage() +
                "\".  Exiting handle_binary_message.");
    }
    catch (...)
    {
       PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
           "Caught unrecognized exception.  Exiting handle_binary_message.");
    }

    PEG_METHOD_EXIT();
    return 0;
}

// requests always go to the output queue
void BinaryMessageHandler::_handleRequest(
    AsyncOpNode* op,
    Message* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::_handleRequest(AsyncOpNode*, Message*)");

    AsyncRequest* async_request =
        static_cast<AsyncRequest*>(op->removeRequest());

    msg->_async = 0;
    try
    {
        _outputQueue->enqueue(msg);
    }
    catch (...)
    {
        // Should this exception really just be ignored?
        // It seems like binary_message_handler should catch it.
        PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
            "Unrecognized exception caught and ignored by _handleRequest().");
    }

    delete async_request;

    _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
    PEG_METHOD_EXIT();
}

// responses have their destination queue id in the message
void BinaryMessageHandler::_handleResponse(
    AsyncOpNode* op,
    Message* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::_handleResponse(AsyncOpNode*, Message*)");

    if (op->_response.get() != 0)
    {
        AsyncReply* asyncReply =
            static_cast<AsyncReply*>(op->removeResponse());
        delete asyncReply;
    }
    msg->_async = 0;

    MessageQueue* dest =
        MessageQueue::lookup(((CIMRequestMessage*)msg)->queueIds.top());
    if (dest == 0)
    {
        PEG_TRACE_STRING(TRC_BINARY_MSG_HANDLER, Tracer::LEVEL4,
            "Bad or non-existent Queue ID for desination in legacy message.");
        delete msg;
    }
    else
    {
        try
        {
            dest->enqueue(msg);
        }
        catch (...)
        {
            // Should this exception really just be ignored?
            // It seems like binary_message_handler should catch it.
            PEG_TRACE_STRING(TRC_DISCARDED_DATA, Tracer::LEVEL2,
                "Unrecognized exception caught and ignored by "
                    "_handleResponse().");
        }
    }

   _complete_op_node(op, ASYNC_OPSTATE_COMPLETE, 0, 0);
   PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleCreateClassRequest(
    AsyncOpNode* op,
    CIMCreateClassRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleCreateClassRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleGetClassRequest(
    AsyncOpNode* op,
    CIMGetClassRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleGetClassRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleModifyClassRequest(
   AsyncOpNode* op,
   CIMModifyClassRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleModifyClassRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleEnumerateClassNamesRequest(
    AsyncOpNode* op,
    CIMEnumerateClassNamesRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleEnumerateClassNamesRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleEnumerateClassesRequest(
   AsyncOpNode* op,
   CIMEnumerateClassesRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleEnumerateClassRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}


void BinaryMessageHandler::handleDeleteClassRequest(
   AsyncOpNode* op,
   CIMDeleteClassRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleDeleteClassRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleCreateInstanceRequest(
    AsyncOpNode* op,
    CIMCreateInstanceRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleCreateInstanceRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleGetInstanceRequest(
    AsyncOpNode* op,
    CIMGetInstanceRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleGetInstanceRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleModifyInstanceRequest(
    AsyncOpNode* op,
    CIMModifyInstanceRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleModifyInstanceRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleEnumerateInstanceNamesRequest(
    AsyncOpNode* op,
    CIMEnumerateInstanceNamesRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleEnumerateInstanceNamesRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleEnumerateInstancesRequest(
    AsyncOpNode* op,
    CIMEnumerateInstancesRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleEnumerateInstancesRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleDeleteInstanceRequest(
    AsyncOpNode* op,
    CIMDeleteInstanceRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleDeleteInstanceRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleSetQualifierRequest(
    AsyncOpNode* op,
    CIMSetQualifierRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleSetQualifierRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleGetQualifierRequest(
    AsyncOpNode* op,
    CIMGetQualifierRequestMessage* msg) throw()
{
    PEG_METHOD_ENTER(TRC_BINARY_MSG_HANDLER,
        "BinaryMessageHandler::handleGetQualifierRequest()");
    _handleRequest(op, msg);
    PEG_METHOD_EXIT();
}

void BinaryMessageHandler::handleEnumerateQualifiersRequest(
    AsyncOpNode* op,
    CIMEnumerateQualifiersRequestMessage* msg) throw()