librpc/idl/eventlog6.idl

   1 #include "idl_types.h"
   2
   3
   4 import "misc.idl";
   5
   6 cpp_quote("#define MAX_RPC_GUID_ARRAY_COUNT (MAX_PAYLOAD / sizeof(struct GUID))")
   7 cpp_quote("#define eventlog6_EvtRpcSubscribePull    0x10000000")
   8 cpp_quote("#define eventlog6_EvtRpcVarFlagsModified 0x00000001")
   9
  10 [
  11     uuid (f6beaff7-1e19-4fbb-9f8f-b89e2018337c),
  12     version(1.0),
  13     endpoint("ncacn_ip_tcp:"),
  14     helpstring("Eventlog6"),
  15     pointer_default(unique)
  16 ]
  17 interface eventlog6
  18 {
  19         const int MAX_PAYLOAD                  = 2 * 1024 * 1024;
  20         const int MAX_RPC_QUERY_LENGTH         = MAX_PAYLOAD / sizeof(uint16_t);
  21         const int MAX_RPC_CHANNEL_NAME_LENGTH  = 512;
  22         const int MAX_RPC_QUERY_CHANNEL_SIZE   = 512;
  23         const int MAX_RPC_EVENT_ID_SIZE        = 256;
  24         const int MAX_RPC_FILE_PATH_LENGTH     = 32768;
  25         const int MAX_RPC_CHANNEL_PATH_LENGTH  = 32768;
  26         const int MAX_RPC_BOOKMARK_LENGTH      = MAX_PAYLOAD / sizeof(uint16_t);
  27         const int MAX_RPC_PUBLISHER_ID_LENGTH  = 2048;
  28         const int MAX_RPC_PROPERTY_BUFFER_SIZE = MAX_PAYLOAD;
  29         const int MAX_RPC_FILTER_LENGTH        = MAX_RPC_QUERY_LENGTH;
  30         const int MAX_RPC_RECORD_COUNT         = 1024;
  31         const int MAX_RPC_EVENT_SIZE           = MAX_PAYLOAD;
  32         const int MAX_RPC_BATCH_SIZE           = MAX_PAYLOAD;
  33         const int MAX_RPC_RENDERED_STRING_SIZE = MAX_PAYLOAD;
  34         const int MAX_RPC_CHANNEL_COUNT        = 8192;
  35         const int MAX_RPC_PUBLISHER_COUNT      = 8192;
  36         const int MAX_RPC_EVENT_METADATA_COUNT = 256;
  37         const int MAX_RPC_VARIANT_LIST_COUNT   = 256;
  38         const int MAX_RPC_BOOLEAN8_ARRAY_COUNT = MAX_PAYLOAD / sizeof(uint8_t);
  39         const int MAX_RPC_UINT32_ARRAY_COUNT   = MAX_PAYLOAD / sizeof(uint32_t);
  40         const int MAX_RPC_UINT64_ARRAY_COUNT   = MAX_PAYLOAD / sizeof(uint64_t);
  41         const int MAX_RPC_STRING_ARRAY_COUNT   = MAX_PAYLOAD / 512;
  42         const int MAX_RPC_STRING_LENGTH        = MAX_PAYLOAD / sizeof(uint16_t);
  43
  44         typedef struct {
  45                 uint32 error;
  46                 uint32 sub_err;
  47                 uint32 sub_err_param;
  48         } eventlog6_RpcInfo;
  49
  50         typedef struct {
  51                 [range(0, MAX_RPC_BOOLEAN8_ARRAY_COUNT)] uint32 count;
  52                 [size_is(count)] boolean8* ptr;
  53         } eventlog6_boolean8Array;
  54
  55         typedef struct {
  56                 [range(0, MAX_RPC_UINT32_ARRAY_COUNT)] uint32 count;
  57                 [size_is(count)] uint32* ptr;
  58         } eventlog6_UInt32Array;
  59
  60         typedef struct {
  61                 [range(0, MAX_RPC_UINT64_ARRAY_COUNT)] uint32 count;
  62                 [size_is(count)] hyper* ptr;
  63         } eventlog6_UInt64Array;
  64
  65         typedef struct {
  66                 [range(0, MAX_RPC_STRING_ARRAY_COUNT)] uint32 count;
  67                 [size_is(count),charset(UTF16),string] uint16 *ptr;
  68         } eventlog6_StringArray;
  69
  70         typedef struct {
  71                 [range(0, MAX_RPC_GUID_ARRAY_COUNT)] uint32 count;
  72                 [size_is(count)] GUID* ptr;
  73         } eventlog6_GuidArray;
  74
  75         typedef [v1_enum] enum {
  76                 EvtRpcVarTypeNull          = 0,
  77                 EvtRpcVarTypeboolean8      = 1,
  78                 EvtRpcVarTypeUInt32        = 2,
  79                 EvtRpcVarTypeUInt64        = 3,
  80                 EvtRpcVarTypeString        = 4,
  81                 EvtRpcVarTypeGuid          = 5,
  82                 EvtRpcVarTypeboolean8Array = 6,
  83                 EvtRpcVarTypeUInt32Array   = 7,
  84                 EvtRpcVarTypeUInt64Array   = 8,
  85                 EvtRpcVarTypeStringArray   = 9,
  86                 EvtRpcVarTypeGuidArray     = 10
  87         } eventlog6_EvtRpcVariantType;
  88
  89         typedef [v1_enum] enum {
  90                 EvtRpcChannelPath   = 0,
  91                 EvtRpcPublisherName = 1
  92         } eventlog6_EvtRpcAssertConfigFlags;
  93
  94         typedef [switch_type(eventlog6_EvtRpcVariantType)] union {
  95                 [case(EvtRpcVarTypeNull)] int nullVal;
  96                 [case(EvtRpcVarTypeboolean8)] boolean8 boolean8Val;
  97                 [case(EvtRpcVarTypeUInt32)] uint32 uint32Val;
  98                 [case(EvtRpcVarTypeUInt64)] hyper uint64Val;
  99                 [case(EvtRpcVarTypeString)] [charset(UTF16),string] uint16 *stringVal;
 100                 [case(EvtRpcVarTypeGuid)] GUID *guidVal;
 101                 [case(EvtRpcVarTypeboolean8Array)] eventlog6_boolean8Array boolean8Array;
 102                 [case(EvtRpcVarTypeUInt32Array)] eventlog6_UInt32Array uint32Array;
 103                 [case(EvtRpcVarTypeUInt64Array)] eventlog6_UInt64Array uint64Array;
 104                 [case(EvtRpcVarTypeStringArray)] eventlog6_StringArray stringArray;
 105                 [case(EvtRpcVarTypeGuidArray)] eventlog6_GuidArray guidArray;
 106         } eventlog6_EvtRpcVariantUnion;
 107
 108         typedef struct {
 109                 eventlog6_EvtRpcVariantType type;
 110                 uint32 flags;
 111                 [in,ref,switch_is(type)] eventlog6_EvtRpcVariantUnion *var;
 112         } eventlog6_EvtRpcVariant;
 113
 114         typedef struct {
 115                 [range(0, MAX_RPC_VARIANT_LIST_COUNT)] uint32 count;
 116                 [size_is(count)] eventlog6_EvtRpcVariant* props;
 117         } eventlog6_EvtRpcVariantList;
 118
 119         typedef struct {
 120                 [charset(UTF16),string] uint16 *name;
 121                 uint32 status;
 122         } eventlog6_EvtRpcQueryChannelInfo;
 123
 124         WERROR eventlog6_EvtRpcRegisterRemoteSubscription(
 125                 [in, unique, range(0, MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16),string] uint16 *channelPath,
 126                 [in, range(1, MAX_RPC_QUERY_LENGTH),charset(UTF16),string] uint16 *query,
 127                 [in, unique, range(0, MAX_RPC_BOOKMARK_LENGTH),charset(UTF16),string] uint16 *bookmarkXml,
 128                 [in] uint32 flags,
 129                 [out, ref] policy_handle *handle,
 130                 [out, ref] policy_handle *control,
 131                 [out, ref] uint32 *queryChannelInfoSize,
 132                 [out, size_is(,*queryChannelInfoSize), range(0, MAX_RPC_QUERY_CHANNEL_SIZE)]
 133                 eventlog6_EvtRpcQueryChannelInfo **queryChannelInfo,
 134                 [out, ref] eventlog6_RpcInfo *error);
 135
 136         WERROR eventlog6_EvtRpcRemoteSubscriptionNextAsync(
 137                 [in, ref] policy_handle *handle,
 138                 [in] uint32 numRequestedRecords,
 139                 [in] uint32 flags,
 140                 [out, ref] uint32 *numActualRecords,
 141                 [out, size_is(,*numActualRecords), range(0, MAX_RPC_RECORD_COUNT)]
 142                 uint32 **eventDataIndices,
 143                 [out, size_is(,*numActualRecords), range(0, MAX_RPC_RECORD_COUNT)]
 144                 uint32 **eventDataSizes,
 145                 [out, ref] uint32* resultBufferSize,
 146                 [out, size_is(,*resultBufferSize), range(0, MAX_RPC_BATCH_SIZE)]
 147                 uint8 **resultBuffer);
 148
 149         WERROR eventlog6_EvtRpcRemoteSubscriptionNext(
 150                 [in, ref] policy_handle *handle,
 151                 [in] uint32 numRequestedRecords,
 152                 [in] uint32 timeOut,
 153                 [in] uint32 flags,
 154                 [out, ref] uint32 *numActualRecords,
 155                 [out, size_is(,*numActualRecords), range(0, MAX_RPC_RECORD_COUNT)]
 156                 uint32 **eventDataIndices,
 157                 [out, size_is(,*numActualRecords), range(0, MAX_RPC_RECORD_COUNT)]
 158                 uint32 **eventDataSizes,
 159                 [out, ref] uint32 *resultBufferSize,
 160                 [out, size_is(,*resultBufferSize), range(0, MAX_RPC_BATCH_SIZE)]
 161                 uint8 **resultBuffer);
 162
 163         WERROR eventlog6_EvtRpcRemoteSubscriptionWaitAsync(
 164                 [in, ref] policy_handle *handle);
 165
 166         WERROR eventlog6_EvtRpcRegisterControllableOperation(
 167                 [out, ref] policy_handle *handle);
 168
 169         WERROR eventlog6_EvtRpcRegisterLogQuery(
 170                 [in, unique, range(0, MAX_RPC_CHANNEL_PATH_LENGTH),charset(UTF16),string] uint16 *path,
 171                 [in, range(1, MAX_RPC_QUERY_LENGTH),charset(UTF16),string] uint16 *query,
 172                 [in] uint32 flags,
 173                 [out, ref] policy_handle *handle,
 174                 [out, ref] policy_handle *opControl,
 175                 [out, ref] uint32 *queryChannelInfoSize,
 176                 [out, size_is(,*queryChannelInfoSize), range(0, MAX_RPC_QUERY_CHANNEL_SIZE)]
 177                 eventlog6_EvtRpcQueryChannelInfo **queryChannelInfo,
 178                 [out, ref] eventlog6_RpcInfo *error);
 179
 180         WERROR eventlog6_EvtRpcClearLog(
 181                 [in, ref] policy_handle *control,
 182                 [in, range(0, MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16),string] uint16 *channelPath,
 183                 [in, unique, range(0, MAX_RPC_FILE_PATH_LENGTH),charset(UTF16),string] uint16 *backupPath,
 184                 [in] uint32 flags,
 185                 [out, ref] eventlog6_RpcInfo *error);
 186
 187         WERROR  eventlog6_EvtRpcExportLog(
 188                 [in, ref] policy_handle *control,
 189                 [in, unique, range(0, MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16),string] uint16 *channelPath,
 190                 [in, range(1, MAX_RPC_QUERY_LENGTH),charset(UTF16),string] uint16 *query,
 191                 [in, range(1, MAX_RPC_FILE_PATH_LENGTH),charset(UTF16),string] uint16 *backupPath,
 192                 [in] uint32 flags,
 193                 [out, ref] eventlog6_RpcInfo *error);
 194
 195         WERROR eventlog6_EvtRpcLocalizeExportLog(
 196                 [in, ref] policy_handle *control,
 197                 [in, range(1, MAX_RPC_FILE_PATH_LENGTH),charset(UTF16),string] uint16 *logFilePath,
 198                 [in] uint32 locale,
 199                 [in] uint32 flags,
 200                 [out, ref] eventlog6_RpcInfo *error);
 201
 202         WERROR eventlog6_EvtRpcMessageRender(
 203                 [in, ref] policy_handle *pubCfgObj,
 204                 [in, range(1, MAX_RPC_EVENT_ID_SIZE)] uint32 sizeEventId,
 205                 [in, size_is(sizeEventId)] uint8 *eventId,
 206                 [in] uint32 messageId,
 207                 [in] eventlog6_EvtRpcVariantList *values,
 208                 [in] uint32 flags,
 209                 [in] uint32 maxSizeString,
 210                 [out, ref] uint32 *actualSizeString,
 211                 [out, ref] uint32 *neededSizeString,
 212                 [out, size_is(,*actualSizeString), range(0, MAX_RPC_RENDERED_STRING_SIZE)]
 213                 uint8 **string,
 214                 [out, ref] eventlog6_RpcInfo *error);
 215
 216         WERROR eventlog6_EvtRpcMessageRenderDefault(
 217                 [in, range(1, MAX_RPC_EVENT_ID_SIZE)] uint32 sizeEventId,
 218                 [in, size_is(sizeEventId)] uint8 *eventId,
 219                 [in] uint32 messageId,
 220                 [in] eventlog6_EvtRpcVariantList *values,
 221                 [in] uint32 flags,
 222                 [in] uint32 maxSizeString,
 223                 [out, ref] uint32 *actualSizeString,
 224                 [out, ref] uint32 *neededSizeString,
 225                 [out, size_is(,*actualSizeString), range(0, MAX_RPC_RENDERED_STRING_SIZE)]
 226                 uint8 **string,
 227                 [out, ref] eventlog6_RpcInfo *error);
 228
 229         WERROR eventlog6_EvtRpcQueryNext(
 230                 [in, ref] policy_handle *logQuery,
 231                 [in] uint32 numRequestedRecords,
 232                 [in] uint32 timeOutEnd,
 233                 [in] uint32 flags,
 234                 [out, ref] uint32 *numActualRecords,
 235                 [out, size_is(,*numActualRecords), range(0, MAX_RPC_RECORD_COUNT)]
 236                 uint32 **eventDataIndices,
 237                 [out, size_is(,*numActualRecords), range(0, MAX_RPC_RECORD_COUNT)]
 238                 uint32 **eventDataSizes,
 239                 [out, ref] uint32 *resultBufferSize,
 240                 [out, size_is(,*resultBufferSize), range(0, MAX_RPC_BATCH_SIZE)]
 241                 uint8 **resultBuffer);
 242
 243         WERROR eventlog6_EvtRpcQuerySeek(
 244                 [in, ref] policy_handle *logQuery,
 245                 [in] hyper pos,
 246                 [in, unique, range(0, MAX_RPC_BOOKMARK_LENGTH),charset(UTF16),string] uint16 *bookmarkXml,
 247                 [in] uint32 timeOut,
 248                 [in] uint32 flags,
 249                 [out, ref] eventlog6_RpcInfo *error);
 250
 251         WERROR eventlog6_EvtRpcClose(
 252                 [in, out, ref] policy_handle **handle);
 253
 254         WERROR eventlog6_EvtRpcCancel(
 255                 [in, ref] policy_handle *handle);
 256
 257         WERROR eventlog6_EvtRpcAssertConfig(
 258                 [in, range(1, MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16),string] uint16 *path,
 259                 [in] uint32 flags);
 260
 261         WERROR eventlog6_EvtRpcRetractConfig(
 262                 [in, range(1, MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16),string] uint16 *path,
 263                 [in] uint32 flags );
 264
 265         WERROR eventlog6_EvtRpcOpenLogHandle(
 266                 [in, range(1, MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16),string] uint16 *channel,
 267                 [in] uint32 flags,
 268                 [out, ref] policy_handle *handle,
 269                 [out, ref] eventlog6_RpcInfo *error);
 270
 271         WERROR eventlog6_EvtRpcGetLogFileInfo(
 272                 [in, ref] policy_handle *logHandle,
 273                 [in] uint32 propertyId,
 274                 [in, range(0, MAX_RPC_PROPERTY_BUFFER_SIZE)]
 275                 uint32 propertyValueBufferSize,
 276                 [out, size_is(propertyValueBufferSize)] uint8 *propertyValueBuffer,
 277                 [out, ref] uint32 *propertyValueBufferLength);
 278
 279         WERROR eventlog6_EvtRpcGetChannelList(
 280                 [in] uint32 flags,
 281                 [out, ref] uint32 *numChannelPaths,
 282                 [out, size_is(,*numChannelPaths), range(0, MAX_RPC_CHANNEL_COUNT),charset(UTF16),string]
 283                 uint16 ***channelPaths);
 284
 285         WERROR eventlog6_EvtRpcGetChannelConfig(
 286                 [in, range(1, MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16),string] uint16 *channelPath,
 287                 [in] uint32 flags,
 288                 [out, ref] eventlog6_EvtRpcVariantList* props);
 289
 290         WERROR eventlog6_EvtRpcPutChannelConfig(
 291                 [in, range(1, MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16),string] uint16 *channelPath,
 292                 [in] uint32 flags,
 293                 [in] eventlog6_EvtRpcVariantList* props,
 294                 [out, ref] eventlog6_RpcInfo *error);
 295
 296         WERROR eventlog6_EvtRpcGetPublisherList(
 297                 [in] uint32 flags,
 298                 [out, ref] uint32 *numPublisherIds,
 299                 [out, size_is(,*numPublisherIds), range(0, MAX_RPC_PUBLISHER_COUNT),charset(UTF16),string]
 300                 uint16 ***publisherIds);
 301
 302         WERROR eventlog6_EvtRpcGetPublisherListForChannel(
 303                 [in] uint16 *channelName,
 304                 [in] uint32 flags,
 305                 [out, ref] uint32* numPublisherIds,
 306                 [out, size_is(,*numPublisherIds), range(0, MAX_RPC_PUBLISHER_COUNT),charset(UTF16),string]
 307                 uint16 ***publisherIds);
 308
 309         WERROR eventlog6_EvtRpcGetPublisherMetadata(
 310                 [in, unique, range(0, MAX_RPC_PUBLISHER_ID_LENGTH),charset(UTF16),string] uint16 *publisherId,
 311                 [in, unique, range(0, MAX_RPC_FILE_PATH_LENGTH),charset(UTF16),string] uint16 *logFilePath,
 312                 [in] uint32 locale,
 313                 [in] uint32 flags,
 314                 [out, ref] eventlog6_EvtRpcVariantList* pubMetadataProps,
 315                 [out, ref] policy_handle *pubMetadata);
 316
 317         WERROR eventlog6_EvtRpcGetPublisherResourceMetadata(
 318                 [in, ref] policy_handle *handle,
 319                 [in] uint32 propertyId,
 320                 [in] uint32 flags,
 321                 [out, ref] eventlog6_EvtRpcVariantList *pubMetadataProps);
 322
 323         WERROR eventlog6_EvtRpcGetEventMetadataEnum(
 324                 [in, ref] policy_handle *pubMetadata,
 325                 [in] uint32 flags,
 326                 [in, unique, range(0, MAX_RPC_FILTER_LENGTH),charset(UTF16),string] uint16 *reservedForFilter,
 327                 [out, ref] policy_handle *eventMetaDataEnum);
 328
 329         WERROR eventlog6_EvtRpcGetNextEventMetadata(
 330                 [in, ref] policy_handle *eventMetaDataEnum,
 331                 [in] uint32 flags,
 332                 [in] uint32 numRequested,
 333                 [out, ref] uint32 *numReturned,
 334                 [out, size_is(,*numReturned), range(0, MAX_RPC_EVENT_METADATA_COUNT)]
 335                 eventlog6_EvtRpcVariantList **eventMetadataInstances);
 336
 337         WERROR eventlog6_EvtRpcGetClassicLogDisplayName(
 338                 [in, range(1, MAX_RPC_CHANNEL_NAME_LENGTH),charset(UTF16),string] uint16 *logName,
 339                 [in] uint32 locale,
 340                 [in] uint32 flags,
 341                 [out] uint16 **displayName);
 342 }
 343