plugins/opcua/opcua_enumparser.c

   1 /******************************************************************************
   2 ** $Id$
   3 **
   4 ** Copyright (C) 2006-2009 ascolab GmbH. All Rights Reserved.
   5 ** Web: http://www.ascolab.com
   6 **
   7 ** This program is free software; you can redistribute it and/or
   8 ** modify it under the terms of the GNU General Public License
   9 ** as published by the Free Software Foundation; either version 2
  10 ** of the License, or (at your option) any later version.
  11 **
  12 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  13 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  14 **
  15 ** Project: OpcUa Wireshark Plugin
  16 **
  17 ** Description: OpcUa Enum Type Parser
  18 **
  19 ** This file was autogenerated on 12.02.2013.
  20 ** DON'T MODIFY THIS FILE!
  21 **
  22 ******************************************************************************/
  23
  24 #include "config.h"
  25
  26 #include <glib.h>
  27 #include <epan/packet.h>
  28
  29 #include "opcua_enumparser.h"
  30
  31 /** NodeIdType enum table */
  32 static const value_string g_NodeIdTypeTable[] = {
  33   { 0, "TwoByte" },
  34   { 1, "FourByte" },
  35   { 2, "Numeric" },
  36   { 3, "String" },
  37   { 4, "Uri" },
  38   { 5, "Guid" },
  39   { 6, "ByteString" },
  40   { 0, NULL }
  41 };
  42 static int hf_opcua_NodeIdType = -1;
  43
  44 void parseNodeIdType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
  45 {
  46     proto_tree_add_item(tree, hf_opcua_NodeIdType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
  47 }
  48 /** OpenFileMode enum table */
  49 static const value_string g_OpenFileModeTable[] = {
  50   { 1, "Read" },
  51   { 2, "Write" },
  52   { 4, "EraseExisiting" },
  53   { 8, "Append" },
  54   { 0, NULL }
  55 };
  56 static int hf_opcua_OpenFileMode = -1;
  57
  58 void parseOpenFileMode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
  59 {
  60     proto_tree_add_item(tree, hf_opcua_OpenFileMode, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
  61 }
  62 /** IdType enum table */
  63 static const value_string g_IdTypeTable[] = {
  64   { 0, "Numeric" },
  65   { 1, "String" },
  66   { 2, "Guid" },
  67   { 3, "Opaque" },
  68   { 0, NULL }
  69 };
  70 static int hf_opcua_IdType = -1;
  71
  72 void parseIdType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
  73 {
  74     proto_tree_add_item(tree, hf_opcua_IdType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
  75 }
  76 /** NodeClass enum table */
  77 static const value_string g_NodeClassTable[] = {
  78   { 0, "Unspecified" },
  79   { 1, "Object" },
  80   { 2, "Variable" },
  81   { 4, "Method" },
  82   { 8, "ObjectType" },
  83   { 16, "VariableType" },
  84   { 32, "ReferenceType" },
  85   { 64, "DataType" },
  86   { 128, "View" },
  87   { 0, NULL }
  88 };
  89 static int hf_opcua_NodeClass = -1;
  90
  91 void parseNodeClass(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
  92 {
  93     proto_tree_add_item(tree, hf_opcua_NodeClass, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
  94 }
  95 /** ApplicationType enum table */
  96 static const value_string g_ApplicationTypeTable[] = {
  97   { 0, "Server" },
  98   { 1, "Client" },
  99   { 2, "ClientAndServer" },
 100   { 3, "DiscoveryServer" },
 101   { 0, NULL }
 102 };
 103 static int hf_opcua_ApplicationType = -1;
 104
 105 void parseApplicationType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 106 {
 107     proto_tree_add_item(tree, hf_opcua_ApplicationType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 108 }
 109 /** MessageSecurityMode enum table */
 110 static const value_string g_MessageSecurityModeTable[] = {
 111   { 0, "Invalid" },
 112   { 1, "None" },
 113   { 2, "Sign" },
 114   { 3, "SignAndEncrypt" },
 115   { 0, NULL }
 116 };
 117 static int hf_opcua_MessageSecurityMode = -1;
 118
 119 void parseMessageSecurityMode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 120 {
 121     proto_tree_add_item(tree, hf_opcua_MessageSecurityMode, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 122 }
 123 /** UserTokenType enum table */
 124 static const value_string g_UserTokenTypeTable[] = {
 125   { 0, "Anonymous" },
 126   { 1, "UserName" },
 127   { 2, "Certificate" },
 128   { 3, "IssuedToken" },
 129   { 0, NULL }
 130 };
 131 static int hf_opcua_UserTokenType = -1;
 132
 133 void parseUserTokenType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 134 {
 135     proto_tree_add_item(tree, hf_opcua_UserTokenType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 136 }
 137 /** SecurityTokenRequestType enum table */
 138 static const value_string g_SecurityTokenRequestTypeTable[] = {
 139   { 0, "Issue" },
 140   { 1, "Renew" },
 141   { 0, NULL }
 142 };
 143 static int hf_opcua_SecurityTokenRequestType = -1;
 144
 145 void parseSecurityTokenRequestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 146 {
 147     proto_tree_add_item(tree, hf_opcua_SecurityTokenRequestType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 148 }
 149 /** NodeAttributesMask enum table */
 150 static const value_string g_NodeAttributesMaskTable[] = {
 151   { 0, "None" },
 152   { 1, "AccessLevel" },
 153   { 2, "ArrayDimensions" },
 154   { 4, "BrowseName" },
 155   { 8, "ContainsNoLoops" },
 156   { 16, "DataType" },
 157   { 32, "Description" },
 158   { 64, "DisplayName" },
 159   { 128, "EventNotifier" },
 160   { 256, "Executable" },
 161   { 512, "Historizing" },
 162   { 1024, "InverseName" },
 163   { 2048, "IsAbstract" },
 164   { 4096, "MinimumSamplingInterval" },
 165   { 8192, "NodeClass" },
 166   { 16384, "NodeId" },
 167   { 32768, "Symmetric" },
 168   { 65536, "UserAccessLevel" },
 169   { 131072, "UserExecutable" },
 170   { 262144, "UserWriteMask" },
 171   { 524288, "ValueRank" },
 172   { 1048576, "WriteMask" },
 173   { 2097152, "Value" },
 174   { 4194303, "All" },
 175   { 1335396, "BaseNode" },
 176   { 1335524, "Object" },
 177   { 1337444, "ObjectTypeOrDataType" },
 178   { 4026999, "Variable" },
 179   { 3958902, "VariableType" },
 180   { 1466724, "Method" },
 181   { 1371236, "ReferenceType" },
 182   { 1335532, "View" },
 183   { 0, NULL }
 184 };
 185 static int hf_opcua_NodeAttributesMask = -1;
 186
 187 void parseNodeAttributesMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 188 {
 189     proto_tree_add_item(tree, hf_opcua_NodeAttributesMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 190 }
 191 /** AttributeWriteMask enum table */
 192 static const value_string g_AttributeWriteMaskTable[] = {
 193   { 0, "None" },
 194   { 1, "AccessLevel" },
 195   { 2, "ArrayDimensions" },
 196   { 4, "BrowseName" },
 197   { 8, "ContainsNoLoops" },
 198   { 16, "DataType" },
 199   { 32, "Description" },
 200   { 64, "DisplayName" },
 201   { 128, "EventNotifier" },
 202   { 256, "Executable" },
 203   { 512, "Historizing" },
 204   { 1024, "InverseName" },
 205   { 2048, "IsAbstract" },
 206   { 4096, "MinimumSamplingInterval" },
 207   { 8192, "NodeClass" },
 208   { 16384, "NodeId" },
 209   { 32768, "Symmetric" },
 210   { 65536, "UserAccessLevel" },
 211   { 131072, "UserExecutable" },
 212   { 262144, "UserWriteMask" },
 213   { 524288, "ValueRank" },
 214   { 1048576, "WriteMask" },
 215   { 2097152, "ValueForVariableType" },
 216   { 0, NULL }
 217 };
 218 static int hf_opcua_AttributeWriteMask = -1;
 219
 220 void parseAttributeWriteMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 221 {
 222     proto_tree_add_item(tree, hf_opcua_AttributeWriteMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 223 }
 224 /** BrowseDirection enum table */
 225 static const value_string g_BrowseDirectionTable[] = {
 226   { 0, "Forward" },
 227   { 1, "Inverse" },
 228   { 2, "Both" },
 229   { 0, NULL }
 230 };
 231 static int hf_opcua_BrowseDirection = -1;
 232
 233 void parseBrowseDirection(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 234 {
 235     proto_tree_add_item(tree, hf_opcua_BrowseDirection, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 236 }
 237 /** BrowseResultMask enum table */
 238 static const value_string g_BrowseResultMaskTable[] = {
 239   { 0, "None" },
 240   { 1, "ReferenceTypeId" },
 241   { 2, "IsForward" },
 242   { 4, "NodeClass" },
 243   { 8, "BrowseName" },
 244   { 16, "DisplayName" },
 245   { 32, "TypeDefinition" },
 246   { 63, "All" },
 247   { 3, "ReferenceTypeInfo" },
 248   { 60, "TargetInfo" },
 249   { 0, NULL }
 250 };
 251 static int hf_opcua_BrowseResultMask = -1;
 252
 253 void parseBrowseResultMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 254 {
 255     proto_tree_add_item(tree, hf_opcua_BrowseResultMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 256 }
 257 /** ComplianceLevel enum table */
 258 static const value_string g_ComplianceLevelTable[] = {
 259   { 0, "Untested" },
 260   { 1, "Partial" },
 261   { 2, "SelfTested" },
 262   { 3, "Certified" },
 263   { 0, NULL }
 264 };
 265 static int hf_opcua_ComplianceLevel = -1;
 266
 267 void parseComplianceLevel(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 268 {
 269     proto_tree_add_item(tree, hf_opcua_ComplianceLevel, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 270 }
 271 /** FilterOperator enum table */
 272 static const value_string g_FilterOperatorTable[] = {
 273   { 0, "Equals" },
 274   { 1, "IsNull" },
 275   { 2, "GreaterThan" },
 276   { 3, "LessThan" },
 277   { 4, "GreaterThanOrEqual" },
 278   { 5, "LessThanOrEqual" },
 279   { 6, "Like" },
 280   { 7, "Not" },
 281   { 8, "Between" },
 282   { 9, "InList" },
 283   { 10, "And" },
 284   { 11, "Or" },
 285   { 12, "Cast" },
 286   { 13, "InView" },
 287   { 14, "OfType" },
 288   { 15, "RelatedTo" },
 289   { 16, "BitwiseAnd" },
 290   { 17, "BitwiseOr" },
 291   { 0, NULL }
 292 };
 293 static int hf_opcua_FilterOperator = -1;
 294
 295 void parseFilterOperator(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 296 {
 297     proto_tree_add_item(tree, hf_opcua_FilterOperator, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 298 }
 299 /** TimestampsToReturn enum table */
 300 static const value_string g_TimestampsToReturnTable[] = {
 301   { 0, "Source" },
 302   { 1, "Server" },
 303   { 2, "Both" },
 304   { 3, "Neither" },
 305   { 0, NULL }
 306 };
 307 static int hf_opcua_TimestampsToReturn = -1;
 308
 309 void parseTimestampsToReturn(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 310 {
 311     proto_tree_add_item(tree, hf_opcua_TimestampsToReturn, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 312 }
 313 /** HistoryUpdateType enum table */
 314 static const value_string g_HistoryUpdateTypeTable[] = {
 315   { 1, "Insert" },
 316   { 2, "Replace" },
 317   { 3, "Update" },
 318   { 4, "Delete" },
 319   { 0, NULL }
 320 };
 321 static int hf_opcua_HistoryUpdateType = -1;
 322
 323 void parseHistoryUpdateType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 324 {
 325     proto_tree_add_item(tree, hf_opcua_HistoryUpdateType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 326 }
 327 /** PerformUpdateType enum table */
 328 static const value_string g_PerformUpdateTypeTable[] = {
 329   { 1, "Insert" },
 330   { 2, "Replace" },
 331   { 3, "Update" },
 332   { 4, "Remove" },
 333   { 0, NULL }
 334 };
 335 static int hf_opcua_PerformUpdateType = -1;
 336
 337 void parsePerformUpdateType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 338 {
 339     proto_tree_add_item(tree, hf_opcua_PerformUpdateType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 340 }
 341 /** MonitoringMode enum table */
 342 static const value_string g_MonitoringModeTable[] = {
 343   { 0, "Disabled" },
 344   { 1, "Sampling" },
 345   { 2, "Reporting" },
 346   { 0, NULL }
 347 };
 348 static int hf_opcua_MonitoringMode = -1;
 349
 350 void parseMonitoringMode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 351 {
 352     proto_tree_add_item(tree, hf_opcua_MonitoringMode, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 353 }
 354 /** DataChangeTrigger enum table */
 355 static const value_string g_DataChangeTriggerTable[] = {
 356   { 0, "Status" },
 357   { 1, "StatusValue" },
 358   { 2, "StatusValueTimestamp" },
 359   { 0, NULL }
 360 };
 361 static int hf_opcua_DataChangeTrigger = -1;
 362
 363 void parseDataChangeTrigger(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 364 {
 365     proto_tree_add_item(tree, hf_opcua_DataChangeTrigger, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 366 }
 367 /** DeadbandType enum table */
 368 static const value_string g_DeadbandTypeTable[] = {
 369   { 0, "None" },
 370   { 1, "Absolute" },
 371   { 2, "Percent" },
 372   { 0, NULL }
 373 };
 374 static int hf_opcua_DeadbandType = -1;
 375
 376 void parseDeadbandType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 377 {
 378     proto_tree_add_item(tree, hf_opcua_DeadbandType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 379 }
 380 /** EnumeratedTestType enum table */
 381 static const value_string g_EnumeratedTestTypeTable[] = {
 382   { 1, "Red" },
 383   { 4, "Yellow" },
 384   { 5, "Green" },
 385   { 0, NULL }
 386 };
 387 static int hf_opcua_EnumeratedTestType = -1;
 388
 389 void parseEnumeratedTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 390 {
 391     proto_tree_add_item(tree, hf_opcua_EnumeratedTestType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 392 }
 393 /** RedundancySupport enum table */
 394 static const value_string g_RedundancySupportTable[] = {
 395   { 0, "None" },
 396   { 1, "Cold" },
 397   { 2, "Warm" },
 398   { 3, "Hot" },
 399   { 4, "Transparent" },
 400   { 5, "HotAndMirrored" },
 401   { 0, NULL }
 402 };
 403 static int hf_opcua_RedundancySupport = -1;
 404
 405 void parseRedundancySupport(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 406 {
 407     proto_tree_add_item(tree, hf_opcua_RedundancySupport, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 408 }
 409 /** ServerState enum table */
 410 static const value_string g_ServerStateTable[] = {
 411   { 0, "Running" },
 412   { 1, "Failed" },
 413   { 2, "NoConfiguration" },
 414   { 3, "Suspended" },
 415   { 4, "Shutdown" },
 416   { 5, "Test" },
 417   { 6, "CommunicationFault" },
 418   { 7, "Unknown" },
 419   { 0, NULL }
 420 };
 421 static int hf_opcua_ServerState = -1;
 422
 423 void parseServerState(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 424 {
 425     proto_tree_add_item(tree, hf_opcua_ServerState, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 426 }
 427 /** ModelChangeStructureVerbMask enum table */
 428 static const value_string g_ModelChangeStructureVerbMaskTable[] = {
 429   { 1, "NodeAdded" },
 430   { 2, "NodeDeleted" },
 431   { 4, "ReferenceAdded" },
 432   { 8, "ReferenceDeleted" },
 433   { 16, "DataTypeChanged" },
 434   { 0, NULL }
 435 };
 436 static int hf_opcua_ModelChangeStructureVerbMask = -1;
 437
 438 void parseModelChangeStructureVerbMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 439 {
 440     proto_tree_add_item(tree, hf_opcua_ModelChangeStructureVerbMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 441 }
 442 /** AxisScaleEnumeration enum table */
 443 static const value_string g_AxisScaleEnumerationTable[] = {
 444   { 0, "Linear" },
 445   { 1, "Log" },
 446   { 2, "Ln" },
 447   { 0, NULL }
 448 };
 449 static int hf_opcua_AxisScaleEnumeration = -1;
 450
 451 void parseAxisScaleEnumeration(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 452 {
 453     proto_tree_add_item(tree, hf_opcua_AxisScaleEnumeration, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 454 }
 455 /** ExceptionDeviationFormat enum table */
 456 static const value_string g_ExceptionDeviationFormatTable[] = {
 457   { 0, "AbsoluteValue" },
 458   { 1, "PercentOfRange" },
 459   { 2, "PercentOfValue" },
 460   { 3, "PercentOfEURange" },
 461   { 4, "Unknown" },
 462   { 0, NULL }
 463 };
 464 static int hf_opcua_ExceptionDeviationFormat = -1;
 465
 466 void parseExceptionDeviationFormat(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 467 {
 468     proto_tree_add_item(tree, hf_opcua_ExceptionDeviationFormat, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 469 }
 470
 471 /** Register enum types. */
 472 void registerEnumTypes(int proto)
 473 {
 474     /** header field definitions */
 475     static hf_register_info hf[] =
 476     {
 477         { &hf_opcua_NodeIdType,
 478         {  "NodeIdType", "opcua.NodeIdType", FT_UINT32, BASE_HEX,  VALS(g_NodeIdTypeTable), 0x0, NULL, HFILL }
 479         },
 480         { &hf_opcua_OpenFileMode,
 481         {  "OpenFileMode", "opcua.OpenFileMode", FT_UINT32, BASE_HEX,  VALS(g_OpenFileModeTable), 0x0, NULL, HFILL }
 482         },
 483         { &hf_opcua_IdType,
 484         {  "IdType", "opcua.IdType", FT_UINT32, BASE_HEX,  VALS(g_IdTypeTable), 0x0, NULL, HFILL }
 485         },
 486         { &hf_opcua_NodeClass,
 487         {  "NodeClass", "opcua.NodeClass", FT_UINT32, BASE_HEX,  VALS(g_NodeClassTable), 0x0, NULL, HFILL }
 488         },
 489         { &hf_opcua_ApplicationType,
 490         {  "ApplicationType", "opcua.ApplicationType", FT_UINT32, BASE_HEX,  VALS(g_ApplicationTypeTable), 0x0, NULL, HFILL }
 491         },
 492         { &hf_opcua_MessageSecurityMode,
 493         {  "MessageSecurityMode", "opcua.MessageSecurityMode", FT_UINT32, BASE_HEX,  VALS(g_MessageSecurityModeTable), 0x0, NULL, HFILL }
 494         },
 495         { &hf_opcua_UserTokenType,
 496         {  "UserTokenType", "opcua.UserTokenType", FT_UINT32, BASE_HEX,  VALS(g_UserTokenTypeTable), 0x0, NULL, HFILL }
 497         },
 498         { &hf_opcua_SecurityTokenRequestType,
 499         {  "SecurityTokenRequestType", "opcua.SecurityTokenRequestType", FT_UINT32, BASE_HEX,  VALS(g_SecurityTokenRequestTypeTable), 0x0, NULL, HFILL }
 500         },
 501         { &hf_opcua_NodeAttributesMask,
 502         {  "NodeAttributesMask", "opcua.NodeAttributesMask", FT_UINT32, BASE_HEX,  VALS(g_NodeAttributesMaskTable), 0x0, NULL, HFILL }
 503         },
 504         { &hf_opcua_AttributeWriteMask,
 505         {  "AttributeWriteMask", "opcua.AttributeWriteMask", FT_UINT32, BASE_HEX,  VALS(g_AttributeWriteMaskTable), 0x0, NULL, HFILL }
 506         },
 507         { &hf_opcua_BrowseDirection,
 508         {  "BrowseDirection", "opcua.BrowseDirection", FT_UINT32, BASE_HEX,  VALS(g_BrowseDirectionTable), 0x0, NULL, HFILL }
 509         },
 510         { &hf_opcua_BrowseResultMask,
 511         {  "BrowseResultMask", "opcua.BrowseResultMask", FT_UINT32, BASE_HEX,  VALS(g_BrowseResultMaskTable), 0x0, NULL, HFILL }
 512         },
 513         { &hf_opcua_ComplianceLevel,
 514         {  "ComplianceLevel", "opcua.ComplianceLevel", FT_UINT32, BASE_HEX,  VALS(g_ComplianceLevelTable), 0x0, NULL, HFILL }
 515         },
 516         { &hf_opcua_FilterOperator,
 517         {  "FilterOperator", "opcua.FilterOperator", FT_UINT32, BASE_HEX,  VALS(g_FilterOperatorTable), 0x0, NULL, HFILL }
 518         },
 519         { &hf_opcua_TimestampsToReturn,
 520         {  "TimestampsToReturn", "opcua.TimestampsToReturn", FT_UINT32, BASE_HEX,  VALS(g_TimestampsToReturnTable), 0x0, NULL, HFILL }
 521         },
 522         { &hf_opcua_HistoryUpdateType,
 523         {  "HistoryUpdateType", "opcua.HistoryUpdateType", FT_UINT32, BASE_HEX,  VALS(g_HistoryUpdateTypeTable), 0x0, NULL, HFILL }
 524         },
 525         { &hf_opcua_PerformUpdateType,
 526         {  "PerformUpdateType", "opcua.PerformUpdateType", FT_UINT32, BASE_HEX,  VALS(g_PerformUpdateTypeTable), 0x0, NULL, HFILL }
 527         },
 528         { &hf_opcua_MonitoringMode,
 529         {  "MonitoringMode", "opcua.MonitoringMode", FT_UINT32, BASE_HEX,  VALS(g_MonitoringModeTable), 0x0, NULL, HFILL }
 530         },
 531         { &hf_opcua_DataChangeTrigger,
 532         {  "DataChangeTrigger", "opcua.DataChangeTrigger", FT_UINT32, BASE_HEX,  VALS(g_DataChangeTriggerTable), 0x0, NULL, HFILL }
 533         },
 534         { &hf_opcua_DeadbandType,
 535         {  "DeadbandType", "opcua.DeadbandType", FT_UINT32, BASE_HEX,  VALS(g_DeadbandTypeTable), 0x0, NULL, HFILL }
 536         },
 537         { &hf_opcua_EnumeratedTestType,
 538         {  "EnumeratedTestType", "opcua.EnumeratedTestType", FT_UINT32, BASE_HEX,  VALS(g_EnumeratedTestTypeTable), 0x0, NULL, HFILL }
 539         },
 540         { &hf_opcua_RedundancySupport,
 541         {  "RedundancySupport", "opcua.RedundancySupport", FT_UINT32, BASE_HEX,  VALS(g_RedundancySupportTable), 0x0, NULL, HFILL }
 542         },
 543         { &hf_opcua_ServerState,
 544         {  "ServerState", "opcua.ServerState", FT_UINT32, BASE_HEX,  VALS(g_ServerStateTable), 0x0, NULL, HFILL }
 545         },
 546         { &hf_opcua_ModelChangeStructureVerbMask,
 547         {  "ModelChangeStructureVerbMask", "opcua.ModelChangeStructureVerbMask", FT_UINT32, BASE_HEX,  VALS(g_ModelChangeStructureVerbMaskTable), 0x0, NULL, HFILL }
 548         },
 549         { &hf_opcua_AxisScaleEnumeration,
 550         {  "AxisScaleEnumeration", "opcua.AxisScaleEnumeration", FT_UINT32, BASE_HEX,  VALS(g_AxisScaleEnumerationTable), 0x0, NULL, HFILL }
 551         },
 552         { &hf_opcua_ExceptionDeviationFormat,
 553         {  "ExceptionDeviationFormat", "opcua.ExceptionDeviationFormat", FT_UINT32, BASE_HEX,  VALS(g_ExceptionDeviationFormatTable), 0x0, NULL, HFILL }
 554         },
 555     };
 556
 557     proto_register_field_array(proto, hf, array_length(hf));
 558 }
 559