Fix some bugs & do extensive cleanup;

Bugs fixed:
 - Calling col_...() fcns or dissectors under 'if (tree)'
 - Potential buffer overflows (if bad data)
 - Misc incorrect data display issues
Cleanup including;
 - Remove unneeded #includes
 - Fix excessive use of value_strings
 - Use extended value_strings & val_to_str_(ext_)const as appropriate
 - Optimize repeated fetches of the same data from a tvb
 - Do general code simplification
 - Remove or #if 0 unused code;
 - Add XXX comments for code which may be incorrect
 - Remove unneeded prefs callback to proto_reg_handoff...()
 - Remove unneeded use of check_col()
 - Define several functions as static
 - Move proto_reg_handoff...() to the end of the file
 - Fix whitespace (including "4 space tabs")
 - ...

svn path=/trunk/; revision=43129

1 files changed, 552 insertions, 559 deletions

diff --git a/epan/dissectors/packet-uaudp.c b/epan/dissectors/packet-uaudp.c
index 8fca31232d..da67a88d02 100644
--- a/epan/dissectors/packet-uaudp.c
+++ b/epan/dissectors/packet-uaudp.c
@@ -27,24 +27,23 @@
 # include "config.h"
 #endif
 
-#ifdef HAVE_SYS_TYPES_H
-# include <sys/types.h>
-#endif
-
-#include "packet-uaudp.h"
-
-#include <string.h>
 #include <glib.h>
 
 #include "epan/packet.h"
 #include "epan/prefs.h"
 #include "epan/tap.h"
-#include "epan/value_string.h"
 
+#include "packet-uaudp.h"
 
 /* GLOBALS */
 
+#if 0
+static dissector_table_t uaudp_opcode_dissector_table;
+#endif
+
+#if 0
 static int uaudp_tap                = -1;
+#endif
 
 static tap_struct_uaudp ua_tap_info;
 
@@ -70,620 +69,614 @@ static guint8 sys_ip[4];
 static const char* pref_sys_ip_s = "";
 
 static gboolean use_sys_ip = FALSE;
-static gboolean decode_ua = TRUE;
-
-#define UAUDP_CONNECT_VERSION           0x00
-#define UAUDP_CONNECT_WINDOW_SIZE       0x01
-#define UAUDP_CONNECT_MTU               0x02
-#define UAUDP_CONNECT_UDP_LOST          0x03
-#define UAUDP_CONNECT_UDP_LOST_REINIT   0x04
-#define UAUDP_CONNECT_KEEPALIVE         0x05
-#define UAUDP_CONNECT_QOS_IP_TOS        0x06
-#define UAUDP_CONNECT_QOS_8021_VLID     0x07
-#define UAUDP_CONNECT_QOS_8021_PRI      0x08
-
+static gboolean decode_ua  = TRUE;
 
 static const value_string uaudp_opcode_str[] =
 {
-	{ UAUDP_CONNECT,        "Connect" },
-	{ UAUDP_CONNECT_ACK,    "Connect ACK" },
-	{ UAUDP_RELEASE,        "Release" },
-	{ UAUDP_RELEASE_ACK,    "Release ACK" },
-	{ UAUDP_KEEPALIVE,      "Keepalive" },
-	{ UAUDP_KEEPALIVE_ACK,  "Keepalive ACK" },
-	{ UAUDP_NACK,           "NACK" },
-	{ UAUDP_DATA,           "Data" },
-	{ 0, NULL }
+    { UAUDP_CONNECT,        "Connect" },
+    { UAUDP_CONNECT_ACK,    "Connect ACK" },
+    { UAUDP_RELEASE,        "Release" },
+    { UAUDP_RELEASE_ACK,    "Release ACK" },
+    { UAUDP_KEEPALIVE,      "Keepalive" },
+    { UAUDP_KEEPALIVE_ACK,  "Keepalive ACK" },
+    { UAUDP_NACK,           "NACK" },
+    { UAUDP_DATA,           "Data" },
+    { 0, NULL }
 };
+value_string_ext uaudp_opcode_str_ext = VALUE_STRING_EXT_INIT(uaudp_opcode_str);
 
-
+#if 0 /* XXX: Unused ? */
 static const value_string uaudp_connect_vals[] =
 {
-	{ UAUDP_CONNECT_VERSION,        "Version" },
-	{ UAUDP_CONNECT_WINDOW_SIZE,    "Window Size" },
-	{ UAUDP_CONNECT_MTU,            "MTU" },
-	{ UAUDP_CONNECT_UDP_LOST,       "UDP lost" },
-	{ UAUDP_CONNECT_UDP_LOST_REINIT,"UDP lost reinit" },
-	{ UAUDP_CONNECT_KEEPALIVE,      "Keepalive" },
-	{ UAUDP_CONNECT_QOS_IP_TOS,     "QoS IP TOS" },
-	{ UAUDP_CONNECT_QOS_8021_VLID,  "QoS 802.1 VLID" },
-	{ UAUDP_CONNECT_QOS_8021_PRI,   "QoS 802.1 PRI"},
-	{ 0, NULL }
+    { UAUDP_CONNECT_VERSION,        "Version" },
+    { UAUDP_CONNECT_WINDOW_SIZE,    "Window Size" },
+    { UAUDP_CONNECT_MTU,            "MTU" },
+    { UAUDP_CONNECT_UDP_LOST,       "UDP lost" },
+    { UAUDP_CONNECT_UDP_LOST_REINIT,"UDP lost reinit" },
+    { UAUDP_CONNECT_KEEPALIVE,      "Keepalive" },
+    { UAUDP_CONNECT_QOS_IP_TOS,     "QoS IP TOS" },
+    { UAUDP_CONNECT_QOS_8021_VLID,  "QoS 802.1 VLID" },
+    { UAUDP_CONNECT_QOS_8021_PRI,   "QoS 802.1 PRI"},
+    { 0, NULL }
 };
-
+value_string_ext uaudp_connect_vals_ext = VALUE_STRING_EXT_INIT(uaudp_connect_vals);
+#endif
 
 static dissector_handle_t ua_sys_to_term_handle;
 static dissector_handle_t ua_term_to_sys_handle;
 
-
 typedef struct
 {
-	const char *name;
-	const char *text;
-	guint port;
-	guint last_port;
+    const char *name;
+    const char *text;
+    guint port;
+    guint last_port;
 } prefs_uaudp_t;
 
-#define MAX_TERMINAL_PORTS 4
-
-static prefs_uaudp_t ports[MAX_TERMINAL_PORTS] =
+static prefs_uaudp_t ports[] =
 {
-	{"port1", "Terminal UDP port (setting 1)",	32000,	32000},
-	{"port2", "Terminal UDP port (setting 2)",	32512,	32512},
-	{"port3", "Terminal UDP port (setting 3)",	0,	0},
-	{"port4", "Terminal UDP port (setting 4)",	0,	0},
-};
-/*
-	{"port5", "Terminal UDP port (setting 5)",	0,	0},
-	{"port6", "Terminal UDP port (setting 6)",	0,	0},
-	{"port7", "Terminal UDP port (setting 7)",	0,	0},
-	{"port8", "Terminal UDP port (setting 8)",	0,	0}
+    {"port1", "Terminal UDP port (setting 1)",  32000,  32000},
+    {"port2", "Terminal UDP port (setting 2)",  32512,  32512},
+    {"port3", "Terminal UDP port (setting 3)",  0,  0},
+    {"port4", "Terminal UDP port (setting 4)",  0,  0},
+#if 0
+    {"port5", "Terminal UDP port (setting 5)",  0,  0},
+    {"port6", "Terminal UDP port (setting 6)",  0,  0},
+    {"port7", "Terminal UDP port (setting 7)",  0,  0},
+    {"port8", "Terminal UDP port (setting 8)",  0,  0}
+#endif
 };
-*/
+#define MAX_TERMINAL_PORTS array_length(ports)
 
-guint find_terminal_port(guint port)
+static gboolean find_terminal_port(guint port)
 {
-	int i;
-	for (i=0; i<MAX_TERMINAL_PORTS; i++)
-		if (ports[i].port == port)
-			return 1;
-	return 0;
+    int i;
+    for (i=0; i<MAX_TERMINAL_PORTS; i++)
+        if (ports[i].port == port)
+            return TRUE;
+    return FALSE;
 }
 
 
 static void rV(proto_tree *tree, int *V, tvbuff_t *tvb, gint offset, gint8 L)
 {
-	switch(L)
-	{
-	case 1:
-	proto_tree_add_uint(tree,
-				*V,
-				tvb,
-				offset,
-				L+2,
-				tvb_get_guint8(tvb, offset+2));
-	break;
-	case 2:
-	proto_tree_add_uint(tree,
-				*V,
-				tvb,
-				offset,
-				L+2,
-				tvb_get_ntohs(tvb, offset+2));
-	break;
-	case 3:
-	proto_tree_add_uint(tree,
-				*V,
-				tvb,
-				offset,
-				L+2,
-				tvb_get_ntoh24(tvb, offset+2));
-	break;
-	case 4:
-	proto_tree_add_uint(tree,
-				*V,
-				tvb,
-				offset,
-				L+2,
-				tvb_get_ntohl(tvb, offset+2));
-	break;
-	}
+    switch(L)
+    {
+    case 1:
+        proto_tree_add_uint(tree,
+                    *V,
+                    tvb,
+                    offset,
+                    L+2,
+                    tvb_get_guint8(tvb, offset+2));
+        break;
+    case 2:
+        proto_tree_add_uint(tree,
+                    *V,
+                    tvb,
+                    offset,
+                    L+2,
+                    tvb_get_ntohs(tvb, offset+2));
+        break;
+    case 3:
+        proto_tree_add_uint(tree,
+                    *V,
+                    tvb,
+                    offset,
+                    L+2,
+                    tvb_get_ntoh24(tvb, offset+2));
+        break;
+    case 4:
+        proto_tree_add_uint(tree,
+                    *V,
+                    tvb,
+                    offset,
+                    L+2,
+                    tvb_get_ntohl(tvb, offset+2));
+        break;
+    }
 }
 
 
 /* UA/UDP DISSECTOR */
 static void _dissect_uaudp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
-						   e_ua_direction direction)
+                           e_ua_direction direction)
 {
-	proto_item *uaudp_item = NULL;
-	proto_tree *uaudp_tree = NULL;
-	gint offset = 0;
-	guint8 opcode = 0;
-
-	/* print the name of the protocol in the "PROTOCOL" column */
-	if (check_col(pinfo->cinfo, COL_PROTOCOL))
-		col_set_str(pinfo->cinfo, COL_PROTOCOL, "UAUDP");
-
-	/* get the identifer, it means operation code */
-	opcode = tvb_get_guint8(tvb, offset);
-	offset++;
-
-	ua_tap_info.opcode = opcode;
-	ua_tap_info.expseq = 0;
-	ua_tap_info.sntseq = 0;
-
-	/* print in "INFO" column the type of UAUDP message */
-
-	if (check_col(pinfo->cinfo, COL_INFO))
-		col_add_fstr(pinfo->cinfo,
-			 COL_INFO,
-			 "%s",
-			 val_to_str(opcode, uaudp_opcode_str, "unknown (0x%02x)"));
-
-	if (tree)
-	{
-		uaudp_item = proto_tree_add_protocol_format(tree, proto_uaudp, tvb, 0, 5,
-			"Universal Alcatel/UDP Encapsulation Protocol, %s",
-			val_to_str(opcode, uaudp_opcode_str, "unknown (0x%02x)"));
-
-		uaudp_tree = proto_item_add_subtree(uaudp_item, ett_uaudp);
-
-		/* print the identifier */
-		proto_tree_add_uint(uaudp_tree, hf_uaudp_opcode, tvb, 0, 1, opcode);
-
-		switch(opcode)
-		{
-		case UAUDP_CONNECT:
-		{
-			while(tvb_offset_exists(tvb, offset))
-			{
-				guint8 T = tvb_get_guint8(tvb, offset+0);
-				guint8 L = tvb_get_guint8(tvb, offset+1);
-
-				switch(T)
-				{
-				case UAUDP_CONNECT_VERSION:
-					rV(uaudp_tree, &hf_uaudp_version        , tvb, offset, L);
-					break;
-				case UAUDP_CONNECT_WINDOW_SIZE:
-					rV(uaudp_tree, &hf_uaudp_window_size    , tvb, offset, L);
-					break;
-				case UAUDP_CONNECT_MTU:
-					rV(uaudp_tree, &hf_uaudp_mtu            , tvb, offset, L);
-					break;
-				case UAUDP_CONNECT_UDP_LOST:
-					rV(uaudp_tree, &hf_uaudp_udp_lost       , tvb, offset, L);
-					break;
-				case UAUDP_CONNECT_UDP_LOST_REINIT:
-					rV(uaudp_tree, &hf_uaudp_udp_lost_reinit, tvb, offset, L);
-					break;
-				case UAUDP_CONNECT_KEEPALIVE:
-					rV(uaudp_tree, &hf_uaudp_keepalive      , tvb, offset, L);
-					break;
-				case UAUDP_CONNECT_QOS_IP_TOS:
-					rV(uaudp_tree, &hf_uaudp_qos_ip_tos     , tvb, offset, L);
-					break;
-				case UAUDP_CONNECT_QOS_8021_VLID:
-					rV(uaudp_tree, &hf_uaudp_qos_8021_vlid  , tvb, offset, L);
-					break;
-				case UAUDP_CONNECT_QOS_8021_PRI:
-					rV(uaudp_tree, &hf_uaudp_qos_8021_pri   , tvb, offset, L);
-					break;
-				}
-				offset += (2 + L);
-			}
-			break;
-		}
-
-		case UAUDP_NACK:
-		{
-			proto_tree_add_uint(uaudp_tree,
-								hf_uaudp_expseq,
-								tvb,
-								offset,
-								2,
-								tvb_get_ntohs(tvb, offset));
-			/*Fix Clang Warning*/
-			/*offset += 2;*/ 
-			break;
-		}
-
-		case UAUDP_DATA:
-		{
-			int datalen;
-
-			proto_tree_add_uint(uaudp_tree,
-								hf_uaudp_expseq,
-								tvb,
-								offset+0,
-								2,
-								tvb_get_ntohs(tvb, offset+0));
-
-			proto_tree_add_uint(uaudp_tree,
-								hf_uaudp_sntseq,
-								tvb,
-								offset+2,
-								2,
-								tvb_get_ntohs(tvb, offset+2));
-
-			ua_tap_info.expseq = hf_uaudp_expseq;
-			ua_tap_info.sntseq = hf_uaudp_sntseq;
-			offset  += 4;
-			datalen  = (tvb_length(tvb) - offset);
-
-			/* if it remains some data, call of UA dissector */
-			if (datalen > 0)
-			{
-				if (direction==SYS_TO_TERM)
-					call_dissector(ua_sys_to_term_handle,
-								   tvb_new_subset(tvb, offset, datalen, datalen),
-								   pinfo,
-								   tree);
-				else if (direction==TERM_TO_SYS)
-					call_dissector(ua_term_to_sys_handle,
-								   tvb_new_subset(tvb, offset, datalen, datalen),
-								   pinfo,
-								   tree);
-				else {
-					if (check_col(pinfo->cinfo, COL_INFO))
-						col_add_str(pinfo->cinfo,
-							 COL_INFO,
-							 "Data - Couldn't resolve direction. Check UAUDP Preferences.");
-				}
-				ua_tap_info.expseq = hf_uaudp_expseq;
-			}
-			else {
-				/* print in "INFO" column */
-				if (check_col(pinfo->cinfo, COL_INFO))
-					col_add_str(pinfo->cinfo,
-								COL_INFO,
-								"Data ACK");
-			}
-			break;
-		}
-		default:
-			break;
-		}
-	}
-	tap_queue_packet(uaudp_tap, pinfo, &ua_tap_info);
+    gint        offset = 0;
+    guint8      opcode;
+    proto_item *uaudp_item;
+    proto_tree *uaudp_tree;
+
+    col_set_str(pinfo->cinfo, COL_PROTOCOL, "UAUDP");
+
+    /* get the identifier; it means operation code */
+    opcode = tvb_get_guint8(tvb, offset);
+    offset += 1;
+
+    ua_tap_info.opcode = opcode;
+    ua_tap_info.expseq = 0;
+    ua_tap_info.sntseq = 0;
+
+    /* print in "INFO" column the type of UAUDP message */
+    if (check_col(pinfo->cinfo, COL_INFO))
+        col_add_fstr(pinfo->cinfo,
+                 COL_INFO,
+                 "%s",
+                 val_to_str_ext(opcode, &uaudp_opcode_str_ext, "unknown (0x%02x)"));
+
+    uaudp_item = proto_tree_add_protocol_format(tree, proto_uaudp, tvb, 0, 5,
+                            "Universal Alcatel/UDP Encapsulation Protocol, %s",
+                            val_to_str_ext(opcode, &uaudp_opcode_str_ext, "unknown (0x%02x)"));
+
+    uaudp_tree = proto_item_add_subtree(uaudp_item, ett_uaudp);
+
+    /* print the identifier */
+    proto_tree_add_uint(uaudp_tree, hf_uaudp_opcode, tvb, 0, 1, opcode);
+
+    switch(opcode)
+    {
+    case UAUDP_CONNECT:
+    {
+        if (!tree)
+            break;
+        while (tvb_offset_exists(tvb, offset))
+        {
+            guint8 T = tvb_get_guint8(tvb, offset+0);
+            guint8 L = tvb_get_guint8(tvb, offset+1);
+
+            switch(T)
+            {
+            case UAUDP_CONNECT_VERSION:
+                rV(uaudp_tree, &hf_uaudp_version        , tvb, offset, L);
+                break;
+            case UAUDP_CONNECT_WINDOW_SIZE:
+                rV(uaudp_tree, &hf_uaudp_window_size    , tvb, offset, L);
+                break;
+            case UAUDP_CONNECT_MTU:
+                rV(uaudp_tree, &hf_uaudp_mtu            , tvb, offset, L);
+                break;
+            case UAUDP_CONNECT_UDP_LOST:
+                rV(uaudp_tree, &hf_uaudp_udp_lost       , tvb, offset, L);
+                break;
+            case UAUDP_CONNECT_UDP_LOST_REINIT:
+                rV(uaudp_tree, &hf_uaudp_udp_lost_reinit, tvb, offset, L);
+                break;
+            case UAUDP_CONNECT_KEEPALIVE:
+                rV(uaudp_tree, &hf_uaudp_keepalive      , tvb, offset, L);
+                break;
+            case UAUDP_CONNECT_QOS_IP_TOS:
+                rV(uaudp_tree, &hf_uaudp_qos_ip_tos     , tvb, offset, L);
+                break;
+            case UAUDP_CONNECT_QOS_8021_VLID:
+                rV(uaudp_tree, &hf_uaudp_qos_8021_vlid  , tvb, offset, L);
+                break;
+            case UAUDP_CONNECT_QOS_8021_PRI:
+                rV(uaudp_tree, &hf_uaudp_qos_8021_pri   , tvb, offset, L);
+                break;
+            }
+            offset += (2 + L);
+        }
+        break;
+    }
+
+    case UAUDP_NACK:
+    {
+        proto_tree_add_uint(uaudp_tree,
+                    hf_uaudp_expseq,
+                    tvb,
+                    offset,
+                    2,
+                    tvb_get_ntohs(tvb, offset));
+        break;
+    }
+
+    case UAUDP_DATA:
+    {
+        int datalen;
+
+        proto_tree_add_uint(uaudp_tree,
+                    hf_uaudp_expseq,
+                    tvb,
+                    offset+0,
+                    2,
+                    tvb_get_ntohs(tvb, offset+0));
+
+        proto_tree_add_uint(uaudp_tree,
+                    hf_uaudp_sntseq,
+                    tvb,
+                    offset+2,
+                    2,
+                    tvb_get_ntohs(tvb, offset+2));
+
+        ua_tap_info.expseq = hf_uaudp_expseq;
+        ua_tap_info.sntseq = hf_uaudp_sntseq;
+
+        offset  += 4;
+        datalen  = tvb_reported_length(tvb) - offset;
+
+        /* if there is remaining data, call the UA dissector */
+        if (datalen > 0)
+        {
+            if (direction == SYS_TO_TERM)
+                call_dissector(ua_sys_to_term_handle,
+                           tvb_new_subset(tvb, offset, datalen, datalen),
+                           pinfo,
+                           tree);
+            else if (direction == TERM_TO_SYS)
+                call_dissector(ua_term_to_sys_handle,
+                           tvb_new_subset(tvb, offset, datalen, datalen),
+                           pinfo,
+                           tree);
+            else {
+                /* XXX: expert ?? */
+                if (check_col(pinfo->cinfo, COL_INFO))
+                    col_add_str(pinfo->cinfo,
+                            COL_INFO,
+                            "Data - Couldn't resolve direction. Check UAUDP Preferences.");
+            }
+            ua_tap_info.expseq = hf_uaudp_expseq;
+        }
+        else {
+            /* print in "INFO" column */
+            col_add_str(pinfo->cinfo,
+                        COL_INFO,
+                        "Data ACK");
+        }
+        break;
+    }
+    default:
+        break;
+    }
+#if 0
+    tap_queue_packet(uaudp_tap, pinfo, &ua_tap_info);
+#endif
 }
 
+#if 0
+/* XXX: The following are never actually used ?? */
 static void dissect_uaudp_dir_unknown(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 {
-	_dissect_uaudp(tvb, pinfo, tree, DIR_UNKNOWN);
+    _dissect_uaudp(tvb, pinfo, tree, DIR_UNKNOWN);
 }
 
 static void dissect_uaudp_term_to_serv(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 {
-	_dissect_uaudp(tvb, pinfo, tree, TERM_TO_SYS);
+    _dissect_uaudp(tvb, pinfo, tree, TERM_TO_SYS);
 }
 
 static void dissect_uaudp_serv_to_term(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 {
-	_dissect_uaudp(tvb, pinfo, tree, SYS_TO_TERM);
+    _dissect_uaudp(tvb, pinfo, tree, SYS_TO_TERM);
 }
+#endif
 
 /*
  * UA/UDP DISSECTOR
- * Ethereal packet dissector entry point
- */
+ Wireshark packet dissector entry point
+*/
 static void dissect_uaudp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
 {
-	/* server addres has precedence on ports if present */
-	if (use_sys_ip) {
-		/* use server address to find direction*/
-		if (memcmp((pinfo->src).data, sys_ip, 4*sizeof(guint8)) == 0)
-		{
-			_dissect_uaudp(tvb, pinfo, tree, SYS_TO_TERM);
-			return;
-		}
-		else if (memcmp((pinfo->dst).data, sys_ip, 4*sizeof(guint8)) == 0)
-		{
-			_dissect_uaudp(tvb, pinfo, tree, TERM_TO_SYS);
-			return;
-		}
-	}
-
-	/* use ports to find direction */
-	if (find_terminal_port(pinfo->srcport))
-	{
-		_dissect_uaudp(tvb, pinfo, tree, TERM_TO_SYS);
-		return;
-	}
-	else if (find_terminal_port(pinfo->destport))
-	{
-		_dissect_uaudp(tvb, pinfo, tree, SYS_TO_TERM);
-		return;
-	}
-
-	_dissect_uaudp(tvb, pinfo, tree, DIR_UNKNOWN);
+    /* server address, if present, has precedence on ports */
+    if (use_sys_ip) {
+        /* use server address to find direction*/
+        if (memcmp((pinfo->src).data, sys_ip, 4*sizeof(guint8)) == 0)
+        {
+            _dissect_uaudp(tvb, pinfo, tree, SYS_TO_TERM);
+            return;
+        }
+        else if (memcmp((pinfo->dst).data, sys_ip, 4*sizeof(guint8)) == 0)
+        {
+            _dissect_uaudp(tvb, pinfo, tree, TERM_TO_SYS);
+            return;
+        }
+    }
+
+    /* use ports to find direction */
+    if (find_terminal_port(pinfo->srcport))
+    {
+        _dissect_uaudp(tvb, pinfo, tree, TERM_TO_SYS);
+        return;
+    }
+    else if (find_terminal_port(pinfo->destport))
+    {
+        _dissect_uaudp(tvb, pinfo, tree, SYS_TO_TERM);
+        return;
+    }
+
+    _dissect_uaudp(tvb, pinfo, tree, DIR_UNKNOWN);
 }
 
-
-gboolean str_to_addr_ip(const gchar *addr, guint8 *ad)
+/* XXX: Presumably there's a util fcn for this ... */
+static gboolean str_to_addr_ip(const gchar *addr, guint8 *ad)
 {
-	int i = 0;
-	const gchar *p = addr;
-	guint32 value;
-
-	if (addr==NULL) return FALSE;
-
-	for (i=0; i<4; i++)
-	{
-		value = 0;
-		while (*p != '.' && *p != '\0')
-		{
-			value = value * 10 + (*p - '0');
-			p++;
-		}
-		if(value > 255)
-		{
-			return FALSE;
-		}
-		ad[i] = value;
-		p++;
-	}
-
-	return TRUE;
+    int          i;
+    const gchar *p = addr;
+    guint32      value;
+
+    if (addr == NULL)
+        return FALSE;
+
+    for (i=0; i<4; i++)
+    {
+        value = 0;
+        while (*p != '.' && *p != '\0')
+        {
+            value = value * 10 + (*p - '0');
+            p++;
+        }
+        if (value > 255)
+        {
+            return FALSE;
+        }
+        ad[i] = value;
+        p++;
+    }
+
+    return TRUE;
 }
 
 
-/* Register the protocol with Ethereal */
+/* Register the protocol with Wireshark */
 void proto_reg_handoff_uaudp(void);
 
 void proto_register_uaudp(void)
 {
-	module_t *uaudp_module;
-	int i;
-
-	/* Setup list of header fields. See Section 1.6.1 for details */
-	static hf_register_info hf_uaudp[] =
-	{
-		{ 
-			&hf_uaudp_opcode,
-			{
-				"Opcode",
-				 "uaudp.opcode",
-				 FT_UINT8,
-				 BASE_DEC,
-				 VALS(uaudp_opcode_str),
-				 0x0,
-				 "UA/UDP Opcode",
-				 HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_version,
-			{
-				"Version",
-				"uaudp.version",
-				FT_UINT8,
-				BASE_DEC,
-				NULL, 0x0,
-				"UA/UDP Version",
-				HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_window_size,
-			{
-				"Window Size",
-				"uaudp.window_size", 
-				FT_UINT8,
-				BASE_DEC,
-				NULL,
-				0x0,
-				"UA/UDP Window Size",
-				HFILL
-			}
-		},
-		{
-			&hf_uaudp_mtu,
-			{
-				"MTU", 
-				"uaudp.mtu",
-				FT_UINT8,
-				BASE_DEC,
-				NULL,
-				0x0,
-				"UA/UDP MTU",
-				HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_udp_lost,
-			{
-				"UDP Lost",
-				"uaudp.udp_lost",
-				FT_UINT8,
-				BASE_DEC,
-				NULL,
-				0x0,
-				"UA/UDP Lost",
-				HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_udp_lost_reinit,
-			{ 
-				"UDP lost reinit",
-				"uaudp.udp_lost_reinit",
-				FT_UINT8,
-				BASE_DEC,
-				NULL, 0x0,
-				"UA/UDP Lost Re-Init",
-				HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_keepalive,
-			{ 
-				"Keepalive",
-				"uaudp.keepalive",
-				FT_UINT8,
-				BASE_DEC,
-				NULL,
-				0x0,
-				"UA/UDP Keepalive",
-				HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_qos_ip_tos,
-			{
-				"QoS IP TOS",
-				"uaudp.qos_ip_tos",
-				FT_UINT8,
-				BASE_DEC,
-				NULL,
-				0x0,
-				"UA/UDP QoS IP TOS",
-				HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_qos_8021_vlid,
-			{ 
-				"QoS 802.1 VLID",
-				"uaudp.qos_8021_vlid",
-				FT_UINT8,
-				BASE_DEC,
-				NULL,
-				0x0,
-				"UA/UDP QoS 802.1 VLID",
-				HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_qos_8021_pri,
-			{ 
-				"QoS 802.1 PRI",
-				"uaudp.qos_8021_pri",
-				FT_UINT8,
-				BASE_DEC,
-				NULL,
-				0x0,
-				"UA/UDP QoS 802.1 PRI",
-				HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_expseq,
-			{
-				"Sequence Number (expected)",
-				"uaudp.expseq",
-				FT_UINT16,
-				BASE_DEC,
-				NULL,
-				0x0,
-				"UA/UDP Expected Sequence Number",
-				HFILL
-			}
-		},
-		{ 
-			&hf_uaudp_sntseq,
-			{ 
-				"Sequence Number (sent)", 
-				"uaudp.sntseq",
-				FT_UINT16,
-				BASE_DEC,
-				NULL,
-				0x0,
-				"UA/UDP Sent Sequence Number",
-				HFILL
-			}
-		},
-	};
-
-	/* Setup protocol subtree array */
-	static gint *ett[] =
-	{
-		&ett_uaudp,
-	};
-
-	/* Register the protocol name and description */
-	proto_uaudp = proto_register_protocol("UA/UDP Encapsulation Protocol", 
-										  "UAUDP",
-										  "uaudp");
-
-	register_dissector("uaudp", dissect_uaudp, proto_uaudp);
-	register_dissector("uaudp_dir_unknown", dissect_uaudp_dir_unknown, proto_uaudp);
-	register_dissector("uaudp_term_to_serv", dissect_uaudp_term_to_serv, proto_uaudp);
-	register_dissector("uaudp_serv_to_term", dissect_uaudp_serv_to_term, proto_uaudp);
-
-	/* Required function calls to register the header fields and subtrees used */
-	proto_register_field_array(proto_uaudp, hf_uaudp, array_length(hf_uaudp));
-	proto_register_subtree_array(ett, array_length(ett));
-
-	/* Register preferences */
-	uaudp_module = prefs_register_protocol(proto_uaudp, proto_reg_handoff_uaudp);
+    module_t *uaudp_module;
+    int       i;
+
+    /* Setup list of header fields. See Section 1.6.1 for details */
+    static hf_register_info hf_uaudp[] = {
+        {
+            &hf_uaudp_opcode,
+            {
+                "Opcode",
+                "uaudp.opcode",
+                FT_UINT8,
+                BASE_DEC | BASE_EXT_STRING,
+                &uaudp_opcode_str_ext,
+                0x0,
+                "UA/UDP Opcode",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_version,
+            {
+                "Version",
+                "uaudp.version",
+                FT_UINT8,
+                BASE_DEC,
+                NULL, 0x0,
+                "UA/UDP Version",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_window_size,
+            {
+                "Window Size",
+                "uaudp.window_size",
+                FT_UINT8,
+                BASE_DEC,
+                NULL,
+                0x0,
+                "UA/UDP Window Size",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_mtu,
+            {
+                "MTU",
+                "uaudp.mtu",
+                FT_UINT8,
+                BASE_DEC,
+                NULL,
+                0x0,
+                "UA/UDP MTU",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_udp_lost,
+            {
+                "UDP Lost",
+                "uaudp.udp_lost",
+                FT_UINT8,
+                BASE_DEC,
+                NULL,
+                0x0,
+                "UA/UDP Lost",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_udp_lost_reinit,
+            {
+                "UDP lost reinit",
+                "uaudp.udp_lost_reinit",
+                FT_UINT8,
+                BASE_DEC,
+                NULL, 0x0,
+                "UA/UDP Lost Re-Init",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_keepalive,
+            {
+                "Keepalive",
+                "uaudp.keepalive",
+                FT_UINT8,
+                BASE_DEC,
+                NULL,
+                0x0,
+                "UA/UDP Keepalive",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_qos_ip_tos,
+            {
+                "QoS IP TOS",
+                "uaudp.qos_ip_tos",
+                FT_UINT8,
+                BASE_DEC,
+                NULL,
+                0x0,
+                "UA/UDP QoS IP TOS",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_qos_8021_vlid,
+            {
+                "QoS 802.1 VLID",
+                "uaudp.qos_8021_vlid",
+                FT_UINT8,
+                BASE_DEC,
+                NULL,
+                0x0,
+                "UA/UDP QoS 802.1 VLID",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_qos_8021_pri,
+            {
+                "QoS 802.1 PRI",
+                "uaudp.qos_8021_pri",
+                FT_UINT8,
+                BASE_DEC,
+                NULL,
+                0x0,
+                "UA/UDP QoS 802.1 PRI",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_expseq,
+            {
+                "Sequence Number (expected)",
+                "uaudp.expseq",
+                FT_UINT16,
+                BASE_DEC,
+                NULL,
+                0x0,
+                "UA/UDP Expected Sequence Number",
+                HFILL
+            }
+        },
+        {
+            &hf_uaudp_sntseq,
+            {
+                "Sequence Number (sent)",
+                "uaudp.sntseq",
+                FT_UINT16,
+                BASE_DEC,
+                NULL,
+                0x0,
+                "UA/UDP Sent Sequence Number",
+                HFILL
+            }
+        },
+    };
+
+    /* Setup protocol subtree array */
+    static gint *ett[] =
+        {
+            &ett_uaudp,
+        };
+
+    /* Register the protocol name and description */
+    proto_uaudp = proto_register_protocol("UA/UDP Encapsulation Protocol",
+                          "UAUDP",
+                          "uaudp");
+
+    register_dissector("uaudp",              dissect_uaudp, proto_uaudp);
+#if 0 /* XXX: Not used ?? */
+    register_dissector("uaudp_dir_unknown",  dissect_uaudp_dir_unknown,  proto_uaudp);
+    register_dissector("uaudp_term_to_serv", dissect_uaudp_term_to_serv, proto_uaudp);
+    register_dissector("uaudp_serv_to_term", dissect_uaudp_serv_to_term, proto_uaudp);
+#endif
 
-/*
-	prefs_register_bool_preference(uaudp_module, "enable",
-								   "Enable UA/UDP decoding based on preferences",
-								   "Enable UA/UDP decoding based on preferences",
-								   &decode_ua);
-*/
-	for (i=0; i<MAX_TERMINAL_PORTS; i++) {
-		prefs_register_uint_preference(uaudp_module,
-									   ports[i].name,
-									   ports[i].text,
-									   ports[i].text,
-									   10,
-									   &ports[i].port);
-	}
-	prefs_register_string_preference(uaudp_module, "system_ip",
-									 "System IP Address (optional)",
-									 "IPv4 address of the DHS3 system. (Used only in case of identical source and destination ports)",
-									 &pref_sys_ip_s);
-
-	/* Register tap listener */
-/*    uaudp_tap = register_tap("uaudp");*/
+    proto_register_field_array(proto_uaudp, hf_uaudp, array_length(hf_uaudp));
+    proto_register_subtree_array(ett, array_length(ett));
+
+    /* Register preferences */
+    uaudp_module = prefs_register_protocol(proto_uaudp, proto_reg_handoff_uaudp);
+
+#if 0
+    prefs_register_bool_preference(uaudp_module, "enable",
+                       "Enable UA/UDP decoding based on preferences",
+                       "Enable UA/UDP decoding based on preferences",
+                       &decode_ua);
+#endif
+    for (i=0; i<MAX_TERMINAL_PORTS; i++) {
+        prefs_register_uint_preference(uaudp_module,
+                           ports[i].name,
+                           ports[i].text,
+                           ports[i].text,
+                           10,
+                           &ports[i].port);
+    }
+    prefs_register_string_preference(uaudp_module, "system_ip",
+                     "System IP Address (optional)",
+                     "IPv4 address of the DHS3 system."
+                     " (Used only in case of identical source and destination ports)",
+                     &pref_sys_ip_s);
+
+#if 0
+    /* Register tap  */
+    uaudp_tap = register_tap("uaudp");*/
+#endif
 }
 
 
-/* If this dissector uses sub-dissector registration add a registration routine.
-   This format is required because a script is used to find these routines and
-   create the code that calls these routines.
-*/
-void
-proto_reg_handoff_uaudp(void)
+void proto_reg_handoff_uaudp(void)
 {
-	static gboolean prefs_initialized = FALSE;
-	static dissector_handle_t uaudp_handle;
-	int i;
-
-	if(!prefs_initialized)
-	{
-		uaudp_handle = create_dissector_handle(dissect_uaudp, proto_uaudp);
-		ua_sys_to_term_handle = find_dissector("ua_sys_to_term");
-		ua_term_to_sys_handle = find_dissector("ua_term_to_sys");
-		prefs_initialized = TRUE;
-	}
-	else
-	{
-		for(i=0; i<MAX_TERMINAL_PORTS; i++)
-		{
-			dissector_delete_uint("udp.port", ports[i].last_port, uaudp_handle);
-		}
-		if(str_to_addr_ip(pref_sys_ip_s, sys_ip))
-		{
-			use_sys_ip = TRUE;
-		}
-		else 
-		{
-			use_sys_ip = FALSE;
-			pref_sys_ip_s = g_strdup("");
-		}
-	}
-
-	if(decode_ua)
-	{
-		for(i=0; i < MAX_TERMINAL_PORTS; i++)
-		{
-			dissector_add_uint("udp.port", ports[i].port, uaudp_handle);
-			ports[i].last_port = ports[i].port;
-		}
-	}
+    static gboolean           prefs_initialized = FALSE;
+    static dissector_handle_t uaudp_handle;
+    int i;
+
+    if (!prefs_initialized)
+    {
+        uaudp_handle          = find_dissector("uaudp");
+        ua_sys_to_term_handle = find_dissector("ua_sys_to_term");
+        ua_term_to_sys_handle = find_dissector("ua_term_to_sys");
+#if 0
+        uaudp_opcode_dissector_table =
+            register_dissector_table("uaudp.opcode",
+                                     "UAUDP opcode",
+                                     FT_UINT8,
+                                     BASE_DEC);
+#endif
+        prefs_initialized     = TRUE;
+    }
+    else
+    {
+        for (i=0; i<MAX_TERMINAL_PORTS; i++)
+        {
+            dissector_delete_uint("udp.port", ports[i].last_port, uaudp_handle);
+        }
+        if (str_to_addr_ip(pref_sys_ip_s, sys_ip))
+        {
+            use_sys_ip = TRUE;
+        }
+        else
+        {
+            use_sys_ip = FALSE;
+            pref_sys_ip_s = g_strdup("");
+        }
+    }
+
+    if (decode_ua)
+    {
+        for (i=0; i < MAX_TERMINAL_PORTS; i++)
+        {
+            dissector_add_uint("udp.port", ports[i].port, uaudp_handle);
+            ports[i].last_port = ports[i].port;
+        }
+    }
 }