* Added in Laurent's OSI/ISO CNLP and COTP support.

* Added Laurent's changes to the man (actually pod) page.
* Copied in VERSION file so that others can make doc/Makefile

svn path=/trunk/; revision=8

1 files changed, 1617 insertions, 0 deletions

diff --git a/packet-osi.c b/packet-osi.c
new file mode 100644
index 0000000000..3d75769630
--- /dev/null
+++ b/packet-osi.c
@@ -0,0 +1,1617 @@
+/* packet-osi.c
+ * Routines for ISO/OSI network and transport protocol packet disassembly
+ *
+ * $Id: packet-osi.c,v 1.1 1998/09/17 02:01:48 gerald Exp $
+ * Laurent Deniel <deniel@worldnet.fr>
+ *
+ * Ethereal - Network traffic analyzer
+ * By Gerald Combs <gerald@zing.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ *
+ * To do:
+ *
+ * - add other network protocols (ES,IS-IS)
+ * - add NSAP decoding & resolution
+ * - complete CLNP decoding (options)
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <gtk/gtk.h>
+#include <pcap.h>
+
+#include <stdio.h>
+
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+
+#include "ethereal.h"
+#include "packet.h"
+
+/* Network layer protocol identifiers */
+
+#define ISO8473_CLNP		0x81
+#define	ISO9542_ESIS		0x82
+#define ISO10589_ISIS		0x83
+#define ISO9542X25_ESIS		0x8a
+
+/*
+ * ISO8473 OSI CLNP definition (see RFC994)
+ *
+ *            _________________________________
+ *           |           Fixed Part            |
+ *           |_________________________________|
+ *           |          Address Part           |
+ *           |_________________________________|
+ *           |   Segmentation Part (optional)  |
+ *           |_________________________________|
+ *           |     Options Part (optional)     |
+ *           |_________________________________|
+ *           |         Data (optional)         |
+ *           |_________________________________|
+ */
+
+#define	ISO8473_V1		0x01	/* CLNP version 1 */
+
+/* Fixed part */
+
+struct clnp_header {
+  u_char	cnf_proto_id;	/* network layer protocol identifier */
+  u_char	cnf_hdr_len;	/* length indicator (octets) */
+  u_char	cnf_vers;	/* version/protocol identifier extension */
+  u_char	cnf_ttl;      	/* lifetime (500 milliseconds) */
+  u_char	cnf_type;      	/* type code */
+  u_char	cnf_seglen_msb;	/* pdu segment length (octets) high byte */
+  u_char	cnf_seglen_lsb;	/* pdu segment length (octets) low byte */
+  u_char	cnf_cksum_msb;	/* checksum high byte */
+  u_char	cnf_cksum_lsb;	/* checksum low byte */
+};
+
+#define CNF_TYPE		0x1f
+#define CNF_ERR_OK		0x20
+#define CNF_MORE_SEGS		0x40
+#define CNF_SEG_OK		0x80
+
+#define ER_NPDU			0x01
+#define DT_NPDU			0x1C
+
+/* field position */
+
+#define P_ADDRESS_PART		9
+
+/* Segmentation part */
+
+struct clnp_segment {
+  u_short	cng_id;		/* data unit identifier */
+  u_short	cng_off;	/* segment offset */
+  u_short	cng_tot_len;	/* total length */
+};
+
+/* NSAP selector */
+
+#define NSEL_NET 		0x00
+#define NSEL_NP  		0x20
+#define NSEL_TP  		0x21
+
+/*
+ * ISO8073 OSI COTP definition (see RFC905)
+ */
+
+/* don't use specific TPDU types to avoid alignment problems & copy overhead */
+
+/* TPDU definition */
+
+#define ED_TPDU        		0x1
+#define EA_TPDU        		0x2
+#define RJ_TPDU        		0x5
+#define AK_TPDU        		0x6
+#define ER_TPDU        		0x7
+#define DR_TPDU        		0x8
+#define DC_TPDU        		0xC
+#define CC_TPDU        		0xD
+#define CR_TPDU        		0xE
+#define DT_TPDU        		0xF
+
+/* field position */
+
+#define P_LI           		0
+#define P_TPDU         		1
+#define P_CDT          		1
+#define P_DST_REF      		2
+#define P_SRC_REF      		4
+#define P_TPDU_NR_0_1  		2
+#define P_TPDU_NR_234  		4
+#define P_VAR_PART_NDT 		5
+#define P_VAR_PART_EDT 		8
+#define P_VAR_PART_NAK 		5
+#define P_VAR_PART_CC  		7
+#define P_VAR_PART_EAK 		10
+#define P_VAR_PART_DC           6
+#define P_VAR_PART_DR		7
+#define P_CDT_IN_AK    		8
+#define P_CDT_IN_RJ    		8
+#define P_REJECT_ER    		4
+#define P_REASON_IN_DR 		6
+#define P_CLASS_OPTION 		6
+
+/* TPDU length indicator */
+
+#define LI_NORMAL_DT_CLASS_01		 2
+#define LI_NORMAL_DT_WITH_CHECKSUM       8
+#define LI_NORMAL_DT_WITHOUT_CHECKSUM    4
+#define LI_EXTENDED_DT_WITH_CHECKSUM     11
+#define LI_EXTENDED_DT_WITHOUT_CHECKSUM  7
+#define LI_NORMAL_EA_WITH_CHECKSUM       8
+#define LI_NORMAL_EA_WITHOUT_CHECKSUM    4
+#define LI_EXTENDED_EA_WITH_CHECKSUM     11
+#define LI_EXTENDED_EA_WITHOUT_CHECKSUM  7
+#define LI_NORMAL_RJ                     4
+#define LI_EXTENDED_RJ                   9
+#define LI_MIN_DR                        6
+#define LI_MAX_DC                        9
+#define LI_MAX_AK                        27
+#define LI_MAX_EA                        11
+#define LI_MAX_ER			 8
+#define LI_DC_WITH_CHECKSUM		 9
+#define LI_DC_WITHOUT_CHECKSUM           5
+#define is_LI_NORMAL_AK(p)               ( p & 0x01 )
+
+/* variant part */
+
+#define VP_ACK_TIME     	0x85
+#define VP_RES_ERROR    	0x86
+#define VP_PRIORITY     	0x87
+#define VP_TRANSIT_DEL  	0x88
+#define VP_THROUGHPUT   	0x89
+#define VP_SEQ_NR       	0x8A         /* in AK */
+#define VP_REASSIGNMENT 	0x8B
+#define VP_FLOW_CNTL    	0x8C         /* in AK */
+#define VP_TPDU_SIZE    	0xC0
+#define VP_SRC_TSAP     	0xC1         /* in CR/CC */
+#define VP_DST_TSAP     	0xC2
+#define VP_CHECKSUM     	0xC3
+#define VP_VERSION_NR   	0xC4
+#define VP_PROTECTION   	0xC5
+#define VP_OPT_SEL      	0xC6
+#define VP_PROTO_CLASS  	0xC7
+
+/* misc */
+
+#define EXTRACT_SHORT(p) 	pntohs(p)
+#define EXTRACT_LONG(p) 	pntohl(p)
+
+/* global variables */
+
+static u_char  li, tpdu, cdt; 	/* common fields */
+static u_short dst_ref;
+
+/* function definitions */
+
+static int osi_decode_DR(const u_char *pd, int offset, 
+			 frame_data *fd, GtkTree *tree) 
+{
+  GtkWidget *cotp_tree, *ti;
+  u_short src_ref;
+  u_char  reason;
+  char *str;
+  
+  if (li < LI_MIN_DR) 
+    return -1;
+
+  src_ref = EXTRACT_SHORT(&pd[offset + P_SRC_REF]);
+  reason  = pd[offset + P_REASON_IN_DR];
+
+  switch(reason) {
+    case (128+0): str = "Normal Disconnect"; break;
+    case (128+1): str = "Remote transport enity congestion"; break;
+    case (128+2): str = "Connection negotiation failed"; break;
+    case (128+3): str = "Duplicate source reference"; break;
+    case (128+4): str = "Mismatched references"; break;
+    case (128+5): str = "Protocol error"; break;
+    case (128+7): str = "Reference overflow"; break;
+    case (128+8): str = "Connection requestion refused"; break;
+    case (128+10):str = "Header or parameter length invalid"; break;
+    case (0):     str = "Reason not specified"; break;
+    case (1):     str = "Congestion at TSAP"; break;
+    case (2):     str = "Session entity not attached to TSAP"; break;
+    case (3):     str = "Address unknown"; break;
+    default:      return -1;
+      /*NOTREACHED*/
+      break;
+  }
+
+  if (fd->win_info[0]) {
+    strcpy(fd->win_info[3], "COTP");
+    sprintf(fd->win_info[4], "DR TPDU src-ref: 0x%04x dst-ref: 0x%04x %s",
+	    src_ref, dst_ref);
+  }
+
+  if (tree) {
+    ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			  "ISO COTP");
+    cotp_tree = gtk_tree_new();
+    add_subtree(ti, cotp_tree, ETT_COTP);
+    add_item_to_tree(cotp_tree, offset,      1,
+		     "Length indicator: %d", li);
+    add_item_to_tree(cotp_tree, offset +  1, 1, 
+		     "TPDU code: Ox%x (DR)", tpdu); 
+    add_item_to_tree(cotp_tree, offset +  2, 2, 
+		     "Destination reference: 0x%04x", dst_ref);
+    add_item_to_tree(cotp_tree, offset +  4, 2, 
+		     "Source reference: 0x%04x", src_ref);
+    add_item_to_tree(cotp_tree, offset +  6, 1, 
+		     "Cause: %s", str);
+  }
+
+  offset += li + 1;
+  dissect_data(pd, offset, fd, tree);
+
+  return 0;
+
+} /* osi_decode_DR */
+
+static int osi_decode_DT(const u_char *pd, int offset, 
+			 frame_data *fd, GtkTree *tree) 
+{
+  GtkWidget *cotp_tree, *ti;
+  u_int    tpdu_nr ;
+  u_short  checksum;
+  u_char   code, length;
+  u_int    fragment = 0;
+    
+  switch (li) {
+    case LI_NORMAL_DT_WITH_CHECKSUM      :
+      tpdu_nr = pd[offset + P_TPDU_NR_234];
+      if ( tpdu_nr & 0x80 )
+	tpdu_nr = tpdu_nr & 0x7F;
+      else
+	fragment = 1;
+      code = pd[offset + P_VAR_PART_NDT];
+      if (code == VP_CHECKSUM)
+	checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NDT + 2]);
+      else
+	return -1;
+      break;
+    case LI_NORMAL_DT_WITHOUT_CHECKSUM   :
+      tpdu_nr = pd[offset + P_TPDU_NR_234];
+      if ( tpdu_nr & 0x80 )
+	tpdu_nr = tpdu_nr & 0x7F;
+      else
+	fragment = 1;
+      break;
+    case LI_EXTENDED_DT_WITH_CHECKSUM    :
+      tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+      if ( tpdu_nr & 0x80000000 )
+	tpdu_nr = tpdu_nr & 0x7FFFFFFF;
+      else
+	fragment = 1;
+      code = pd[offset + P_VAR_PART_EDT];
+      if (code == VP_CHECKSUM)
+	checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EDT + 2]);
+      else
+	return -1;
+      break;
+    case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
+      tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+      if ( tpdu_nr & 0x80000000 )
+	tpdu_nr = tpdu_nr & 0x7FFFFFFF;
+      else
+	fragment = 1;
+      break;
+    case LI_NORMAL_DT_CLASS_01           :
+      tpdu_nr = pd[offset + P_TPDU_NR_0_1];
+      if ( tpdu_nr & 0x80 )
+	tpdu_nr = tpdu_nr & 0x7F;
+      else
+	fragment = 1;      
+      break;
+    default : /* bad TPDU */
+      return -1;
+      /*NOTREACHED*/
+      break;
+  }
+
+  if (fd->win_info[0]) {
+    strcpy(fd->win_info[3], "COTP");
+    sprintf(fd->win_info[4], "DT TPDU (%d) dst-ref: 0x%04x %s", 
+	    tpdu_nr,
+	    dst_ref,
+	    (fragment)? "(fragment)" : "");
+  }
+
+  if (tree) {
+    ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			  "ISO COTP");
+    cotp_tree = gtk_tree_new();
+    add_subtree(ti, cotp_tree, ETT_COTP);
+    add_item_to_tree(cotp_tree, offset,      1,
+		     "Length indicator: %d", li);
+    add_item_to_tree(cotp_tree, offset +  1, 1, 
+		     "TPDU code: Ox%x (DT)", tpdu); 
+
+    if (li != LI_NORMAL_DT_CLASS_01)
+      add_item_to_tree(cotp_tree, offset +  2, 2, 
+		       "Destination reference: 0x%04x", dst_ref);
+
+    switch (li) {
+      case LI_NORMAL_DT_WITH_CHECKSUM      :
+	add_item_to_tree(cotp_tree, offset +  4, 1, 
+			 "TPDU number: 0x%02x (%s)", 
+			 tpdu_nr,
+			 (fragment)? "fragment":"complete");
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_NDT, 1, 
+			 "Parameter code: 0x%02x (checksum)", code);
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_NDT + 1, 1, 
+			 "Parameter length: 0x%02x", length);
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_NDT + 2, length, 
+			 "Checksum: 0x%04x", checksum);
+	break;
+      case LI_NORMAL_DT_WITHOUT_CHECKSUM   :
+	add_item_to_tree(cotp_tree, offset +  4, 1, 
+			 "TPDU number: 0x%02x (%s)", 
+			 tpdu_nr,
+			 (fragment)? "fragment":"complete");
+	break;
+      case LI_EXTENDED_DT_WITH_CHECKSUM    :
+	add_item_to_tree(cotp_tree, offset +  4, 4, 
+			 "TPDU number: 0x%08x (%s)", 
+			 tpdu_nr,
+			 (fragment)? "fragment":"complete");
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_EDT, 1, 
+			 "Parameter code: 0x%02x (checksum)", code);
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_EDT + 1, 1, 
+			 "Parameter length: 0x%02x", length);
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_EDT + 2, length, 
+			 "Checksum: 0x%04x", checksum);
+	break;
+      case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
+	add_item_to_tree(cotp_tree, offset +  4, 4, 
+			 "TPDU number: 0x%08x (%s)", 
+			 tpdu_nr,
+			 (fragment)? "fragment":"complete");
+	break;
+      case LI_NORMAL_DT_CLASS_01           :
+	add_item_to_tree(cotp_tree, offset +  2, 1, 
+			 "TPDU number: 0x%02x (%s)", 
+			 tpdu_nr,
+			 (fragment)? "fragment":"complete");
+	break;
+    }
+  } /* tree */
+
+  offset += li + 1;
+  dissect_data(pd, offset, fd, tree);
+
+  return 0;
+
+} /* osi_decode_DT */
+
+static int osi_decode_ED(const u_char *pd, int offset, 
+			 frame_data *fd, GtkTree *tree)
+{
+  GtkWidget *cotp_tree, *ti;
+  u_int    tpdu_nr ;
+  u_short  checksum;
+  u_char   code, length;
+
+  /* ED TPDUs are never fragmented */
+
+  switch (li) {
+    case LI_NORMAL_DT_WITH_CHECKSUM      :
+      tpdu_nr = pd[offset + P_TPDU_NR_234];
+      if ( tpdu_nr & 0x80 )
+	tpdu_nr = tpdu_nr & 0x7F;
+      else
+	return -1;
+      code = pd[offset + P_VAR_PART_NDT];
+      length = pd[offset + P_VAR_PART_NDT + 1];
+      if (code == VP_CHECKSUM)
+	checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NDT + 2]);
+      else
+	return -1;
+      break;
+    case LI_NORMAL_DT_WITHOUT_CHECKSUM   :
+      tpdu_nr = pd[offset + P_TPDU_NR_234];
+      if ( tpdu_nr & 0x80 )
+	tpdu_nr = tpdu_nr & 0x7F;
+      else
+	return -1;
+      break;
+    case LI_EXTENDED_DT_WITH_CHECKSUM    :
+      tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+      if ( tpdu_nr & 0x80000000 )
+	tpdu_nr = tpdu_nr & 0x7FFFFFFF;
+      else
+	return -1;
+      code = pd[offset + P_VAR_PART_EDT];
+      length = pd[offset + P_VAR_PART_EDT + 1];
+      if (code == VP_CHECKSUM)
+	checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EDT + 2]);
+      else
+	return -1;
+      break;
+    case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
+      tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+      if ( tpdu_nr & 0x80000000 )
+	tpdu_nr = tpdu_nr & 0x7FFFFFFF;
+      else
+	return -1;
+      break;
+    default : /* bad TPDU */
+      return -1;
+      /*NOTREACHED*/
+      break;
+  } /* li */
+
+  if (fd->win_info[0]) {
+    strcpy(fd->win_info[3], "COTP");
+    sprintf(fd->win_info[4], "ED TPDU (%d) dst-ref: 0x%04x", tpdu_nr, dst_ref);
+  }
+
+  if (tree) {
+    ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			  "ISO COTP");
+    cotp_tree = gtk_tree_new();
+    add_subtree(ti, cotp_tree, ETT_COTP);
+    add_item_to_tree(cotp_tree, offset,      1,
+		     "Length indicator: %d", li);
+    add_item_to_tree(cotp_tree, offset +  1, 1, 
+		     "TPDU code: Ox%x (ED)", tpdu); 
+    add_item_to_tree(cotp_tree, offset +  2, 2, 
+		     "Destination reference: 0x%04x", dst_ref);
+
+    switch (li) {
+      case LI_NORMAL_DT_WITH_CHECKSUM      :
+	add_item_to_tree(cotp_tree, offset +  4, 1, 
+			 "TPDU number: 0x%02x", tpdu_nr);	
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_NDT, 1, 
+			 "Parameter code: 0x%02x (checksum)", code);
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_NDT + 1, 1, 
+			 "Parameter length: 0x%02x", length);
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_NDT + 2, length, 
+			 "Checksum: 0x%04x", checksum);
+	break;
+      case LI_NORMAL_DT_WITHOUT_CHECKSUM   :
+	add_item_to_tree(cotp_tree, offset +  4, 1, 
+			 "TPDU number: 0x%02x", tpdu_nr);
+	break;
+      case LI_EXTENDED_DT_WITH_CHECKSUM    :
+	add_item_to_tree(cotp_tree, offset +  4, 4, 
+			 "TPDU number: 0x%02x", tpdu_nr);	
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_EDT, 1, 
+			 "Parameter code: 0x%02x (checksum)", code);
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_EDT + 1, 1, 
+			 "Parameter length: 0x%02x", length);
+	add_item_to_tree(cotp_tree, 
+			 offset +  P_VAR_PART_EDT + 2, length, 
+			 "Checksum: 0x%04x", checksum);
+	break;
+      case LI_EXTENDED_DT_WITHOUT_CHECKSUM :
+	add_item_to_tree(cotp_tree, offset +  4, 4, 
+			 "TPDU number: 0x%02x", tpdu_nr);
+	break;
+    }
+  } /* tree */
+
+  offset += li + 1;
+  dissect_data(pd, offset, fd, tree);
+
+  return 0;
+
+} /* osi_decode_ED */
+
+static int osi_decode_RJ(const u_char *pd, int offset, 
+			 frame_data *fd, GtkTree *tree)
+{
+  GtkWidget *cotp_tree, *ti;
+  u_int    tpdu_nr ;
+  u_short  credit;
+
+  switch(li) {
+    case LI_NORMAL_RJ   :
+      tpdu_nr = pd[offset + P_TPDU_NR_234];
+      break;
+    case LI_EXTENDED_RJ :
+      tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+      credit = EXTRACT_SHORT(&pd[offset + P_CDT_IN_RJ]);
+      break;
+    default :
+      return -1;
+      /*NOTREACHED*/
+      break;
+  }
+
+  if (fd->win_info[0]) {
+    strcpy(fd->win_info[3], "COTP");
+    sprintf(fd->win_info[4], "RJ TPDU (%d) dst-ref: 0x%04x", tpdu_nr, dst_ref);
+  }
+
+  if (tree) {
+    ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			  "ISO COTP");
+    cotp_tree = gtk_tree_new();
+    add_subtree(ti, cotp_tree, ETT_COTP);
+    add_item_to_tree(cotp_tree, offset,      1,
+		     "Length indicator: %d", li);
+    add_item_to_tree(cotp_tree, offset +  1, 1, 
+		     "TPDU code: Ox%x (RJ)", tpdu); 
+    if (li == LI_NORMAL_RJ)
+      add_item_to_tree(cotp_tree, offset +  1, 1, 
+		       "Credit: %d", cdt);
+    add_item_to_tree(cotp_tree, offset +  2, 2, 
+		     "Destination reference: 0x%04x", dst_ref);
+    if (li == LI_NORMAL_RJ)
+      add_item_to_tree(cotp_tree, offset +  4, 1, 
+		       "Your TPDU number: 0x%02x", tpdu_nr);
+    else {
+      add_item_to_tree(cotp_tree, offset +  4, 4, 
+		       "Your TPDU number: 0x%02x", tpdu_nr);
+      add_item_to_tree(cotp_tree, offset +  8, 2, 
+		       "Credit: 0x%02x", credit);
+    }
+  }
+
+  offset += li + 1;
+  dissect_data(pd, offset, fd, tree);
+
+  return 0;
+
+} /* osi_decode_RJ */
+
+#define MAX_TSAP_LEN	32
+
+static gchar *print_tsap(const u_char *tsap, int length)
+{
+
+  static gchar  str[3][MAX_TSAP_LEN * 2 + 1];
+  static gchar *cur;
+  gchar tmp[3];
+
+  if (cur == &str[0][0]) {
+    cur = &str[1][0];
+  } else if (cur == &str[1][0]) {  
+    cur = &str[2][0];
+  } else {  
+    cur = &str[0][0];
+  }
+
+  /* to do: test if all bytes are printable */
+
+  cur[0] = '\0';
+  if (length <= 0 || length > MAX_TSAP_LEN) 
+    sprintf(cur, "<unsupported TSAP length>");
+  else {    
+    while (length != 0) {
+      sprintf(tmp, "%02x", *tsap ++);
+      strcat(cur, tmp);
+      length --;
+    }
+  }
+  return cur;
+
+} /* print_tsap */
+
+static int osi_decode_CC(const u_char *pd, int offset, 
+			 frame_data *fd, GtkTree *tree)
+{
+
+  /* CC & CR decoding in the same function */
+
+  GtkWidget *cotp_tree, *ti;
+  u_short src_ref, checksum;
+  u_char  class_option, code, length;
+  u_int   i = 0;
+
+  src_ref = EXTRACT_SHORT(&pd[offset + P_SRC_REF]);
+  class_option = (pd[offset + P_CLASS_OPTION] >> 4 ) & 0x0F;
+  if (class_option > 4)
+    return -1;
+
+  if (fd->win_info[0]) {
+    strcpy(fd->win_info[3], "COTP");
+    sprintf(fd->win_info[4], "%s TPDU src-ref: 0x%04x dst-ref: 0x%04x",
+	    (tpdu == CR_TPDU) ? "CR" : "CC",
+	    src_ref,
+	    dst_ref);
+  }      
+
+  if (tree) {
+    ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			  "ISO COTP");
+    cotp_tree = gtk_tree_new();
+    add_subtree(ti, cotp_tree, ETT_COTP);
+    add_item_to_tree(cotp_tree, offset,      1,
+		     "Length indicator: %d", li);
+    add_item_to_tree(cotp_tree, offset +  1, 1, 
+		     "TPDU code: Ox%x (%s)", tpdu,
+		     (tpdu == CR_TPDU) ? "CR" : "CC"); 
+    add_item_to_tree(cotp_tree, offset +  2, 2, 
+		     "Destination reference: 0x%04x", dst_ref);
+    add_item_to_tree(cotp_tree, offset +  4, 2, 
+		     "Source reference: 0x%04x", src_ref);
+    add_item_to_tree(cotp_tree, offset +  6, 1, 
+		     "Class option: 0x%02x", class_option);
+  }
+
+  if (tree)
+    while(li > P_VAR_PART_CC + i - 1) {
+      
+      u_char  c1,c2;
+      u_short s, s1,s2,s3,s4;
+      u_int   t1,t2,t3,t4;
+      
+      switch( (code = pd[offset + P_VAR_PART_CC + i]) )	{
+	case VP_CHECKSUM :
+	  length   = pd[offset + P_VAR_PART_CC + i + 1];
+	  checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 2]);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i, 1, 
+			   "Parameter code: 0x%02x (checksum)", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 2, length, 
+			   "Checksum: 0x%04x", checksum);
+	  i += length + 2;
+	  break;
+	case VP_SRC_TSAP    :
+	  length = pd[offset + P_VAR_PART_CC + i + 1];
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i, 1, 
+			   "Parameter code: 0x%02x (src-tsap)", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 2, length, 
+			   "Calling TSAP: 0x%s", 
+			   print_tsap(&pd[offset + P_VAR_PART_CC + i + 2],
+				      length));
+	  i += length + 2;
+	  break;
+	case VP_DST_TSAP    :
+	  length = pd[offset + P_VAR_PART_CC + i + 1];
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i, 1, 
+			   "Parameter code: 0x%02x (dst-tsap)", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 2, length, 
+			   "Called TSAP: 0x%s", 
+			   print_tsap(&pd[offset + P_VAR_PART_CC + i + 2],
+				      length));
+	  i += length + 2;
+	  break;
+	case VP_TPDU_SIZE   :
+	  length = pd[offset + P_VAR_PART_CC + i + 1];
+	  c1 = pd[offset + P_VAR_PART_CC + i + 2] & 0x0F;
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i, 1, 
+			   "Parameter code: 0x%02x (tpdu-size)", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 2, length, 
+			   "TPDU size: %d", 2 << c1);
+	  i += length + 2;
+	  break;
+	case VP_OPT_SEL     :
+	  length = pd[offset + P_VAR_PART_CC + i + 1];
+	  c1 = pd[offset + P_VAR_PART_CC + i + 2] & 0x0F;
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i, 1, 
+			   "Parameter code: 0x%02x (options)", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  if (class_option == 1) {
+	    if (c1 & 0x8)
+	      add_item_to_tree(cotp_tree, 
+			       offset +  P_VAR_PART_CC + i + 2, 1,
+			       "Use of network expedited data");
+	    else
+	      add_item_to_tree(cotp_tree, 
+			       offset +  P_VAR_PART_CC + i + 2, 1,
+			       "Non use of network expedited data");
+	    if (c1 & 0x4)
+	      add_item_to_tree(cotp_tree, 
+			       offset +  P_VAR_PART_CC + i + 2, 1,
+			       "Use of Receipt confirmation");
+	    else
+	      add_item_to_tree(cotp_tree, 
+			       offset +  P_VAR_PART_CC + i + 2, 1,
+			       "Use of explicit AK variant");
+	  } else if (class_option == 4) {
+	    if (c1 & 0x2)
+	      add_item_to_tree(cotp_tree, 
+			       offset +  P_VAR_PART_CC + i + 2, 1,
+			       "Use 16 bit checksum ");
+	    else
+	      add_item_to_tree(cotp_tree, 
+			       offset +  P_VAR_PART_CC + i + 2, 1,
+			       "Non-use 16 bit checksum in class 4");
+	  }
+	  if (c1 & 0x1)
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_CC + i + 2, 1,
+			     "Use of transport expedited data transfer\n");
+	  else
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_CC + i + 2, 1,
+			     "Non-use of transport expedited data transfer");
+	  i += length + 2;
+	  break;
+	case VP_ACK_TIME    :
+	  length = pd[offset + P_VAR_PART_CC + i + 1];
+	  s = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 2]);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i, 1, 
+			   "Parameter code: 0x%02x (ack time)", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 2, length, 
+			   "Ack time (ms): %d", s);
+	  i += length + 2;
+	  break;
+	case VP_THROUGHPUT  :
+	  length = pd[offset + P_VAR_PART_CC + i + 1];
+	  t1 = EXTRACT_LONG(&pd[offset + P_VAR_PART_CC + i + 1]);
+	  t2 = EXTRACT_LONG(&pd[offset + P_VAR_PART_CC + i + 4]);
+	  t3 = EXTRACT_LONG(&pd[offset + P_VAR_PART_CC + i + 7]);
+	  t4 = EXTRACT_LONG(&pd[offset + P_VAR_PART_CC + i + 10]);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i, 1, 
+			   "Parameter code: 0x%02x (throughput)", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 2, 4, 
+			   "Target value / calling-called: %d o/s", t1);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 6, 4, 
+			   "Minimum / calling-called: %d o/s", t2);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 10, 4, 
+			   "Target value / called-calling: %d o/s", t3);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 14, 4, 
+			   "Minimum / called-calling: %d o/s", t4);
+	  i += length + 2;
+	  break;
+	case VP_TRANSIT_DEL :
+	  length = pd[offset + P_VAR_PART_CC + i + 1];
+	  s1 = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 2]);
+	  s2 = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 4]);
+	  s3 = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 6]);
+	  s4 = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 8]);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i, 1, 
+			   "Parameter code: 0x%02x (transit delay)", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 2, 2, 
+			   "Target value / calling-called: %d ms", s1);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 4, 2, 
+			   "Minimum / calling-called: %d ms", s2);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 6, 2, 
+			   "Target value / called-calling: %d ms", s3);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 8, 2, 
+			   "Minimum / called-calling: %d ms", s4);
+	  i += length + 2;
+	  break;
+	case VP_PRIORITY    :
+	  length = pd[offset + P_VAR_PART_CC + i + 1];
+	  s = EXTRACT_SHORT(&pd[offset + P_VAR_PART_CC + i + 2]);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i, 1, 
+			   "Parameter code: 0x%02x (priority)", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 2, length,
+			   "Priority: %d", s);
+	  i += length + 2;
+	  break;
+
+	case VP_REASSIGNMENT: 	  /* todo */
+	case VP_RES_ERROR   :
+	case VP_VERSION_NR  :
+	case VP_PROTECTION  :
+	case VP_PROTO_CLASS :
+	default             :	  /* no decoding */
+	  length = pd[offset + P_VAR_PART_CC + i + 1];
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 0, 1, 
+			   "Parameter code: 0x%02x", code);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 1, 1, 
+			   "Parameter length: 0x%02x", length);
+	  add_item_to_tree(cotp_tree, 
+			   offset +  P_VAR_PART_CC + i + 2, length, 
+			   "Parameter value: <not shown>");
+	  i += length + 2;
+	  break; 
+      }
+    } /* while */
+
+  offset += li + 1;
+  dissect_data(pd, offset, fd, tree);
+
+  return 0;
+
+} /* osi_decode_CC */
+
+static int osi_decode_DC(const u_char *pd, int offset, 
+			 frame_data *fd, GtkTree *tree)
+{
+  GtkWidget *cotp_tree, *ti;
+  u_short src_ref, checksum;
+  u_char  length, code = 0;
+
+  if (li > LI_MAX_DC) 
+    return -1;
+
+  src_ref = EXTRACT_SHORT(&pd[offset + P_SRC_REF]);
+
+  switch(li) {
+    case LI_DC_WITHOUT_CHECKSUM :
+      break;
+    case LI_DC_WITH_CHECKSUM :
+      if ((code = pd[offset + P_VAR_PART_DC]) != VP_CHECKSUM) 
+	return -1;
+      length   = pd[offset + P_VAR_PART_DC + 1];
+      checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_DC + 2]);
+      break;
+    default :
+      return -1;
+      /*NOTREACHED*/
+      break;
+  } /* li */
+
+  if (fd->win_info[0]) {
+    strcpy(fd->win_info[3], "COTP");
+    sprintf(fd->win_info[4], "DC TPDU src-ref: 0x%04x dst-ref: 0x%04x", 
+	    src_ref,
+	    dst_ref);
+  }      
+
+  if (tree) {
+    ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			  "ISO COTP");
+    cotp_tree = gtk_tree_new();
+    add_subtree(ti, cotp_tree, ETT_COTP);
+    add_item_to_tree(cotp_tree, offset,      1,
+		     "Length indicator: %d", li);
+    add_item_to_tree(cotp_tree, offset +  1, 1, 
+		     "TPDU code: Ox%x (DC)", tpdu); 
+    add_item_to_tree(cotp_tree, offset +  2, 2, 
+		     "Destination reference: 0x%04x", dst_ref);
+    add_item_to_tree(cotp_tree, offset +  4, 2, 
+		     "Source reference: 0x%04x", src_ref);
+    if (code) {
+      add_item_to_tree(cotp_tree, 
+		       offset +  P_VAR_PART_DC + 0, 1, 
+		       "Parameter code: 0x%02x (checksum)", code);
+      add_item_to_tree(cotp_tree, 
+		       offset +  P_VAR_PART_DC + 1, 1, 
+		       "Parameter length: 0x%02x", length);
+      add_item_to_tree(cotp_tree, 
+		       offset +  P_VAR_PART_DC + 2, 2, 
+		       "Checksum: 0x%04x", checksum);
+    }
+  }
+
+  offset += li + 1;
+  dissect_data(pd, offset, fd, tree);
+
+  return 0;
+
+} /* osi_decode_DC */
+
+static int osi_decode_AK(const u_char *pd, int offset, 
+			 frame_data *fd, GtkTree *tree)
+{
+  GtkWidget *cotp_tree, *ti;
+  u_int      tpdu_nr,i =0, r_lower_window_edge ;
+  u_short    cdt_in_ak;
+  u_short    checksum, seq_nr, r_seq_nr, r_cdt;
+  u_char     code, length;
+
+  if (li > LI_MAX_AK) 
+    return -1;
+
+  if (!is_LI_NORMAL_AK(li)) {
+    tpdu_nr = pd[offset + P_TPDU_NR_234];
+
+    if (fd->win_info[0]) {
+      strcpy(fd->win_info[3], "COTP");
+      sprintf(fd->win_info[4], "AK TPDU (%d) dst-ref: 0x%04x", 
+	      tpdu_nr, dst_ref);
+    }      
+    
+    if (tree) {
+      ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			    "ISO COTP");
+      cotp_tree = gtk_tree_new();
+      add_subtree(ti, cotp_tree, ETT_COTP);
+      add_item_to_tree(cotp_tree, offset,      1,
+		       "Length indicator: %d", li);
+      add_item_to_tree(cotp_tree, offset +  1, 1, 
+		       "TPDU code: Ox%x (AK)", tpdu); 
+      add_item_to_tree(cotp_tree, offset +  1, 1, 
+		       "Credit: %d", cdt);
+      add_item_to_tree(cotp_tree, offset +  2, 2, 
+		       "Destination reference: 0x%04x", dst_ref);
+      add_item_to_tree(cotp_tree, offset +  4, 1, 
+		       "Your TPDU number: 0x%02x", tpdu_nr);
+    }
+
+    while(li > P_VAR_PART_NAK + i - 1) {
+      switch( (code = pd[offset + P_VAR_PART_NAK + i]) ) {
+        case VP_CHECKSUM :
+	  length   = pd[offset + P_VAR_PART_NAK + i + 1];
+	  checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NAK + i + 2]);
+	  if (tree) {
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 0, 1, 
+			     "Parameter code: 0x%02x (checksum)", code);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 1, 1, 
+			     "Parameter length: 0x%02x", length);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 2, 2, 
+			     "Checksum: 0x%04x", checksum);
+	  }
+	  i += length + 2;
+	  break;
+        case VP_FLOW_CNTL :
+	  length = pd[offset + P_VAR_PART_NAK + i + 1];
+	  r_lower_window_edge = 
+	    EXTRACT_LONG(&pd[offset + P_VAR_PART_NAK + i + 2]);
+	  r_seq_nr = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NAK + i + 6]);
+	  r_cdt = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NAK + i + 8]);
+	  if (tree) {
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 0, 1, 
+			     "Parameter code: 0x%02x (flow control)", 
+			     code);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 1, 1, 
+			     "Parameter length: 0x%02x", length);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 2, 4, 
+			     "Lower window edge: 0x%08x", 
+			     r_lower_window_edge);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 6, 2, 
+			     "Sequence number: 0x%04x", 
+			     r_seq_nr);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 8, 2, 
+			     "Credit: 0x%04x", 
+			     r_cdt);
+	  }
+	  i += length + 2;
+	  break;
+        case VP_SEQ_NR :
+	  length = pd[offset + P_VAR_PART_NAK + i + 1];
+	  seq_nr = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NAK + i + 2]);
+	  if (tree) {
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 0, 1, 
+			     "Parameter code: 0x%02x (seq number)", code);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 1, 1, 
+			     "Parameter length: 0x%02x", length);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 2, 2, 
+			     "Sequence number: 0x%04x", seq_nr);
+	  }
+	  i += length + 2;
+	  break;
+        default :
+	  length = pd[offset + P_VAR_PART_NAK + i + 1];
+	  if (tree) {
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 0, 1, 
+			     "Parameter code: 0x%02x (unknown)", code);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 1, 1, 
+			     "Parameter length: 0x%02x", length);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_NAK + i + 2, length, 
+			     "Parameter value: <not shown>");
+	  }
+	  i += length + 2;
+	  break;
+      } /* code */
+    }
+  } else { /* extended format */
+    
+    tpdu_nr   = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+    cdt_in_ak = EXTRACT_SHORT(&pd[offset + P_CDT_IN_AK]);
+
+    if (fd->win_info[0]) {
+      strcpy(fd->win_info[3], "COTP");
+      sprintf(fd->win_info[4], "AK TPDU (%d) dst-ref: 0x%04x", 
+	      tpdu_nr, dst_ref);
+    }      
+    
+    if (tree) {
+      ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			    "ISO COTP");
+      cotp_tree = gtk_tree_new();
+      add_subtree(ti, cotp_tree, ETT_COTP);
+      add_item_to_tree(cotp_tree, offset,      1,
+		       "Length indicator: %d", li);
+      add_item_to_tree(cotp_tree, offset +  1, 1, 
+		       "TPDU code: Ox%x (AK)", tpdu); 
+      add_item_to_tree(cotp_tree, offset +  2, 2, 
+		       "Destination reference: 0x%04x", dst_ref);
+      add_item_to_tree(cotp_tree, offset +  4, 4, 
+		       "Your TPDU number: 0x%08x", tpdu_nr);
+      add_item_to_tree(cotp_tree, offset +  8, 2, 
+		       "Credit: 0x%04x", cdt_in_ak);
+    }
+    
+    while(li > P_VAR_PART_EAK + i - 1) {
+      switch( (code = pd[offset + P_VAR_PART_EAK + i]) ) {
+        case VP_CHECKSUM :
+	  length   = pd[offset + P_VAR_PART_EAK + i + 1];
+	  checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EAK + i + 2]);
+	  if (tree) {
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 0, 1, 
+			     "Parameter code: 0x%02x (checksum)", code);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 1, 1, 
+			     "Parameter length: 0x%02x", length);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 2, 2, 
+			     "Checksum: 0x%04x", checksum);
+	  }
+	  i += length + 2;
+	  break;
+        case VP_FLOW_CNTL :
+	  length   = pd[offset + P_VAR_PART_EAK + i + 1];
+	  r_lower_window_edge = 
+	    EXTRACT_LONG(&pd[offset + P_VAR_PART_EAK + i + 2]);
+	  r_seq_nr = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EAK + i + 6]);
+	  r_cdt = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EAK + i + 8]);
+	  if (tree) {
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 0, 1, 
+			     "Parameter code: 0x%02x (flow control)",
+			     code);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 1, 1, 
+			     "Parameter length: 0x%02x", length);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 2, 4, 
+			     "Lower window edge: 0x%08x", 
+			     r_lower_window_edge);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 6, 2, 
+			     "Sequence number: 0x%04x", 
+			     r_seq_nr);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 8, 2, 
+			     "Credit: 0x%04x", 
+			     r_cdt);
+	  }
+	  i += length + 2;
+	  break;
+        case VP_SEQ_NR :
+	  length   = pd[offset + P_VAR_PART_EAK + i + 1];
+	  seq_nr = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EAK + i + 2]);
+	  if (tree) {
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 0, 1, 
+			     "Parameter code: 0x%02x (seq number)", code);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 1, 1, 
+			     "Parameter length: 0x%02x", length);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 2, 2, 
+			     "Sequence number: 0x%04x", seq_nr);
+	  }
+	  i += length + 2;
+	  break;
+        default :
+	  length   = pd[offset + P_VAR_PART_EAK + i + 1];
+	  if (tree) {
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 0, 1, 
+			     "Parameter code: 0x%02x (unknown)", code);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 1, 1, 
+			     "Parameter length: 0x%02x", length);
+	    add_item_to_tree(cotp_tree, 
+			     offset +  P_VAR_PART_EAK + i + 2, length, 
+			     "Parameter value: <not shown>");
+	  }
+	  i += length + 2;
+	  break;
+      } /* code */
+    }
+    
+  } /* is_LI_NORMAL_AK */
+
+  offset += li + 1;
+  dissect_data(pd, offset, fd, tree);
+
+  return 0;
+
+} /* osi_decode_AK */
+
+static int osi_decode_EA(const u_char *pd, int offset, 
+			 frame_data *fd, GtkTree *tree)
+{
+  GtkWidget *cotp_tree, *ti;
+  u_int    tpdu_nr ;
+  u_short  checksum;
+  u_char   code;
+  u_char   length;
+
+  if (li > LI_MAX_EA) 
+    return -1;
+
+  switch (li) {
+    case LI_NORMAL_EA_WITH_CHECKSUM      :
+      tpdu_nr = pd[offset + P_TPDU_NR_234];
+      code    = pd[offset + P_VAR_PART_NDT];
+      length  = pd[offset + P_VAR_PART_NDT + 1];
+      if (code != VP_CHECKSUM || length != 1)
+	return -1;
+      checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_NDT + 2]);
+      break;
+    case LI_NORMAL_EA_WITHOUT_CHECKSUM   :
+      tpdu_nr = pd[offset + P_TPDU_NR_234];
+      break;
+    case LI_EXTENDED_EA_WITH_CHECKSUM    :
+      tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+      code    = pd[offset + P_VAR_PART_EDT];
+      length  = pd[offset + P_VAR_PART_EDT + 1];
+      if (code != VP_CHECKSUM || length != 1)
+	return -1;
+      checksum = EXTRACT_SHORT(&pd[offset + P_VAR_PART_EDT + 2]);
+      break;
+    case LI_EXTENDED_EA_WITHOUT_CHECKSUM :
+      tpdu_nr = EXTRACT_LONG(&pd[offset + P_TPDU_NR_234]);
+      break;
+    default : /* bad TPDU */
+      return -1;
+      /*NOTREACHED*/
+      break;
+  } /* li */
+
+  if (fd->win_info[0]) {
+    strcpy(fd->win_info[3], "COTP");
+    sprintf(fd->win_info[4], "EA TPDU (%d) dst-ref: 0x%04x", tpdu_nr, dst_ref);
+  }      
+
+  if (tree) {
+    ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			  "ISO COTP");
+    cotp_tree = gtk_tree_new();
+    add_subtree(ti, cotp_tree, ETT_COTP);
+    add_item_to_tree(cotp_tree, offset,      1,
+		     "Length indicator: %d", li);
+    add_item_to_tree(cotp_tree, offset +  1, 1, 
+		     "TPDU code: Ox%x (EA)", tpdu); 
+    add_item_to_tree(cotp_tree, offset +  2, 2, 
+		     "Destination reference: 0x%04x", dst_ref);
+
+    switch (li) {
+      case LI_NORMAL_EA_WITH_CHECKSUM      :
+	add_item_to_tree(cotp_tree, offset +  4, 1, 
+			 "Your TPDU number: 0x%02x", tpdu_nr);
+	add_item_to_tree(cotp_tree, offset +  5, 1, 
+			 "Parameter code: 0x%02x (checksum)", code);
+	add_item_to_tree(cotp_tree, offset +  6, 1, 
+			 "Parameter length: 0x%02x", length);
+	add_item_to_tree(cotp_tree, offset +  7, 2, 
+			 "Checksum: 0x%04x", checksum);
+	break;
+      case LI_NORMAL_EA_WITHOUT_CHECKSUM   :
+	add_item_to_tree(cotp_tree, offset +  4, 1, 
+			 "Your TPDU number: 0x%02x", tpdu_nr);
+	break;
+      case LI_EXTENDED_EA_WITH_CHECKSUM    :
+	add_item_to_tree(cotp_tree, offset +  4, 4, 
+			 "Your TPDU number: 0x%08x", tpdu_nr);
+	add_item_to_tree(cotp_tree, offset +  8, 1, 
+			 "Parameter code: 0x%02x (checksum)", code);
+	add_item_to_tree(cotp_tree, offset +  9, 1, 
+			 "Parameter length: 0x%02x", length);
+	add_item_to_tree(cotp_tree, offset +  10, 2, 
+			 "Checksum: 0x%04x", checksum);
+	break;
+      case LI_EXTENDED_EA_WITHOUT_CHECKSUM :
+	add_item_to_tree(cotp_tree, offset +  4, 4, 
+			 "Your TPDU number: 0x%08x", tpdu_nr);
+	break;
+      default :
+	break;
+    } /* li */
+  } /* tree */
+
+  offset += li + 1;
+  dissect_data(pd, offset, fd, tree);
+
+  return 0;
+
+} /* osi_decode_EA */
+
+static int osi_decode_ER(const u_char *pd, int offset, 
+			 frame_data *fd, GtkTree *tree)
+{
+  GtkWidget *cotp_tree, *ti;
+  u_char *str;
+
+  if (li > LI_MAX_ER) 
+    return -1;
+
+  switch(pd[offset + P_REJECT_ER]) {
+    case 0 :
+      str = "Reason not specified";
+      break;
+    case 1 :
+      str = "Invalid parameter code";
+      break;
+    case 2 :
+      str = "Invalid TPDU type";
+      break;
+    case 3 :
+      str = "Invalid parameter value";
+      break;
+    default:
+      return -1;
+      /*NOTREACHED*/
+      break;
+  }
+
+  if (fd->win_info[0]) {
+    strcpy(fd->win_info[3], "COTP");
+    sprintf(fd->win_info[4], "ER TPDU dst-ref: 0x%04x", dst_ref);
+  }      
+
+  if (tree) {
+    ti = add_item_to_tree(GTK_WIDGET(tree), offset, li + 1,
+			  "ISO COTP");
+    cotp_tree = gtk_tree_new();
+    add_subtree(ti, cotp_tree, ETT_COTP);
+    add_item_to_tree(cotp_tree, offset,      1,
+		     "Length indicator: %d", li);
+    add_item_to_tree(cotp_tree, offset +  1, 1, 
+		     "TPDU code: Ox%x (ER)", tpdu); 
+    add_item_to_tree(cotp_tree, offset +  2, 2, 
+		     "Destination reference: 0x%04x", dst_ref);
+    add_item_to_tree(cotp_tree, offset +  4, 1, 
+		     "Reject cause: %s", str);
+  }
+
+  offset += li + 1;
+  dissect_data(pd, offset, fd, tree);
+
+  return 0;
+
+} /* osi_decode_ER */
+
+void dissect_cotp(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) 
+{
+
+  int status = -1;
+
+  if (((li = pd[offset + P_LI]) == 0) ||
+      (offset + P_LI + li + 1 > fd->cap_len)) {
+    dissect_data(pd, offset, fd, tree);
+    return;
+  }
+
+  tpdu    = (pd[offset + P_TPDU] >> 4) & 0x0F;
+  cdt     = pd[offset + P_CDT] & 0x0F;
+  dst_ref = EXTRACT_SHORT(&pd[offset + P_DST_REF]);
+
+  switch (tpdu) {
+    case CC_TPDU :
+    case CR_TPDU :
+      status = osi_decode_CC(pd, offset, fd, tree);
+      break;
+    case DR_TPDU :
+      status = osi_decode_DR(pd, offset, fd, tree);
+      break;
+    case DT_TPDU :
+      status = osi_decode_DT(pd, offset, fd, tree);
+      break;
+    case ED_TPDU :
+      status = osi_decode_ED(pd, offset, fd, tree);
+      break;
+    case RJ_TPDU :
+      status = osi_decode_RJ(pd, offset, fd, tree);
+      break;
+    case DC_TPDU :
+      status = osi_decode_DC(pd, offset, fd, tree);
+      break;
+    case AK_TPDU :
+      status = osi_decode_AK(pd, offset, fd, tree);
+      break;
+    case EA_TPDU :
+      status = osi_decode_EA(pd, offset, fd, tree);
+      break;
+    case ER_TPDU :
+      status = osi_decode_ER(pd, offset, fd, tree);
+      break;
+    default      :
+      break;
+  }
+
+  if (status == -1) /* incorrect TPDU */
+    dissect_data(pd, offset, fd, tree);
+
+} /* dissect_cotp */
+
+
+/*
+ *  CLNP part 
+ */
+
+#define MAX_NSAP_LEN	20
+
+static gchar *print_nsap(const u_char *nsap, int length)
+{
+
+  /* to do : real NSAP decoding */
+
+  static gchar  str[3][MAX_NSAP_LEN * 3 + 1];
+  static gchar *cur;
+  gchar tmp[5];
+
+  if (cur == &str[0][0]) {
+    cur = &str[1][0];
+  } else if (cur == &str[1][0]) {  
+    cur = &str[2][0];
+  } else {  
+    cur = &str[0][0];
+  }
+
+  cur[0] = '\0';
+  if (length <= 0 || length > MAX_NSAP_LEN) 
+    sprintf(cur, "<invalid NSAP>");
+  else
+    while (length != 1) {
+      sprintf(tmp, "%02x:", *nsap ++);
+      strcat(cur, tmp);
+      length --;
+    }
+  sprintf(tmp, "%02x", *nsap);
+  strcat(cur, tmp);
+  return cur;
+
+} /* print_nsap */
+
+void dissect_clnp(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) 
+{
+
+  struct clnp_header clnp;
+  GtkWidget *clnp_tree, *ti;
+  u_char src_len, dst_len, nsel;
+  u_int first_offset = offset;
+
+  if (fd->cap_len < offset + sizeof(clnp)) {
+    dissect_data(pd, offset, fd, tree);
+    return;
+  }
+
+  /* avoid alignment problem */
+  memcpy(&clnp, &pd[offset], sizeof(clnp));
+  
+  /* return if version not known */
+  if (clnp.cnf_vers != ISO8473_V1) {
+    dissect_data(pd, offset, fd, tree);
+    return;
+  }
+
+  /* fixed part decoding */
+
+  if (tree) {
+    ti = add_item_to_tree(GTK_WIDGET(tree), offset, clnp.cnf_hdr_len,
+			  "ISO CLNP");
+    clnp_tree = gtk_tree_new();
+    add_subtree(ti, clnp_tree, ETT_CLNP);
+    add_item_to_tree(clnp_tree, offset,      1,
+		     "Protocol identifier: 0x%02x", clnp.cnf_proto_id);
+    add_item_to_tree(clnp_tree, offset +  1, 1, 
+		     "Length: %d", clnp.cnf_hdr_len); 
+    add_item_to_tree(clnp_tree, offset +  2, 1, 
+		     "Version: %d", clnp.cnf_vers);
+    add_item_to_tree(clnp_tree, offset +  3, 1, 
+		     "TTL: %d (%d secs)", 
+		     clnp.cnf_ttl, clnp.cnf_ttl / 2);
+    add_item_to_tree(clnp_tree, offset +  4, 1, 
+		     "Type code: 0x%02x (%s%s%s%s)", 
+		     clnp.cnf_type,
+		     (clnp.cnf_type & CNF_SEG_OK) ? "S " : "",
+		     (clnp.cnf_type & CNF_MORE_SEGS) ? "M " : "",
+		     (clnp.cnf_type & CNF_ERR_OK) ? "E " : "",
+		     (clnp.cnf_type & CNF_TYPE) == DT_NPDU ? "DT" : "ER");
+    add_item_to_tree(clnp_tree, offset +  5, 2, 
+		     "PDU segment length: %d",
+		     EXTRACT_SHORT(&clnp.cnf_seglen_msb));
+    add_item_to_tree(clnp_tree, offset +  7, 2, 
+		     "Checksum: 0x%04x",
+		     EXTRACT_SHORT(&clnp.cnf_cksum_msb));
+  } /* tree */
+
+  /* stop here if header is not complete */
+
+  if (fd->cap_len < offset + clnp.cnf_hdr_len) {
+    dissect_data(pd, offset, fd, tree);
+    return;
+  }
+
+  /* address part */
+  
+  offset += P_ADDRESS_PART;
+  dst_len = pd[offset];
+  nsel    = pd[offset + dst_len];
+  src_len = pd[offset + dst_len + 1];
+
+  if (tree) {
+    add_item_to_tree(clnp_tree, offset, 1, 
+		     "Destination address length: 0x%02x", dst_len);
+    add_item_to_tree(clnp_tree, offset + 1 , dst_len, 
+		     "Destination address: %s", 
+		     print_nsap(&pd[offset + 1], dst_len));
+    add_item_to_tree(clnp_tree, offset + 1 + dst_len, 1, 
+		     "Source address length: 0x%02x", src_len);
+    add_item_to_tree(clnp_tree, offset + dst_len + 2, src_len, 
+		     "Source address: %s", 
+		     print_nsap(&pd[offset + dst_len + 2], src_len));
+  }
+
+  if (fd->win_info[0]) {
+    sprintf(fd->win_info[1], "%s", 
+	    print_nsap(&pd[offset + dst_len + 2], src_len));
+    sprintf(fd->win_info[2], "%s", 
+	    print_nsap(&pd[offset + 1], dst_len));
+  }
+
+  /* Segmentation Part */
+
+  offset += dst_len + src_len + 2;
+
+  if (tree && (clnp.cnf_type & CNF_SEG_OK)) {
+    struct clnp_segment seg;
+    memcpy(&seg, &pd[offset], sizeof(seg));
+    
+    add_item_to_tree(clnp_tree, offset, 2, 
+		     "Data unit identifier: 0x%04x",
+		     EXTRACT_SHORT(&pd[offset]));
+    add_item_to_tree(clnp_tree, offset + 2 , 2,
+		     "Segment offset: 0x%04x", 
+		     EXTRACT_SHORT(&pd[offset + 2]));
+    add_item_to_tree(clnp_tree, offset + 4 , 2,
+		     "Total length: 0x%04x", 
+		     EXTRACT_SHORT(&pd[offset + 4]));
+    
+    offset += 6;
+  }
+
+  if (tree) {
+    /* To do : decode options  */
+
+    add_item_to_tree(clnp_tree, offset, 
+		     clnp.cnf_hdr_len + first_offset - offset,
+		     "Options/Data: <not shown>");
+  }
+
+
+  offset = first_offset + clnp.cnf_hdr_len;
+
+  if (offset == fd->cap_len)
+    return;
+
+  /* continue with COTP if any */
+
+  if (nsel == NSEL_TP) 	/* just guessing here - valid for DECNet-OSI */
+    dissect_cotp(pd, offset, fd, tree);
+  else
+    dissect_data(pd, offset, fd, tree);
+
+} /* dissect_clnp */
+
+
+/* main entry point */
+
+void dissect_osi(const u_char *pd, int offset, frame_data *fd, GtkTree *tree) 
+{
+
+  switch (pd[offset]) {
+
+      /* only CLNP is currently decoded */
+
+    case ISO8473_CLNP:
+      if (fd->win_info[0]) 
+	{
+	  strcpy(fd->win_info[3], "CLNP");
+	}      
+      dissect_clnp(pd, offset, fd, tree);
+      break;
+    case ISO9542_ESIS:
+      if (fd->win_info[0]) 
+	{
+	  strcpy(fd->win_info[3], "ESIS");
+	}
+      dissect_data(pd, offset, fd, tree);
+      break;
+    case ISO9542X25_ESIS:
+      if (fd->win_info[0]) 
+	{
+	  strcpy(fd->win_info[3], "ESIS(X25)");
+	}
+      dissect_data(pd, offset, fd, tree);
+      break;
+    case ISO10589_ISIS:
+      if (fd->win_info[0]) 
+	{
+	  strcpy(fd->win_info[3], "ISIS");
+	}
+      dissect_data(pd, offset, fd, tree);
+      break;
+    default:
+      if (fd->win_info[0]) 
+	{
+	  strcpy(fd->win_info[3], "ISO");
+	  sprintf(fd->win_info[4], "Unknown ISO protocol (%02x)", pd[offset]);
+	}
+      dissect_data(pd, offset, fd, tree);
+      break;
+  }
+  
+} /* dissect_osi */
+