From Hannes Mezger via https://bugs.wireshark.org/bugzilla/show_bug.cgi?id=8327

Updates to the OPCUA plugin so that subtrees of the dissector select the
appropriate number of bytes. Also fix dissection of the array dimensions
field for matrix values and the highlighting for empty string fields.

svn path=/trunk/; revision=47673

13 files changed, 1412 insertions, 795 deletions

diff --git a/plugins/opcua/opcua_complextypeparser.c b/plugins/opcua/opcua_complextypeparser.c
index 9fd6367c56..afa119d67a 100644
--- a/plugins/opcua/opcua_complextypeparser.c
+++ b/plugins/opcua/opcua_complextypeparser.c
@@ -16,7 +16,7 @@
 **
 ** Description: OpcUa Complex Type Parser
 **
-** This file was autogenerated on 01.04.2009.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 **
 ******************************************************************************/
@@ -33,7 +33,7 @@
 gint ett_opcua_Node = -1;
 void parseNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : Node", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : Node", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_Node);
   parseNodeId(subtree, tvb, pOffset, "NodeId");
   parseNodeClass(subtree, tvb, pOffset);
@@ -44,26 +44,88 @@ void parseNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFie
   parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
   /* Array length field ignored: NoOfReferences */
   parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_InstanceNode = -1;
+void parseInstanceNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : InstanceNode", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_InstanceNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_TypeNode = -1;
+void parseTypeNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : TypeNode", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TypeNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ObjectNode = -1;
 void parseObjectNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ObjectNode", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ObjectNode", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ObjectNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
   parseByte(subtree, tvb, pOffset, hf_opcua_EventNotifier);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ObjectTypeNode = -1;
 void parseObjectTypeNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ObjectTypeNode", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ObjectTypeNode", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ObjectTypeNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsAbstract);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_VariableNode = -1;
 void parseVariableNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : VariableNode", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : VariableNode", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_VariableNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
   parseVariant(subtree, tvb, pOffset, "Value");
   parseNodeId(subtree, tvb, pOffset, "DataType");
   parseInt32(subtree, tvb, pOffset, hf_opcua_ValueRank);
@@ -73,64 +135,116 @@ void parseVariableNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const cha
   parseByte(subtree, tvb, pOffset, hf_opcua_UserAccessLevel);
   parseDouble(subtree, tvb, pOffset, hf_opcua_MinimumSamplingInterval);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_Historizing);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_VariableTypeNode = -1;
 void parseVariableTypeNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : VariableTypeNode", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : VariableTypeNode", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_VariableTypeNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
   parseVariant(subtree, tvb, pOffset, "Value");
   parseNodeId(subtree, tvb, pOffset, "DataType");
   parseInt32(subtree, tvb, pOffset, hf_opcua_ValueRank);
   /* Array length field ignored: NoOfArrayDimensions */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_ArrayDimensions, parseUInt32);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsAbstract);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReferenceTypeNode = -1;
 void parseReferenceTypeNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ReferenceTypeNode", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ReferenceTypeNode", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReferenceTypeNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsAbstract);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_Symmetric);
   parseLocalizedText(subtree, tvb, pOffset, "InverseName");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_MethodNode = -1;
 void parseMethodNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : MethodNode", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : MethodNode", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_MethodNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_Executable);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_UserExecutable);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ViewNode = -1;
 void parseViewNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ViewNode", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ViewNode", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ViewNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_ContainsNoLoops);
   parseByte(subtree, tvb, pOffset, hf_opcua_EventNotifier);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DataTypeNode = -1;
 void parseDataTypeNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : DataTypeNode", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DataTypeNode", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DataTypeNode);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseNodeClass(subtree, tvb, pOffset);
+  parseQualifiedName(subtree, tvb, pOffset, "BrowseName");
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  /* Array length field ignored: NoOfReferences */
+  parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceNode);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsAbstract);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReferenceNode = -1;
 void parseReferenceNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ReferenceNode", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ReferenceNode", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReferenceNode);
   parseNodeId(subtree, tvb, pOffset, "ReferenceTypeId");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsInverse);
   parseExpandedNodeId(subtree, tvb, pOffset, "TargetId");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_Argument = -1;
 void parseArgument(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : Argument", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : Argument", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_Argument);
   parseString(subtree, tvb, pOffset, hf_opcua_Name);
   parseNodeId(subtree, tvb, pOffset, "DataType");
@@ -138,60 +252,94 @@ void parseArgument(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *s
   /* Array length field ignored: NoOfArrayDimensions */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_ArrayDimensions, parseUInt32);
   parseLocalizedText(subtree, tvb, pOffset, "Description");
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_EnumValueType = -1;
+void parseEnumValueType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : EnumValueType", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EnumValueType);
+  parseInt64(subtree, tvb, pOffset, hf_opcua_Value);
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_TimeZoneDataType = -1;
 void parseTimeZoneDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : TimeZoneDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : TimeZoneDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TimeZoneDataType);
   parseInt16(subtree, tvb, pOffset, hf_opcua_Offset);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_DaylightSavingInOffset);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
-gint ett_opcua_EnumValueInfo = -1;
-void parseEnumValueInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+gint ett_opcua_ApplicationDescription = -1;
+void parseApplicationDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : EnumValueInfo", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EnumValueInfo);
-  parseLocalizedText(subtree, tvb, pOffset, "Name");
-  parseInt32(subtree, tvb, pOffset, hf_opcua_Value);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ApplicationDescription", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ApplicationDescription);
+  parseString(subtree, tvb, pOffset, hf_opcua_ApplicationUri);
+  parseString(subtree, tvb, pOffset, hf_opcua_ProductUri);
+  parseLocalizedText(subtree, tvb, pOffset, "ApplicationName");
+  parseApplicationType(subtree, tvb, pOffset);
+  parseString(subtree, tvb, pOffset, hf_opcua_GatewayServerUri);
+  parseString(subtree, tvb, pOffset, hf_opcua_DiscoveryProfileUri);
+  /* Array length field ignored: NoOfDiscoveryUrls */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_DiscoveryUrls, parseString);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
-gint ett_opcua_StatusResult = -1;
-void parseStatusResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+gint ett_opcua_RequestHeader = -1;
+void parseRequestHeader(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : StatusResult", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_StatusResult);
-  parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
-  parseDiagnosticInfo(subtree, tvb, pOffset, "DiagnosticInfo");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : RequestHeader", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RequestHeader);
+  parseNodeId(subtree, tvb, pOffset, "AuthenticationToken");
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_Timestamp);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_RequestHandle);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_ReturnDiagnostics);
+  parseString(subtree, tvb, pOffset, hf_opcua_AuditEntryId);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_TimeoutHint);
+  parseExtensionObject(subtree, tvb, pOffset, "AdditionalHeader");
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_ResponseHeader = -1;
+void parseResponseHeader(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ResponseHeader", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ResponseHeader);
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_Timestamp);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_RequestHandle);
+  parseStatusCode(subtree, tvb, pOffset, hf_opcua_ServiceResult);
+  parseDiagnosticInfo(subtree, tvb, pOffset, "ServiceDiagnostics");
+  /* Array length field ignored: NoOfStringTable */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_StringTable, parseString);
+  parseExtensionObject(subtree, tvb, pOffset, "AdditionalHeader");
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_ServiceFault = -1;
+void parseServiceFault(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ServiceFault", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ServiceFault);
+  parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_UserTokenPolicy = -1;
 void parseUserTokenPolicy(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : UserTokenPolicy", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : UserTokenPolicy", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_UserTokenPolicy);
   parseString(subtree, tvb, pOffset, hf_opcua_PolicyId);
   parseUserTokenType(subtree, tvb, pOffset);
   parseString(subtree, tvb, pOffset, hf_opcua_IssuedTokenType);
   parseString(subtree, tvb, pOffset, hf_opcua_IssuerEndpointUrl);
   parseString(subtree, tvb, pOffset, hf_opcua_SecurityPolicyUri);
-}
-gint ett_opcua_ApplicationDescription = -1;
-void parseApplicationDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ApplicationDescription", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ApplicationDescription);
-  parseString(subtree, tvb, pOffset, hf_opcua_ApplicationUri);
-  parseString(subtree, tvb, pOffset, hf_opcua_ProductUri);
-  parseLocalizedText(subtree, tvb, pOffset, "ApplicationName");
-  parseApplicationType(subtree, tvb, pOffset);
-  parseString(subtree, tvb, pOffset, hf_opcua_GatewayServerUri);
-  parseString(subtree, tvb, pOffset, hf_opcua_DiscoveryProfileUri);
-  /* Array length field ignored: NoOfDiscoveryUrls */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_DiscoveryUrls, parseString);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_EndpointDescription = -1;
 void parseEndpointDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : EndpointDescription", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : EndpointDescription", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EndpointDescription);
   parseString(subtree, tvb, pOffset, hf_opcua_EndpointUrl);
   parseApplicationDescription(subtree, tvb, pOffset, "Server");
@@ -202,126 +350,135 @@ void parseEndpointDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, co
   parseArrayComplex(subtree, tvb, pOffset, "UserIdentityTokens", parseUserTokenPolicy);
   parseString(subtree, tvb, pOffset, hf_opcua_TransportProfileUri);
   parseByte(subtree, tvb, pOffset, hf_opcua_SecurityLevel);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_RegisteredServer = -1;
+void parseRegisteredServer(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : RegisteredServer", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RegisteredServer);
+  parseString(subtree, tvb, pOffset, hf_opcua_ServerUri);
+  parseString(subtree, tvb, pOffset, hf_opcua_ProductUri);
+  /* Array length field ignored: NoOfServerNames */
+  parseArrayComplex(subtree, tvb, pOffset, "ServerNames", parseLocalizedText);
+  parseApplicationType(subtree, tvb, pOffset);
+  parseString(subtree, tvb, pOffset, hf_opcua_GatewayServerUri);
+  /* Array length field ignored: NoOfDiscoveryUrls */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_DiscoveryUrls, parseString);
+  parseString(subtree, tvb, pOffset, hf_opcua_SemaphoreFilePath);
+  parseBoolean(subtree, tvb, pOffset, hf_opcua_IsOnline);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_ChannelSecurityToken = -1;
+void parseChannelSecurityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ChannelSecurityToken", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ChannelSecurityToken);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_ChannelId);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_TokenId);
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_CreatedAt);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_RevisedLifetime);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_SignedSoftwareCertificate = -1;
+void parseSignedSoftwareCertificate(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SignedSoftwareCertificate", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SignedSoftwareCertificate);
+  parseByteString(subtree, tvb, pOffset, hf_opcua_CertificateData);
+  parseByteString(subtree, tvb, pOffset, hf_opcua_Signature);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_SignatureData = -1;
+void parseSignatureData(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SignatureData", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SignatureData);
+  parseString(subtree, tvb, pOffset, hf_opcua_Algorithm);
+  parseByteString(subtree, tvb, pOffset, hf_opcua_Signature);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_UserIdentityToken = -1;
 void parseUserIdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : UserIdentityToken", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : UserIdentityToken", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_UserIdentityToken);
   parseString(subtree, tvb, pOffset, hf_opcua_PolicyId);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_AnonymousIdentityToken = -1;
+void parseAnonymousIdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : AnonymousIdentityToken", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AnonymousIdentityToken);
+  parseString(subtree, tvb, pOffset, hf_opcua_PolicyId);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_UserNameIdentityToken = -1;
 void parseUserNameIdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : UserNameIdentityToken", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : UserNameIdentityToken", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_UserNameIdentityToken);
+  parseString(subtree, tvb, pOffset, hf_opcua_PolicyId);
   parseString(subtree, tvb, pOffset, hf_opcua_UserName);
   parseByteString(subtree, tvb, pOffset, hf_opcua_Password);
   parseString(subtree, tvb, pOffset, hf_opcua_EncryptionAlgorithm);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_X509IdentityToken = -1;
 void parseX509IdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : X509IdentityToken", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : X509IdentityToken", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_X509IdentityToken);
+  parseString(subtree, tvb, pOffset, hf_opcua_PolicyId);
   parseByteString(subtree, tvb, pOffset, hf_opcua_CertificateData);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_IssuedIdentityToken = -1;
 void parseIssuedIdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : IssuedIdentityToken", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : IssuedIdentityToken", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_IssuedIdentityToken);
+  parseString(subtree, tvb, pOffset, hf_opcua_PolicyId);
   parseByteString(subtree, tvb, pOffset, hf_opcua_TokenData);
   parseString(subtree, tvb, pOffset, hf_opcua_EncryptionAlgorithm);
-}
-gint ett_opcua_EndpointConfiguration = -1;
-void parseEndpointConfiguration(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : EndpointConfiguration", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EndpointConfiguration);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_OperationTimeout);
-  parseBoolean(subtree, tvb, pOffset, hf_opcua_UseBinaryEncoding);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxStringLength);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxByteStringLength);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxArrayLength);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxMessageSize);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxBufferSize);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_ChannelLifetime);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_SecurityTokenLifetime);
-}
-gint ett_opcua_SupportedProfile = -1;
-void parseSupportedProfile(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SupportedProfile", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SupportedProfile);
-  parseString(subtree, tvb, pOffset, hf_opcua_OrganizationUri);
-  parseString(subtree, tvb, pOffset, hf_opcua_ProfileId);
-  parseString(subtree, tvb, pOffset, hf_opcua_ComplianceTool);
-  parseDateTime(subtree, tvb, pOffset, hf_opcua_ComplianceDate);
-  parseComplianceLevel(subtree, tvb, pOffset);
-  /* Array length field ignored: NoOfUnsupportedUnitIds */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_UnsupportedUnitIds, parseString);
-}
-gint ett_opcua_BuildInfo = -1;
-void parseBuildInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : BuildInfo", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BuildInfo);
-  parseString(subtree, tvb, pOffset, hf_opcua_ProductUri);
-  parseString(subtree, tvb, pOffset, hf_opcua_ManufacturerName);
-  parseString(subtree, tvb, pOffset, hf_opcua_ProductName);
-  parseString(subtree, tvb, pOffset, hf_opcua_SoftwareVersion);
-  parseString(subtree, tvb, pOffset, hf_opcua_BuildNumber);
-  parseDateTime(subtree, tvb, pOffset, hf_opcua_BuildDate);
-}
-gint ett_opcua_SoftwareCertificate = -1;
-void parseSoftwareCertificate(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SoftwareCertificate", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SoftwareCertificate);
-  parseString(subtree, tvb, pOffset, hf_opcua_ProductName);
-  parseString(subtree, tvb, pOffset, hf_opcua_ProductUri);
-  parseString(subtree, tvb, pOffset, hf_opcua_VendorName);
-  parseByteString(subtree, tvb, pOffset, hf_opcua_VendorProductCertificate);
-  parseString(subtree, tvb, pOffset, hf_opcua_SoftwareVersion);
-  parseString(subtree, tvb, pOffset, hf_opcua_BuildNumber);
-  parseDateTime(subtree, tvb, pOffset, hf_opcua_BuildDate);
-  parseString(subtree, tvb, pOffset, hf_opcua_IssuedBy);
-  parseDateTime(subtree, tvb, pOffset, hf_opcua_IssueDate);
-  /* Array length field ignored: NoOfSupportedProfiles */
-  parseArrayComplex(subtree, tvb, pOffset, "SupportedProfiles", parseSupportedProfile);
-}
-gint ett_opcua_SignedSoftwareCertificate = -1;
-void parseSignedSoftwareCertificate(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SignedSoftwareCertificate", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SignedSoftwareCertificate);
-  parseByteString(subtree, tvb, pOffset, hf_opcua_CertificateData);
-  parseByteString(subtree, tvb, pOffset, hf_opcua_Signature);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_NodeAttributes = -1;
 void parseNodeAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : NodeAttributes", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : NodeAttributes", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_NodeAttributes);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_SpecifiedAttributes);
   parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
   parseLocalizedText(subtree, tvb, pOffset, "Description");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ObjectAttributes = -1;
 void parseObjectAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ObjectAttributes", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ObjectAttributes", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ObjectAttributes);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_SpecifiedAttributes);
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
   parseByte(subtree, tvb, pOffset, hf_opcua_EventNotifier);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_VariableAttributes = -1;
 void parseVariableAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : VariableAttributes", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : VariableAttributes", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_VariableAttributes);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_SpecifiedAttributes);
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
   parseVariant(subtree, tvb, pOffset, "Value");
   parseNodeId(subtree, tvb, pOffset, "DataType");
   parseInt32(subtree, tvb, pOffset, hf_opcua_ValueRank);
@@ -331,62 +488,99 @@ void parseVariableAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, con
   parseByte(subtree, tvb, pOffset, hf_opcua_UserAccessLevel);
   parseDouble(subtree, tvb, pOffset, hf_opcua_MinimumSamplingInterval);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_Historizing);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_MethodAttributes = -1;
 void parseMethodAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : MethodAttributes", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : MethodAttributes", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_MethodAttributes);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_SpecifiedAttributes);
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_Executable);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_UserExecutable);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ObjectTypeAttributes = -1;
 void parseObjectTypeAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ObjectTypeAttributes", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ObjectTypeAttributes", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ObjectTypeAttributes);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_SpecifiedAttributes);
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsAbstract);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_VariableTypeAttributes = -1;
 void parseVariableTypeAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : VariableTypeAttributes", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : VariableTypeAttributes", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_VariableTypeAttributes);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_SpecifiedAttributes);
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
   parseVariant(subtree, tvb, pOffset, "Value");
   parseNodeId(subtree, tvb, pOffset, "DataType");
   parseInt32(subtree, tvb, pOffset, hf_opcua_ValueRank);
   /* Array length field ignored: NoOfArrayDimensions */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_ArrayDimensions, parseUInt32);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsAbstract);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReferenceTypeAttributes = -1;
 void parseReferenceTypeAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ReferenceTypeAttributes", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ReferenceTypeAttributes", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReferenceTypeAttributes);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_SpecifiedAttributes);
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsAbstract);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_Symmetric);
   parseLocalizedText(subtree, tvb, pOffset, "InverseName");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DataTypeAttributes = -1;
 void parseDataTypeAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : DataTypeAttributes", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DataTypeAttributes", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DataTypeAttributes);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_SpecifiedAttributes);
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsAbstract);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ViewAttributes = -1;
 void parseViewAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ViewAttributes", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ViewAttributes", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ViewAttributes);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_SpecifiedAttributes);
+  parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
+  parseLocalizedText(subtree, tvb, pOffset, "Description");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_WriteMask);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UserWriteMask);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_ContainsNoLoops);
   parseByte(subtree, tvb, pOffset, hf_opcua_EventNotifier);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AddNodesItem = -1;
 void parseAddNodesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : AddNodesItem", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : AddNodesItem", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AddNodesItem);
   parseExpandedNodeId(subtree, tvb, pOffset, "ParentNodeId");
   parseNodeId(subtree, tvb, pOffset, "ReferenceTypeId");
@@ -395,11 +589,21 @@ void parseAddNodesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const cha
   parseNodeClass(subtree, tvb, pOffset);
   parseExtensionObject(subtree, tvb, pOffset, "NodeAttributes");
   parseExpandedNodeId(subtree, tvb, pOffset, "TypeDefinition");
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_AddNodesResult = -1;
+void parseAddNodesResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : AddNodesResult", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AddNodesResult);
+  parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
+  parseNodeId(subtree, tvb, pOffset, "AddedNodeId");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AddReferencesItem = -1;
 void parseAddReferencesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : AddReferencesItem", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : AddReferencesItem", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AddReferencesItem);
   parseNodeId(subtree, tvb, pOffset, "SourceNodeId");
   parseNodeId(subtree, tvb, pOffset, "ReferenceTypeId");
@@ -407,209 +611,43 @@ void parseAddReferencesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, cons
   parseString(subtree, tvb, pOffset, hf_opcua_TargetServerUri);
   parseExpandedNodeId(subtree, tvb, pOffset, "TargetNodeId");
   parseNodeClass(subtree, tvb, pOffset);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteNodesItem = -1;
 void parseDeleteNodesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : DeleteNodesItem", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DeleteNodesItem", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteNodesItem);
   parseNodeId(subtree, tvb, pOffset, "NodeId");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_DeleteTargetReferences);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteReferencesItem = -1;
 void parseDeleteReferencesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : DeleteReferencesItem", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DeleteReferencesItem", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteReferencesItem);
   parseNodeId(subtree, tvb, pOffset, "SourceNodeId");
   parseNodeId(subtree, tvb, pOffset, "ReferenceTypeId");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsForward);
   parseExpandedNodeId(subtree, tvb, pOffset, "TargetNodeId");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_DeleteBidirectional);
-}
-gint ett_opcua_RequestHeader = -1;
-void parseRequestHeader(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : RequestHeader", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RequestHeader);
-  parseNodeId(subtree, tvb, pOffset, "AuthenticationToken");
-  parseDateTime(subtree, tvb, pOffset, hf_opcua_Timestamp);
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_RequestHandle);
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_ReturnDiagnostics);
-  parseString(subtree, tvb, pOffset, hf_opcua_AuditEntryId);
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_TimeoutHint);
-  parseExtensionObject(subtree, tvb, pOffset, "AdditionalHeader");
-}
-gint ett_opcua_ResponseHeader = -1;
-void parseResponseHeader(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ResponseHeader", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ResponseHeader);
-  parseDateTime(subtree, tvb, pOffset, hf_opcua_Timestamp);
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_RequestHandle);
-  parseStatusCode(subtree, tvb, pOffset, hf_opcua_ServiceResult);
-  parseDiagnosticInfo(subtree, tvb, pOffset, "ServiceDiagnostics");
-  /* Array length field ignored: NoOfStringTable */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_StringTable, parseString);
-  parseExtensionObject(subtree, tvb, pOffset, "AdditionalHeader");
-}
-gint ett_opcua_ServiceFault = -1;
-void parseServiceFault(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ServiceFault", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ServiceFault);
-  parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
-}
-gint ett_opcua_ScalarTestType = -1;
-void parseScalarTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ScalarTestType", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ScalarTestType);
-  parseBoolean(subtree, tvb, pOffset, hf_opcua_Boolean);
-  parseSByte(subtree, tvb, pOffset, hf_opcua_SByte);
-  parseByte(subtree, tvb, pOffset, hf_opcua_Byte);
-  parseInt16(subtree, tvb, pOffset, hf_opcua_Int16);
-  parseUInt16(subtree, tvb, pOffset, hf_opcua_UInt16);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_Int32);
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_UInt32);
-  parseInt64(subtree, tvb, pOffset, hf_opcua_Int64);
-  parseUInt64(subtree, tvb, pOffset, hf_opcua_UInt64);
-  parseFloat(subtree, tvb, pOffset, hf_opcua_Float);
-  parseDouble(subtree, tvb, pOffset, hf_opcua_Double);
-  parseString(subtree, tvb, pOffset, hf_opcua_String);
-  parseDateTime(subtree, tvb, pOffset, hf_opcua_DateTime);
-  parseGuid(subtree, tvb, pOffset, hf_opcua_Guid);
-  parseByteString(subtree, tvb, pOffset, hf_opcua_ByteString);
-  parseXmlElement(subtree, tvb, pOffset, hf_opcua_XmlElement);
-  parseNodeId(subtree, tvb, pOffset, "NodeId");
-  parseExpandedNodeId(subtree, tvb, pOffset, "ExpandedNodeId");
-  parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
-  parseDiagnosticInfo(subtree, tvb, pOffset, "DiagnosticInfo");
-  parseQualifiedName(subtree, tvb, pOffset, "QualifiedName");
-  parseLocalizedText(subtree, tvb, pOffset, "LocalizedText");
-  parseExtensionObject(subtree, tvb, pOffset, "ExtensionObject");
-  parseDataValue(subtree, tvb, pOffset, "DataValue");
-  parseEnumeratedTestType(subtree, tvb, pOffset);
-}
-gint ett_opcua_ArrayTestType = -1;
-void parseArrayTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ArrayTestType", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ArrayTestType);
-  /* Array length field ignored: NoOfBooleans */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Booleans, parseBoolean);
-  /* Array length field ignored: NoOfSBytes */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_SBytes, parseSByte);
-  /* Array length field ignored: NoOfInt16s */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Int16s, parseInt16);
-  /* Array length field ignored: NoOfUInt16s */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_UInt16s, parseUInt16);
-  /* Array length field ignored: NoOfInt32s */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Int32s, parseInt32);
-  /* Array length field ignored: NoOfUInt32s */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_UInt32s, parseUInt32);
-  /* Array length field ignored: NoOfInt64s */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Int64s, parseInt64);
-  /* Array length field ignored: NoOfUInt64s */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_UInt64s, parseUInt64);
-  /* Array length field ignored: NoOfFloats */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Floats, parseFloat);
-  /* Array length field ignored: NoOfDoubles */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Doubles, parseDouble);
-  /* Array length field ignored: NoOfStrings */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Strings, parseString);
-  /* Array length field ignored: NoOfDateTimes */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_DateTimes, parseDateTime);
-  /* Array length field ignored: NoOfGuids */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Guids, parseGuid);
-  /* Array length field ignored: NoOfByteStrings */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_ByteStrings, parseByteString);
-  /* Array length field ignored: NoOfXmlElements */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_XmlElements, parseXmlElement);
-  /* Array length field ignored: NoOfNodeIds */
-  parseArrayComplex(subtree, tvb, pOffset, "NodeIds", parseNodeId);
-  /* Array length field ignored: NoOfExpandedNodeIds */
-  parseArrayComplex(subtree, tvb, pOffset, "ExpandedNodeIds", parseExpandedNodeId);
-  /* Array length field ignored: NoOfStatusCodes */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_StatusCodes, parseStatusCode);
-  /* Array length field ignored: NoOfDiagnosticInfos */
-  parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
-  /* Array length field ignored: NoOfQualifiedNames */
-  parseArrayComplex(subtree, tvb, pOffset, "QualifiedNames", parseQualifiedName);
-  /* Array length field ignored: NoOfLocalizedTexts */
-  parseArrayComplex(subtree, tvb, pOffset, "LocalizedTexts", parseLocalizedText);
-  /* Array length field ignored: NoOfExtensionObjects */
-  parseArrayComplex(subtree, tvb, pOffset, "ExtensionObjects", parseExtensionObject);
-  /* Array length field ignored: NoOfDataValues */
-  parseArrayComplex(subtree, tvb, pOffset, "DataValues", parseDataValue);
-  /* Array length field ignored: NoOfVariants */
-  parseArrayComplex(subtree, tvb, pOffset, "Variants", parseVariant);
-  /* Array length field ignored: NoOfEnumeratedValues */
-  parseArrayEnum(subtree, tvb, pOffset, parseEnumeratedTestType);
-}
-gint ett_opcua_CompositeTestType = -1;
-void parseCompositeTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : CompositeTestType", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CompositeTestType);
-  parseScalarTestType(subtree, tvb, pOffset, "Field1");
-  parseArrayTestType(subtree, tvb, pOffset, "Field2");
-}
-gint ett_opcua_RegisteredServer = -1;
-void parseRegisteredServer(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : RegisteredServer", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RegisteredServer);
-  parseString(subtree, tvb, pOffset, hf_opcua_ServerUri);
-  parseString(subtree, tvb, pOffset, hf_opcua_ProductUri);
-  /* Array length field ignored: NoOfServerNames */
-  parseArrayComplex(subtree, tvb, pOffset, "ServerNames", parseLocalizedText);
-  parseApplicationType(subtree, tvb, pOffset);
-  parseString(subtree, tvb, pOffset, hf_opcua_GatewayServerUri);
-  /* Array length field ignored: NoOfDiscoveryUrls */
-  parseArraySimple(subtree, tvb, pOffset, hf_opcua_DiscoveryUrls, parseString);
-  parseString(subtree, tvb, pOffset, hf_opcua_SemaphoreFilePath);
-  parseBoolean(subtree, tvb, pOffset, hf_opcua_IsOnline);
-}
-gint ett_opcua_ChannelSecurityToken = -1;
-void parseChannelSecurityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ChannelSecurityToken", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ChannelSecurityToken);
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_ChannelId);
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_TokenId);
-  parseDateTime(subtree, tvb, pOffset, hf_opcua_CreatedAt);
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_RevisedLifetime);
-}
-gint ett_opcua_SignatureData = -1;
-void parseSignatureData(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SignatureData", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SignatureData);
-  parseString(subtree, tvb, pOffset, hf_opcua_Algorithm);
-  parseByteString(subtree, tvb, pOffset, hf_opcua_Signature);
-}
-gint ett_opcua_AddNodesResult = -1;
-void parseAddNodesResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : AddNodesResult", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AddNodesResult);
-  parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
-  parseNodeId(subtree, tvb, pOffset, "AddedNodeId");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ViewDescription = -1;
 void parseViewDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ViewDescription", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ViewDescription", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ViewDescription);
   parseNodeId(subtree, tvb, pOffset, "ViewId");
   parseDateTime(subtree, tvb, pOffset, hf_opcua_Timestamp);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_ViewVersion);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_BrowseDescription = -1;
 void parseBrowseDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : BrowseDescription", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : BrowseDescription", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BrowseDescription);
   parseNodeId(subtree, tvb, pOffset, "NodeId");
   parseBrowseDirection(subtree, tvb, pOffset);
@@ -617,11 +655,12 @@ void parseBrowseDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, cons
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IncludeSubtypes);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_NodeClassMask);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_ResultMask);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReferenceDescription = -1;
 void parseReferenceDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ReferenceDescription", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ReferenceDescription", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReferenceDescription);
   parseNodeId(subtree, tvb, pOffset, "ReferenceTypeId");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsForward);
@@ -630,373 +669,489 @@ void parseReferenceDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, c
   parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
   parseNodeClass(subtree, tvb, pOffset);
   parseExpandedNodeId(subtree, tvb, pOffset, "TypeDefinition");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_BrowseResult = -1;
 void parseBrowseResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : BrowseResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : BrowseResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BrowseResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   parseByteString(subtree, tvb, pOffset, hf_opcua_ContinuationPoint);
   /* Array length field ignored: NoOfReferences */
   parseArrayComplex(subtree, tvb, pOffset, "References", parseReferenceDescription);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_RelativePathElement = -1;
 void parseRelativePathElement(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : RelativePathElement", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : RelativePathElement", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RelativePathElement);
   parseNodeId(subtree, tvb, pOffset, "ReferenceTypeId");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsInverse);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IncludeSubtypes);
   parseQualifiedName(subtree, tvb, pOffset, "TargetName");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_RelativePath = -1;
 void parseRelativePath(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : RelativePath", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : RelativePath", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RelativePath);
   /* Array length field ignored: NoOfElements */
   parseArrayComplex(subtree, tvb, pOffset, "Elements", parseRelativePathElement);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_BrowsePath = -1;
 void parseBrowsePath(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : BrowsePath", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : BrowsePath", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BrowsePath);
   parseNodeId(subtree, tvb, pOffset, "StartingNode");
   parseRelativePath(subtree, tvb, pOffset, "RelativePath");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_BrowsePathTarget = -1;
 void parseBrowsePathTarget(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : BrowsePathTarget", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : BrowsePathTarget", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BrowsePathTarget);
   parseExpandedNodeId(subtree, tvb, pOffset, "TargetId");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RemainingPathIndex);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_BrowsePathResult = -1;
 void parseBrowsePathResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : BrowsePathResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : BrowsePathResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BrowsePathResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   /* Array length field ignored: NoOfTargets */
   parseArrayComplex(subtree, tvb, pOffset, "Targets", parseBrowsePathTarget);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_EndpointConfiguration = -1;
+void parseEndpointConfiguration(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : EndpointConfiguration", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EndpointConfiguration);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_OperationTimeout);
+  parseBoolean(subtree, tvb, pOffset, hf_opcua_UseBinaryEncoding);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxStringLength);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxByteStringLength);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxArrayLength);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxMessageSize);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_MaxBufferSize);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_ChannelLifetime);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_SecurityTokenLifetime);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_SupportedProfile = -1;
+void parseSupportedProfile(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SupportedProfile", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SupportedProfile);
+  parseString(subtree, tvb, pOffset, hf_opcua_OrganizationUri);
+  parseString(subtree, tvb, pOffset, hf_opcua_ProfileId);
+  parseString(subtree, tvb, pOffset, hf_opcua_ComplianceTool);
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_ComplianceDate);
+  parseComplianceLevel(subtree, tvb, pOffset);
+  /* Array length field ignored: NoOfUnsupportedUnitIds */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_UnsupportedUnitIds, parseString);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_SoftwareCertificate = -1;
+void parseSoftwareCertificate(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SoftwareCertificate", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SoftwareCertificate);
+  parseString(subtree, tvb, pOffset, hf_opcua_ProductName);
+  parseString(subtree, tvb, pOffset, hf_opcua_ProductUri);
+  parseString(subtree, tvb, pOffset, hf_opcua_VendorName);
+  parseByteString(subtree, tvb, pOffset, hf_opcua_VendorProductCertificate);
+  parseString(subtree, tvb, pOffset, hf_opcua_SoftwareVersion);
+  parseString(subtree, tvb, pOffset, hf_opcua_BuildNumber);
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_BuildDate);
+  parseString(subtree, tvb, pOffset, hf_opcua_IssuedBy);
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_IssueDate);
+  /* Array length field ignored: NoOfSupportedProfiles */
+  parseArrayComplex(subtree, tvb, pOffset, "SupportedProfiles", parseSupportedProfile);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_QueryDataDescription = -1;
 void parseQueryDataDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : QueryDataDescription", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : QueryDataDescription", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_QueryDataDescription);
   parseRelativePath(subtree, tvb, pOffset, "RelativePath");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_AttributeId);
   parseString(subtree, tvb, pOffset, hf_opcua_IndexRange);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_NodeTypeDescription = -1;
 void parseNodeTypeDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : NodeTypeDescription", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : NodeTypeDescription", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_NodeTypeDescription);
   parseExpandedNodeId(subtree, tvb, pOffset, "TypeDefinitionNode");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IncludeSubTypes);
   /* Array length field ignored: NoOfDataToReturn */
   parseArrayComplex(subtree, tvb, pOffset, "DataToReturn", parseQueryDataDescription);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_QueryDataSet = -1;
 void parseQueryDataSet(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : QueryDataSet", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : QueryDataSet", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_QueryDataSet);
   parseExpandedNodeId(subtree, tvb, pOffset, "NodeId");
   parseExpandedNodeId(subtree, tvb, pOffset, "TypeDefinitionNode");
   /* Array length field ignored: NoOfValues */
   parseArrayComplex(subtree, tvb, pOffset, "Values", parseVariant);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_NodeReference = -1;
 void parseNodeReference(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : NodeReference", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : NodeReference", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_NodeReference);
   parseNodeId(subtree, tvb, pOffset, "NodeId");
   parseNodeId(subtree, tvb, pOffset, "ReferenceTypeId");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsForward);
   /* Array length field ignored: NoOfReferencedNodeIds */
   parseArrayComplex(subtree, tvb, pOffset, "ReferencedNodeIds", parseNodeId);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ContentFilterElement = -1;
 void parseContentFilterElement(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ContentFilterElement", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ContentFilterElement", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ContentFilterElement);
   parseFilterOperator(subtree, tvb, pOffset);
   /* Array length field ignored: NoOfFilterOperands */
   parseArrayComplex(subtree, tvb, pOffset, "FilterOperands", parseExtensionObject);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ContentFilter = -1;
 void parseContentFilter(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ContentFilter", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ContentFilter", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ContentFilter);
   /* Array length field ignored: NoOfElements */
   parseArrayComplex(subtree, tvb, pOffset, "Elements", parseContentFilterElement);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ElementOperand = -1;
 void parseElementOperand(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ElementOperand", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ElementOperand", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ElementOperand);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_Index);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_LiteralOperand = -1;
 void parseLiteralOperand(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : LiteralOperand", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : LiteralOperand", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_LiteralOperand);
   parseVariant(subtree, tvb, pOffset, "Value");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AttributeOperand = -1;
 void parseAttributeOperand(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : AttributeOperand", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : AttributeOperand", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AttributeOperand);
   parseNodeId(subtree, tvb, pOffset, "NodeId");
   parseString(subtree, tvb, pOffset, hf_opcua_Alias);
   parseRelativePath(subtree, tvb, pOffset, "BrowsePath");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_AttributeId);
   parseString(subtree, tvb, pOffset, hf_opcua_IndexRange);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SimpleAttributeOperand = -1;
 void parseSimpleAttributeOperand(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SimpleAttributeOperand", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SimpleAttributeOperand", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SimpleAttributeOperand);
   parseNodeId(subtree, tvb, pOffset, "TypeDefinitionId");
   /* Array length field ignored: NoOfBrowsePath */
   parseArrayComplex(subtree, tvb, pOffset, "BrowsePath", parseQualifiedName);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_AttributeId);
   parseString(subtree, tvb, pOffset, hf_opcua_IndexRange);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ContentFilterElementResult = -1;
 void parseContentFilterElementResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ContentFilterElementResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ContentFilterElementResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ContentFilterElementResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   /* Array length field ignored: NoOfOperandStatusCodes */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_OperandStatusCodes, parseStatusCode);
   /* Array length field ignored: NoOfOperandDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "OperandDiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ContentFilterResult = -1;
 void parseContentFilterResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ContentFilterResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ContentFilterResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ContentFilterResult);
   /* Array length field ignored: NoOfElementResults */
   parseArrayComplex(subtree, tvb, pOffset, "ElementResults", parseContentFilterElementResult);
   /* Array length field ignored: NoOfElementDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "ElementDiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ParsingResult = -1;
 void parseParsingResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ParsingResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ParsingResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ParsingResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   /* Array length field ignored: NoOfDataStatusCodes */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_DataStatusCodes, parseStatusCode);
   /* Array length field ignored: NoOfDataDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DataDiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReadValueId = -1;
 void parseReadValueId(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ReadValueId", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ReadValueId", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReadValueId);
   parseNodeId(subtree, tvb, pOffset, "NodeId");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_AttributeId);
   parseString(subtree, tvb, pOffset, hf_opcua_IndexRange);
   parseQualifiedName(subtree, tvb, pOffset, "DataEncoding");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryReadValueId = -1;
 void parseHistoryReadValueId(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : HistoryReadValueId", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : HistoryReadValueId", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryReadValueId);
   parseNodeId(subtree, tvb, pOffset, "NodeId");
   parseString(subtree, tvb, pOffset, hf_opcua_IndexRange);
   parseQualifiedName(subtree, tvb, pOffset, "DataEncoding");
   parseByteString(subtree, tvb, pOffset, hf_opcua_ContinuationPoint);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryReadResult = -1;
 void parseHistoryReadResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : HistoryReadResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : HistoryReadResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryReadResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   parseByteString(subtree, tvb, pOffset, hf_opcua_ContinuationPoint);
   parseExtensionObject(subtree, tvb, pOffset, "HistoryData");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReadEventDetails = -1;
 void parseReadEventDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ReadEventDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ReadEventDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReadEventDetails);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_NumValuesPerNode);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_StartTime);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_EndTime);
   parseEventFilter(subtree, tvb, pOffset, "Filter");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReadRawModifiedDetails = -1;
 void parseReadRawModifiedDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ReadRawModifiedDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ReadRawModifiedDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReadRawModifiedDetails);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsReadModified);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_StartTime);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_EndTime);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_NumValuesPerNode);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_ReturnBounds);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReadProcessedDetails = -1;
 void parseReadProcessedDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ReadProcessedDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ReadProcessedDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReadProcessedDetails);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_StartTime);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_EndTime);
-  parseDouble(subtree, tvb, pOffset, hf_opcua_ResampleInterval);
+  parseDouble(subtree, tvb, pOffset, hf_opcua_ProcessingInterval);
   /* Array length field ignored: NoOfAggregateType */
   parseArrayComplex(subtree, tvb, pOffset, "AggregateType", parseNodeId);
   parseAggregateConfiguration(subtree, tvb, pOffset, "AggregateConfiguration");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReadAtTimeDetails = -1;
 void parseReadAtTimeDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ReadAtTimeDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ReadAtTimeDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReadAtTimeDetails);
   /* Array length field ignored: NoOfReqTimes */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_ReqTimes, parseDateTime);
+  parseBoolean(subtree, tvb, pOffset, hf_opcua_UseSimpleBounds);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryData = -1;
 void parseHistoryData(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : HistoryData", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : HistoryData", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryData);
   /* Array length field ignored: NoOfDataValues */
   parseArrayComplex(subtree, tvb, pOffset, "DataValues", parseDataValue);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_ModificationInfo = -1;
+void parseModificationInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ModificationInfo", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ModificationInfo);
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_ModificationTime);
+  parseHistoryUpdateType(subtree, tvb, pOffset);
+  parseString(subtree, tvb, pOffset, hf_opcua_UserName);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_HistoryModifiedData = -1;
+void parseHistoryModifiedData(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : HistoryModifiedData", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryModifiedData);
+  /* Array length field ignored: NoOfDataValues */
+  parseArrayComplex(subtree, tvb, pOffset, "DataValues", parseDataValue);
+  /* Array length field ignored: NoOfModificationInfos */
+  parseArrayComplex(subtree, tvb, pOffset, "ModificationInfos", parseModificationInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryEvent = -1;
 void parseHistoryEvent(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : HistoryEvent", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : HistoryEvent", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryEvent);
   /* Array length field ignored: NoOfEvents */
   parseArrayComplex(subtree, tvb, pOffset, "Events", parseHistoryEventFieldList);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_WriteValue = -1;
 void parseWriteValue(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : WriteValue", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : WriteValue", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_WriteValue);
   parseNodeId(subtree, tvb, pOffset, "NodeId");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_AttributeId);
   parseString(subtree, tvb, pOffset, hf_opcua_IndexRange);
   parseDataValue(subtree, tvb, pOffset, "Value");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryUpdateDetails = -1;
 void parseHistoryUpdateDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : HistoryUpdateDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : HistoryUpdateDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryUpdateDetails);
   parseNodeId(subtree, tvb, pOffset, "NodeId");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_UpdateDataDetails = -1;
 void parseUpdateDataDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : UpdateDataDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : UpdateDataDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_UpdateDataDetails);
-  parseHistoryUpdateMode(subtree, tvb, pOffset);
-  parseHistoryData(subtree, tvb, pOffset, "UpdateValue");
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parsePerformUpdateType(subtree, tvb, pOffset);
+  /* Array length field ignored: NoOfUpdateValues */
+  parseArrayComplex(subtree, tvb, pOffset, "UpdateValues", parseDataValue);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
-gint ett_opcua_InsertReplaceEventDetails = -1;
-void parseInsertReplaceEventDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+gint ett_opcua_UpdateStructureDataDetails = -1;
+void parseUpdateStructureDataDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : InsertReplaceEventDetails", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_InsertReplaceEventDetails);
-  parseHistoryUpdateMode(subtree, tvb, pOffset);
-  /* Array length field ignored: NoOfSelectClause */
-  parseArrayComplex(subtree, tvb, pOffset, "SelectClause", parseSimpleAttributeOperand);
-  /* Array length field ignored: NoOfEventData */
-  parseArrayComplex(subtree, tvb, pOffset, "EventData", parseHistoryEventFieldList);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : UpdateStructureDataDetails", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_UpdateStructureDataDetails);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parsePerformUpdateType(subtree, tvb, pOffset);
+  /* Array length field ignored: NoOfUpdateValues */
+  parseArrayComplex(subtree, tvb, pOffset, "UpdateValues", parseDataValue);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_UpdateEventDetails = -1;
 void parseUpdateEventDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : UpdateEventDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : UpdateEventDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_UpdateEventDetails);
-  parseHistoryUpdateMode(subtree, tvb, pOffset);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parsePerformUpdateType(subtree, tvb, pOffset);
   parseEventFilter(subtree, tvb, pOffset, "Filter");
   parseHistoryEventFieldList(subtree, tvb, pOffset, "EventData");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteRawModifiedDetails = -1;
 void parseDeleteRawModifiedDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : DeleteRawModifiedDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DeleteRawModifiedDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteRawModifiedDetails);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_IsDeleteModified);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_StartTime);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_EndTime);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteAtTimeDetails = -1;
 void parseDeleteAtTimeDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : DeleteAtTimeDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DeleteAtTimeDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteAtTimeDetails);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
   /* Array length field ignored: NoOfReqTimes */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_ReqTimes, parseDateTime);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteEventDetails = -1;
 void parseDeleteEventDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : DeleteEventDetails", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DeleteEventDetails", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteEventDetails);
-  parseByteString(subtree, tvb, pOffset, hf_opcua_EventIds);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  /* Array length field ignored: NoOfEventIds */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_EventIds, parseByteString);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryUpdateResult = -1;
 void parseHistoryUpdateResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : HistoryUpdateResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : HistoryUpdateResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryUpdateResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   /* Array length field ignored: NoOfOperationResults */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_OperationResults, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryUpdateEventResult = -1;
 void parseHistoryUpdateEventResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : HistoryUpdateEventResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : HistoryUpdateEventResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryUpdateEventResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   parseEventFilterResult(subtree, tvb, pOffset, "EventFilterResult");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CallMethodRequest = -1;
 void parseCallMethodRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : CallMethodRequest", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : CallMethodRequest", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CallMethodRequest);
   parseNodeId(subtree, tvb, pOffset, "ObjectId");
   parseNodeId(subtree, tvb, pOffset, "MethodId");
   /* Array length field ignored: NoOfInputArguments */
   parseArrayComplex(subtree, tvb, pOffset, "InputArguments", parseVariant);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CallMethodResult = -1;
 void parseCallMethodResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : CallMethodResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : CallMethodResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CallMethodResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   /* Array length field ignored: NoOfInputArgumentResults */
@@ -1005,216 +1160,369 @@ void parseCallMethodResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const
   parseArrayComplex(subtree, tvb, pOffset, "InputArgumentDiagnosticInfos", parseDiagnosticInfo);
   /* Array length field ignored: NoOfOutputArguments */
   parseArrayComplex(subtree, tvb, pOffset, "OutputArguments", parseVariant);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DataChangeFilter = -1;
 void parseDataChangeFilter(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : DataChangeFilter", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DataChangeFilter", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DataChangeFilter);
   parseDataChangeTrigger(subtree, tvb, pOffset);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_DeadbandType);
   parseDouble(subtree, tvb, pOffset, hf_opcua_DeadbandValue);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_EventFilter = -1;
 void parseEventFilter(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : EventFilter", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : EventFilter", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EventFilter);
   /* Array length field ignored: NoOfSelectClauses */
   parseArrayComplex(subtree, tvb, pOffset, "SelectClauses", parseSimpleAttributeOperand);
   parseContentFilter(subtree, tvb, pOffset, "WhereClause");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AggregateConfiguration = -1;
 void parseAggregateConfiguration(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : AggregateConfiguration", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : AggregateConfiguration", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AggregateConfiguration);
-  parseBoolean(subtree, tvb, pOffset, hf_opcua_UseSeverCapabilitiesDefaults);
+  parseBoolean(subtree, tvb, pOffset, hf_opcua_UseServerCapabilitiesDefaults);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_TreatUncertainAsBad);
   parseByte(subtree, tvb, pOffset, hf_opcua_PercentDataBad);
   parseByte(subtree, tvb, pOffset, hf_opcua_PercentDataGood);
-  parseBoolean(subtree, tvb, pOffset, hf_opcua_SteppedSlopedExtrapolation);
+  parseBoolean(subtree, tvb, pOffset, hf_opcua_UseSlopedExtrapolation);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AggregateFilter = -1;
 void parseAggregateFilter(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : AggregateFilter", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : AggregateFilter", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AggregateFilter);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_StartTime);
   parseNodeId(subtree, tvb, pOffset, "AggregateType");
   parseDouble(subtree, tvb, pOffset, hf_opcua_ProcessingInterval);
   parseAggregateConfiguration(subtree, tvb, pOffset, "AggregateConfiguration");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_EventFilterResult = -1;
 void parseEventFilterResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : EventFilterResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : EventFilterResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EventFilterResult);
   /* Array length field ignored: NoOfSelectClauseResults */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_SelectClauseResults, parseStatusCode);
   /* Array length field ignored: NoOfSelectClauseDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "SelectClauseDiagnosticInfos", parseDiagnosticInfo);
   parseContentFilterResult(subtree, tvb, pOffset, "WhereClauseResult");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AggregateFilterResult = -1;
 void parseAggregateFilterResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : AggregateFilterResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : AggregateFilterResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AggregateFilterResult);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_RevisedStartTime);
   parseDouble(subtree, tvb, pOffset, hf_opcua_RevisedProcessingInterval);
   parseAggregateConfiguration(subtree, tvb, pOffset, "RevisedAggregateConfiguration");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_MonitoringParameters = -1;
 void parseMonitoringParameters(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : MonitoringParameters", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : MonitoringParameters", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_MonitoringParameters);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_ClientHandle);
   parseDouble(subtree, tvb, pOffset, hf_opcua_SamplingInterval);
   parseExtensionObject(subtree, tvb, pOffset, "Filter");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_QueueSize);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_DiscardOldest);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_MonitoredItemCreateRequest = -1;
 void parseMonitoredItemCreateRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : MonitoredItemCreateRequest", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : MonitoredItemCreateRequest", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_MonitoredItemCreateRequest);
   parseReadValueId(subtree, tvb, pOffset, "ItemToMonitor");
   parseMonitoringMode(subtree, tvb, pOffset);
   parseMonitoringParameters(subtree, tvb, pOffset, "RequestedParameters");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_MonitoredItemCreateResult = -1;
 void parseMonitoredItemCreateResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : MonitoredItemCreateResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : MonitoredItemCreateResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_MonitoredItemCreateResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MonitoredItemId);
   parseDouble(subtree, tvb, pOffset, hf_opcua_RevisedSamplingInterval);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RevisedQueueSize);
   parseExtensionObject(subtree, tvb, pOffset, "FilterResult");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_MonitoredItemModifyRequest = -1;
 void parseMonitoredItemModifyRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : MonitoredItemModifyRequest", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : MonitoredItemModifyRequest", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_MonitoredItemModifyRequest);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MonitoredItemId);
   parseMonitoringParameters(subtree, tvb, pOffset, "RequestedParameters");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_MonitoredItemModifyResult = -1;
 void parseMonitoredItemModifyResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : MonitoredItemModifyResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : MonitoredItemModifyResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_MonitoredItemModifyResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   parseDouble(subtree, tvb, pOffset, hf_opcua_RevisedSamplingInterval);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RevisedQueueSize);
   parseExtensionObject(subtree, tvb, pOffset, "FilterResult");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_NotificationMessage = -1;
 void parseNotificationMessage(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : NotificationMessage", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : NotificationMessage", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_NotificationMessage);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_SequenceNumber);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_PublishTime);
   /* Array length field ignored: NoOfNotificationData */
   parseArrayComplex(subtree, tvb, pOffset, "NotificationData", parseExtensionObject);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DataChangeNotification = -1;
 void parseDataChangeNotification(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : DataChangeNotification", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DataChangeNotification", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DataChangeNotification);
   /* Array length field ignored: NoOfMonitoredItems */
   parseArrayComplex(subtree, tvb, pOffset, "MonitoredItems", parseMonitoredItemNotification);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_MonitoredItemNotification = -1;
 void parseMonitoredItemNotification(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : MonitoredItemNotification", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : MonitoredItemNotification", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_MonitoredItemNotification);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_ClientHandle);
   parseDataValue(subtree, tvb, pOffset, "Value");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_EventNotificationList = -1;
 void parseEventNotificationList(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : EventNotificationList", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : EventNotificationList", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EventNotificationList);
   /* Array length field ignored: NoOfEvents */
   parseArrayComplex(subtree, tvb, pOffset, "Events", parseEventFieldList);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_EventFieldList = -1;
 void parseEventFieldList(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : EventFieldList", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : EventFieldList", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EventFieldList);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_ClientHandle);
   /* Array length field ignored: NoOfEventFields */
   parseArrayComplex(subtree, tvb, pOffset, "EventFields", parseVariant);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryEventFieldList = -1;
 void parseHistoryEventFieldList(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : HistoryEventFieldList", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : HistoryEventFieldList", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryEventFieldList);
   /* Array length field ignored: NoOfEventFields */
   parseArrayComplex(subtree, tvb, pOffset, "EventFields", parseVariant);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_StatusChangeNotification = -1;
 void parseStatusChangeNotification(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : StatusChangeNotification", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : StatusChangeNotification", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_StatusChangeNotification);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_Status);
   parseDiagnosticInfo(subtree, tvb, pOffset, "DiagnosticInfo");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SubscriptionAcknowledgement = -1;
 void parseSubscriptionAcknowledgement(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SubscriptionAcknowledgement", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SubscriptionAcknowledgement", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SubscriptionAcknowledgement);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_SubscriptionId);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_SequenceNumber);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_TransferResult = -1;
 void parseTransferResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : TransferResult", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : TransferResult", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TransferResult);
   parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
   /* Array length field ignored: NoOfAvailableSequenceNumbers */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_AvailableSequenceNumbers, parseUInt32);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_ScalarTestType = -1;
+void parseScalarTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ScalarTestType", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ScalarTestType);
+  parseBoolean(subtree, tvb, pOffset, hf_opcua_Boolean);
+  parseSByte(subtree, tvb, pOffset, hf_opcua_SByte);
+  parseByte(subtree, tvb, pOffset, hf_opcua_Byte);
+  parseInt16(subtree, tvb, pOffset, hf_opcua_Int16);
+  parseUInt16(subtree, tvb, pOffset, hf_opcua_UInt16);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_Int32);
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_UInt32);
+  parseInt64(subtree, tvb, pOffset, hf_opcua_Int64);
+  parseUInt64(subtree, tvb, pOffset, hf_opcua_UInt64);
+  parseFloat(subtree, tvb, pOffset, hf_opcua_Float);
+  parseDouble(subtree, tvb, pOffset, hf_opcua_Double);
+  parseString(subtree, tvb, pOffset, hf_opcua_String);
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_DateTime);
+  parseGuid(subtree, tvb, pOffset, hf_opcua_Guid);
+  parseByteString(subtree, tvb, pOffset, hf_opcua_ByteString);
+  parseXmlElement(subtree, tvb, pOffset, hf_opcua_XmlElement);
+  parseNodeId(subtree, tvb, pOffset, "NodeId");
+  parseExpandedNodeId(subtree, tvb, pOffset, "ExpandedNodeId");
+  parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
+  parseDiagnosticInfo(subtree, tvb, pOffset, "DiagnosticInfo");
+  parseQualifiedName(subtree, tvb, pOffset, "QualifiedName");
+  parseLocalizedText(subtree, tvb, pOffset, "LocalizedText");
+  parseExtensionObject(subtree, tvb, pOffset, "ExtensionObject");
+  parseDataValue(subtree, tvb, pOffset, "DataValue");
+  parseEnumeratedTestType(subtree, tvb, pOffset);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_ArrayTestType = -1;
+void parseArrayTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ArrayTestType", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ArrayTestType);
+  /* Array length field ignored: NoOfBooleans */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Booleans, parseBoolean);
+  /* Array length field ignored: NoOfSBytes */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_SBytes, parseSByte);
+  /* Array length field ignored: NoOfInt16s */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Int16s, parseInt16);
+  /* Array length field ignored: NoOfUInt16s */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_UInt16s, parseUInt16);
+  /* Array length field ignored: NoOfInt32s */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Int32s, parseInt32);
+  /* Array length field ignored: NoOfUInt32s */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_UInt32s, parseUInt32);
+  /* Array length field ignored: NoOfInt64s */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Int64s, parseInt64);
+  /* Array length field ignored: NoOfUInt64s */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_UInt64s, parseUInt64);
+  /* Array length field ignored: NoOfFloats */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Floats, parseFloat);
+  /* Array length field ignored: NoOfDoubles */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Doubles, parseDouble);
+  /* Array length field ignored: NoOfStrings */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Strings, parseString);
+  /* Array length field ignored: NoOfDateTimes */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_DateTimes, parseDateTime);
+  /* Array length field ignored: NoOfGuids */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_Guids, parseGuid);
+  /* Array length field ignored: NoOfByteStrings */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_ByteStrings, parseByteString);
+  /* Array length field ignored: NoOfXmlElements */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_XmlElements, parseXmlElement);
+  /* Array length field ignored: NoOfNodeIds */
+  parseArrayComplex(subtree, tvb, pOffset, "NodeIds", parseNodeId);
+  /* Array length field ignored: NoOfExpandedNodeIds */
+  parseArrayComplex(subtree, tvb, pOffset, "ExpandedNodeIds", parseExpandedNodeId);
+  /* Array length field ignored: NoOfStatusCodes */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_StatusCodes, parseStatusCode);
+  /* Array length field ignored: NoOfDiagnosticInfos */
+  parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  /* Array length field ignored: NoOfQualifiedNames */
+  parseArrayComplex(subtree, tvb, pOffset, "QualifiedNames", parseQualifiedName);
+  /* Array length field ignored: NoOfLocalizedTexts */
+  parseArrayComplex(subtree, tvb, pOffset, "LocalizedTexts", parseLocalizedText);
+  /* Array length field ignored: NoOfExtensionObjects */
+  parseArrayComplex(subtree, tvb, pOffset, "ExtensionObjects", parseExtensionObject);
+  /* Array length field ignored: NoOfDataValues */
+  parseArrayComplex(subtree, tvb, pOffset, "DataValues", parseDataValue);
+  /* Array length field ignored: NoOfVariants */
+  parseArrayComplex(subtree, tvb, pOffset, "Variants", parseVariant);
+  /* Array length field ignored: NoOfEnumeratedValues */
+  parseArrayEnum(subtree, tvb, pOffset, parseEnumeratedTestType);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_CompositeTestType = -1;
+void parseCompositeTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : CompositeTestType", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CompositeTestType);
+  parseScalarTestType(subtree, tvb, pOffset, "Field1");
+  parseArrayTestType(subtree, tvb, pOffset, "Field2");
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_BuildInfo = -1;
+void parseBuildInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : BuildInfo", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BuildInfo);
+  parseString(subtree, tvb, pOffset, hf_opcua_ProductUri);
+  parseString(subtree, tvb, pOffset, hf_opcua_ManufacturerName);
+  parseString(subtree, tvb, pOffset, hf_opcua_ProductName);
+  parseString(subtree, tvb, pOffset, hf_opcua_SoftwareVersion);
+  parseString(subtree, tvb, pOffset, hf_opcua_BuildNumber);
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_BuildDate);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_RedundantServerDataType = -1;
 void parseRedundantServerDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : RedundantServerDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : RedundantServerDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RedundantServerDataType);
   parseString(subtree, tvb, pOffset, hf_opcua_ServerId);
   parseByte(subtree, tvb, pOffset, hf_opcua_ServiceLevel);
   parseServerState(subtree, tvb, pOffset);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_EndpointUrlListDataType = -1;
+void parseEndpointUrlListDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : EndpointUrlListDataType", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EndpointUrlListDataType);
+  /* Array length field ignored: NoOfEndpointUrlList */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_EndpointUrlList, parseString);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_NetworkGroupDataType = -1;
+void parseNetworkGroupDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : NetworkGroupDataType", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_NetworkGroupDataType);
+  parseString(subtree, tvb, pOffset, hf_opcua_ServerUri);
+  /* Array length field ignored: NoOfNetworkPaths */
+  parseArrayComplex(subtree, tvb, pOffset, "NetworkPaths", parseEndpointUrlListDataType);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SamplingIntervalDiagnosticsDataType = -1;
 void parseSamplingIntervalDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SamplingIntervalDiagnosticsDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SamplingIntervalDiagnosticsDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SamplingIntervalDiagnosticsDataType);
   parseDouble(subtree, tvb, pOffset, hf_opcua_SamplingInterval);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MonitoredItemCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MaxMonitoredItemCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_DisabledMonitoredItemCount);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ServerDiagnosticsSummaryDataType = -1;
 void parseServerDiagnosticsSummaryDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ServerDiagnosticsSummaryDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ServerDiagnosticsSummaryDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ServerDiagnosticsSummaryDataType);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_ServerViewCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_CurrentSessionCount);
@@ -1228,11 +1536,12 @@ void parseServerDiagnosticsSummaryDataType(proto_tree *tree, tvbuff_t *tvb, gint
   parseUInt32(subtree, tvb, pOffset, hf_opcua_PublishingIntervalCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_SecurityRejectedRequestsCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RejectedRequestsCount);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ServerStatusDataType = -1;
 void parseServerStatusDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ServerStatusDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ServerStatusDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ServerStatusDataType);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_StartTime);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_CurrentTime);
@@ -1240,11 +1549,12 @@ void parseServerStatusDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, c
   parseBuildInfo(subtree, tvb, pOffset, "BuildInfo");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_SecondsTillShutdown);
   parseLocalizedText(subtree, tvb, pOffset, "ShutdownReason");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SessionDiagnosticsDataType = -1;
 void parseSessionDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SessionDiagnosticsDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SessionDiagnosticsDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SessionDiagnosticsDataType);
   parseNodeId(subtree, tvb, pOffset, "SessionId");
   parseString(subtree, tvb, pOffset, hf_opcua_SessionName);
@@ -1290,11 +1600,12 @@ void parseSessionDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOff
   parseServiceCounterDataType(subtree, tvb, pOffset, "QueryNextCount");
   parseServiceCounterDataType(subtree, tvb, pOffset, "RegisterNodesCount");
   parseServiceCounterDataType(subtree, tvb, pOffset, "UnregisterNodesCount");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SessionSecurityDiagnosticsDataType = -1;
 void parseSessionSecurityDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SessionSecurityDiagnosticsDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SessionSecurityDiagnosticsDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SessionSecurityDiagnosticsDataType);
   parseNodeId(subtree, tvb, pOffset, "SessionId");
   parseString(subtree, tvb, pOffset, hf_opcua_ClientUserIdOfSession);
@@ -1306,19 +1617,30 @@ void parseSessionSecurityDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gi
   parseMessageSecurityMode(subtree, tvb, pOffset);
   parseString(subtree, tvb, pOffset, hf_opcua_SecurityPolicyUri);
   parseByteString(subtree, tvb, pOffset, hf_opcua_ClientCertificate);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ServiceCounterDataType = -1;
 void parseServiceCounterDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ServiceCounterDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ServiceCounterDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ServiceCounterDataType);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_TotalCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_ErrorCount);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_StatusResult = -1;
+void parseStatusResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : StatusResult", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_StatusResult);
+  parseStatusCode(subtree, tvb, pOffset, hf_opcua_StatusCode);
+  parseDiagnosticInfo(subtree, tvb, pOffset, "DiagnosticInfo");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SubscriptionDiagnosticsDataType = -1;
 void parseSubscriptionDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SubscriptionDiagnosticsDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SubscriptionDiagnosticsDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SubscriptionDiagnosticsDataType);
   parseNodeId(subtree, tvb, pOffset, "SessionId");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_SubscriptionId);
@@ -1351,55 +1673,91 @@ void parseSubscriptionDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MonitoringQueueOverflowCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_NextSequenceNumber);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_EventQueueOverFlowCount);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ModelChangeStructureDataType = -1;
 void parseModelChangeStructureDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ModelChangeStructureDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ModelChangeStructureDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ModelChangeStructureDataType);
   parseNodeId(subtree, tvb, pOffset, "Affected");
   parseNodeId(subtree, tvb, pOffset, "AffectedType");
   parseByte(subtree, tvb, pOffset, hf_opcua_Verb);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SemanticChangeStructureDataType = -1;
 void parseSemanticChangeStructureDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : SemanticChangeStructureDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : SemanticChangeStructureDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SemanticChangeStructureDataType);
   parseNodeId(subtree, tvb, pOffset, "Affected");
   parseNodeId(subtree, tvb, pOffset, "AffectedType");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_Range = -1;
 void parseRange(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : Range", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : Range", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_Range);
   parseDouble(subtree, tvb, pOffset, hf_opcua_Low);
   parseDouble(subtree, tvb, pOffset, hf_opcua_High);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_EUInformation = -1;
 void parseEUInformation(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : EUInformation", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : EUInformation", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_EUInformation);
   parseString(subtree, tvb, pOffset, hf_opcua_NamespaceUri);
   parseInt32(subtree, tvb, pOffset, hf_opcua_UnitId);
   parseLocalizedText(subtree, tvb, pOffset, "DisplayName");
   parseLocalizedText(subtree, tvb, pOffset, "Description");
-}
-gint ett_opcua_Annotation = -1;
-void parseAnnotation(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : Annotation", szFieldName);
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_Annotation);
-  parseString(subtree, tvb, pOffset, hf_opcua_Message);
-  parseString(subtree, tvb, pOffset, hf_opcua_UserName);
-  parseDateTime(subtree, tvb, pOffset, hf_opcua_AnnotationTime);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_ComplexNumberType = -1;
+void parseComplexNumberType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ComplexNumberType", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ComplexNumberType);
+  parseFloat(subtree, tvb, pOffset, hf_opcua_Real);
+  parseFloat(subtree, tvb, pOffset, hf_opcua_Imaginary);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_DoubleComplexNumberType = -1;
+void parseDoubleComplexNumberType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : DoubleComplexNumberType", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DoubleComplexNumberType);
+  parseDouble(subtree, tvb, pOffset, hf_opcua_Real);
+  parseDouble(subtree, tvb, pOffset, hf_opcua_Imaginary);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_AxisInformation = -1;
+void parseAxisInformation(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : AxisInformation", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AxisInformation);
+  parseEUInformation(subtree, tvb, pOffset, "EngineeringUnits");
+  parseRange(subtree, tvb, pOffset, "EURange");
+  parseLocalizedText(subtree, tvb, pOffset, "Title");
+  parseAxisScaleEnumeration(subtree, tvb, pOffset);
+  /* Array length field ignored: NoOfAxisSteps */
+  parseArraySimple(subtree, tvb, pOffset, hf_opcua_AxisSteps, parseDouble);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_XVType = -1;
+void parseXVType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : XVType", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_XVType);
+  parseDouble(subtree, tvb, pOffset, hf_opcua_X);
+  parseFloat(subtree, tvb, pOffset, hf_opcua_Value);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ProgramDiagnosticDataType = -1;
 void parseProgramDiagnosticDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ProgramDiagnosticDataType", szFieldName);
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ProgramDiagnosticDataType", szFieldName);
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ProgramDiagnosticDataType);
   parseNodeId(subtree, tvb, pOffset, "CreateSessionId");
   parseString(subtree, tvb, pOffset, hf_opcua_CreateClientName);
@@ -1413,12 +1771,25 @@ void parseProgramDiagnosticDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffs
   parseArrayComplex(subtree, tvb, pOffset, "LastMethodOutputArguments", parseArgument);
   parseDateTime(subtree, tvb, pOffset, hf_opcua_LastMethodCallTime);
   parseStatusResult(subtree, tvb, pOffset, "LastMethodReturnStatus");
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_Annotation = -1;
+void parseAnnotation(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : Annotation", szFieldName);
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_Annotation);
+  parseString(subtree, tvb, pOffset, hf_opcua_Message);
+  parseString(subtree, tvb, pOffset, hf_opcua_UserName);
+  parseDateTime(subtree, tvb, pOffset, hf_opcua_AnnotationTime);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 
 /** Setup protocol subtree array */
 static gint *ett[] =
 {
   &ett_opcua_Node,
+  &ett_opcua_InstanceNode,
+  &ett_opcua_TypeNode,
   &ett_opcua_ObjectNode,
   &ett_opcua_ObjectTypeNode,
   &ett_opcua_VariableNode,
@@ -1429,21 +1800,23 @@ static gint *ett[] =
   &ett_opcua_DataTypeNode,
   &ett_opcua_ReferenceNode,
   &ett_opcua_Argument,
+  &ett_opcua_EnumValueType,
   &ett_opcua_TimeZoneDataType,
-  &ett_opcua_EnumValueInfo,
-  &ett_opcua_StatusResult,
-  &ett_opcua_UserTokenPolicy,
   &ett_opcua_ApplicationDescription,
+  &ett_opcua_RequestHeader,
+  &ett_opcua_ResponseHeader,
+  &ett_opcua_ServiceFault,
+  &ett_opcua_UserTokenPolicy,
   &ett_opcua_EndpointDescription,
+  &ett_opcua_RegisteredServer,
+  &ett_opcua_ChannelSecurityToken,
+  &ett_opcua_SignedSoftwareCertificate,
+  &ett_opcua_SignatureData,
   &ett_opcua_UserIdentityToken,
+  &ett_opcua_AnonymousIdentityToken,
   &ett_opcua_UserNameIdentityToken,
   &ett_opcua_X509IdentityToken,
   &ett_opcua_IssuedIdentityToken,
-  &ett_opcua_EndpointConfiguration,
-  &ett_opcua_SupportedProfile,
-  &ett_opcua_BuildInfo,
-  &ett_opcua_SoftwareCertificate,
-  &ett_opcua_SignedSoftwareCertificate,
   &ett_opcua_NodeAttributes,
   &ett_opcua_ObjectAttributes,
   &ett_opcua_VariableAttributes,
@@ -1454,19 +1827,10 @@ static gint *ett[] =
   &ett_opcua_DataTypeAttributes,
   &ett_opcua_ViewAttributes,
   &ett_opcua_AddNodesItem,
+  &ett_opcua_AddNodesResult,
   &ett_opcua_AddReferencesItem,
   &ett_opcua_DeleteNodesItem,
   &ett_opcua_DeleteReferencesItem,
-  &ett_opcua_RequestHeader,
-  &ett_opcua_ResponseHeader,
-  &ett_opcua_ServiceFault,
-  &ett_opcua_ScalarTestType,
-  &ett_opcua_ArrayTestType,
-  &ett_opcua_CompositeTestType,
-  &ett_opcua_RegisteredServer,
-  &ett_opcua_ChannelSecurityToken,
-  &ett_opcua_SignatureData,
-  &ett_opcua_AddNodesResult,
   &ett_opcua_ViewDescription,
   &ett_opcua_BrowseDescription,
   &ett_opcua_ReferenceDescription,
@@ -1476,6 +1840,9 @@ static gint *ett[] =
   &ett_opcua_BrowsePath,
   &ett_opcua_BrowsePathTarget,
   &ett_opcua_BrowsePathResult,
+  &ett_opcua_EndpointConfiguration,
+  &ett_opcua_SupportedProfile,
+  &ett_opcua_SoftwareCertificate,
   &ett_opcua_QueryDataDescription,
   &ett_opcua_NodeTypeDescription,
   &ett_opcua_QueryDataSet,
@@ -1497,11 +1864,13 @@ static gint *ett[] =
   &ett_opcua_ReadProcessedDetails,
   &ett_opcua_ReadAtTimeDetails,
   &ett_opcua_HistoryData,
+  &ett_opcua_ModificationInfo,
+  &ett_opcua_HistoryModifiedData,
   &ett_opcua_HistoryEvent,
   &ett_opcua_WriteValue,
   &ett_opcua_HistoryUpdateDetails,
   &ett_opcua_UpdateDataDetails,
-  &ett_opcua_InsertReplaceEventDetails,
+  &ett_opcua_UpdateStructureDataDetails,
   &ett_opcua_UpdateEventDetails,
   &ett_opcua_DeleteRawModifiedDetails,
   &ett_opcua_DeleteAtTimeDetails,
@@ -1530,20 +1899,31 @@ static gint *ett[] =
   &ett_opcua_StatusChangeNotification,
   &ett_opcua_SubscriptionAcknowledgement,
   &ett_opcua_TransferResult,
+  &ett_opcua_ScalarTestType,
+  &ett_opcua_ArrayTestType,
+  &ett_opcua_CompositeTestType,
+  &ett_opcua_BuildInfo,
   &ett_opcua_RedundantServerDataType,
+  &ett_opcua_EndpointUrlListDataType,
+  &ett_opcua_NetworkGroupDataType,
   &ett_opcua_SamplingIntervalDiagnosticsDataType,
   &ett_opcua_ServerDiagnosticsSummaryDataType,
   &ett_opcua_ServerStatusDataType,
   &ett_opcua_SessionDiagnosticsDataType,
   &ett_opcua_SessionSecurityDiagnosticsDataType,
   &ett_opcua_ServiceCounterDataType,
+  &ett_opcua_StatusResult,
   &ett_opcua_SubscriptionDiagnosticsDataType,
   &ett_opcua_ModelChangeStructureDataType,
   &ett_opcua_SemanticChangeStructureDataType,
   &ett_opcua_Range,
   &ett_opcua_EUInformation,
-  &ett_opcua_Annotation,
+  &ett_opcua_ComplexNumberType,
+  &ett_opcua_DoubleComplexNumberType,
+  &ett_opcua_AxisInformation,
+  &ett_opcua_XVType,
   &ett_opcua_ProgramDiagnosticDataType,
+  &ett_opcua_Annotation,
 };
 
 void registerComplexTypes(void)
diff --git a/plugins/opcua/opcua_complextypeparser.h b/plugins/opcua/opcua_complextypeparser.h
index 9ca1a54ae8..13492208b8 100644
--- a/plugins/opcua/opcua_complextypeparser.h
+++ b/plugins/opcua/opcua_complextypeparser.h
@@ -16,7 +16,7 @@
 **
 ** Description: OpcUa Complex Type Parser
 **
-** This file was autogenerated on 31.03.2009.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 ** XXX - well, except that you may have to.  See the README.
 **
@@ -27,6 +27,8 @@
 
 
 void parseNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseInstanceNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseTypeNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseObjectNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseObjectTypeNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseVariableNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
@@ -37,21 +39,23 @@ void parseViewNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *s
 void parseDataTypeNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseReferenceNode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseArgument(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseEnumValueType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseTimeZoneDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseEnumValueInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseStatusResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseUserTokenPolicy(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseApplicationDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseRequestHeader(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseResponseHeader(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseServiceFault(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseUserTokenPolicy(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseEndpointDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseRegisteredServer(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseChannelSecurityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseSignedSoftwareCertificate(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseSignatureData(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseUserIdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseAnonymousIdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseUserNameIdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseX509IdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseIssuedIdentityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseEndpointConfiguration(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseSupportedProfile(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseBuildInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseSoftwareCertificate(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseSignedSoftwareCertificate(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseNodeAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseObjectAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseVariableAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
@@ -62,19 +66,10 @@ void parseReferenceTypeAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset
 void parseDataTypeAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseViewAttributes(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseAddNodesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseAddNodesResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseAddReferencesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseDeleteNodesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseDeleteReferencesItem(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseRequestHeader(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseResponseHeader(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseServiceFault(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseScalarTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseArrayTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseCompositeTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseRegisteredServer(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseChannelSecurityToken(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseSignatureData(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseAddNodesResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseViewDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseBrowseDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseReferenceDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
@@ -84,6 +79,9 @@ void parseRelativePath(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const cha
 void parseBrowsePath(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseBrowsePathTarget(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseBrowsePathResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseEndpointConfiguration(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseSupportedProfile(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseSoftwareCertificate(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseQueryDataDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseNodeTypeDescription(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseQueryDataSet(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
@@ -105,11 +103,13 @@ void parseReadRawModifiedDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset,
 void parseReadProcessedDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseReadAtTimeDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseHistoryData(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseModificationInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseHistoryModifiedData(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseHistoryEvent(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseWriteValue(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseHistoryUpdateDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseUpdateDataDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseInsertReplaceEventDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseUpdateStructureDataDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseUpdateEventDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseDeleteRawModifiedDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseDeleteAtTimeDetails(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
@@ -138,19 +138,30 @@ void parseHistoryEventFieldList(proto_tree *tree, tvbuff_t *tvb, gint *pOffset,
 void parseStatusChangeNotification(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseSubscriptionAcknowledgement(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseTransferResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseScalarTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseArrayTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseCompositeTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseBuildInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseRedundantServerDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseEndpointUrlListDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseNetworkGroupDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseSamplingIntervalDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseServerDiagnosticsSummaryDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseServerStatusDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseSessionDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseSessionSecurityDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseServiceCounterDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseStatusResult(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseSubscriptionDiagnosticsDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseModelChangeStructureDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseSemanticChangeStructureDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseRange(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseEUInformation(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
-void parseAnnotation(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseComplexNumberType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseDoubleComplexNumberType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseAxisInformation(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseXVType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 void parseProgramDiagnosticDataType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
+void parseAnnotation(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName);
 
 void registerComplexTypes(void);
diff --git a/plugins/opcua/opcua_enumparser.c b/plugins/opcua/opcua_enumparser.c
index e11868f72b..100db8124a 100644
--- a/plugins/opcua/opcua_enumparser.c
+++ b/plugins/opcua/opcua_enumparser.c
@@ -16,7 +16,7 @@
 **
 ** Description: OpcUa Enum Type Parser
 **
-** This file was autogenerated on 31.03.2009.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 **
 ******************************************************************************/
@@ -45,21 +45,19 @@ void parseNodeIdType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
     proto_tree_add_item(tree, hf_opcua_NodeIdType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
-/** DialogConditionChoice enum table */
-static const value_string g_DialogConditionChoiceTable[] = {
-  { 0, "None" },
-  { 1, "Ok" },
-  { 2, "Cancel" },
-  { 4, "Yes" },
-  { 8, "No" },
-  { 16, "Abort" },
+/** OpenFileMode enum table */
+static const value_string g_OpenFileModeTable[] = {
+  { 1, "Read" },
+  { 2, "Write" },
+  { 4, "EraseExisiting" },
+  { 8, "Append" },
   { 0, NULL }
 };
-static int hf_opcua_DialogConditionChoice = -1;
+static int hf_opcua_OpenFileMode = -1;
 
-void parseDialogConditionChoice(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+void parseOpenFileMode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-    proto_tree_add_item(tree, hf_opcua_DialogConditionChoice, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
+    proto_tree_add_item(tree, hf_opcua_OpenFileMode, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
 /** IdType enum table */
 static const value_string g_IdTypeTable[] = {
@@ -94,6 +92,20 @@ void parseNodeClass(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
     proto_tree_add_item(tree, hf_opcua_NodeClass, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
+/** ApplicationType enum table */
+static const value_string g_ApplicationTypeTable[] = {
+  { 0, "Server" },
+  { 1, "Client" },
+  { 2, "ClientAndServer" },
+  { 3, "DiscoveryServer" },
+  { 0, NULL }
+};
+static int hf_opcua_ApplicationType = -1;
+
+void parseApplicationType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+{
+    proto_tree_add_item(tree, hf_opcua_ApplicationType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
+}
 /** MessageSecurityMode enum table */
 static const value_string g_MessageSecurityModeTable[] = {
   { 0, "Invalid" },
@@ -122,20 +134,6 @@ void parseUserTokenType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
     proto_tree_add_item(tree, hf_opcua_UserTokenType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
-/** ApplicationType enum table */
-static const value_string g_ApplicationTypeTable[] = {
-  { 0, "Server" },
-  { 1, "Client" },
-  { 2, "ClientAndServer" },
-  { 3, "DiscoveryServer" },
-  { 0, NULL }
-};
-static int hf_opcua_ApplicationType = -1;
-
-void parseApplicationType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
-{
-    proto_tree_add_item(tree, hf_opcua_ApplicationType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
-}
 /** SecurityTokenRequestType enum table */
 static const value_string g_SecurityTokenRequestTypeTable[] = {
   { 0, "Issue" },
@@ -148,22 +146,8 @@ void parseSecurityTokenRequestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffse
 {
     proto_tree_add_item(tree, hf_opcua_SecurityTokenRequestType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
-/** ComplianceLevel enum table */
-static const value_string g_ComplianceLevelTable[] = {
-  { 0, "Untested" },
-  { 1, "Partial" },
-  { 2, "SelfTested" },
-  { 3, "Certified" },
-  { 0, NULL }
-};
-static int hf_opcua_ComplianceLevel = -1;
-
-void parseComplianceLevel(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
-{
-    proto_tree_add_item(tree, hf_opcua_ComplianceLevel, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
-}
-/** AttributeWriteMask enum table */
-static const value_string g_AttributeWriteMaskTable[] = {
+/** NodeAttributesMask enum table */
+static const value_string g_NodeAttributesMaskTable[] = {
   { 0, "None" },
   { 1, "AccessLevel" },
   { 2, "ArrayDimensions" },
@@ -186,20 +170,30 @@ static const value_string g_AttributeWriteMaskTable[] = {
   { 262144, "UserWriteMask" },
   { 524288, "ValueRank" },
   { 1048576, "WriteMask" },
-  { 2097152, "ValueForVariableType" },
+  { 2097152, "Value" },
+  { 4194303, "All" },
+  { 1335396, "BaseNode" },
+  { 1335524, "Object" },
+  { 1337444, "ObjectTypeOrDataType" },
+  { 4026999, "Variable" },
+  { 3958902, "VariableType" },
+  { 1466724, "Method" },
+  { 1371236, "ReferenceType" },
+  { 1335532, "View" },
   { 0, NULL }
 };
-static int hf_opcua_AttributeWriteMask = -1;
+static int hf_opcua_NodeAttributesMask = -1;
 
-void parseAttributeWriteMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+void parseNodeAttributesMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-    proto_tree_add_item(tree, hf_opcua_AttributeWriteMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
+    proto_tree_add_item(tree, hf_opcua_NodeAttributesMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
-/** NodeAttributesMask enum table */
-static const value_string g_NodeAttributesMaskTable[] = {
+/** AttributeWriteMask enum table */
+static const value_string g_AttributeWriteMaskTable[] = {
   { 0, "None" },
   { 1, "AccessLevel" },
   { 2, "ArrayDimensions" },
+  { 4, "BrowseName" },
   { 8, "ContainsNoLoops" },
   { 16, "DataType" },
   { 32, "Description" },
@@ -210,42 +204,22 @@ static const value_string g_NodeAttributesMaskTable[] = {
   { 1024, "InverseName" },
   { 2048, "IsAbstract" },
   { 4096, "MinimumSamplingInterval" },
+  { 8192, "NodeClass" },
+  { 16384, "NodeId" },
   { 32768, "Symmetric" },
   { 65536, "UserAccessLevel" },
   { 131072, "UserExecutable" },
   { 262144, "UserWriteMask" },
   { 524288, "ValueRank" },
   { 1048576, "WriteMask" },
-  { 2097152, "Value" },
-  { 4194303, "All" },
-  { 1335396, "BaseNode" },
-  { 1335524, "Object" },
-  { 1337444, "ObjectTypeOrDataType" },
-  { 4026999, "Variable" },
-  { 3958902, "VariableType" },
-  { 1466724, "Method" },
-  { 1371236, "ReferenceType" },
-  { 1335532, "View" },
-  { 0, NULL }
-};
-static int hf_opcua_NodeAttributesMask = -1;
-
-void parseNodeAttributesMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
-{
-    proto_tree_add_item(tree, hf_opcua_NodeAttributesMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
-}
-/** EnumeratedTestType enum table */
-static const value_string g_EnumeratedTestTypeTable[] = {
-  { 1, "Red" },
-  { 4, "Yellow" },
-  { 5, "Green" },
+  { 2097152, "ValueForVariableType" },
   { 0, NULL }
 };
-static int hf_opcua_EnumeratedTestType = -1;
+static int hf_opcua_AttributeWriteMask = -1;
 
-void parseEnumeratedTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+void parseAttributeWriteMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-    proto_tree_add_item(tree, hf_opcua_EnumeratedTestType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
+    proto_tree_add_item(tree, hf_opcua_AttributeWriteMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
 /** BrowseDirection enum table */
 static const value_string g_BrowseDirectionTable[] = {
@@ -280,6 +254,20 @@ void parseBrowseResultMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
     proto_tree_add_item(tree, hf_opcua_BrowseResultMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
+/** ComplianceLevel enum table */
+static const value_string g_ComplianceLevelTable[] = {
+  { 0, "Untested" },
+  { 1, "Partial" },
+  { 2, "SelfTested" },
+  { 3, "Certified" },
+  { 0, NULL }
+};
+static int hf_opcua_ComplianceLevel = -1;
+
+void parseComplianceLevel(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+{
+    proto_tree_add_item(tree, hf_opcua_ComplianceLevel, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
+}
 /** FilterOperator enum table */
 static const value_string g_FilterOperatorTable[] = {
   { 0, "Equals" },
@@ -322,18 +310,33 @@ void parseTimestampsToReturn(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
     proto_tree_add_item(tree, hf_opcua_TimestampsToReturn, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
-/** HistoryUpdateMode enum table */
-static const value_string g_HistoryUpdateModeTable[] = {
+/** HistoryUpdateType enum table */
+static const value_string g_HistoryUpdateTypeTable[] = {
+  { 1, "Insert" },
+  { 2, "Replace" },
+  { 3, "Update" },
+  { 4, "Delete" },
+  { 0, NULL }
+};
+static int hf_opcua_HistoryUpdateType = -1;
+
+void parseHistoryUpdateType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+{
+    proto_tree_add_item(tree, hf_opcua_HistoryUpdateType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
+}
+/** PerformUpdateType enum table */
+static const value_string g_PerformUpdateTypeTable[] = {
   { 1, "Insert" },
   { 2, "Replace" },
-  { 3, "InsertReplace" },
+  { 3, "Update" },
+  { 4, "Remove" },
   { 0, NULL }
 };
-static int hf_opcua_HistoryUpdateMode = -1;
+static int hf_opcua_PerformUpdateType = -1;
 
-void parseHistoryUpdateMode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+void parsePerformUpdateType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-    proto_tree_add_item(tree, hf_opcua_HistoryUpdateMode, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
+    proto_tree_add_item(tree, hf_opcua_PerformUpdateType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
 /** MonitoringMode enum table */
 static const value_string g_MonitoringModeTable[] = {
@@ -374,6 +377,19 @@ void parseDeadbandType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
     proto_tree_add_item(tree, hf_opcua_DeadbandType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
+/** EnumeratedTestType enum table */
+static const value_string g_EnumeratedTestTypeTable[] = {
+  { 1, "Red" },
+  { 4, "Yellow" },
+  { 5, "Green" },
+  { 0, NULL }
+};
+static int hf_opcua_EnumeratedTestType = -1;
+
+void parseEnumeratedTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+{
+    proto_tree_add_item(tree, hf_opcua_EnumeratedTestType, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
+}
 /** RedundancySupport enum table */
 static const value_string g_RedundancySupportTable[] = {
   { 0, "None" },
@@ -381,6 +397,7 @@ static const value_string g_RedundancySupportTable[] = {
   { 2, "Warm" },
   { 3, "Hot" },
   { 4, "Transparent" },
+  { 5, "HotAndMirrored" },
   { 0, NULL }
 };
 static int hf_opcua_RedundancySupport = -1;
@@ -422,6 +439,19 @@ void parseModelChangeStructureVerbMask(proto_tree *tree, tvbuff_t *tvb, gint *pO
 {
     proto_tree_add_item(tree, hf_opcua_ModelChangeStructureVerbMask, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 }
+/** AxisScaleEnumeration enum table */
+static const value_string g_AxisScaleEnumerationTable[] = {
+  { 0, "Linear" },
+  { 1, "Log" },
+  { 2, "Ln" },
+  { 0, NULL }
+};
+static int hf_opcua_AxisScaleEnumeration = -1;
+
+void parseAxisScaleEnumeration(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+{
+    proto_tree_add_item(tree, hf_opcua_AxisScaleEnumeration, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
+}
 /** ExceptionDeviationFormat enum table */
 static const value_string g_ExceptionDeviationFormatTable[] = {
   { 0, "AbsoluteValue" },
@@ -447,8 +477,8 @@ void registerEnumTypes(int proto)
         { &hf_opcua_NodeIdType,
         {  "NodeIdType", "opcua.NodeIdType", FT_UINT32, BASE_HEX,  VALS(g_NodeIdTypeTable), 0x0, NULL, HFILL }
         },
-        { &hf_opcua_DialogConditionChoice,
-        {  "DialogConditionChoice", "opcua.DialogConditionChoice", FT_UINT32, BASE_HEX,  VALS(g_DialogConditionChoiceTable), 0x0, NULL, HFILL }
+        { &hf_opcua_OpenFileMode,
+        {  "OpenFileMode", "opcua.OpenFileMode", FT_UINT32, BASE_HEX,  VALS(g_OpenFileModeTable), 0x0, NULL, HFILL }
         },
         { &hf_opcua_IdType,
         {  "IdType", "opcua.IdType", FT_UINT32, BASE_HEX,  VALS(g_IdTypeTable), 0x0, NULL, HFILL }
@@ -456,29 +486,23 @@ void registerEnumTypes(int proto)
         { &hf_opcua_NodeClass,
         {  "NodeClass", "opcua.NodeClass", FT_UINT32, BASE_HEX,  VALS(g_NodeClassTable), 0x0, NULL, HFILL }
         },
+        { &hf_opcua_ApplicationType,
+        {  "ApplicationType", "opcua.ApplicationType", FT_UINT32, BASE_HEX,  VALS(g_ApplicationTypeTable), 0x0, NULL, HFILL }
+        },
         { &hf_opcua_MessageSecurityMode,
         {  "MessageSecurityMode", "opcua.MessageSecurityMode", FT_UINT32, BASE_HEX,  VALS(g_MessageSecurityModeTable), 0x0, NULL, HFILL }
         },
         { &hf_opcua_UserTokenType,
         {  "UserTokenType", "opcua.UserTokenType", FT_UINT32, BASE_HEX,  VALS(g_UserTokenTypeTable), 0x0, NULL, HFILL }
         },
-        { &hf_opcua_ApplicationType,
-        {  "ApplicationType", "opcua.ApplicationType", FT_UINT32, BASE_HEX,  VALS(g_ApplicationTypeTable), 0x0, NULL, HFILL }
-        },
         { &hf_opcua_SecurityTokenRequestType,
         {  "SecurityTokenRequestType", "opcua.SecurityTokenRequestType", FT_UINT32, BASE_HEX,  VALS(g_SecurityTokenRequestTypeTable), 0x0, NULL, HFILL }
         },
-        { &hf_opcua_ComplianceLevel,
-        {  "ComplianceLevel", "opcua.ComplianceLevel", FT_UINT32, BASE_HEX,  VALS(g_ComplianceLevelTable), 0x0, NULL, HFILL }
-        },
-        { &hf_opcua_AttributeWriteMask,
-        {  "AttributeWriteMask", "opcua.AttributeWriteMask", FT_UINT32, BASE_HEX,  VALS(g_AttributeWriteMaskTable), 0x0, NULL, HFILL }
-        },
         { &hf_opcua_NodeAttributesMask,
         {  "NodeAttributesMask", "opcua.NodeAttributesMask", FT_UINT32, BASE_HEX,  VALS(g_NodeAttributesMaskTable), 0x0, NULL, HFILL }
         },
-        { &hf_opcua_EnumeratedTestType,
-        {  "EnumeratedTestType", "opcua.EnumeratedTestType", FT_UINT32, BASE_HEX,  VALS(g_EnumeratedTestTypeTable), 0x0, NULL, HFILL }
+        { &hf_opcua_AttributeWriteMask,
+        {  "AttributeWriteMask", "opcua.AttributeWriteMask", FT_UINT32, BASE_HEX,  VALS(g_AttributeWriteMaskTable), 0x0, NULL, HFILL }
         },
         { &hf_opcua_BrowseDirection,
         {  "BrowseDirection", "opcua.BrowseDirection", FT_UINT32, BASE_HEX,  VALS(g_BrowseDirectionTable), 0x0, NULL, HFILL }
@@ -486,14 +510,20 @@ void registerEnumTypes(int proto)
         { &hf_opcua_BrowseResultMask,
         {  "BrowseResultMask", "opcua.BrowseResultMask", FT_UINT32, BASE_HEX,  VALS(g_BrowseResultMaskTable), 0x0, NULL, HFILL }
         },
+        { &hf_opcua_ComplianceLevel,
+        {  "ComplianceLevel", "opcua.ComplianceLevel", FT_UINT32, BASE_HEX,  VALS(g_ComplianceLevelTable), 0x0, NULL, HFILL }
+        },
         { &hf_opcua_FilterOperator,
         {  "FilterOperator", "opcua.FilterOperator", FT_UINT32, BASE_HEX,  VALS(g_FilterOperatorTable), 0x0, NULL, HFILL }
         },
         { &hf_opcua_TimestampsToReturn,
         {  "TimestampsToReturn", "opcua.TimestampsToReturn", FT_UINT32, BASE_HEX,  VALS(g_TimestampsToReturnTable), 0x0, NULL, HFILL }
         },
-        { &hf_opcua_HistoryUpdateMode,
-        {  "HistoryUpdateMode", "opcua.HistoryUpdateMode", FT_UINT32, BASE_HEX,  VALS(g_HistoryUpdateModeTable), 0x0, NULL, HFILL }
+        { &hf_opcua_HistoryUpdateType,
+        {  "HistoryUpdateType", "opcua.HistoryUpdateType", FT_UINT32, BASE_HEX,  VALS(g_HistoryUpdateTypeTable), 0x0, NULL, HFILL }
+        },
+        { &hf_opcua_PerformUpdateType,
+        {  "PerformUpdateType", "opcua.PerformUpdateType", FT_UINT32, BASE_HEX,  VALS(g_PerformUpdateTypeTable), 0x0, NULL, HFILL }
         },
         { &hf_opcua_MonitoringMode,
         {  "MonitoringMode", "opcua.MonitoringMode", FT_UINT32, BASE_HEX,  VALS(g_MonitoringModeTable), 0x0, NULL, HFILL }
@@ -504,6 +534,9 @@ void registerEnumTypes(int proto)
         { &hf_opcua_DeadbandType,
         {  "DeadbandType", "opcua.DeadbandType", FT_UINT32, BASE_HEX,  VALS(g_DeadbandTypeTable), 0x0, NULL, HFILL }
         },
+        { &hf_opcua_EnumeratedTestType,
+        {  "EnumeratedTestType", "opcua.EnumeratedTestType", FT_UINT32, BASE_HEX,  VALS(g_EnumeratedTestTypeTable), 0x0, NULL, HFILL }
+        },
         { &hf_opcua_RedundancySupport,
         {  "RedundancySupport", "opcua.RedundancySupport", FT_UINT32, BASE_HEX,  VALS(g_RedundancySupportTable), 0x0, NULL, HFILL }
         },
@@ -513,6 +546,9 @@ void registerEnumTypes(int proto)
         { &hf_opcua_ModelChangeStructureVerbMask,
         {  "ModelChangeStructureVerbMask", "opcua.ModelChangeStructureVerbMask", FT_UINT32, BASE_HEX,  VALS(g_ModelChangeStructureVerbMaskTable), 0x0, NULL, HFILL }
         },
+        { &hf_opcua_AxisScaleEnumeration,
+        {  "AxisScaleEnumeration", "opcua.AxisScaleEnumeration", FT_UINT32, BASE_HEX,  VALS(g_AxisScaleEnumerationTable), 0x0, NULL, HFILL }
+        },
         { &hf_opcua_ExceptionDeviationFormat,
         {  "ExceptionDeviationFormat", "opcua.ExceptionDeviationFormat", FT_UINT32, BASE_HEX,  VALS(g_ExceptionDeviationFormatTable), 0x0, NULL, HFILL }
         },
diff --git a/plugins/opcua/opcua_enumparser.h b/plugins/opcua/opcua_enumparser.h
index b82c5a98f8..a6fe3a0a9f 100644
--- a/plugins/opcua/opcua_enumparser.h
+++ b/plugins/opcua/opcua_enumparser.h
@@ -16,7 +16,7 @@
 **
 ** Description: OpcUa Enum Type Parser
 **
-** This file was autogenerated on 31.03.2009.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 ** XXX - well, except that you may have to.  See the README.
 **
@@ -26,27 +26,29 @@
 #include <epan/packet.h>
 
 void parseNodeIdType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
-void parseDialogConditionChoice(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseOpenFileMode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseIdType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseNodeClass(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseApplicationType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseMessageSecurityMode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseUserTokenType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
-void parseApplicationType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseSecurityTokenRequestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
-void parseComplianceLevel(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
-void parseAttributeWriteMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseNodeAttributesMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
-void parseEnumeratedTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseAttributeWriteMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseBrowseDirection(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseBrowseResultMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseComplianceLevel(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseFilterOperator(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseTimestampsToReturn(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
-void parseHistoryUpdateMode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseHistoryUpdateType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parsePerformUpdateType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseMonitoringMode(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseDataChangeTrigger(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseDeadbandType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseEnumeratedTestType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseRedundancySupport(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseServerState(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseModelChangeStructureVerbMask(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseAxisScaleEnumeration(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseExceptionDeviationFormat(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void registerEnumTypes(int proto);
diff --git a/plugins/opcua/opcua_extensionobjectids.h b/plugins/opcua/opcua_extensionobjectids.h
index c4547801e0..bd18cd9804 100644
--- a/plugins/opcua/opcua_extensionobjectids.h
+++ b/plugins/opcua/opcua_extensionobjectids.h
@@ -19,6 +19,8 @@
 ******************************************************************************/
 
 #define OpcUaId_Node_Encoding_DefaultBinary 260
+#define OpcUaId_InstanceNode_Encoding_DefaultBinary 11889
+#define OpcUaId_TypeNode_Encoding_DefaultBinary 11890
 #define OpcUaId_ObjectNode_Encoding_DefaultBinary 263
 #define OpcUaId_ObjectTypeNode_Encoding_DefaultBinary 266
 #define OpcUaId_VariableNode_Encoding_DefaultBinary 269
@@ -29,47 +31,16 @@
 #define OpcUaId_DataTypeNode_Encoding_DefaultBinary 284
 #define OpcUaId_ReferenceNode_Encoding_DefaultBinary 287
 #define OpcUaId_Argument_Encoding_DefaultBinary 298
-#define OpcUaId_TimeZoneDataType_Encoding_DefaultBinary 8917
 #define OpcUaId_EnumValueType_Encoding_DefaultBinary 8251
-#define OpcUaId_StatusResult_Encoding_DefaultBinary 301
-#define OpcUaId_UserTokenPolicy_Encoding_DefaultBinary 306
+#define OpcUaId_TimeZoneDataType_Encoding_DefaultBinary 8917
 #define OpcUaId_ApplicationDescription_Encoding_DefaultBinary 310
-#define OpcUaId_EndpointDescription_Encoding_DefaultBinary 314
-#define OpcUaId_UserIdentityToken_Encoding_DefaultBinary 318
-#define OpcUaId_AnonymousIdentityToken_Encoding_DefaultBinary 321
-#define OpcUaId_UserNameIdentityToken_Encoding_DefaultBinary 324
-#define OpcUaId_X509IdentityToken_Encoding_DefaultBinary 327
-#define OpcUaId_IssuedIdentityToken_Encoding_DefaultBinary 940
-#define OpcUaId_EndpointConfiguration_Encoding_DefaultBinary 333
-#define OpcUaId_SupportedProfile_Encoding_DefaultBinary 337
-#define OpcUaId_BuildInfo_Encoding_DefaultBinary 340
-#define OpcUaId_SoftwareCertificate_Encoding_DefaultBinary 343
-#define OpcUaId_SignedSoftwareCertificate_Encoding_DefaultBinary 346
-#define OpcUaId_NodeAttributes_Encoding_DefaultBinary 351
-#define OpcUaId_ObjectAttributes_Encoding_DefaultBinary 354
-#define OpcUaId_VariableAttributes_Encoding_DefaultBinary 357
-#define OpcUaId_MethodAttributes_Encoding_DefaultBinary 360
-#define OpcUaId_ObjectTypeAttributes_Encoding_DefaultBinary 363
-#define OpcUaId_VariableTypeAttributes_Encoding_DefaultBinary 366
-#define OpcUaId_ReferenceTypeAttributes_Encoding_DefaultBinary 369
-#define OpcUaId_DataTypeAttributes_Encoding_DefaultBinary 372
-#define OpcUaId_ViewAttributes_Encoding_DefaultBinary 375
-#define OpcUaId_AddNodesItem_Encoding_DefaultBinary 378
-#define OpcUaId_AddReferencesItem_Encoding_DefaultBinary 381
-#define OpcUaId_DeleteNodesItem_Encoding_DefaultBinary 384
-#define OpcUaId_DeleteReferencesItem_Encoding_DefaultBinary 387
 #define OpcUaId_RequestHeader_Encoding_DefaultBinary 391
 #define OpcUaId_ResponseHeader_Encoding_DefaultBinary 394
 #define OpcUaId_ServiceFault_Encoding_DefaultBinary 397
-#define OpcUaId_ScalarTestType_Encoding_DefaultBinary 401
-#define OpcUaId_ArrayTestType_Encoding_DefaultBinary 404
-#define OpcUaId_CompositeTestType_Encoding_DefaultBinary 407
-#define OpcUaId_TestStackRequest_Encoding_DefaultBinary 410
-#define OpcUaId_TestStackResponse_Encoding_DefaultBinary 413
-#define OpcUaId_TestStackExRequest_Encoding_DefaultBinary 416
-#define OpcUaId_TestStackExResponse_Encoding_DefaultBinary 419
 #define OpcUaId_FindServersRequest_Encoding_DefaultBinary 422
 #define OpcUaId_FindServersResponse_Encoding_DefaultBinary 425
+#define OpcUaId_UserTokenPolicy_Encoding_DefaultBinary 306
+#define OpcUaId_EndpointDescription_Encoding_DefaultBinary 314
 #define OpcUaId_GetEndpointsRequest_Encoding_DefaultBinary 428
 #define OpcUaId_GetEndpointsResponse_Encoding_DefaultBinary 431
 #define OpcUaId_RegisteredServer_Encoding_DefaultBinary 434
@@ -80,22 +51,41 @@
 #define OpcUaId_OpenSecureChannelResponse_Encoding_DefaultBinary 449
 #define OpcUaId_CloseSecureChannelRequest_Encoding_DefaultBinary 452
 #define OpcUaId_CloseSecureChannelResponse_Encoding_DefaultBinary 455
+#define OpcUaId_SignedSoftwareCertificate_Encoding_DefaultBinary 346
 #define OpcUaId_SignatureData_Encoding_DefaultBinary 458
 #define OpcUaId_CreateSessionRequest_Encoding_DefaultBinary 461
 #define OpcUaId_CreateSessionResponse_Encoding_DefaultBinary 464
+#define OpcUaId_UserIdentityToken_Encoding_DefaultBinary 318
+#define OpcUaId_AnonymousIdentityToken_Encoding_DefaultBinary 321
+#define OpcUaId_UserNameIdentityToken_Encoding_DefaultBinary 324
+#define OpcUaId_X509IdentityToken_Encoding_DefaultBinary 327
+#define OpcUaId_IssuedIdentityToken_Encoding_DefaultBinary 940
 #define OpcUaId_ActivateSessionRequest_Encoding_DefaultBinary 467
 #define OpcUaId_ActivateSessionResponse_Encoding_DefaultBinary 470
 #define OpcUaId_CloseSessionRequest_Encoding_DefaultBinary 473
 #define OpcUaId_CloseSessionResponse_Encoding_DefaultBinary 476
 #define OpcUaId_CancelRequest_Encoding_DefaultBinary 479
 #define OpcUaId_CancelResponse_Encoding_DefaultBinary 482
+#define OpcUaId_NodeAttributes_Encoding_DefaultBinary 351
+#define OpcUaId_ObjectAttributes_Encoding_DefaultBinary 354
+#define OpcUaId_VariableAttributes_Encoding_DefaultBinary 357
+#define OpcUaId_MethodAttributes_Encoding_DefaultBinary 360
+#define OpcUaId_ObjectTypeAttributes_Encoding_DefaultBinary 363
+#define OpcUaId_VariableTypeAttributes_Encoding_DefaultBinary 366
+#define OpcUaId_ReferenceTypeAttributes_Encoding_DefaultBinary 369
+#define OpcUaId_DataTypeAttributes_Encoding_DefaultBinary 372
+#define OpcUaId_ViewAttributes_Encoding_DefaultBinary 375
+#define OpcUaId_AddNodesItem_Encoding_DefaultBinary 378
 #define OpcUaId_AddNodesResult_Encoding_DefaultBinary 485
 #define OpcUaId_AddNodesRequest_Encoding_DefaultBinary 488
 #define OpcUaId_AddNodesResponse_Encoding_DefaultBinary 491
+#define OpcUaId_AddReferencesItem_Encoding_DefaultBinary 381
 #define OpcUaId_AddReferencesRequest_Encoding_DefaultBinary 494
 #define OpcUaId_AddReferencesResponse_Encoding_DefaultBinary 497
+#define OpcUaId_DeleteNodesItem_Encoding_DefaultBinary 384
 #define OpcUaId_DeleteNodesRequest_Encoding_DefaultBinary 500
 #define OpcUaId_DeleteNodesResponse_Encoding_DefaultBinary 503
+#define OpcUaId_DeleteReferencesItem_Encoding_DefaultBinary 387
 #define OpcUaId_DeleteReferencesRequest_Encoding_DefaultBinary 506
 #define OpcUaId_DeleteReferencesResponse_Encoding_DefaultBinary 509
 #define OpcUaId_ViewDescription_Encoding_DefaultBinary 513
@@ -117,6 +107,9 @@
 #define OpcUaId_RegisterNodesResponse_Encoding_DefaultBinary 563
 #define OpcUaId_UnregisterNodesRequest_Encoding_DefaultBinary 566
 #define OpcUaId_UnregisterNodesResponse_Encoding_DefaultBinary 569
+#define OpcUaId_EndpointConfiguration_Encoding_DefaultBinary 333
+#define OpcUaId_SupportedProfile_Encoding_DefaultBinary 337
+#define OpcUaId_SoftwareCertificate_Encoding_DefaultBinary 343
 #define OpcUaId_QueryDataDescription_Encoding_DefaultBinary 572
 #define OpcUaId_NodeTypeDescription_Encoding_DefaultBinary 575
 #define OpcUaId_QueryDataSet_Encoding_DefaultBinary 579
@@ -156,6 +149,7 @@
 #define OpcUaId_WriteResponse_Encoding_DefaultBinary 676
 #define OpcUaId_HistoryUpdateDetails_Encoding_DefaultBinary 679
 #define OpcUaId_UpdateDataDetails_Encoding_DefaultBinary 682
+#define OpcUaId_UpdateStructureDataDetails_Encoding_DefaultBinary 11300
 #define OpcUaId_UpdateEventDetails_Encoding_DefaultBinary 685
 #define OpcUaId_DeleteRawModifiedDetails_Encoding_DefaultBinary 688
 #define OpcUaId_DeleteAtTimeDetails_Encoding_DefaultBinary 691
@@ -215,18 +209,33 @@
 #define OpcUaId_TransferSubscriptionsResponse_Encoding_DefaultBinary 844
 #define OpcUaId_DeleteSubscriptionsRequest_Encoding_DefaultBinary 847
 #define OpcUaId_DeleteSubscriptionsResponse_Encoding_DefaultBinary 850
+#define OpcUaId_ScalarTestType_Encoding_DefaultBinary 401
+#define OpcUaId_ArrayTestType_Encoding_DefaultBinary 404
+#define OpcUaId_CompositeTestType_Encoding_DefaultBinary 407
+#define OpcUaId_TestStackRequest_Encoding_DefaultBinary 410
+#define OpcUaId_TestStackResponse_Encoding_DefaultBinary 413
+#define OpcUaId_TestStackExRequest_Encoding_DefaultBinary 416
+#define OpcUaId_TestStackExResponse_Encoding_DefaultBinary 419
+#define OpcUaId_BuildInfo_Encoding_DefaultBinary 340
 #define OpcUaId_RedundantServerDataType_Encoding_DefaultBinary 855
+#define OpcUaId_EndpointUrlListDataType_Encoding_DefaultBinary 11957
+#define OpcUaId_NetworkGroupDataType_Encoding_DefaultBinary 11958
 #define OpcUaId_SamplingIntervalDiagnosticsDataType_Encoding_DefaultBinary 858
 #define OpcUaId_ServerDiagnosticsSummaryDataType_Encoding_DefaultBinary 861
 #define OpcUaId_ServerStatusDataType_Encoding_DefaultBinary 864
 #define OpcUaId_SessionDiagnosticsDataType_Encoding_DefaultBinary 867
 #define OpcUaId_SessionSecurityDiagnosticsDataType_Encoding_DefaultBinary 870
 #define OpcUaId_ServiceCounterDataType_Encoding_DefaultBinary 873
+#define OpcUaId_StatusResult_Encoding_DefaultBinary 301
 #define OpcUaId_SubscriptionDiagnosticsDataType_Encoding_DefaultBinary 876
 #define OpcUaId_ModelChangeStructureDataType_Encoding_DefaultBinary 879
 #define OpcUaId_SemanticChangeStructureDataType_Encoding_DefaultBinary 899
 #define OpcUaId_Range_Encoding_DefaultBinary 886
 #define OpcUaId_EUInformation_Encoding_DefaultBinary 889
-#define OpcUaId_Annotation_Encoding_DefaultBinary 893
+#define OpcUaId_ComplexNumberType_Encoding_DefaultBinary 12181
+#define OpcUaId_DoubleComplexNumberType_Encoding_DefaultBinary 12182
+#define OpcUaId_AxisInformation_Encoding_DefaultBinary 12089
+#define OpcUaId_XVType_Encoding_DefaultBinary 12090
 #define OpcUaId_ProgramDiagnosticDataType_Encoding_DefaultBinary 896
+#define OpcUaId_Annotation_Encoding_DefaultBinary 893
 
diff --git a/plugins/opcua/opcua_extensionobjecttable.c b/plugins/opcua/opcua_extensionobjecttable.c
index 40d6e48efa..023e90a3ff 100644
--- a/plugins/opcua/opcua_extensionobjecttable.c
+++ b/plugins/opcua/opcua_extensionobjecttable.c
@@ -16,7 +16,7 @@
 **
 ** Description: Service table and service dispatcher.
 **
-** This file was autogenerated on 22.11.2010.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 ** XXX - well, except that you may have to.  See the README.
 **
@@ -33,6 +33,8 @@
 
 ExtensionObjectParserEntry g_arExtensionObjectParserTable[] = {
     { OpcUaId_Node_Encoding_DefaultBinary, parseNode, "Node" },
+    { OpcUaId_InstanceNode_Encoding_DefaultBinary, parseInstanceNode, "InstanceNode" },
+    { OpcUaId_TypeNode_Encoding_DefaultBinary, parseTypeNode, "TypeNode" },
     { OpcUaId_ObjectNode_Encoding_DefaultBinary, parseObjectNode, "ObjectNode" },
     { OpcUaId_ObjectTypeNode_Encoding_DefaultBinary, parseObjectTypeNode, "ObjectTypeNode" },
     { OpcUaId_VariableNode_Encoding_DefaultBinary, parseVariableNode, "VariableNode" },
@@ -43,20 +45,23 @@ ExtensionObjectParserEntry g_arExtensionObjectParserTable[] = {
     { OpcUaId_DataTypeNode_Encoding_DefaultBinary, parseDataTypeNode, "DataTypeNode" },
     { OpcUaId_ReferenceNode_Encoding_DefaultBinary, parseReferenceNode, "ReferenceNode" },
     { OpcUaId_Argument_Encoding_DefaultBinary, parseArgument, "Argument" },
+    { OpcUaId_EnumValueType_Encoding_DefaultBinary, parseEnumValueType, "EnumValueType" },
     { OpcUaId_TimeZoneDataType_Encoding_DefaultBinary, parseTimeZoneDataType, "TimeZoneDataType" },
-    { OpcUaId_StatusResult_Encoding_DefaultBinary, parseStatusResult, "StatusResult" },
-    { OpcUaId_UserTokenPolicy_Encoding_DefaultBinary, parseUserTokenPolicy, "UserTokenPolicy" },
     { OpcUaId_ApplicationDescription_Encoding_DefaultBinary, parseApplicationDescription, "ApplicationDescription" },
+    { OpcUaId_RequestHeader_Encoding_DefaultBinary, parseRequestHeader, "RequestHeader" },
+    { OpcUaId_ResponseHeader_Encoding_DefaultBinary, parseResponseHeader, "ResponseHeader" },
+    { OpcUaId_ServiceFault_Encoding_DefaultBinary, parseServiceFault, "ServiceFault" },
+    { OpcUaId_UserTokenPolicy_Encoding_DefaultBinary, parseUserTokenPolicy, "UserTokenPolicy" },
     { OpcUaId_EndpointDescription_Encoding_DefaultBinary, parseEndpointDescription, "EndpointDescription" },
+    { OpcUaId_RegisteredServer_Encoding_DefaultBinary, parseRegisteredServer, "RegisteredServer" },
+    { OpcUaId_ChannelSecurityToken_Encoding_DefaultBinary, parseChannelSecurityToken, "ChannelSecurityToken" },
+    { OpcUaId_SignedSoftwareCertificate_Encoding_DefaultBinary, parseSignedSoftwareCertificate, "SignedSoftwareCertificate" },
+    { OpcUaId_SignatureData_Encoding_DefaultBinary, parseSignatureData, "SignatureData" },
     { OpcUaId_UserIdentityToken_Encoding_DefaultBinary, parseUserIdentityToken, "UserIdentityToken" },
+    { OpcUaId_AnonymousIdentityToken_Encoding_DefaultBinary, parseAnonymousIdentityToken, "AnonymousIdentityToken" },
     { OpcUaId_UserNameIdentityToken_Encoding_DefaultBinary, parseUserNameIdentityToken, "UserNameIdentityToken" },
     { OpcUaId_X509IdentityToken_Encoding_DefaultBinary, parseX509IdentityToken, "X509IdentityToken" },
     { OpcUaId_IssuedIdentityToken_Encoding_DefaultBinary, parseIssuedIdentityToken, "IssuedIdentityToken" },
-    { OpcUaId_EndpointConfiguration_Encoding_DefaultBinary, parseEndpointConfiguration, "EndpointConfiguration" },
-    { OpcUaId_SupportedProfile_Encoding_DefaultBinary, parseSupportedProfile, "SupportedProfile" },
-    { OpcUaId_BuildInfo_Encoding_DefaultBinary, parseBuildInfo, "BuildInfo" },
-    { OpcUaId_SoftwareCertificate_Encoding_DefaultBinary, parseSoftwareCertificate, "SoftwareCertificate" },
-    { OpcUaId_SignedSoftwareCertificate_Encoding_DefaultBinary, parseSignedSoftwareCertificate, "SignedSoftwareCertificate" },
     { OpcUaId_NodeAttributes_Encoding_DefaultBinary, parseNodeAttributes, "NodeAttributes" },
     { OpcUaId_ObjectAttributes_Encoding_DefaultBinary, parseObjectAttributes, "ObjectAttributes" },
     { OpcUaId_VariableAttributes_Encoding_DefaultBinary, parseVariableAttributes, "VariableAttributes" },
@@ -67,19 +72,10 @@ ExtensionObjectParserEntry g_arExtensionObjectParserTable[] = {
     { OpcUaId_DataTypeAttributes_Encoding_DefaultBinary, parseDataTypeAttributes, "DataTypeAttributes" },
     { OpcUaId_ViewAttributes_Encoding_DefaultBinary, parseViewAttributes, "ViewAttributes" },
     { OpcUaId_AddNodesItem_Encoding_DefaultBinary, parseAddNodesItem, "AddNodesItem" },
+    { OpcUaId_AddNodesResult_Encoding_DefaultBinary, parseAddNodesResult, "AddNodesResult" },
     { OpcUaId_AddReferencesItem_Encoding_DefaultBinary, parseAddReferencesItem, "AddReferencesItem" },
     { OpcUaId_DeleteNodesItem_Encoding_DefaultBinary, parseDeleteNodesItem, "DeleteNodesItem" },
     { OpcUaId_DeleteReferencesItem_Encoding_DefaultBinary, parseDeleteReferencesItem, "DeleteReferencesItem" },
-    { OpcUaId_RequestHeader_Encoding_DefaultBinary, parseRequestHeader, "RequestHeader" },
-    { OpcUaId_ResponseHeader_Encoding_DefaultBinary, parseResponseHeader, "ResponseHeader" },
-    { OpcUaId_ServiceFault_Encoding_DefaultBinary, parseServiceFault, "ServiceFault" },
-    { OpcUaId_ScalarTestType_Encoding_DefaultBinary, parseScalarTestType, "ScalarTestType" },
-    { OpcUaId_ArrayTestType_Encoding_DefaultBinary, parseArrayTestType, "ArrayTestType" },
-    { OpcUaId_CompositeTestType_Encoding_DefaultBinary, parseCompositeTestType, "CompositeTestType" },
-    { OpcUaId_RegisteredServer_Encoding_DefaultBinary, parseRegisteredServer, "RegisteredServer" },
-    { OpcUaId_ChannelSecurityToken_Encoding_DefaultBinary, parseChannelSecurityToken, "ChannelSecurityToken" },
-    { OpcUaId_SignatureData_Encoding_DefaultBinary, parseSignatureData, "SignatureData" },
-    { OpcUaId_AddNodesResult_Encoding_DefaultBinary, parseAddNodesResult, "AddNodesResult" },
     { OpcUaId_ViewDescription_Encoding_DefaultBinary, parseViewDescription, "ViewDescription" },
     { OpcUaId_BrowseDescription_Encoding_DefaultBinary, parseBrowseDescription, "BrowseDescription" },
     { OpcUaId_ReferenceDescription_Encoding_DefaultBinary, parseReferenceDescription, "ReferenceDescription" },
@@ -89,6 +85,9 @@ ExtensionObjectParserEntry g_arExtensionObjectParserTable[] = {
     { OpcUaId_BrowsePath_Encoding_DefaultBinary, parseBrowsePath, "BrowsePath" },
     { OpcUaId_BrowsePathTarget_Encoding_DefaultBinary, parseBrowsePathTarget, "BrowsePathTarget" },
     { OpcUaId_BrowsePathResult_Encoding_DefaultBinary, parseBrowsePathResult, "BrowsePathResult" },
+    { OpcUaId_EndpointConfiguration_Encoding_DefaultBinary, parseEndpointConfiguration, "EndpointConfiguration" },
+    { OpcUaId_SupportedProfile_Encoding_DefaultBinary, parseSupportedProfile, "SupportedProfile" },
+    { OpcUaId_SoftwareCertificate_Encoding_DefaultBinary, parseSoftwareCertificate, "SoftwareCertificate" },
     { OpcUaId_QueryDataDescription_Encoding_DefaultBinary, parseQueryDataDescription, "QueryDataDescription" },
     { OpcUaId_NodeTypeDescription_Encoding_DefaultBinary, parseNodeTypeDescription, "NodeTypeDescription" },
     { OpcUaId_QueryDataSet_Encoding_DefaultBinary, parseQueryDataSet, "QueryDataSet" },
@@ -110,10 +109,13 @@ ExtensionObjectParserEntry g_arExtensionObjectParserTable[] = {
     { OpcUaId_ReadProcessedDetails_Encoding_DefaultBinary, parseReadProcessedDetails, "ReadProcessedDetails" },
     { OpcUaId_ReadAtTimeDetails_Encoding_DefaultBinary, parseReadAtTimeDetails, "ReadAtTimeDetails" },
     { OpcUaId_HistoryData_Encoding_DefaultBinary, parseHistoryData, "HistoryData" },
+    { OpcUaId_ModificationInfo_Encoding_DefaultBinary, parseModificationInfo, "ModificationInfo" },
+    { OpcUaId_HistoryModifiedData_Encoding_DefaultBinary, parseHistoryModifiedData, "HistoryModifiedData" },
     { OpcUaId_HistoryEvent_Encoding_DefaultBinary, parseHistoryEvent, "HistoryEvent" },
     { OpcUaId_WriteValue_Encoding_DefaultBinary, parseWriteValue, "WriteValue" },
     { OpcUaId_HistoryUpdateDetails_Encoding_DefaultBinary, parseHistoryUpdateDetails, "HistoryUpdateDetails" },
     { OpcUaId_UpdateDataDetails_Encoding_DefaultBinary, parseUpdateDataDetails, "UpdateDataDetails" },
+    { OpcUaId_UpdateStructureDataDetails_Encoding_DefaultBinary, parseUpdateStructureDataDetails, "UpdateStructureDataDetails" },
     { OpcUaId_UpdateEventDetails_Encoding_DefaultBinary, parseUpdateEventDetails, "UpdateEventDetails" },
     { OpcUaId_DeleteRawModifiedDetails_Encoding_DefaultBinary, parseDeleteRawModifiedDetails, "DeleteRawModifiedDetails" },
     { OpcUaId_DeleteAtTimeDetails_Encoding_DefaultBinary, parseDeleteAtTimeDetails, "DeleteAtTimeDetails" },
@@ -142,20 +144,31 @@ ExtensionObjectParserEntry g_arExtensionObjectParserTable[] = {
     { OpcUaId_StatusChangeNotification_Encoding_DefaultBinary, parseStatusChangeNotification, "StatusChangeNotification" },
     { OpcUaId_SubscriptionAcknowledgement_Encoding_DefaultBinary, parseSubscriptionAcknowledgement, "SubscriptionAcknowledgement" },
     { OpcUaId_TransferResult_Encoding_DefaultBinary, parseTransferResult, "TransferResult" },
+    { OpcUaId_ScalarTestType_Encoding_DefaultBinary, parseScalarTestType, "ScalarTestType" },
+    { OpcUaId_ArrayTestType_Encoding_DefaultBinary, parseArrayTestType, "ArrayTestType" },
+    { OpcUaId_CompositeTestType_Encoding_DefaultBinary, parseCompositeTestType, "CompositeTestType" },
+    { OpcUaId_BuildInfo_Encoding_DefaultBinary, parseBuildInfo, "BuildInfo" },
     { OpcUaId_RedundantServerDataType_Encoding_DefaultBinary, parseRedundantServerDataType, "RedundantServerDataType" },
+    { OpcUaId_EndpointUrlListDataType_Encoding_DefaultBinary, parseEndpointUrlListDataType, "EndpointUrlListDataType" },
+    { OpcUaId_NetworkGroupDataType_Encoding_DefaultBinary, parseNetworkGroupDataType, "NetworkGroupDataType" },
     { OpcUaId_SamplingIntervalDiagnosticsDataType_Encoding_DefaultBinary, parseSamplingIntervalDiagnosticsDataType, "SamplingIntervalDiagnosticsDataType" },
     { OpcUaId_ServerDiagnosticsSummaryDataType_Encoding_DefaultBinary, parseServerDiagnosticsSummaryDataType, "ServerDiagnosticsSummaryDataType" },
     { OpcUaId_ServerStatusDataType_Encoding_DefaultBinary, parseServerStatusDataType, "ServerStatusDataType" },
     { OpcUaId_SessionDiagnosticsDataType_Encoding_DefaultBinary, parseSessionDiagnosticsDataType, "SessionDiagnosticsDataType" },
     { OpcUaId_SessionSecurityDiagnosticsDataType_Encoding_DefaultBinary, parseSessionSecurityDiagnosticsDataType, "SessionSecurityDiagnosticsDataType" },
     { OpcUaId_ServiceCounterDataType_Encoding_DefaultBinary, parseServiceCounterDataType, "ServiceCounterDataType" },
+    { OpcUaId_StatusResult_Encoding_DefaultBinary, parseStatusResult, "StatusResult" },
     { OpcUaId_SubscriptionDiagnosticsDataType_Encoding_DefaultBinary, parseSubscriptionDiagnosticsDataType, "SubscriptionDiagnosticsDataType" },
     { OpcUaId_ModelChangeStructureDataType_Encoding_DefaultBinary, parseModelChangeStructureDataType, "ModelChangeStructureDataType" },
     { OpcUaId_SemanticChangeStructureDataType_Encoding_DefaultBinary, parseSemanticChangeStructureDataType, "SemanticChangeStructureDataType" },
     { OpcUaId_Range_Encoding_DefaultBinary, parseRange, "Range" },
     { OpcUaId_EUInformation_Encoding_DefaultBinary, parseEUInformation, "EUInformation" },
-    { OpcUaId_Annotation_Encoding_DefaultBinary, parseAnnotation, "Annotation" },
+    { OpcUaId_ComplexNumberType_Encoding_DefaultBinary, parseComplexNumberType, "ComplexNumberType" },
+    { OpcUaId_DoubleComplexNumberType_Encoding_DefaultBinary, parseDoubleComplexNumberType, "DoubleComplexNumberType" },
+    { OpcUaId_AxisInformation_Encoding_DefaultBinary, parseAxisInformation, "AxisInformation" },
+    { OpcUaId_XVType_Encoding_DefaultBinary, parseXVType, "XVType" },
     { OpcUaId_ProgramDiagnosticDataType_Encoding_DefaultBinary, parseProgramDiagnosticDataType, "ProgramDiagnosticDataType" },
+    { OpcUaId_Annotation_Encoding_DefaultBinary, parseAnnotation, "Annotation" },
 };
 const int g_NumTypes = sizeof(g_arExtensionObjectParserTable) / sizeof(ExtensionObjectParserEntry);
 
@@ -187,7 +200,7 @@ void dispatchExtensionObjectType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset,
     {
         if (iLen == -1)
         {
-            proto_tree_add_text(tree, tvb, iOffset, 0, "[OpcUa Null ByteString]");
+            proto_tree_add_text(tree, tvb, *pOffset, 4, "[OpcUa Null ByteString]");
         }
         else if (iLen >= 0)
         {
@@ -197,7 +210,7 @@ void dispatchExtensionObjectType(proto_tree *tree, tvbuff_t *tvb, gint *pOffset,
         else
         {
             char *szValue = ep_strdup_printf("[Invalid ByteString] Invalid length: %d", iLen);
-            proto_tree_add_text(tree, tvb, iOffset, 0, "%s", szValue);
+            proto_tree_add_text(tree, tvb, *pOffset, 4, "%s", szValue);
         }
     }
 
diff --git a/plugins/opcua/opcua_hfindeces.c b/plugins/opcua/opcua_hfindeces.c
index 9628f02442..0ad022e67b 100644
--- a/plugins/opcua/opcua_hfindeces.c
+++ b/plugins/opcua/opcua_hfindeces.c
@@ -16,7 +16,7 @@
 **
 ** Description: This file contains protocol field handles.
 **
-** This file was autogenerated on 31.03.2009.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 **
 ******************************************************************************/
@@ -38,6 +38,7 @@ int hf_opcua_AttributeId = -1;
 int hf_opcua_AuditEntryId = -1;
 int hf_opcua_AuthenticationMechanism = -1;
 int hf_opcua_AvailableSequenceNumbers = -1;
+int hf_opcua_AxisSteps = -1;
 int hf_opcua_Boolean = -1;
 int hf_opcua_Booleans = -1;
 int hf_opcua_BuildDate = -1;
@@ -97,6 +98,7 @@ int hf_opcua_Encoding = -1;
 int hf_opcua_EncryptionAlgorithm = -1;
 int hf_opcua_EndTime = -1;
 int hf_opcua_EndpointUrl = -1;
+int hf_opcua_EndpointUrlList = -1;
 int hf_opcua_ErrorCount = -1;
 int hf_opcua_EventIds = -1;
 int hf_opcua_EventNotificationsCount = -1;
@@ -110,6 +112,7 @@ int hf_opcua_Guid = -1;
 int hf_opcua_Guids = -1;
 int hf_opcua_High = -1;
 int hf_opcua_Historizing = -1;
+int hf_opcua_Imaginary = -1;
 int hf_opcua_IncludeSubTypes = -1;
 int hf_opcua_IncludeSubtypes = -1;
 int hf_opcua_Index = -1;
@@ -158,6 +161,7 @@ int hf_opcua_MaxResponseMessageSize = -1;
 int hf_opcua_MaxStringLength = -1;
 int hf_opcua_Message = -1;
 int hf_opcua_MinimumSamplingInterval = -1;
+int hf_opcua_ModificationTime = -1;
 int hf_opcua_ModifyCount = -1;
 int hf_opcua_MonitoredItemCount = -1;
 int hf_opcua_MonitoredItemId = -1;
@@ -172,6 +176,7 @@ int hf_opcua_NoOfAddResults = -1;
 int hf_opcua_NoOfAggregateType = -1;
 int hf_opcua_NoOfArrayDimensions = -1;
 int hf_opcua_NoOfAvailableSequenceNumbers = -1;
+int hf_opcua_NoOfAxisSteps = -1;
 int hf_opcua_NoOfBooleans = -1;
 int hf_opcua_NoOfBrowsePath = -1;
 int hf_opcua_NoOfBrowsePaths = -1;
@@ -190,10 +195,11 @@ int hf_opcua_NoOfDoubles = -1;
 int hf_opcua_NoOfElementDiagnosticInfos = -1;
 int hf_opcua_NoOfElementResults = -1;
 int hf_opcua_NoOfElements = -1;
+int hf_opcua_NoOfEndpointUrlList = -1;
 int hf_opcua_NoOfEndpoints = -1;
 int hf_opcua_NoOfEnumeratedValues = -1;
-int hf_opcua_NoOfEventData = -1;
 int hf_opcua_NoOfEventFields = -1;
+int hf_opcua_NoOfEventIds = -1;
 int hf_opcua_NoOfEvents = -1;
 int hf_opcua_NoOfExpandedNodeIds = -1;
 int hf_opcua_NoOfExtensionObjects = -1;
@@ -216,8 +222,10 @@ int hf_opcua_NoOfLinksToRemove = -1;
 int hf_opcua_NoOfLocaleIds = -1;
 int hf_opcua_NoOfLocalizedTexts = -1;
 int hf_opcua_NoOfMethodsToCall = -1;
+int hf_opcua_NoOfModificationInfos = -1;
 int hf_opcua_NoOfMonitoredItemIds = -1;
 int hf_opcua_NoOfMonitoredItems = -1;
+int hf_opcua_NoOfNetworkPaths = -1;
 int hf_opcua_NoOfNodeIds = -1;
 int hf_opcua_NoOfNodeTypes = -1;
 int hf_opcua_NoOfNodesToAdd = -1;
@@ -246,7 +254,6 @@ int hf_opcua_NoOfRemoveResults = -1;
 int hf_opcua_NoOfReqTimes = -1;
 int hf_opcua_NoOfResults = -1;
 int hf_opcua_NoOfSBytes = -1;
-int hf_opcua_NoOfSelectClause = -1;
 int hf_opcua_NoOfSelectClauseDiagnosticInfos = -1;
 int hf_opcua_NoOfSelectClauseResults = -1;
 int hf_opcua_NoOfSelectClauses = -1;
@@ -266,6 +273,7 @@ int hf_opcua_NoOfUInt16s = -1;
 int hf_opcua_NoOfUInt32s = -1;
 int hf_opcua_NoOfUInt64s = -1;
 int hf_opcua_NoOfUnsupportedUnitIds = -1;
+int hf_opcua_NoOfUpdateValues = -1;
 int hf_opcua_NoOfUserIdentityTokens = -1;
 int hf_opcua_NoOfValues = -1;
 int hf_opcua_NoOfVariants = -1;
@@ -294,6 +302,7 @@ int hf_opcua_PublishingEnabled = -1;
 int hf_opcua_PublishingInterval = -1;
 int hf_opcua_PublishingIntervalCount = -1;
 int hf_opcua_QueueSize = -1;
+int hf_opcua_Real = -1;
 int hf_opcua_RejectedRequestsCount = -1;
 int hf_opcua_RejectedSessionCount = -1;
 int hf_opcua_ReleaseContinuationPoint = -1;
@@ -311,7 +320,6 @@ int hf_opcua_RequestedMaxKeepAliveCount = -1;
 int hf_opcua_RequestedMaxReferencesPerNode = -1;
 int hf_opcua_RequestedPublishingInterval = -1;
 int hf_opcua_RequestedSessionTimeout = -1;
-int hf_opcua_ResampleInterval = -1;
 int hf_opcua_ResultMask = -1;
 int hf_opcua_Results = -1;
 int hf_opcua_RetransmitSequenceNumber = -1;
@@ -359,7 +367,6 @@ int hf_opcua_StartTime = -1;
 int hf_opcua_Status = -1;
 int hf_opcua_StatusCode = -1;
 int hf_opcua_StatusCodes = -1;
-int hf_opcua_SteppedSlopedExtrapolation = -1;
 int hf_opcua_String = -1;
 int hf_opcua_StringTable = -1;
 int hf_opcua_Strings = -1;
@@ -391,7 +398,9 @@ int hf_opcua_UnauthorizedRequestCount = -1;
 int hf_opcua_UnitId = -1;
 int hf_opcua_UnsupportedUnitIds = -1;
 int hf_opcua_UseBinaryEncoding = -1;
-int hf_opcua_UseSeverCapabilitiesDefaults = -1;
+int hf_opcua_UseServerCapabilitiesDefaults = -1;
+int hf_opcua_UseSimpleBounds = -1;
+int hf_opcua_UseSlopedExtrapolation = -1;
 int hf_opcua_UserAccessLevel = -1;
 int hf_opcua_UserExecutable = -1;
 int hf_opcua_UserName = -1;
@@ -403,6 +412,7 @@ int hf_opcua_VendorProductCertificate = -1;
 int hf_opcua_Verb = -1;
 int hf_opcua_ViewVersion = -1;
 int hf_opcua_WriteMask = -1;
+int hf_opcua_X = -1;
 int hf_opcua_XmlElement = -1;
 int hf_opcua_XmlElements = -1;
 
@@ -424,6 +434,7 @@ void registerFieldTypes(int proto)
        { &hf_opcua_AuditEntryId, { "AuditEntryId", "opcua.AuditEntryId", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_AuthenticationMechanism, { "AuthenticationMechanism", "opcua.AuthenticationMechanism", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_AvailableSequenceNumbers, { "AvailableSequenceNumbers", "opcua.AvailableSequenceNumbers", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_AxisSteps, { "AxisSteps", "opcua.AxisSteps", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_Boolean, { "Boolean", "opcua.Boolean", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_Booleans, { "Booleans", "opcua.Booleans", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_BuildDate, { "BuildDate", "opcua.BuildDate", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0, NULL, HFILL } },
@@ -483,6 +494,7 @@ void registerFieldTypes(int proto)
        { &hf_opcua_EncryptionAlgorithm, { "EncryptionAlgorithm", "opcua.EncryptionAlgorithm", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_EndTime, { "EndTime", "opcua.EndTime", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_EndpointUrl, { "EndpointUrl", "opcua.EndpointUrl", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_EndpointUrlList, { "EndpointUrlList", "opcua.EndpointUrlList", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_ErrorCount, { "ErrorCount", "opcua.ErrorCount", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_EventIds, { "EventIds", "opcua.EventIds", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_EventNotificationsCount, { "EventNotificationsCount", "opcua.EventNotificationsCount", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@@ -496,6 +508,7 @@ void registerFieldTypes(int proto)
        { &hf_opcua_Guids, { "Guids", "opcua.Guids", FT_GUID, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_High, { "High", "opcua.High", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_Historizing, { "Historizing", "opcua.Historizing", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_Imaginary, { "Imaginary", "opcua.Imaginary", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_IncludeSubTypes, { "IncludeSubTypes", "opcua.IncludeSubTypes", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_IncludeSubtypes, { "IncludeSubtypes", "opcua.IncludeSubtypes", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_Index, { "Index", "opcua.Index", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@@ -544,6 +557,7 @@ void registerFieldTypes(int proto)
        { &hf_opcua_MaxStringLength, { "MaxStringLength", "opcua.MaxStringLength", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_Message, { "Message", "opcua.Message", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_MinimumSamplingInterval, { "MinimumSamplingInterval", "opcua.MinimumSamplingInterval", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_ModificationTime, { "ModificationTime", "opcua.ModificationTime", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_ModifyCount, { "ModifyCount", "opcua.ModifyCount", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_MonitoredItemCount, { "MonitoredItemCount", "opcua.MonitoredItemCount", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_MonitoredItemId, { "MonitoredItemId", "opcua.MonitoredItemId", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@@ -558,6 +572,7 @@ void registerFieldTypes(int proto)
        { &hf_opcua_NoOfAggregateType, { "NoOfAggregateType", "opcua.NoOfAggregateType", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfArrayDimensions, { "NoOfArrayDimensions", "opcua.NoOfArrayDimensions", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfAvailableSequenceNumbers, { "NoOfAvailableSequenceNumbers", "opcua.NoOfAvailableSequenceNumbers", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_NoOfAxisSteps, { "NoOfAxisSteps", "opcua.NoOfAxisSteps", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfBooleans, { "NoOfBooleans", "opcua.NoOfBooleans", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfBrowsePath, { "NoOfBrowsePath", "opcua.NoOfBrowsePath", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfBrowsePaths, { "NoOfBrowsePaths", "opcua.NoOfBrowsePaths", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@@ -576,10 +591,11 @@ void registerFieldTypes(int proto)
        { &hf_opcua_NoOfElementDiagnosticInfos, { "NoOfElementDiagnosticInfos", "opcua.NoOfElementDiagnosticInfos", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfElementResults, { "NoOfElementResults", "opcua.NoOfElementResults", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfElements, { "NoOfElements", "opcua.NoOfElements", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_NoOfEndpointUrlList, { "NoOfEndpointUrlList", "opcua.NoOfEndpointUrlList", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfEndpoints, { "NoOfEndpoints", "opcua.NoOfEndpoints", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfEnumeratedValues, { "NoOfEnumeratedValues", "opcua.NoOfEnumeratedValues", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
-       { &hf_opcua_NoOfEventData, { "NoOfEventData", "opcua.NoOfEventData", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfEventFields, { "NoOfEventFields", "opcua.NoOfEventFields", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_NoOfEventIds, { "NoOfEventIds", "opcua.NoOfEventIds", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfEvents, { "NoOfEvents", "opcua.NoOfEvents", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfExpandedNodeIds, { "NoOfExpandedNodeIds", "opcua.NoOfExpandedNodeIds", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfExtensionObjects, { "NoOfExtensionObjects", "opcua.NoOfExtensionObjects", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@@ -602,8 +618,10 @@ void registerFieldTypes(int proto)
        { &hf_opcua_NoOfLocaleIds, { "NoOfLocaleIds", "opcua.NoOfLocaleIds", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfLocalizedTexts, { "NoOfLocalizedTexts", "opcua.NoOfLocalizedTexts", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfMethodsToCall, { "NoOfMethodsToCall", "opcua.NoOfMethodsToCall", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_NoOfModificationInfos, { "NoOfModificationInfos", "opcua.NoOfModificationInfos", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfMonitoredItemIds, { "NoOfMonitoredItemIds", "opcua.NoOfMonitoredItemIds", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfMonitoredItems, { "NoOfMonitoredItems", "opcua.NoOfMonitoredItems", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_NoOfNetworkPaths, { "NoOfNetworkPaths", "opcua.NoOfNetworkPaths", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfNodeIds, { "NoOfNodeIds", "opcua.NoOfNodeIds", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfNodeTypes, { "NoOfNodeTypes", "opcua.NoOfNodeTypes", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfNodesToAdd, { "NoOfNodesToAdd", "opcua.NoOfNodesToAdd", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@@ -632,7 +650,6 @@ void registerFieldTypes(int proto)
        { &hf_opcua_NoOfReqTimes, { "NoOfReqTimes", "opcua.NoOfReqTimes", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfResults, { "NoOfResults", "opcua.NoOfResults", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfSBytes, { "NoOfSBytes", "opcua.NoOfSBytes", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
-       { &hf_opcua_NoOfSelectClause, { "NoOfSelectClause", "opcua.NoOfSelectClause", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfSelectClauseDiagnosticInfos, { "NoOfSelectClauseDiagnosticInfos", "opcua.NoOfSelectClauseDiagnosticInfos", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfSelectClauseResults, { "NoOfSelectClauseResults", "opcua.NoOfSelectClauseResults", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfSelectClauses, { "NoOfSelectClauses", "opcua.NoOfSelectClauses", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@@ -652,6 +669,7 @@ void registerFieldTypes(int proto)
        { &hf_opcua_NoOfUInt32s, { "NoOfUInt32s", "opcua.NoOfUInt32s", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfUInt64s, { "NoOfUInt64s", "opcua.NoOfUInt64s", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfUnsupportedUnitIds, { "NoOfUnsupportedUnitIds", "opcua.NoOfUnsupportedUnitIds", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_NoOfUpdateValues, { "NoOfUpdateValues", "opcua.NoOfUpdateValues", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfUserIdentityTokens, { "NoOfUserIdentityTokens", "opcua.NoOfUserIdentityTokens", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfValues, { "NoOfValues", "opcua.NoOfValues", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_NoOfVariants, { "NoOfVariants", "opcua.NoOfVariants", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@@ -680,6 +698,7 @@ void registerFieldTypes(int proto)
        { &hf_opcua_PublishingInterval, { "PublishingInterval", "opcua.PublishingInterval", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_PublishingIntervalCount, { "PublishingIntervalCount", "opcua.PublishingIntervalCount", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_QueueSize, { "QueueSize", "opcua.QueueSize", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_Real, { "Real", "opcua.Real", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_RejectedRequestsCount, { "RejectedRequestsCount", "opcua.RejectedRequestsCount", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_RejectedSessionCount, { "RejectedSessionCount", "opcua.RejectedSessionCount", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_ReleaseContinuationPoint, { "ReleaseContinuationPoint", "opcua.ReleaseContinuationPoint", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
@@ -697,7 +716,6 @@ void registerFieldTypes(int proto)
        { &hf_opcua_RequestedMaxReferencesPerNode, { "RequestedMaxReferencesPerNode", "opcua.RequestedMaxReferencesPerNode", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_RequestedPublishingInterval, { "RequestedPublishingInterval", "opcua.RequestedPublishingInterval", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_RequestedSessionTimeout, { "RequestedSessionTimeout", "opcua.RequestedSessionTimeout", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
-       { &hf_opcua_ResampleInterval, { "ResampleInterval", "opcua.ResampleInterval", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_ResultMask, { "ResultMask", "opcua.ResultMask", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_Results, { "Results", "opcua.Results", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_RetransmitSequenceNumber, { "RetransmitSequenceNumber", "opcua.RetransmitSequenceNumber", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
@@ -745,7 +763,6 @@ void registerFieldTypes(int proto)
        { &hf_opcua_Status, { "Status", "opcua.Status", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_StatusCode, { "StatusCode", "opcua.StatusCode", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_StatusCodes, { "StatusCodes", "opcua.StatusCodes", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
-       { &hf_opcua_SteppedSlopedExtrapolation, { "SteppedSlopedExtrapolation", "opcua.SteppedSlopedExtrapolation", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_String, { "String", "opcua.String", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_StringTable, { "StringTable", "opcua.StringTable", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_Strings, { "Strings", "opcua.Strings", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
@@ -777,18 +794,21 @@ void registerFieldTypes(int proto)
        { &hf_opcua_UnitId, { "UnitId", "opcua.UnitId", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_UnsupportedUnitIds, { "UnsupportedUnitIds", "opcua.UnsupportedUnitIds", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_UseBinaryEncoding, { "UseBinaryEncoding", "opcua.UseBinaryEncoding", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
-       { &hf_opcua_UseSeverCapabilitiesDefaults, { "UseSeverCapabilitiesDefaults", "opcua.UseSeverCapabilitiesDefaults", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_UseServerCapabilitiesDefaults, { "UseServerCapabilitiesDefaults", "opcua.UseServerCapabilitiesDefaults", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_UseSimpleBounds, { "UseSimpleBounds", "opcua.UseSimpleBounds", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_UseSlopedExtrapolation, { "UseSlopedExtrapolation", "opcua.UseSlopedExtrapolation", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_UserAccessLevel, { "UserAccessLevel", "opcua.UserAccessLevel", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_UserExecutable, { "UserExecutable", "opcua.UserExecutable", FT_BOOLEAN, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_UserName, { "UserName", "opcua.UserName", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_UserWriteMask, { "UserWriteMask", "opcua.UserWriteMask", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
-       { &hf_opcua_Value, { "Value", "opcua.Value", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_Value, { "Value", "opcua.Value", FT_FLOAT, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_ValueRank, { "ValueRank", "opcua.ValueRank", FT_INT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_VendorName, { "VendorName", "opcua.VendorName", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_VendorProductCertificate, { "VendorProductCertificate", "opcua.VendorProductCertificate", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_Verb, { "Verb", "opcua.Verb", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_ViewVersion, { "ViewVersion", "opcua.ViewVersion", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_WriteMask, { "WriteMask", "opcua.WriteMask", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
+       { &hf_opcua_X, { "X", "opcua.X", FT_DOUBLE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_XmlElement, { "XmlElement", "opcua.XmlElement", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
        { &hf_opcua_XmlElements, { "XmlElements", "opcua.XmlElements", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
     };
diff --git a/plugins/opcua/opcua_hfindeces.h b/plugins/opcua/opcua_hfindeces.h
index 44cd27a0f5..d2b4f3adc2 100644
--- a/plugins/opcua/opcua_hfindeces.h
+++ b/plugins/opcua/opcua_hfindeces.h
@@ -16,7 +16,7 @@
 **
 ** Description: This file contains protocol field handles.
 **
-** This file was autogenerated on 31.03.2009.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 ** XXX - well, except that you may have to.  See the README.
 **
@@ -37,6 +37,7 @@ extern int hf_opcua_AttributeId;
 extern int hf_opcua_AuditEntryId;
 extern int hf_opcua_AuthenticationMechanism;
 extern int hf_opcua_AvailableSequenceNumbers;
+extern int hf_opcua_AxisSteps;
 extern int hf_opcua_Boolean;
 extern int hf_opcua_Booleans;
 extern int hf_opcua_BuildDate;
@@ -96,6 +97,7 @@ extern int hf_opcua_Encoding;
 extern int hf_opcua_EncryptionAlgorithm;
 extern int hf_opcua_EndTime;
 extern int hf_opcua_EndpointUrl;
+extern int hf_opcua_EndpointUrlList;
 extern int hf_opcua_ErrorCount;
 extern int hf_opcua_EventIds;
 extern int hf_opcua_EventNotificationsCount;
@@ -109,6 +111,7 @@ extern int hf_opcua_Guid;
 extern int hf_opcua_Guids;
 extern int hf_opcua_High;
 extern int hf_opcua_Historizing;
+extern int hf_opcua_Imaginary;
 extern int hf_opcua_IncludeSubTypes;
 extern int hf_opcua_IncludeSubtypes;
 extern int hf_opcua_Index;
@@ -157,6 +160,7 @@ extern int hf_opcua_MaxResponseMessageSize;
 extern int hf_opcua_MaxStringLength;
 extern int hf_opcua_Message;
 extern int hf_opcua_MinimumSamplingInterval;
+extern int hf_opcua_ModificationTime;
 extern int hf_opcua_ModifyCount;
 extern int hf_opcua_MonitoredItemCount;
 extern int hf_opcua_MonitoredItemId;
@@ -171,6 +175,7 @@ extern int hf_opcua_NoOfAddResults;
 extern int hf_opcua_NoOfAggregateType;
 extern int hf_opcua_NoOfArrayDimensions;
 extern int hf_opcua_NoOfAvailableSequenceNumbers;
+extern int hf_opcua_NoOfAxisSteps;
 extern int hf_opcua_NoOfBooleans;
 extern int hf_opcua_NoOfBrowsePath;
 extern int hf_opcua_NoOfBrowsePaths;
@@ -189,10 +194,11 @@ extern int hf_opcua_NoOfDoubles;
 extern int hf_opcua_NoOfElementDiagnosticInfos;
 extern int hf_opcua_NoOfElementResults;
 extern int hf_opcua_NoOfElements;
+extern int hf_opcua_NoOfEndpointUrlList;
 extern int hf_opcua_NoOfEndpoints;
 extern int hf_opcua_NoOfEnumeratedValues;
-extern int hf_opcua_NoOfEventData;
 extern int hf_opcua_NoOfEventFields;
+extern int hf_opcua_NoOfEventIds;
 extern int hf_opcua_NoOfEvents;
 extern int hf_opcua_NoOfExpandedNodeIds;
 extern int hf_opcua_NoOfExtensionObjects;
@@ -215,8 +221,10 @@ extern int hf_opcua_NoOfLinksToRemove;
 extern int hf_opcua_NoOfLocaleIds;
 extern int hf_opcua_NoOfLocalizedTexts;
 extern int hf_opcua_NoOfMethodsToCall;
+extern int hf_opcua_NoOfModificationInfos;
 extern int hf_opcua_NoOfMonitoredItemIds;
 extern int hf_opcua_NoOfMonitoredItems;
+extern int hf_opcua_NoOfNetworkPaths;
 extern int hf_opcua_NoOfNodeIds;
 extern int hf_opcua_NoOfNodeTypes;
 extern int hf_opcua_NoOfNodesToAdd;
@@ -245,7 +253,6 @@ extern int hf_opcua_NoOfRemoveResults;
 extern int hf_opcua_NoOfReqTimes;
 extern int hf_opcua_NoOfResults;
 extern int hf_opcua_NoOfSBytes;
-extern int hf_opcua_NoOfSelectClause;
 extern int hf_opcua_NoOfSelectClauseDiagnosticInfos;
 extern int hf_opcua_NoOfSelectClauseResults;
 extern int hf_opcua_NoOfSelectClauses;
@@ -265,6 +272,7 @@ extern int hf_opcua_NoOfUInt16s;
 extern int hf_opcua_NoOfUInt32s;
 extern int hf_opcua_NoOfUInt64s;
 extern int hf_opcua_NoOfUnsupportedUnitIds;
+extern int hf_opcua_NoOfUpdateValues;
 extern int hf_opcua_NoOfUserIdentityTokens;
 extern int hf_opcua_NoOfValues;
 extern int hf_opcua_NoOfVariants;
@@ -293,6 +301,7 @@ extern int hf_opcua_PublishingEnabled;
 extern int hf_opcua_PublishingInterval;
 extern int hf_opcua_PublishingIntervalCount;
 extern int hf_opcua_QueueSize;
+extern int hf_opcua_Real;
 extern int hf_opcua_RejectedRequestsCount;
 extern int hf_opcua_RejectedSessionCount;
 extern int hf_opcua_ReleaseContinuationPoint;
@@ -310,7 +319,6 @@ extern int hf_opcua_RequestedMaxKeepAliveCount;
 extern int hf_opcua_RequestedMaxReferencesPerNode;
 extern int hf_opcua_RequestedPublishingInterval;
 extern int hf_opcua_RequestedSessionTimeout;
-extern int hf_opcua_ResampleInterval;
 extern int hf_opcua_ResultMask;
 extern int hf_opcua_Results;
 extern int hf_opcua_RetransmitSequenceNumber;
@@ -358,7 +366,6 @@ extern int hf_opcua_StartTime;
 extern int hf_opcua_Status;
 extern int hf_opcua_StatusCode;
 extern int hf_opcua_StatusCodes;
-extern int hf_opcua_SteppedSlopedExtrapolation;
 extern int hf_opcua_String;
 extern int hf_opcua_StringTable;
 extern int hf_opcua_Strings;
@@ -390,7 +397,9 @@ extern int hf_opcua_UnauthorizedRequestCount;
 extern int hf_opcua_UnitId;
 extern int hf_opcua_UnsupportedUnitIds;
 extern int hf_opcua_UseBinaryEncoding;
-extern int hf_opcua_UseSeverCapabilitiesDefaults;
+extern int hf_opcua_UseServerCapabilitiesDefaults;
+extern int hf_opcua_UseSimpleBounds;
+extern int hf_opcua_UseSlopedExtrapolation;
 extern int hf_opcua_UserAccessLevel;
 extern int hf_opcua_UserExecutable;
 extern int hf_opcua_UserName;
@@ -402,6 +411,7 @@ extern int hf_opcua_VendorProductCertificate;
 extern int hf_opcua_Verb;
 extern int hf_opcua_ViewVersion;
 extern int hf_opcua_WriteMask;
+extern int hf_opcua_X;
 extern int hf_opcua_XmlElement;
 extern int hf_opcua_XmlElements;
 
diff --git a/plugins/opcua/opcua_serviceparser.c b/plugins/opcua/opcua_serviceparser.c
index 25ce95b623..b431bbb7b8 100644
--- a/plugins/opcua/opcua_serviceparser.c
+++ b/plugins/opcua/opcua_serviceparser.c
@@ -16,7 +16,7 @@
 **
 ** Description: OpcUa Complex Type Parser
 **
-** This file was autogenerated on 01.04.2009.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 **
 ******************************************************************************/
@@ -30,50 +30,10 @@
 #include "opcua_simpletypes.h"
 #include "opcua_hfindeces.h"
 
-gint ett_opcua_TestStackRequest = -1;
-void parseTestStackRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "TestStackRequest");
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TestStackRequest);
-
-  parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_TestId);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_Iteration);
-  parseVariant(subtree, tvb, pOffset, "Input");
-}
-gint ett_opcua_TestStackResponse = -1;
-void parseTestStackResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "TestStackResponse");
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TestStackResponse);
-
-  parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
-  parseVariant(subtree, tvb, pOffset, "Output");
-}
-gint ett_opcua_TestStackExRequest = -1;
-void parseTestStackExRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "TestStackExRequest");
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TestStackExRequest);
-
-  parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
-  parseUInt32(subtree, tvb, pOffset, hf_opcua_TestId);
-  parseInt32(subtree, tvb, pOffset, hf_opcua_Iteration);
-  parseCompositeTestType(subtree, tvb, pOffset, "Input");
-}
-gint ett_opcua_TestStackExResponse = -1;
-void parseTestStackExResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
-{
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "TestStackExResponse");
-  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TestStackExResponse);
-
-  parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
-  parseCompositeTestType(subtree, tvb, pOffset, "Output");
-}
 gint ett_opcua_FindServersRequest = -1;
 void parseFindServersRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "FindServersRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "FindServersRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_FindServersRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -82,21 +42,23 @@ void parseFindServersRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_LocaleIds, parseString);
   /* Array length field ignored: NoOfServerUris */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_ServerUris, parseString);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_FindServersResponse = -1;
 void parseFindServersResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "FindServersResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "FindServersResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_FindServersResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
   /* Array length field ignored: NoOfServers */
   parseArrayComplex(subtree, tvb, pOffset, "Servers", parseApplicationDescription);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_GetEndpointsRequest = -1;
 void parseGetEndpointsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "GetEndpointsRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "GetEndpointsRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_GetEndpointsRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -105,38 +67,42 @@ void parseGetEndpointsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_LocaleIds, parseString);
   /* Array length field ignored: NoOfProfileUris */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_ProfileUris, parseString);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_GetEndpointsResponse = -1;
 void parseGetEndpointsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "GetEndpointsResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "GetEndpointsResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_GetEndpointsResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
   /* Array length field ignored: NoOfEndpoints */
   parseArrayComplex(subtree, tvb, pOffset, "Endpoints", parseEndpointDescription);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_RegisterServerRequest = -1;
 void parseRegisterServerRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "RegisterServerRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "RegisterServerRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RegisterServerRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   parseRegisteredServer(subtree, tvb, pOffset, "Server");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_RegisterServerResponse = -1;
 void parseRegisterServerResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "RegisterServerResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "RegisterServerResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RegisterServerResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_OpenSecureChannelRequest = -1;
 void parseOpenSecureChannelRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "OpenSecureChannelRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "OpenSecureChannelRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_OpenSecureChannelRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -145,38 +111,42 @@ void parseOpenSecureChannelRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffse
   parseMessageSecurityMode(subtree, tvb, pOffset);
   parseByteString(subtree, tvb, pOffset, hf_opcua_ClientNonce);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RequestedLifetime);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_OpenSecureChannelResponse = -1;
 void parseOpenSecureChannelResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "OpenSecureChannelResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "OpenSecureChannelResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_OpenSecureChannelResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_ServerProtocolVersion);
   parseChannelSecurityToken(subtree, tvb, pOffset, "SecurityToken");
   parseByteString(subtree, tvb, pOffset, hf_opcua_ServerNonce);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CloseSecureChannelRequest = -1;
 void parseCloseSecureChannelRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CloseSecureChannelRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CloseSecureChannelRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CloseSecureChannelRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CloseSecureChannelResponse = -1;
 void parseCloseSecureChannelResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CloseSecureChannelResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CloseSecureChannelResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CloseSecureChannelResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CreateSessionRequest = -1;
 void parseCreateSessionRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CreateSessionRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CreateSessionRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CreateSessionRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -188,11 +158,12 @@ void parseCreateSessionRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseByteString(subtree, tvb, pOffset, hf_opcua_ClientCertificate);
   parseDouble(subtree, tvb, pOffset, hf_opcua_RequestedSessionTimeout);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MaxResponseMessageSize);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CreateSessionResponse = -1;
 void parseCreateSessionResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CreateSessionResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CreateSessionResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CreateSessionResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -207,11 +178,12 @@ void parseCreateSessionResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArrayComplex(subtree, tvb, pOffset, "ServerSoftwareCertificates", parseSignedSoftwareCertificate);
   parseSignatureData(subtree, tvb, pOffset, "ServerSignature");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MaxRequestMessageSize);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ActivateSessionRequest = -1;
 void parseActivateSessionRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "ActivateSessionRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "ActivateSessionRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ActivateSessionRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -222,11 +194,12 @@ void parseActivateSessionRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_LocaleIds, parseString);
   parseExtensionObject(subtree, tvb, pOffset, "UserIdentityToken");
   parseSignatureData(subtree, tvb, pOffset, "UserTokenSignature");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ActivateSessionResponse = -1;
 void parseActivateSessionResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "ActivateSessionResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "ActivateSessionResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ActivateSessionResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -235,56 +208,62 @@ void parseActivateSessionResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CloseSessionRequest = -1;
 void parseCloseSessionRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CloseSessionRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CloseSessionRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CloseSessionRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_DeleteSubscriptions);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CloseSessionResponse = -1;
 void parseCloseSessionResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CloseSessionResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CloseSessionResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CloseSessionResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CancelRequest = -1;
 void parseCancelRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CancelRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CancelRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CancelRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RequestHandle);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CancelResponse = -1;
 void parseCancelResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CancelResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CancelResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CancelResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_CancelCount);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AddNodesRequest = -1;
 void parseAddNodesRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "AddNodesRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "AddNodesRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AddNodesRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfNodesToAdd */
   parseArrayComplex(subtree, tvb, pOffset, "NodesToAdd", parseAddNodesItem);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AddNodesResponse = -1;
 void parseAddNodesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "AddNodesResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "AddNodesResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AddNodesResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -292,21 +271,23 @@ void parseAddNodesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseAddNodesResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AddReferencesRequest = -1;
 void parseAddReferencesRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "AddReferencesRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "AddReferencesRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AddReferencesRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfReferencesToAdd */
   parseArrayComplex(subtree, tvb, pOffset, "ReferencesToAdd", parseAddReferencesItem);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_AddReferencesResponse = -1;
 void parseAddReferencesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "AddReferencesResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "AddReferencesResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_AddReferencesResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -314,21 +295,23 @@ void parseAddReferencesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteNodesRequest = -1;
 void parseDeleteNodesRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "DeleteNodesRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "DeleteNodesRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteNodesRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfNodesToDelete */
   parseArrayComplex(subtree, tvb, pOffset, "NodesToDelete", parseDeleteNodesItem);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteNodesResponse = -1;
 void parseDeleteNodesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "DeleteNodesResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "DeleteNodesResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteNodesResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -336,21 +319,23 @@ void parseDeleteNodesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteReferencesRequest = -1;
 void parseDeleteReferencesRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "DeleteReferencesRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "DeleteReferencesRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteReferencesRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfReferencesToDelete */
   parseArrayComplex(subtree, tvb, pOffset, "ReferencesToDelete", parseDeleteReferencesItem);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteReferencesResponse = -1;
 void parseDeleteReferencesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "DeleteReferencesResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "DeleteReferencesResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteReferencesResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -358,11 +343,12 @@ void parseDeleteReferencesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffse
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_BrowseRequest = -1;
 void parseBrowseRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "BrowseRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "BrowseRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BrowseRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -370,11 +356,12 @@ void parseBrowseRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RequestedMaxReferencesPerNode);
   /* Array length field ignored: NoOfNodesToBrowse */
   parseArrayComplex(subtree, tvb, pOffset, "NodesToBrowse", parseBrowseDescription);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_BrowseResponse = -1;
 void parseBrowseResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "BrowseResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "BrowseResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BrowseResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -382,22 +369,24 @@ void parseBrowseResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseBrowseResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_BrowseNextRequest = -1;
 void parseBrowseNextRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "BrowseNextRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "BrowseNextRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BrowseNextRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_ReleaseContinuationPoints);
   /* Array length field ignored: NoOfContinuationPoints */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_ContinuationPoints, parseByteString);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_BrowseNextResponse = -1;
 void parseBrowseNextResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "BrowseNextResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "BrowseNextResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_BrowseNextResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -405,21 +394,23 @@ void parseBrowseNextResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseBrowseResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_TranslateBrowsePathsToNodeIdsRequest = -1;
 void parseTranslateBrowsePathsToNodeIdsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "TranslateBrowsePathsToNodeIdsRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "TranslateBrowsePathsToNodeIdsRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TranslateBrowsePathsToNodeIdsRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfBrowsePaths */
   parseArrayComplex(subtree, tvb, pOffset, "BrowsePaths", parseBrowsePath);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_TranslateBrowsePathsToNodeIdsResponse = -1;
 void parseTranslateBrowsePathsToNodeIdsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "TranslateBrowsePathsToNodeIdsResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "TranslateBrowsePathsToNodeIdsResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TranslateBrowsePathsToNodeIdsResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -427,49 +418,54 @@ void parseTranslateBrowsePathsToNodeIdsResponse(proto_tree *tree, tvbuff_t *tvb,
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseBrowsePathResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_RegisterNodesRequest = -1;
 void parseRegisterNodesRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "RegisterNodesRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "RegisterNodesRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RegisterNodesRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfNodesToRegister */
   parseArrayComplex(subtree, tvb, pOffset, "NodesToRegister", parseNodeId);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_RegisterNodesResponse = -1;
 void parseRegisterNodesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "RegisterNodesResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "RegisterNodesResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RegisterNodesResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
   /* Array length field ignored: NoOfRegisteredNodeIds */
   parseArrayComplex(subtree, tvb, pOffset, "RegisteredNodeIds", parseNodeId);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_UnregisterNodesRequest = -1;
 void parseUnregisterNodesRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "UnregisterNodesRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "UnregisterNodesRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_UnregisterNodesRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfNodesToUnregister */
   parseArrayComplex(subtree, tvb, pOffset, "NodesToUnregister", parseNodeId);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_UnregisterNodesResponse = -1;
 void parseUnregisterNodesResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "UnregisterNodesResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "UnregisterNodesResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_UnregisterNodesResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_QueryFirstRequest = -1;
 void parseQueryFirstRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "QueryFirstRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "QueryFirstRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_QueryFirstRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -479,11 +475,12 @@ void parseQueryFirstRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseContentFilter(subtree, tvb, pOffset, "Filter");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MaxDataSetsToReturn);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MaxReferencesToReturn);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_QueryFirstResponse = -1;
 void parseQueryFirstResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "QueryFirstResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "QueryFirstResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_QueryFirstResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -495,32 +492,35 @@ void parseQueryFirstResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
   parseContentFilterResult(subtree, tvb, pOffset, "FilterResult");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_QueryNextRequest = -1;
 void parseQueryNextRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "QueryNextRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "QueryNextRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_QueryNextRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_ReleaseContinuationPoint);
   parseByteString(subtree, tvb, pOffset, hf_opcua_ContinuationPoint);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_QueryNextResponse = -1;
 void parseQueryNextResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "QueryNextResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "QueryNextResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_QueryNextResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
   /* Array length field ignored: NoOfQueryDataSets */
   parseArrayComplex(subtree, tvb, pOffset, "QueryDataSets", parseQueryDataSet);
   parseByteString(subtree, tvb, pOffset, hf_opcua_RevisedContinuationPoint);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReadRequest = -1;
 void parseReadRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "ReadRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "ReadRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReadRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -528,11 +528,12 @@ void parseReadRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseTimestampsToReturn(subtree, tvb, pOffset);
   /* Array length field ignored: NoOfNodesToRead */
   parseArrayComplex(subtree, tvb, pOffset, "NodesToRead", parseReadValueId);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ReadResponse = -1;
 void parseReadResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "ReadResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "ReadResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ReadResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -540,11 +541,12 @@ void parseReadResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseDataValue);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryReadRequest = -1;
 void parseHistoryReadRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "HistoryReadRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "HistoryReadRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryReadRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -553,11 +555,12 @@ void parseHistoryReadRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseBoolean(subtree, tvb, pOffset, hf_opcua_ReleaseContinuationPoints);
   /* Array length field ignored: NoOfNodesToRead */
   parseArrayComplex(subtree, tvb, pOffset, "NodesToRead", parseHistoryReadValueId);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryReadResponse = -1;
 void parseHistoryReadResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "HistoryReadResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "HistoryReadResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryReadResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -565,21 +568,23 @@ void parseHistoryReadResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseHistoryReadResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_WriteRequest = -1;
 void parseWriteRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "WriteRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "WriteRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_WriteRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfNodesToWrite */
   parseArrayComplex(subtree, tvb, pOffset, "NodesToWrite", parseWriteValue);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_WriteResponse = -1;
 void parseWriteResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "WriteResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "WriteResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_WriteResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -587,21 +592,23 @@ void parseWriteResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryUpdateRequest = -1;
 void parseHistoryUpdateRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "HistoryUpdateRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "HistoryUpdateRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryUpdateRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfHistoryUpdateDetails */
   parseArrayComplex(subtree, tvb, pOffset, "HistoryUpdateDetails", parseExtensionObject);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_HistoryUpdateResponse = -1;
 void parseHistoryUpdateResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "HistoryUpdateResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "HistoryUpdateResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_HistoryUpdateResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -609,21 +616,23 @@ void parseHistoryUpdateResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseHistoryUpdateResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CallRequest = -1;
 void parseCallRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CallRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CallRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CallRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfMethodsToCall */
   parseArrayComplex(subtree, tvb, pOffset, "MethodsToCall", parseCallMethodRequest);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CallResponse = -1;
 void parseCallResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CallResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CallResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CallResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -631,11 +640,12 @@ void parseCallResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseCallMethodResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CreateMonitoredItemsRequest = -1;
 void parseCreateMonitoredItemsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CreateMonitoredItemsRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CreateMonitoredItemsRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CreateMonitoredItemsRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -643,11 +653,12 @@ void parseCreateMonitoredItemsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOf
   parseTimestampsToReturn(subtree, tvb, pOffset);
   /* Array length field ignored: NoOfItemsToCreate */
   parseArrayComplex(subtree, tvb, pOffset, "ItemsToCreate", parseMonitoredItemCreateRequest);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CreateMonitoredItemsResponse = -1;
 void parseCreateMonitoredItemsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CreateMonitoredItemsResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CreateMonitoredItemsResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CreateMonitoredItemsResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -655,11 +666,12 @@ void parseCreateMonitoredItemsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pO
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseMonitoredItemCreateResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ModifyMonitoredItemsRequest = -1;
 void parseModifyMonitoredItemsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "ModifyMonitoredItemsRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "ModifyMonitoredItemsRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ModifyMonitoredItemsRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -667,11 +679,12 @@ void parseModifyMonitoredItemsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOf
   parseTimestampsToReturn(subtree, tvb, pOffset);
   /* Array length field ignored: NoOfItemsToModify */
   parseArrayComplex(subtree, tvb, pOffset, "ItemsToModify", parseMonitoredItemModifyRequest);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ModifyMonitoredItemsResponse = -1;
 void parseModifyMonitoredItemsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "ModifyMonitoredItemsResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "ModifyMonitoredItemsResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ModifyMonitoredItemsResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -679,11 +692,12 @@ void parseModifyMonitoredItemsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pO
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseMonitoredItemModifyResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SetMonitoringModeRequest = -1;
 void parseSetMonitoringModeRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "SetMonitoringModeRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "SetMonitoringModeRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SetMonitoringModeRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -691,11 +705,12 @@ void parseSetMonitoringModeRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffse
   parseMonitoringMode(subtree, tvb, pOffset);
   /* Array length field ignored: NoOfMonitoredItemIds */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_MonitoredItemIds, parseUInt32);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SetMonitoringModeResponse = -1;
 void parseSetMonitoringModeResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "SetMonitoringModeResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "SetMonitoringModeResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SetMonitoringModeResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -703,11 +718,12 @@ void parseSetMonitoringModeResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffs
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SetTriggeringRequest = -1;
 void parseSetTriggeringRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "SetTriggeringRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "SetTriggeringRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SetTriggeringRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -717,11 +733,12 @@ void parseSetTriggeringRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_LinksToAdd, parseUInt32);
   /* Array length field ignored: NoOfLinksToRemove */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_LinksToRemove, parseUInt32);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SetTriggeringResponse = -1;
 void parseSetTriggeringResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "SetTriggeringResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "SetTriggeringResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SetTriggeringResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -733,22 +750,24 @@ void parseSetTriggeringResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_RemoveResults, parseStatusCode);
   /* Array length field ignored: NoOfRemoveDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "RemoveDiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteMonitoredItemsRequest = -1;
 void parseDeleteMonitoredItemsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "DeleteMonitoredItemsRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "DeleteMonitoredItemsRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteMonitoredItemsRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_SubscriptionId);
   /* Array length field ignored: NoOfMonitoredItemIds */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_MonitoredItemIds, parseUInt32);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteMonitoredItemsResponse = -1;
 void parseDeleteMonitoredItemsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "DeleteMonitoredItemsResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "DeleteMonitoredItemsResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteMonitoredItemsResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -756,11 +775,12 @@ void parseDeleteMonitoredItemsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pO
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CreateSubscriptionRequest = -1;
 void parseCreateSubscriptionRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CreateSubscriptionRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CreateSubscriptionRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CreateSubscriptionRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -770,11 +790,12 @@ void parseCreateSubscriptionRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffs
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MaxNotificationsPerPublish);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_PublishingEnabled);
   parseByte(subtree, tvb, pOffset, hf_opcua_Priority);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_CreateSubscriptionResponse = -1;
 void parseCreateSubscriptionResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "CreateSubscriptionResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "CreateSubscriptionResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_CreateSubscriptionResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -782,11 +803,12 @@ void parseCreateSubscriptionResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOff
   parseDouble(subtree, tvb, pOffset, hf_opcua_RevisedPublishingInterval);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RevisedLifetimeCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RevisedMaxKeepAliveCount);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ModifySubscriptionRequest = -1;
 void parseModifySubscriptionRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "ModifySubscriptionRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "ModifySubscriptionRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ModifySubscriptionRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
@@ -796,33 +818,36 @@ void parseModifySubscriptionRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffs
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RequestedMaxKeepAliveCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_MaxNotificationsPerPublish);
   parseByte(subtree, tvb, pOffset, hf_opcua_Priority);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_ModifySubscriptionResponse = -1;
 void parseModifySubscriptionResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "ModifySubscriptionResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "ModifySubscriptionResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_ModifySubscriptionResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
   parseDouble(subtree, tvb, pOffset, hf_opcua_RevisedPublishingInterval);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RevisedLifetimeCount);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RevisedMaxKeepAliveCount);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SetPublishingModeRequest = -1;
 void parseSetPublishingModeRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "SetPublishingModeRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "SetPublishingModeRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SetPublishingModeRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   parseBoolean(subtree, tvb, pOffset, hf_opcua_PublishingEnabled);
   /* Array length field ignored: NoOfSubscriptionIds */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_SubscriptionIds, parseUInt32);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_SetPublishingModeResponse = -1;
 void parseSetPublishingModeResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "SetPublishingModeResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "SetPublishingModeResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_SetPublishingModeResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -830,21 +855,23 @@ void parseSetPublishingModeResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffs
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_PublishRequest = -1;
 void parsePublishRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "PublishRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "PublishRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_PublishRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfSubscriptionAcknowledgements */
   parseArrayComplex(subtree, tvb, pOffset, "SubscriptionAcknowledgements", parseSubscriptionAcknowledgement);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_PublishResponse = -1;
 void parsePublishResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "PublishResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "PublishResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_PublishResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -857,41 +884,45 @@ void parsePublishResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_RepublishRequest = -1;
 void parseRepublishRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "RepublishRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "RepublishRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RepublishRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   parseUInt32(subtree, tvb, pOffset, hf_opcua_SubscriptionId);
   parseUInt32(subtree, tvb, pOffset, hf_opcua_RetransmitSequenceNumber);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_RepublishResponse = -1;
 void parseRepublishResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "RepublishResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "RepublishResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_RepublishResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
   parseNotificationMessage(subtree, tvb, pOffset, "NotificationMessage");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_TransferSubscriptionsRequest = -1;
 void parseTransferSubscriptionsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "TransferSubscriptionsRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "TransferSubscriptionsRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TransferSubscriptionsRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfSubscriptionIds */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_SubscriptionIds, parseUInt32);
   parseBoolean(subtree, tvb, pOffset, hf_opcua_SendInitialValues);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_TransferSubscriptionsResponse = -1;
 void parseTransferSubscriptionsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "TransferSubscriptionsResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "TransferSubscriptionsResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TransferSubscriptionsResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -899,21 +930,23 @@ void parseTransferSubscriptionsResponse(proto_tree *tree, tvbuff_t *tvb, gint *p
   parseArrayComplex(subtree, tvb, pOffset, "Results", parseTransferResult);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteSubscriptionsRequest = -1;
 void parseDeleteSubscriptionsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "DeleteSubscriptionsRequest");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "DeleteSubscriptionsRequest");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteSubscriptionsRequest);
 
   parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
   /* Array length field ignored: NoOfSubscriptionIds */
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_SubscriptionIds, parseUInt32);
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 gint ett_opcua_DeleteSubscriptionsResponse = -1;
 void parseDeleteSubscriptionsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
-  proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "DeleteSubscriptionsResponse");
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "DeleteSubscriptionsResponse");
   proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_DeleteSubscriptionsResponse);
 
   parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
@@ -921,15 +954,56 @@ void parseDeleteSubscriptionsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOf
   parseArraySimple(subtree, tvb, pOffset, hf_opcua_Results, parseStatusCode);
   /* Array length field ignored: NoOfDiagnosticInfos */
   parseArrayComplex(subtree, tvb, pOffset, "DiagnosticInfos", parseDiagnosticInfo);
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_TestStackRequest = -1;
+void parseTestStackRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "TestStackRequest");
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TestStackRequest);
+
+  parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_TestId);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_Iteration);
+  parseVariant(subtree, tvb, pOffset, "Input");
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_TestStackResponse = -1;
+void parseTestStackResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "TestStackResponse");
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TestStackResponse);
+
+  parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
+  parseVariant(subtree, tvb, pOffset, "Output");
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_TestStackExRequest = -1;
+void parseTestStackExRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "TestStackExRequest");
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TestStackExRequest);
+
+  parseRequestHeader(subtree, tvb, pOffset, "RequestHeader");
+  parseUInt32(subtree, tvb, pOffset, hf_opcua_TestId);
+  parseInt32(subtree, tvb, pOffset, hf_opcua_Iteration);
+  parseCompositeTestType(subtree, tvb, pOffset, "Input");
+  proto_item_set_end(ti, tvb, *pOffset);
+}
+gint ett_opcua_TestStackExResponse = -1;
+void parseTestStackExResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
+{
+  proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "TestStackExResponse");
+  proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_TestStackExResponse);
+
+  parseResponseHeader(subtree, tvb, pOffset, "ResponseHeader");
+  parseCompositeTestType(subtree, tvb, pOffset, "Output");
+  proto_item_set_end(ti, tvb, *pOffset);
 }
 
 /** Setup protocol subtree array */
 static gint *ett[] =
 {
-  &ett_opcua_TestStackRequest,
-  &ett_opcua_TestStackResponse,
-  &ett_opcua_TestStackExRequest,
-  &ett_opcua_TestStackExResponse,
   &ett_opcua_FindServersRequest,
   &ett_opcua_FindServersResponse,
   &ett_opcua_GetEndpointsRequest,
@@ -1004,6 +1078,10 @@ static gint *ett[] =
   &ett_opcua_TransferSubscriptionsResponse,
   &ett_opcua_DeleteSubscriptionsRequest,
   &ett_opcua_DeleteSubscriptionsResponse,
+  &ett_opcua_TestStackRequest,
+  &ett_opcua_TestStackResponse,
+  &ett_opcua_TestStackExRequest,
+  &ett_opcua_TestStackExResponse,
 };
 
 void registerServiceTypes(void)
diff --git a/plugins/opcua/opcua_serviceparser.h b/plugins/opcua/opcua_serviceparser.h
index b674ebf284..6d36d845ac 100644
--- a/plugins/opcua/opcua_serviceparser.h
+++ b/plugins/opcua/opcua_serviceparser.h
@@ -16,7 +16,7 @@
 **
 ** Description: OpcUa Service Type Parser
 **
-** This file was autogenerated on 31.03.2009.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 ** XXX - well, except that you may have to.  See the README.
 **
@@ -25,10 +25,6 @@
 #include <glib.h>
 #include <epan/packet.h>
 
-void parseTestStackRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
-void parseTestStackResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
-void parseTestStackExRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
-void parseTestStackExResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseFindServersRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseFindServersResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseGetEndpointsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
@@ -103,4 +99,8 @@ void parseTransferSubscriptionsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pO
 void parseTransferSubscriptionsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseDeleteSubscriptionsRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void parseDeleteSubscriptionsResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseTestStackRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseTestStackResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseTestStackExRequest(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
+void parseTestStackExResponse(proto_tree *tree, tvbuff_t *tvb, gint *pOffset);
 void registerServiceTypes(void);
diff --git a/plugins/opcua/opcua_servicetable.c b/plugins/opcua/opcua_servicetable.c
index 1d39ca5fc1..4d82d6ac4c 100644
--- a/plugins/opcua/opcua_servicetable.c
+++ b/plugins/opcua/opcua_servicetable.c
@@ -16,7 +16,7 @@
 **
 ** Description: Service table and service dispatcher.
 **
-** This file was autogenerated on 31.03.2009.
+** This file was autogenerated on 12.02.2013.
 ** DON'T MODIFY THIS FILE!
 **
 ******************************************************************************/
@@ -30,10 +30,6 @@
 #include "opcua_serviceids.h"
 
 ParserEntry g_arParserTable[] = {
-    { OpcUaId_TestStackRequest_Encoding_DefaultBinary, parseTestStackRequest },
-    { OpcUaId_TestStackResponse_Encoding_DefaultBinary, parseTestStackResponse },
-    { OpcUaId_TestStackExRequest_Encoding_DefaultBinary, parseTestStackExRequest },
-    { OpcUaId_TestStackExResponse_Encoding_DefaultBinary, parseTestStackExResponse },
     { OpcUaId_FindServersRequest_Encoding_DefaultBinary, parseFindServersRequest },
     { OpcUaId_FindServersResponse_Encoding_DefaultBinary, parseFindServersResponse },
     { OpcUaId_GetEndpointsRequest_Encoding_DefaultBinary, parseGetEndpointsRequest },
@@ -108,15 +104,15 @@ ParserEntry g_arParserTable[] = {
     { OpcUaId_TransferSubscriptionsResponse_Encoding_DefaultBinary, parseTransferSubscriptionsResponse },
     { OpcUaId_DeleteSubscriptionsRequest_Encoding_DefaultBinary, parseDeleteSubscriptionsRequest },
     { OpcUaId_DeleteSubscriptionsResponse_Encoding_DefaultBinary, parseDeleteSubscriptionsResponse },
+    { OpcUaId_TestStackRequest_Encoding_DefaultBinary, parseTestStackRequest },
+    { OpcUaId_TestStackResponse_Encoding_DefaultBinary, parseTestStackResponse },
+    { OpcUaId_TestStackExRequest_Encoding_DefaultBinary, parseTestStackExRequest },
+    { OpcUaId_TestStackExResponse_Encoding_DefaultBinary, parseTestStackExResponse },
 };
 const int g_NumServices = sizeof(g_arParserTable) / sizeof(ParserEntry);
 
 /** Service type table */
 const value_string g_requesttypes[] = {
-    { OpcUaId_TestStackRequest_Encoding_DefaultBinary, "TestStackRequest" },
-    { OpcUaId_TestStackResponse_Encoding_DefaultBinary, "TestStackResponse" },
-    { OpcUaId_TestStackExRequest_Encoding_DefaultBinary, "TestStackExRequest" },
-    { OpcUaId_TestStackExResponse_Encoding_DefaultBinary, "TestStackExResponse" },
     { OpcUaId_FindServersRequest_Encoding_DefaultBinary, "FindServersRequest" },
     { OpcUaId_FindServersResponse_Encoding_DefaultBinary, "FindServersResponse" },
     { OpcUaId_GetEndpointsRequest_Encoding_DefaultBinary, "GetEndpointsRequest" },
@@ -191,6 +187,10 @@ const value_string g_requesttypes[] = {
     { OpcUaId_TransferSubscriptionsResponse_Encoding_DefaultBinary, "TransferSubscriptionsResponse" },
     { OpcUaId_DeleteSubscriptionsRequest_Encoding_DefaultBinary, "DeleteSubscriptionsRequest" },
     { OpcUaId_DeleteSubscriptionsResponse_Encoding_DefaultBinary, "DeleteSubscriptionsResponse" },
+    { OpcUaId_TestStackRequest_Encoding_DefaultBinary, "TestStackRequest" },
+    { OpcUaId_TestStackResponse_Encoding_DefaultBinary, "TestStackResponse" },
+    { OpcUaId_TestStackExRequest_Encoding_DefaultBinary, "TestStackExRequest" },
+    { OpcUaId_TestStackExResponse_Encoding_DefaultBinary, "TestStackExResponse" },
     { 0, NULL }
 };
 
diff --git a/plugins/opcua/opcua_simpletypes.c b/plugins/opcua/opcua_simpletypes.c
index 0bbcb6f928..14a446b532 100644
--- a/plugins/opcua/opcua_simpletypes.c
+++ b/plugins/opcua/opcua_simpletypes.c
@@ -192,6 +192,32 @@ static const value_string g_VariantTypes[] = {
     { 0x80+23, "Array of DataValue" },
     { 0x80+24, "Array of Variant" },
     { 0x80+25, "Array of DiagnosticInfo" },
+    { 0xC0,   "Matrix of Null" },
+    { 0xC0+1, "Matrix of Boolean" },
+    { 0xC0+2, "Matrix of SByte" },
+    { 0xC0+3, "Matrix of Byte" },
+    { 0xC0+4, "Matrix of Int16" },
+    { 0xC0+5, "Matrix of UInt16" },
+    { 0xC0+6, "Matrix of Int32" },
+    { 0xC0+7, "Matrix of UInt32" },
+    { 0xC0+8, "Matrix of Int64" },
+    { 0xC0+9, "Matrix of UInt64" },
+    { 0xC0+10, "Matrix of Float" },
+    { 0xC0+11, "Matrix of Double" },
+    { 0xC0+12, "Matrix of String" },
+    { 0xC0+13, "Matrix of DateTime" },
+    { 0xC0+14, "Matrix of Guid" },
+    { 0xC0+15, "Matrix of ByteString" },
+    { 0xC0+16, "Matrix of XmlElement" },
+    { 0xC0+17, "Matrix of NodeId" },
+    { 0xC0+18, "Matrix of ExpandedNodeId" },
+    { 0xC0+19, "Matrix of StatusCode" },
+    { 0xC0+20, "Matrix of QualifiedName" },
+    { 0xC0+21, "Matrix of LocalizedText" },
+    { 0xC0+22, "Matrix of ExtensionObject" },
+    { 0xC0+23, "Matrix of DataValue" },
+    { 0xC0+24, "Matrix of Variant" },
+    { 0xC0+25, "Matrix of DiagnosticInfo" },
     { 0, NULL }
 };
 #define VARIANT_ARRAYDIMENSIONS 0x40
@@ -345,24 +371,27 @@ void parseString(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, int hfIndex)
 
     if (iLen == -1)
     {
-        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, iOffset, 0, ENC_ASCII|ENC_NA);
+        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, *pOffset, 0, ENC_NA);
         proto_item_append_text(item, "[OpcUa Null String]");
+        proto_item_set_end(item, tvb, *pOffset + 4);
     }
     else if (iLen == 0)
     {
-        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, iOffset, 0, ENC_ASCII|ENC_NA);
+        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, *pOffset, 0, ENC_NA);
         proto_item_append_text(item, "[OpcUa Empty String]");
+        proto_item_set_end(item, tvb, *pOffset + 4);
     }
     else if (iLen > 0)
     {
-        proto_tree_add_item(tree, hfIndex, tvb, iOffset, iLen, ENC_ASCII|ENC_NA);
+        proto_tree_add_item(tree, hfIndex, tvb, iOffset, iLen, ENC_UTF_8|ENC_NA);
         iOffset += iLen; /* eat the whole string */
     }
     else
     {
-        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, iOffset, 0, ENC_ASCII|ENC_NA);
+        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, *pOffset, 0, ENC_NA);
         szValue = ep_strdup_printf("[Invalid String] Invalid length: %d", iLen);
         proto_item_append_text(item, "%s", szValue);
+        proto_item_set_end(item, tvb, *pOffset + 4);
     }
 
     *pOffset = iOffset;
@@ -381,14 +410,15 @@ void parseLocalizedText(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const ch
     proto_tree *mask_tree;
     proto_tree *subtree;
     proto_item *ti;
+    proto_item *ti_inner;
 
-    ti = proto_tree_add_text(tree, tvb, 0, -1, "%s: LocalizedText", szFieldName);
+    ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s: LocalizedText", szFieldName);
     subtree = proto_item_add_subtree(ti, ett_opcua_localizedtext);
 
     /* parse encoding mask */
     EncodingMask = tvb_get_guint8(tvb, iOffset);
-    ti = proto_tree_add_text(subtree, tvb, 0, -1, "EncodingMask");
-    mask_tree = proto_item_add_subtree(ti, ett_opcua_localizedtext);
+    ti_inner = proto_tree_add_text(subtree, tvb, iOffset, 1, "EncodingMask");
+    mask_tree = proto_item_add_subtree(ti_inner, ett_opcua_localizedtext);
     proto_tree_add_item(mask_tree, hf_opcua_loctext_mask_localeflag, tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
     proto_tree_add_item(mask_tree, hf_opcua_loctext_mask_textflag,   tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
     iOffset++;
@@ -403,6 +433,7 @@ void parseLocalizedText(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const ch
         parseString(subtree, tvb, &iOffset, hf_opcua_localizedtext_text);
     }
 
+    proto_item_set_end(ti, tvb, iOffset);
     *pOffset = iOffset;
 }
 
@@ -420,13 +451,15 @@ void parseByteString(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, int hfIndex
 
     if (iLen == -1)
     {
-        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, iOffset, 0, ENC_NA);
+        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, *pOffset, 0, ENC_NA);
         proto_item_append_text(item, "[OpcUa Null ByteString]");
+        proto_item_set_end(item, tvb, *pOffset + 4);
     }
     else if (iLen == 0)
     {
-        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, iOffset, 0, ENC_NA);
+        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, *pOffset, 0, ENC_NA);
         proto_item_append_text(item, "[OpcUa Empty ByteString]");
+        proto_item_set_end(item, tvb, *pOffset + 4);
     }
     else if (iLen > 0)
     {
@@ -435,9 +468,10 @@ void parseByteString(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, int hfIndex
     }
     else
     {
-        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, iOffset, 0, ENC_NA);
+        proto_item *item = proto_tree_add_item(tree, hfIndex, tvb, *pOffset, 0, ENC_NA);
         szValue = ep_strdup_printf("[Invalid ByteString] Invalid length: %d", iLen);
         proto_item_append_text(item, "%s", szValue);
+        proto_item_set_end(item, tvb, *pOffset + 4);
     }
 
     *pOffset = iOffset;
@@ -472,14 +506,15 @@ void parseDiagnosticInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const c
     proto_tree *mask_tree;
     proto_tree *subtree;
     proto_item *ti;
+    proto_item *ti_inner;
 
-    ti = proto_tree_add_text(tree, tvb, 0, -1, "%s: DiagnosticInfo", szFieldName);
+    ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s: DiagnosticInfo", szFieldName);
     subtree = proto_item_add_subtree(ti, ett_opcua_diagnosticinfo);
 
     /* parse encoding mask */
     EncodingMask = tvb_get_guint8(tvb, iOffset);
-    ti = proto_tree_add_text(subtree, tvb, 0, -1, "EncodingMask");
-    mask_tree = proto_item_add_subtree(ti, ett_opcua_diagnosticinfo);
+    ti_inner = proto_tree_add_text(subtree, tvb, iOffset, 1, "EncodingMask");
+    mask_tree = proto_item_add_subtree(ti_inner, ett_opcua_diagnosticinfo);
     proto_tree_add_item(mask_tree, hf_opcua_diag_mask_symbolicflag,        tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
     proto_tree_add_item(mask_tree, hf_opcua_diag_mask_namespaceflag,       tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
     proto_tree_add_item(mask_tree, hf_opcua_diag_mask_localizedtextflag,   tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
@@ -513,29 +548,33 @@ void parseDiagnosticInfo(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const c
         parseDiagnosticInfo(subtree, tvb, &iOffset, "Inner DiagnosticInfo");
     }
 
+    proto_item_set_end(ti, tvb, iOffset);
     *pOffset = iOffset;
 }
 
 void parseQualifiedName(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-    proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s: QualifiedName", szFieldName);
+    proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s: QualifiedName", szFieldName);
     proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_qualifiedname);
 
     parseUInt16(subtree, tvb, pOffset, hf_opcua_qualifiedname_id);
     parseString(subtree, tvb, pOffset, hf_opcua_qualifiedname_name);
+
+    proto_item_set_end(ti, tvb, *pOffset);
 }
 
 void parseDataValue(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-    proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s: DataValue", szFieldName);
+    proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s: DataValue", szFieldName);
     proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_datavalue);
     proto_tree *mask_tree;
     gint    iOffset = *pOffset;
     guint8  EncodingMask;
+    proto_item *ti_inner;
 
     EncodingMask = tvb_get_guint8(tvb, iOffset);
-    ti = proto_tree_add_text(subtree, tvb, 0, -1, "EncodingMask");
-    mask_tree = proto_item_add_subtree(ti, ett_opcua_datavalue);
+    ti_inner = proto_tree_add_text(subtree, tvb, iOffset, 1, "EncodingMask");
+    mask_tree = proto_item_add_subtree(ti_inner, ett_opcua_datavalue);
     proto_tree_add_item(mask_tree, hf_opcua_datavalue_mask_valueflag,           tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
     proto_tree_add_item(mask_tree, hf_opcua_datavalue_mask_statuscodeflag,      tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
     proto_tree_add_item(mask_tree, hf_opcua_datavalue_mask_sourcetimestampflag, tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
@@ -569,16 +608,17 @@ void parseDataValue(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *
         parseUInt16(subtree, tvb, &iOffset, hf_opcua_ServerPicoseconds);
     }
 
+    proto_item_set_end(ti, tvb, iOffset);
     *pOffset = iOffset;
 }
 
 void parseVariant(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-    proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s: Variant", szFieldName);
+    proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s: Variant", szFieldName);
     proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_variant);
     gint    iOffset = *pOffset;
     guint8  EncodingMask;
-    gint32  ArrayLength = 0;
+    gint32  ArrayDimensions = 0;
 
     EncodingMask = tvb_get_guint8(tvb, iOffset);
     proto_tree_add_item(subtree, hf_opcua_variant_encodingmask, tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
@@ -586,8 +626,6 @@ void parseVariant(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *sz
 
     if (EncodingMask & VARIANT_ARRAYMASK)
     {
-        ArrayLength = tvb_get_letohl(tvb, iOffset);
-
         /* type is encoded in bits 0-5 */
         switch(EncodingMask & 0x3f)
         {
@@ -621,24 +659,28 @@ void parseVariant(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *sz
 
         if (EncodingMask & VARIANT_ARRAYDIMENSIONS)
         {
-            proto_item *ti_2 = proto_tree_add_text(tree, tvb, 0, -1, "Array Dimensions");
+            proto_item *ti_2 = proto_tree_add_text(subtree, tvb, iOffset, -1, "ArrayDimensions");
             proto_tree *subtree_2 = proto_item_add_subtree(ti_2, ett_opcua_array);
             int i;
 
-            if (ArrayLength < MAX_ARRAY_LEN)
-            {
-                for (i=0; i<ArrayLength; i++)
-                {
-                    parseInt32(subtree_2, tvb, pOffset, hf_opcua_Int32);
-                }
-            }
-            else
+            /* read array length */
+            ArrayDimensions = tvb_get_letohl(tvb, iOffset);
+            proto_tree_add_item(subtree_2, hf_opcua_ArraySize, tvb, iOffset, 4, ENC_LITTLE_ENDIAN);
+
+            if (ArrayDimensions > MAX_ARRAY_LEN)
             {
                 proto_item *pi;
-                /* XXX - This should be expert_add_info_format, but we need pinfo for that */
-                pi = proto_tree_add_text(tree, tvb, iOffset, 4, "Array length %d too large to process", ArrayLength);
+                pi = proto_tree_add_text(subtree_2, tvb, iOffset, 4, "ArrayDimensions length %d too large to process", ArrayDimensions);
                 PROTO_ITEM_SET_GENERATED(pi);
+                return;
+            }
+
+            iOffset += 4;
+            for (i=0; i<ArrayDimensions; i++)
+            {
+                parseInt32(subtree_2, tvb, &iOffset, hf_opcua_Int32);
             }
+            proto_item_set_end(ti_2, tvb, iOffset);
         }
     }
     else
@@ -675,6 +717,7 @@ void parseVariant(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *sz
         }
     }
 
+    proto_item_set_end(ti, tvb, iOffset);
     *pOffset = iOffset;
 }
 
@@ -685,7 +728,7 @@ void parseVariant(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *sz
 void parseArraySimple(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, int hfIndex, fctSimpleTypeParser pParserFunction)
 {
     static const char szFieldName[] = "Array of Simple Type";
-    proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s", szFieldName);
+    proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s", szFieldName);
     proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_array);
     int i;
     gint32 iLen;
@@ -696,9 +739,9 @@ void parseArraySimple(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, int hfInde
 
     if (iLen > MAX_ARRAY_LEN)
     {
-	proto_item *pi;
+        proto_item *pi;
         pi = proto_tree_add_text(tree, tvb, *pOffset, 4, "Array length %d too large to process", iLen);
-	PROTO_ITEM_SET_GENERATED(pi);
+        PROTO_ITEM_SET_GENERATED(pi);
         return;
     }
 
@@ -707,6 +750,7 @@ void parseArraySimple(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, int hfInde
     {
         (*pParserFunction)(subtree, tvb, pOffset, hfIndex);
     }
+    proto_item_set_end(ti, tvb, *pOffset);
 }
 
 /** General parsing function for arrays of enums.
@@ -716,7 +760,7 @@ void parseArraySimple(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, int hfInde
 void parseArrayEnum(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, fctEnumParser pParserFunction)
 {
     static const char szFieldName[] = "Array of Enum Type";
-    proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s", szFieldName);
+    proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s", szFieldName);
     proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_array);
     int i;
     gint32 iLen;
@@ -727,9 +771,9 @@ void parseArrayEnum(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, fctEnumParse
 
     if (iLen > MAX_ARRAY_LEN)
     {
-	proto_item *pi;
+        proto_item *pi;
         pi = proto_tree_add_text(tree, tvb, *pOffset, 4, "Array length %d too large to process", iLen);
-	PROTO_ITEM_SET_GENERATED(pi);
+        PROTO_ITEM_SET_GENERATED(pi);
         return;
     }
 
@@ -738,6 +782,7 @@ void parseArrayEnum(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, fctEnumParse
     {
         (*pParserFunction)(subtree, tvb, pOffset);
     }
+    proto_item_set_end(ti, tvb, *pOffset);
 }
 
 /** General parsing function for arrays of complex types.
@@ -746,7 +791,7 @@ void parseArrayEnum(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, fctEnumParse
  */
 void parseArrayComplex(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName, fctComplexTypeParser pParserFunction)
 {
-    proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "Array of %s", szFieldName);
+    proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "Array of %s", szFieldName);
     proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_array);
     int i;
     gint32 iLen;
@@ -757,9 +802,9 @@ void parseArrayComplex(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const cha
 
     if (iLen > MAX_ARRAY_LEN)
     {
-	proto_item *pi;
+        proto_item *pi;
         pi = proto_tree_add_text(tree, tvb, *pOffset, 4, "Array length %d too large to process", iLen);
-	PROTO_ITEM_SET_GENERATED(pi);
+        PROTO_ITEM_SET_GENERATED(pi);
         return;
     }
 
@@ -770,11 +815,12 @@ void parseArrayComplex(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const cha
         g_snprintf(szNum, 20, "[%i]", i);
         (*pParserFunction)(subtree, tvb, pOffset, szNum);
     }
+    proto_item_set_end(ti, tvb, *pOffset);
 }
 
 void parseNodeId(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-    proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s: NodeId", szFieldName);
+    proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s: NodeId", szFieldName);
     proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_nodeid);
     gint    iOffset = *pOffset;
     guint8  EncodingMask;
@@ -818,6 +864,7 @@ void parseNodeId(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szF
         break;
     };
 
+    proto_item_set_end(ti, tvb, iOffset);
     *pOffset = iOffset;
 }
 
@@ -829,9 +876,10 @@ void parseExtensionObject(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const
     proto_tree *extobj_tree;
     proto_tree *mask_tree;
     proto_item *ti;
+    proto_item *ti_inner;
 
     /* add extension object subtree */
-    ti = proto_tree_add_text(tree, tvb, 0, -1, "%s : ExtensionObject", szFieldName);
+    ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s : ExtensionObject", szFieldName);
     extobj_tree = proto_item_add_subtree(ti, ett_opcua_extensionobject);
 
     /* add nodeid subtree */
@@ -840,8 +888,8 @@ void parseExtensionObject(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const
 
     /* parse encoding mask */
     EncodingMask = tvb_get_guint8(tvb, iOffset);
-    ti = proto_tree_add_text(extobj_tree, tvb, 0, -1, "EncodingMask");
-    mask_tree = proto_item_add_subtree(ti, ett_opcua_extobj_encodingmask);
+    ti_inner = proto_tree_add_text(extobj_tree, tvb, iOffset, 1, "EncodingMask");
+    mask_tree = proto_item_add_subtree(ti_inner, ett_opcua_extobj_encodingmask);
     proto_tree_add_item(mask_tree, hf_opcua_extobj_mask_binbodyflag, tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
     proto_tree_add_item(mask_tree, hf_opcua_extobj_mask_xmlbodyflag, tvb, iOffset, 1, ENC_LITTLE_ENDIAN);
     iOffset++;
@@ -851,12 +899,13 @@ void parseExtensionObject(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const
         dispatchExtensionObjectType(extobj_tree, tvb, &iOffset, TypeId);
     }
 
+    proto_item_set_end(ti, tvb, iOffset);
     *pOffset = iOffset;
 }
 
 void parseExpandedNodeId(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const char *szFieldName)
 {
-    proto_item *ti = proto_tree_add_text(tree, tvb, 0, -1, "%s: ExpandedNodeId", szFieldName);
+    proto_item *ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "%s: ExpandedNodeId", szFieldName);
     proto_tree *subtree = proto_item_add_subtree(ti, ett_opcua_nodeid);
     gint    iOffset = *pOffset;
     guint8  EncodingMask;
@@ -909,6 +958,7 @@ void parseExpandedNodeId(proto_tree *tree, tvbuff_t *tvb, gint *pOffset, const c
         parseUInt32(subtree, tvb, &iOffset, hf_opcua_ServerIndex);
     }
 
+    proto_item_set_end(ti, tvb, iOffset);
     *pOffset = iOffset;
 }
 
diff --git a/plugins/opcua/opcua_transport_layer.c b/plugins/opcua/opcua_transport_layer.c
index 4307698c04..427a1f6c41 100644
--- a/plugins/opcua/opcua_transport_layer.c
+++ b/plugins/opcua/opcua_transport_layer.c
@@ -178,6 +178,7 @@ int parseMessage(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 int parseService(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
     proto_item *ti;
+    proto_item *ti_inner;
     proto_tree *encobj_tree;
     proto_tree *nodeid_tree;
     int ServiceId = 0;
@@ -187,21 +188,25 @@ int parseService(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
      * THIS WILL CHAHNGE IN THE FUTURE. */
 
     /* add encodeable object subtree */
-    ti = proto_tree_add_text(tree, tvb, 0, -1, "OpcUa Service : Encodeable Object");
+    ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "OpcUa Service : Encodeable Object");
     encobj_tree = proto_item_add_subtree(ti, ett_opcua_extensionobject);
 
     /* add nodeid subtree */
-    ti = proto_tree_add_text(encobj_tree, tvb, 0, -1, "TypeId : ExpandedNodeId");
-    nodeid_tree = proto_item_add_subtree(ti, ett_opcua_nodeid);
+    ti_inner = proto_tree_add_text(encobj_tree, tvb, *pOffset, -1, "TypeId : ExpandedNodeId");
+    nodeid_tree = proto_item_add_subtree(ti_inner, ett_opcua_nodeid);
     ServiceId = parseServiceNodeId(nodeid_tree, tvb, pOffset);
+    proto_item_set_end(ti_inner, tvb, *pOffset);
 
     dispatchService(encobj_tree, tvb, pOffset, ServiceId);
+
+    proto_item_set_end(ti, tvb, *pOffset);
     return ServiceId;
 }
 
 int parseOpenSecureChannel(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
 {
     proto_item *ti;
+    proto_item *ti_inner;
     proto_tree *encobj_tree;
     proto_tree *nodeid_tree;
     int ServiceId = 0;
@@ -217,15 +222,18 @@ int parseOpenSecureChannel(proto_tree *tree, tvbuff_t *tvb, gint *pOffset)
     proto_tree_add_item(tree, hf_opcua_transport_rqid, tvb, *pOffset, 4, ENC_LITTLE_ENDIAN); *pOffset+=4;
 
     /* add encodeable object subtree */
-    ti = proto_tree_add_text(tree, tvb, 0, -1, "Message : Encodeable Object");
+    ti = proto_tree_add_text(tree, tvb, *pOffset, -1, "Message : Encodeable Object");
     encobj_tree = proto_item_add_subtree(ti, ett_opcua_extensionobject);
 
     /* add nodeid subtree */
-    ti = proto_tree_add_text(encobj_tree, tvb, 0, -1, "TypeId : ExpandedNodeId");
-    nodeid_tree = proto_item_add_subtree(ti, ett_opcua_nodeid);
+    ti_inner = proto_tree_add_text(encobj_tree, tvb, *pOffset, -1, "TypeId : ExpandedNodeId");
+    nodeid_tree = proto_item_add_subtree(ti_inner, ett_opcua_nodeid);
     ServiceId = parseServiceNodeId(nodeid_tree, tvb, pOffset);
+    proto_item_set_end(ti_inner, tvb, *pOffset);
 
     dispatchService(encobj_tree, tvb, pOffset, ServiceId);
+
+    proto_item_set_end(ti, tvb, *pOffset);
     return -1;
 }