/*
**==============================================================================
**
** Open Management Infrastructure (OMI)
**
** Copyright (c) Microsoft Corporation
**
** Licensed under the Apache License, Version 2.0 (the "License"); you may not
** use this file except in compliance with the License. You may obtain a copy
** of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
** MERCHANTABLITY OR NON-INFRINGEMENT.
**
** See the Apache 2 License for the specific language governing permissions
** and limitations under the License.
**
**==============================================================================
*/
#ifndef _omi_messages_h
#define _omi_messages_h
#include "config.h"
#include <common.h>
#include <stdio.h>
#include "batch.h"
#include "instance.h"
#include "stringarray.h"
#include "atomic.h"
#include "user.h"
BEGIN_EXTERNC
/*
**==============================================================================
**
** MessageTag
**
** Enumeration of all message tags.
**
**==============================================================================
*/
typedef enum _MessageTag
{
GetInstanceReqTag = 1,
PostInstanceMsgTag = 2,
EnumerateInstancesReqTag = 3,
PostResultMsgTag = 4,
NoOpReqTag = 5,
NoOpRspTag = 6,
DispResultMsgTag = 7,
InvokeReqTag = 8,
AssociatorsOfReqTag = 9,
ReferencesOfReqTag = 10,
SubscribeReqTag = 11,
SubscribeResTag = 12,
DeleteInstanceReqTag = 13,
CreateInstanceReqTag = 14,
ModifyInstanceReqTag = 15,
BinProtocolNotificationTag = 16
}
MessageTag;
/*
**==============================================================================
**
** MessageFlag
**
** Supported flags for message.
**
**==============================================================================
*/
typedef enum _MessageFlag
{
/* Instance encoding type (only one can be set at a time) */
BinaryProtocolFlag = 0x0001,
WSMANFlag = 0x0002,
CIMXMLFlag = 0x0004,
/* WSMAN-specific encoding options */
WSMAN_ObjectAndEPRFlag =0x0018,
WSMAN_EPRFlag = 0x0008,
WSMAN_ObjectFlag = 0x0010,
WSMAN_CreatedEPRFlag = 0x0020
}
MessageFlag;
/*
**==============================================================================
**
** Message
**
** Base type for all messages.
**
**==============================================================================
*/
typedef struct _Message Message;
struct _Message
{
/* Links for inserting messages onto linked-lists */
struct _Message* next;
struct _Message* prev;
/* The batch this message was allocated from */
Batch *batch;
/* original request (can be NULL); lifetime controlled by ref-counter */
struct _Message* request;
/* The message tag (see MessageTag enum above) */
MI_Uint32 tag;
/* Flags for message processing - like instance encoding type (see MessageFlag enum above) */
MI_Uint32 flags;
/* ref counter */
AtomicInt refCounter;
/* Message identifier derived from the original request */
MI_Uint64 msgID;
/* Client identifier derived from requestor */
MI_Uint64 clientID;
/* Callback used to deliver response to this message */
void (*callback)(Message* message, void* callbackData);
/* Data passed as 2nd argument of 'callback' */
void* callbackData;
/* Message's destructor [opt]
'Release' will call dtor (if set) right before destroying the message */
void (*dtor)(Message* message, void* callbackData);
/* Data passed as 2nd argument of 'dtor' */
void* dtorData;
/* Server -> agent IPC specific */
const char* libraryName;
/* Requestor information */
uid_t uid;
gid_t gid;
};
Message* __Message_New(
MessageTag tag,
size_t structSize,
MI_Uint64 msgID,
MI_Uint32 flags);
void Message_Release(
Message* self);
MI_INLINE void Message_AddRef(
Message* self)
{
AtomicInc(&self->refCounter);
}
MI_INLINE void Message_SetRequest(
Message* self,
Message* request)
{
if (self->request)
Message_Release(self->request);
self->request = request;
if (self->request)
Message_AddRef(self->request);
}
/*
Verifies if message is final reposne to the initial request
*/
MI_INLINE MI_Boolean Message_IsFinalRepsonse(
const Message* msg)
{
if (PostResultMsgTag == msg->tag ||
NoOpRspTag == msg->tag ||
SubscribeResTag == msg->tag)
return MI_TRUE;
return MI_FALSE;
}
/*
**==============================================================================
**
** PostResultMsg
**
** generic error response
**
**==============================================================================
*/
typedef struct _PostResultMsg
{
Message base;
MI_Result result;
}
PostResultMsg;
MI_INLINE PostResultMsg* PostResultMsg_New(
MI_Uint64 msgID)
{
return (PostResultMsg*)__Message_New(
PostResultMsgTag, sizeof(PostResultMsg), msgID, 0);
}
MI_INLINE void PostResultMsg_Release(
PostResultMsg* self)
{
Message_Release(&self->base);
}
void PostResultMsg_Print(const PostResultMsg* msg, FILE* os);
/*
**==============================================================================
**
** DispResultMsg
**
** interanl strucutre for dispatcher
** dispatcher keeps track of multiple 'enumerate' responses
**
**==============================================================================
*/
typedef struct _DispResultMsg
{
Message base;
/* number of outstanding requests */
AtomicInt requestCounter;
/* current result */
MI_Result result;
}
DispResultMsg;
MI_INLINE DispResultMsg* DispResultMsg_New(
MI_Uint64 msgID)
{
return (DispResultMsg*)__Message_New(
DispResultMsgTag, sizeof(DispResultMsg), msgID, 0);
}
MI_INLINE void DispResultMsg_Release(
DispResultMsg* self)
{
Message_Release(&self->base);
}
void DispResultMsg_Print(const DispResultMsg* msg, FILE* os);
/*
**==============================================================================
**
** GetInstanceReq
**
** A CIM GetInstance request (see DSP0200).
**
**==============================================================================
*/
typedef struct _GetInstanceReq
{
Message base;
MI_ConstString nameSpace;
/* un-packed version of instance */
MI_Instance* instanceName;
/* packed version of instance */
void* packedInstanceNamePtr;
MI_Uint32 packedInstanceNameSize;
MI_Boolean includeClassOrigin;
StringArray* propertySet;
}
GetInstanceReq;
MI_INLINE GetInstanceReq* GetInstanceReq_New(
MI_Uint64 msgID,
MI_Uint32 flags)
{
return (GetInstanceReq*)__Message_New(
GetInstanceReqTag, sizeof(GetInstanceReq), msgID, flags);
}
MI_INLINE void GetInstanceReq_Release(
GetInstanceReq* self)
{
Message_Release(&self->base);
}
void GetInstanceReq_Print(const GetInstanceReq* msg, FILE* os);
/*
**==============================================================================
**
** CreateInstanceReq
**
** A CIM CreateInstance request (see DSP0200).
**
**==============================================================================
*/
typedef struct _CreateInstanceReq
{
Message base;
MI_ConstString nameSpace;
MI_Instance* instance;
void* packedInstancePtr;
MI_Uint32 packedInstanceSize;
StringArray* propertySet;
}
CreateInstanceReq;
MI_INLINE CreateInstanceReq* CreateInstanceReq_New(
MI_Uint64 msgID,
MI_Uint32 flags)
{
return (CreateInstanceReq*)__Message_New(
CreateInstanceReqTag, sizeof(CreateInstanceReq), msgID, flags);
}
MI_INLINE void CreateInstanceReq_Release(
CreateInstanceReq* self)
{
Message_Release(&self->base);
}
void CreateInstanceReq_Print(const CreateInstanceReq* msg, FILE* os);
/*
**==============================================================================
**
** ModifyInstanceReq
**
** A CIM ModifyInstance request (see DSP0200).
**
**==============================================================================
*/
typedef struct _ModifyInstanceReq
{
Message base;
MI_ConstString nameSpace;
MI_Instance* instance;
void* packedInstancePtr;
MI_Uint32 packedInstanceSize;
StringArray* propertySet;
}
ModifyInstanceReq;
MI_INLINE ModifyInstanceReq* ModifyInstanceReq_New(
MI_Uint64 msgID,
MI_Uint32 flags)
{
return (ModifyInstanceReq*)__Message_New(
ModifyInstanceReqTag, sizeof(ModifyInstanceReq), msgID, flags);
}
MI_INLINE void ModifyInstanceReq_Release(
ModifyInstanceReq* self)
{
Message_Release(&self->base);
}
void ModifyInstanceReq_Print(const ModifyInstanceReq* msg, FILE* os);
/*
**==============================================================================
**
** DeleteInstanceReq
**
** A CIM DeleteInstance request (see DSP0200).
**
**==============================================================================
*/
typedef struct _DeleteInstanceReq
{
Message base;
MI_ConstString nameSpace;
MI_Instance* instanceName;
void* packedInstanceNamePtr;
MI_Uint32 packedInstanceNameSize;
}
DeleteInstanceReq;
MI_INLINE DeleteInstanceReq* DeleteInstanceReq_New(
MI_Uint64 msgID,
MI_Uint32 flags)
{
return (DeleteInstanceReq*)__Message_New(
DeleteInstanceReqTag, sizeof(DeleteInstanceReq), msgID, flags);
}
MI_INLINE void DeleteInstanceReq_Release(
DeleteInstanceReq* self)
{
Message_Release(&self->base);
}
void DeleteInstanceReq_Print(
const DeleteInstanceReq* msg,
FILE* os);
/*
**==============================================================================
**
** InvokeReq
**
** A CIM Invoke request (see DSP0200).
**
**==============================================================================
*/
typedef struct _InvokeReq
{
Message base;
MI_ConstString nameSpace;
MI_ConstString function;
MI_ConstString className; /* for static functions only, otherwise null */
/* un-packed version of instance (for non-static functions) and parameters */
MI_Instance* instance;
MI_Instance* instanceParams;
/* packed version of instance */
void* packedInstancePtr;
void* packedInstanceParamsPtr;
MI_Uint32 packedInstanceSize;
MI_Uint32 packedInstanceParamsSize;
}
InvokeReq;
MI_INLINE InvokeReq* InvokeReq_New(
MI_Uint64 msgID,
MI_Uint32 flags)
{
return (InvokeReq*)__Message_New(
InvokeReqTag, sizeof(InvokeReq), msgID, flags);
}
MI_INLINE void InvokeReq_Release(
InvokeReq* self)
{
Message_Release(&self->base);
}
void InvokeReq_Print(const InvokeReq* msg, FILE* os);
/*
**==============================================================================
**
** AssociatorsOfReq
**
** A CIM "Associators of" request (see DSP0200).
**
**==============================================================================
*/
typedef struct _AssociatorsOfReq
{
Message base;
MI_ConstString nameSpace;
MI_ConstString assocClass;
MI_ConstString resultClass;
MI_ConstString role;
MI_ConstString resultRole;
/* dispatcher to provider only */
MI_ConstString className;
/* un-packed version of instance */
MI_Instance* instance;
/* packed version of instance */
void* packedInstancePtr;
MI_Uint32 packedInstanceSize;
}
AssociatorsOfReq;
MI_INLINE AssociatorsOfReq* AssociatorsOfReq_New(
MI_Uint64 msgID,
MI_Uint32 flags)
{
return (AssociatorsOfReq*)__Message_New(
AssociatorsOfReqTag, sizeof(AssociatorsOfReq), msgID, flags);
}
MI_INLINE void AssociatorsOfReq_Release(
AssociatorsOfReq* self)
{
Message_Release(&self->base);
}
void AssociatorsOfReq_Print(const AssociatorsOfReq* msg, FILE* os);
/*
**==============================================================================
**
** ReferencesOfReq
**
** A CIM "References of" request (see DSP0200).
**
**==============================================================================
*/
typedef struct _ReferencesOfReq
{
Message base;
MI_ConstString nameSpace;
MI_ConstString assocClass;
MI_ConstString role;
/* dispatcher to provider only */
MI_ConstString className;
/* un-packed version of instance */
MI_Instance* instance;
/* packed version of instance */
void* packedInstancePtr;
MI_Uint32 packedInstanceSize;
}
ReferencesOfReq;
MI_INLINE ReferencesOfReq* ReferencesOfReq_New(
MI_Uint64 msgID,
MI_Uint32 flags)
{
return (ReferencesOfReq*)__Message_New(
ReferencesOfReqTag, sizeof(ReferencesOfReq), msgID, flags);
}
MI_INLINE void ReferencesOfReq_Release(
ReferencesOfReq* self)
{
Message_Release(&self->base);
}
void ReferencesOfReq_Print(const ReferencesOfReq* msg, FILE* os);
/*
**==============================================================================
**
** PostInstanceMsg
**
** A CIM GetInstance response (see DSP0200).
**
**==============================================================================
*/
typedef struct _PostInstanceMsg
{
Message base;
/* un-packed version of instance */
MI_Instance* instance;
/* packed version of instance */
void* packedInstancePtr;
MI_Uint32 packedInstanceSize;
}
PostInstanceMsg;
MI_INLINE PostInstanceMsg* PostInstanceMsg_New(
MI_Uint64 msgID)
{
return (PostInstanceMsg*)__Message_New(
PostInstanceMsgTag, sizeof(PostInstanceMsg), msgID, 0);
}
MI_INLINE void PostInstanceMsg_Release(
PostInstanceMsg* self)
{
Message_Release(&self->base);
}
void PostInstanceMsg_Print(const PostInstanceMsg* msg, FILE* os);
/*
**==============================================================================
**
** EnumerateInstancesReq
**
** A CIM EnumerateInstances request (see DSP0200).
**
**==============================================================================
*/
typedef struct _EnumerateInstancesReq
{
Message base;
MI_ConstString nameSpace;
MI_ConstString className;
/* Used for 'base-properties-only' mode to transfer
request's class-name */
MI_ConstString requestClassName;
StringArray* propertySet;
MI_Boolean deepInheritance;
MI_Boolean includeClassOrigin;
MI_Boolean basePropertiesOnly;
/* Query language (or null none) */
const MI_Char* queryLanguage;
/* Query expression (or null none) */
const MI_Char* queryExpression;
/* Compiled WQL query */
struct _WQL* wql;
}
EnumerateInstancesReq;
MI_INLINE EnumerateInstancesReq* EnumerateInstancesReq_New(
MI_Uint64 msgID,
MI_Uint32 flags)
{
return (EnumerateInstancesReq*)__Message_New(
EnumerateInstancesReqTag, sizeof(EnumerateInstancesReq), msgID, flags);
}
MI_INLINE void EnumerateInstancesReq_Release(
EnumerateInstancesReq* self)
{
Message_Release(&self->base);
}
void EnumerateInstancesReq_Print(const EnumerateInstancesReq* msg, FILE* os);
/*
**==============================================================================
**
** SubscribeReq
**
** Subscribe request (internal representation of it)
**
**==============================================================================
*/
typedef struct _SubscribeReq
{
Message base;
MI_ConstString nameSpace;
MI_ConstString className;
MI_ConstString filter;
MI_ConstString language;
/* used for disp -> provmgr */
MI_Uint64 ctxID;
/* used for disp -> provider */
MI_Uint64 subscriptionID;
}
SubscribeReq;
MI_INLINE SubscribeReq* SubscribeReq_New(
MI_Uint64 msgID,
MI_Uint32 flags)
{
return (SubscribeReq*)__Message_New(
SubscribeReqTag, sizeof(SubscribeReq), msgID, flags);
}
MI_INLINE void SubscribeReq_Release(
SubscribeReq* self)
{
Message_Release(&self->base);
}
void SubscribeReq_Print(const SubscribeReq* msg, FILE* os);
/*
**==============================================================================
**
** SubscribeRes
**
** Subscribe request (internal representation of it)
**
**==============================================================================
*/
typedef struct _SubscribeRes
{
Message base;
MI_ConstString subscriptionID;
}
SubscribeRes;
MI_INLINE SubscribeRes* SubscribeRes_New(
MI_Uint64 msgID)
{
return (SubscribeRes*)__Message_New(
SubscribeResTag, sizeof(SubscribeRes), msgID, 0);
}
MI_INLINE void SubscribeRes_Release(
SubscribeRes* self)
{
Message_Release(&self->base);
}
void SubscribeRes_Print(const SubscribeRes* msg, FILE* os);
/*
**==============================================================================
**
** NoOpReq
**
** A NoOp request.
**
**==============================================================================
*/
typedef struct _NoOpReq
{
Message base;
}
NoOpReq;
MI_INLINE NoOpReq* NoOpReq_New(
MI_Uint64 msgID)
{
return (NoOpReq*)__Message_New(
NoOpReqTag, sizeof(NoOpReq), msgID, BinaryProtocolFlag);
}
MI_INLINE void NoOpReq_Release(
NoOpReq* self)
{
Message_Release(&self->base);
}
void NoOpReq_Print(const NoOpReq* msg, FILE* os);
/*
**==============================================================================
**
** NoOpRsp
**
** A NoOp request.
**
**==============================================================================
*/
typedef struct _NoOpRsp
{
Message base;
}
NoOpRsp;
MI_INLINE NoOpRsp* NoOpRsp_New(
MI_Uint64 msgID)
{
return (NoOpRsp*)__Message_New(
NoOpRspTag, sizeof(NoOpRsp), msgID, 0);
}
MI_INLINE void NoOpRsp_Release(
NoOpRsp* self)
{
Message_Release(&self->base);
}
void NoOpRsp_Print(const NoOpRsp* msg, FILE* os);
/*
**==============================================================================
**
** BinProtocolNotification
**
** A internal notification transfered over bin protocol.
**
**==============================================================================
*/
typedef enum _BinProtNotificationType
{
BinNotificationAgentIdle = 0,
BinNotificationConnectRequest = 1,
BinNotificationConnectResponse = 2
}
BinProtNotificationType;
#define AUTH_RANDOM_DATA_SIZE 64
typedef struct _BinProtocolNotification
{
Message base;
/* see BinProtNotificationType for supported types */
MI_Uint32 type;
/* **** Connect-request specific data **** */
/* explicit auth [opt] */
const char* user;
const char* password;
/* implicit auth - Requestor information */
uid_t uid;
gid_t gid;
/* File-based authentication - files's content */
unsigned char authData[AUTH_RANDOM_DATA_SIZE];
/* **** Connect-response specific data **** */
/* ok/access-denied */
MI_Result result;
/* file name - client has to read it and send back content */
const char* authFile;
}
BinProtocolNotification;
MI_INLINE BinProtocolNotification* BinProtocolNotification_New(BinProtNotificationType type)
{
BinProtocolNotification* res = (BinProtocolNotification*)__Message_New(
BinProtocolNotificationTag, sizeof(BinProtocolNotification), 0, 0);
if (res)
res->type = type;
return res;
}
MI_INLINE void BinProtocolNotification_Release(
BinProtocolNotification* self)
{
Message_Release(&self->base);
}
void BinProtocolNotification_Print(const BinProtocolNotification* msg, FILE* os);
/*
**==============================================================================
**
** binary transport with batch support
**
**
**
**==============================================================================
*/
MI_Result MessageFromBatch(
Batch* batch,
void* originalMsgPtr,
const Header_BatchInfoItem* ptrAdjustmentInfo,
size_t ptrAdjustmentInfoCount,
MI_Boolean skipInstanceUnpack,
Message** msgOut
);
/*
**==============================================================================
**
** Creates a clone of given message,
** suitable for sending with binary protocol
** This is needed to:
** - make batch smaller (no small blocks form instance's parts
** - all instances are packed
**
** Note: requests without instances (like Enum) don't need a copy -
** add-ref-ed original message is returned in that case
**
**==============================================================================
*/
MI_Result MessagePackCloneForBinarySending(
Message* msgSrc,
Message** msgOut);
/*
**==============================================================================
**
** Print the message
**
**==============================================================================
*/
void MessagePrint(const Message* msg, FILE* os);
/*
**==============================================================================
**
** Uint64ToPtr()
** PtrToUint64()
**
**==============================================================================
*/
MI_INLINE void* Uint64ToPtr(MI_Uint64 x)
{
union U
{
void* ptr;
MI_Uint64 x;
};
union U u;
u.x = x;
return u.ptr;
}
MI_INLINE MI_Uint64 PtrToUint64(void* ptr)
{
union U
{
void* ptr;
MI_Uint64 x;
};
union U u;
u.ptr = ptr;
return u.x;
}
END_EXTERNC
#endif /* _omi_messages_h */
Return to
messages.h
CVS log
Up to [OMI] / omi / base