/builds/wireshark/wireshark/plugins/epan/irda/packet-irda.c

Bug Summary

File:	builds/wireshark/wireshark/plugins/epan/irda/packet-irda.c
Warning:	line 1243, column 32 Access to field 'iap_result_frame' results in a dereference of a null pointer (loaded from variable 'lmp_conv')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name packet-irda.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-22/lib/clang/22 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -D CARES_NO_DEPRECATED -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D PLUGIN_VERSION="0.0.6" -D WS_DEBUG -D WS_DEBUG_UTF_8 -D irda_EXPORTS -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/plugins/epan/irda -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-22/lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-nonliteral -std=gnu17 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -fdwarf2-cfi-asm -o /builds/wireshark/wireshark/sbout/2026-10-17-100342-3661-1 -x c /builds/wireshark/wireshark/plugins/epan/irda/packet-irda.c
1/* packet-irda.c
* Routines for IrDA dissection
* By Shaun Jackman <sjackman@pathwayconnect.com>
* Copyright 2000 Shaun Jackman
*
* Extended by Jan Kiszka <jan.kiszka@web.de>
* Copyright 2003 Jan Kiszka
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/

16#include "config.h"

18#include <string.h>

20#include <epan/packet.h>
21#include <epan/address_types.h>
22#include <epan/to_str.h>
23#include <epan/strutil.h>
24#include <epan/conversation.h>
25#include <epan/tfs.h>
26#include <wsutil/array.h>
27#include <wiretap/wtap.h>

29#include <epan/dissectors/packet-sll.h>
30#include <epan/dissectors/packet-xdlc.h>
31#include "irda-appl.h"

33/*
* This plugin dissects infrared data transmissions as defined by IrDA
* specifications.  See
*
*    https://web.archive.org/web/20040405053146/http://www.irda.org/standards/specifications.asp
*
* or
*
*    https://archive.org/search?query=creator%3A%22Infrared+Data+Association%22
*
* for various IrDA specifications, including a zip archive of the IrPHY
* 1.4, IrLAP 1.1, IrLMP 1.1, IrDA Tiny TP 1.1, and IrDA Point and Shoot
* Profile 1.1 and Test Specification 1.0 at
*
*    https://web.archive.org/web/20040405053146/http://www.irda.org/standards/pubs/IrData.zip
*
* or the the IrLAP 1.1 specification at
*
*    https://archive.org/details/ir-lap-11
*
* The plugin operates both offline with libpcap files and online on supported
* platforms. Live dissection is currently available for Linux-IrDA
* (irda.sourceforge.net) and for Windows if the Linux-IrDA port IrCOMM2k
* (www.ircomm2k.de) is installed.
*/

59/*
* LAP
*/

63/* Frame types and templates */
64#define INVALID0xff   0xff

66/*
* XXX - the IrDA spec gives XID as 0x2c; HDLC (and other HDLC-derived
* protocols) use 0xAC.
*/
70#define IRDA_XID_CMD0x2c   0x2c /* Exchange Station Identification */

72#define CMD_FRAME0x01 0x01
73#define RSP_FRAME0x00 0x00

75/* Discovery Flags */
76#define S_MASK0x03    0x03
77#define CONFLICT0x04  0x04

79/* Negotiation Parameters */
80#define PI_BAUD_RATE0x01        0x01
81#define PI_MAX_TURN_TIME0x82    0x82
82#define PI_DATA_SIZE0x83        0x83
83#define PI_WINDOW_SIZE0x84      0x84
84#define PI_ADD_BOFS0x85         0x85
85#define PI_MIN_TURN_TIME0x86    0x86
86#define PI_LINK_DISC0x08        0x08


89/*
* LMP
*/

93/* IrLMP frame opcodes */
94#define CONNECT_CMD0x01    0x01
95#define CONNECT_CNF0x81    0x81
96#define DISCONNECT0x02     0x02
97#define ACCESSMODE_CMD0x03 0x03
98#define ACCESSMODE_CNF0x83 0x83

100#define CONTROL_BIT0x80    0x80
101#define RESERVED_BIT0x80   0x80

103/* LSAP-SEL's */
104#define LSAP_MASK0x7f     0x7f
105#define LSAP_IAS0x00      0x00
106#define LSAP_ANY0xff      0xff
107#define LSAP_MAX0x6f      0x6f /* 0x70-0x7f are reserved */
108#define LSAP_CONNLESS0x70 0x70 /* Connectionless LSAP, mostly used for Ultra */


111/*
* IAP
*/

115/* IrIAP Op-codes */
116#define GET_INFO_BASE0x01      0x01
117#define GET_OBJECTS0x02        0x02
118#define GET_VALUE0x03          0x03
119#define GET_VALUE_BY_CLASS0x04 0x04
120#define GET_OBJECT_INFO0x05    0x05
121#define GET_ATTRIB_NAMES0x06   0x06

123#define IAP_LST0x80            0x80
124#define IAP_ACK0x40            0x40
125#define IAP_OP0x3F             0x3F

127#define IAS_SUCCESS0        0
128#define IAS_CLASS_UNKNOWN1  1
129#define IAS_ATTRIB_UNKNOWN2 2
130#define IAS_ATTR_TOO_LONG3  3
131#define IAS_DISCONNECT10     10
132#define IAS_UNSUPPORTED0xFF    0xFF


135/*
* TTP
*/

139#define TTP_PARAMETERS0x80         0x80
140#define TTP_MORE0x80               0x80

142void proto_reg_handoff_irda(void);
143void proto_register_irda(void);

145/* Initialize the protocol and registered fields */
146static int proto_irlap;
147static int hf_lap_a;
148static int hf_lap_a_cr;
149static int hf_lap_a_address;
150static int hf_lap_c;
151static int hf_lap_c_nr;
152static int hf_lap_c_ns;
153static int hf_lap_c_p;
154static int hf_lap_c_f;
155static int hf_lap_c_s;
156static int hf_lap_c_u_cmd;
157static int hf_lap_c_u_rsp;
158static int hf_lap_c_i;
159static int hf_lap_c_s_u;
160static int hf_lap_i;
161static int hf_snrm_saddr;
162static int hf_snrm_daddr;
163static int hf_snrm_ca;
164static int hf_ua_saddr;
165static int hf_ua_daddr;
166static int hf_negotiation_param;
167static int hf_param_pi;
168static int hf_param_pl;
169static int hf_param_pv;
170static int hf_xid_ident;
171static int hf_xid_saddr;
172static int hf_xid_daddr;
173static int hf_xid_flags;
174static int hf_xid_s;
175static int hf_xid_conflict;
176static int hf_xid_slotnr;
177static int hf_xid_version;

179static int proto_irlmp;
180static int hf_lmp_xid_hints;
181static int hf_lmp_xid_charset;
182static int hf_lmp_xid_name;
183static int hf_lmp_xid_name_no_encoding;
184static int hf_lmp_dst;
185static int hf_lmp_dst_control;
186static int hf_lmp_dst_lsap;
187static int hf_lmp_src;
188static int hf_lmp_src_r;
189static int hf_lmp_src_lsap;
190static int hf_lmp_opcode;
191static int hf_lmp_rsvd;
192static int hf_lmp_reason;
193static int hf_lmp_mode;
194static int hf_lmp_status;

196static int proto_iap;
197static int hf_iap_ctl;
198static int hf_iap_ctl_lst;
199static int hf_iap_ctl_ack;
200static int hf_iap_ctl_opcode;
201static int hf_iap_class_name;
202static int hf_iap_attr_name;
203static int hf_iap_return;
204static int hf_iap_list_len;
205static int hf_iap_list_entry;
206static int hf_iap_obj_id;
207static int hf_iap_attr_type;
208static int hf_iap_int;
209static int hf_iap_seq_len;
210static int hf_iap_oct_seq;
211static int hf_iap_char_set;
212static int hf_iap_string;
213static int hf_iap_invaloctet;
214static int hf_iap_invallsap;

216static int proto_ttp;
217static int hf_ttp_p;
218static int hf_ttp_icredit;
219static int hf_ttp_m;
220static int hf_ttp_dcredit;

222static int proto_log;
223static int hf_log_msg;
224static int hf_log_missed;

226/* Initialize the subtree pointers */
227static int ett_irlap;
228static int ett_lap_a;
229static int ett_lap_c;
230static int ett_lap_i;
231static int ett_xid_flags;
232static int ett_log;
233static int ett_irlmp;
234static int ett_lmp_dst;
235static int ett_lmp_src;
236static int ett_iap;
237static int ett_iap_ctl;
238static int ett_ttp;

240#define MAX_PARAMETERS32      32
241static int ett_param[MAX_PARAMETERS32];

243static int ett_iap_entry[MAX_IAP_ENTRIES32];

245static int irda_address_type = -1;

247static dissector_handle_t irda_handle;

249static const xdlc_cf_items irlap_cf_items = {
  &hf_lap_c_nr,
  &hf_lap_c_ns,
  &hf_lap_c_p,
  &hf_lap_c_f,
  &hf_lap_c_s,
  &hf_lap_c_u_cmd,
  &hf_lap_c_u_rsp,
  &hf_lap_c_i,
  &hf_lap_c_s_u
259};

261/* IAP conversation type */
262typedef struct iap_conversation {
  struct iap_conversation*    pnext;
  uint32_t                    iap_query_frame;
  ias_attr_dissector_t* pattr_dissector;
266} iap_conversation_t;

268/* IrLMP conversation type */
269typedef struct lmp_conversation {
  struct lmp_conversation*    pnext;
  uint32_t                    iap_result_frame;
  bool_Bool                        ttp;
  dissector_handle_t          dissector;
274} lmp_conversation_t;

276static const true_false_string lap_cr_vals = {
  "Command",
  "Response"
279};

281static const true_false_string set_notset = {
  "Set",
  "Not set"
284};

286static const value_string lap_c_ftype_vals[] = {
  { XDLC_I0x00, "Information frame" },
  { XDLC_S0x01, "Supervisory frame" },
  { XDLC_U0x03, "Unnumbered frame" },
  { 0,      NULL((void*)0) }
291};

293static const value_string lap_c_u_cmd_abbr_vals[] = {
  { XDLC_SNRM0x80,    "SNRM" },
  { XDLC_DISC0x40,    "DISC" },
  { XDLC_UI0x00,      "UI" },
  { IRDA_XID_CMD0x2c, "XID" },
  { XDLC_TEST0xE0,    "TEST" },
  { 0,            NULL((void*)0) }
300};

302static const value_string lap_c_u_rsp_abbr_vals[] = {
  { XDLC_SNRM0x80, "RNRM" },
  { XDLC_UA0x60,   "UA" },
  { XDLC_FRMR0x84, "FRMR" },
  { XDLC_DM0x0C,   "DM" },
  { XDLC_RD0x40,   "RD" },
  { XDLC_UI0x00,   "UI" },
  { XDLC_XID0xAC,  "XID" },
  { XDLC_TEST0xE0, "TEST" },
  { 0,         NULL((void*)0) }
312};

314static const value_string lap_c_u_cmd_vals[] = {
  { XDLC_SNRM0x80>>2,    "Set Normal Response Mode" },
  { XDLC_DISC0x40>>2,    "Disconnect" },
  { XDLC_UI0x00>>2,      "Unnumbered Information" },
  { IRDA_XID_CMD0x2c>>2, "Exchange Station Identification" },
  { XDLC_TEST0xE0>>2,    "Test" },
  { 0,               NULL((void*)0) }
321};

323static const value_string lap_c_u_rsp_vals[] = {
  { XDLC_SNRM0x80>>2,  "Request Normal Response Mode" },
  { XDLC_UA0x60>>2,    "Unnumbered Acknowledge" },
  { XDLC_FRMR0x84>>2,  "Frame Reject" },
  { XDLC_DM0x0C>>2,    "Disconnect Mode" },
  { XDLC_RD0x40>>2,    "Request Disconnect" },
  { XDLC_UI0x00>>2,    "Unnumbered Information" },
  { XDLC_XID0xAC>>2,   "Exchange Station Identification" },
  { XDLC_TEST0xE0>>2,  "Test" },
  { 0,             NULL((void*)0) }
333};

335static const value_string lap_c_s_vals[] = {
  { XDLC_RR0x00>>2,   "Receiver ready" },
  { XDLC_RNR0x04>>2,  "Receiver not ready" },
  { XDLC_REJ0x08>>2,  "Reject" },
  { XDLC_SREJ0x0C>>2, "Selective reject" },
  { 0,            NULL((void*)0) }
341};

343static const value_string xid_slot_numbers[] = {
344/* Number of XID slots */
  { 0, "1" },
  { 1, "6" },
  { 2, "8" },
  { 3, "16" },
  { 0, NULL((void*)0) }
350};

352static const value_string lmp_opcode_vals[] = {
353/* IrLMP frame opcodes */
  { CONNECT_CMD0x01,    "Connect Command" },
  { CONNECT_CNF0x81,    "Connect Confirm" },
  { DISCONNECT0x02,     "Disconnect" },
  { ACCESSMODE_CMD0x03, "Access Mode Command" },
  { ACCESSMODE_CNF0x83, "Access Mode Confirm" },
  { 0,              NULL((void*)0) }
360};

362static const value_string lmp_reason_vals[] = {
363/* IrLMP disconnect reasons */
  { 0x01, "User Request" },
  { 0x02, "Unexpected IrLAP Disconnect" },
  { 0x03, "Failed to establish IrLAP connection" },
  { 0x04, "IrLAP Reset" },
  { 0x05, "Link Management Initiated Disconnect" },
  { 0x06, "Data delivered on disconnected LSAP-Connection"},
  { 0x07, "Non Responsive LM-MUX Client" },
  { 0x08, "No available LM-MUX Client" },
  { 0x09, "Connection Half Open" },
  { 0x0A, "Illegal Source Address" },
  { 0xFF, "Unspecified Disconnect Reason" },
  { 0,    NULL((void*)0) }
376};

378static const value_string lmp_mode_vals[] = {
379/* IrLMP modes */
  { 0x00, "Multiplexed" },
  { 0x01, "Exclusive" },
  { 0,    NULL((void*)0) }
383};

385static const value_string lmp_status_vals[] = {
386/* IrLMP status */
  { 0x00, "Success" },
  { 0x01, "Failure" },
  { 0xFF, "Unsupported" },
  { 0,    NULL((void*)0) }
391};

393#define LMP_CHARSET_ASCII0      0
394#define LMP_CHARSET_ISO_8859_11 1
395#define LMP_CHARSET_ISO_8859_22 2
396#define LMP_CHARSET_ISO_8859_33 3
397#define LMP_CHARSET_ISO_8859_44 4
398#define LMP_CHARSET_ISO_8859_55 5
399#define LMP_CHARSET_ISO_8859_66 6
400#define LMP_CHARSET_ISO_8859_77 7
401#define LMP_CHARSET_ISO_8859_88 8
402#define LMP_CHARSET_ISO_8859_99 9
403#define LMP_CHARSET_UNICODE0xFF    0xFF /* UCS-2 (byte order?) */

405static const value_string lmp_charset_vals[] = {
406/* IrLMP character set */
  { LMP_CHARSET_ASCII0,      "ASCII" },
  { LMP_CHARSET_ISO_8859_11, "ISO 8859-1" },
  { LMP_CHARSET_ISO_8859_22, "ISO 8859-2" },
  { LMP_CHARSET_ISO_8859_33, "ISO 8859-3" },
  { LMP_CHARSET_ISO_8859_44, "ISO 8859-4" },
  { LMP_CHARSET_ISO_8859_55, "ISO 8859-5" },
  { LMP_CHARSET_ISO_8859_66, "ISO 8859-6" },
  { LMP_CHARSET_ISO_8859_77, "ISO 8859-7" },
  { LMP_CHARSET_ISO_8859_88, "ISO 8859-8" },
  { LMP_CHARSET_ISO_8859_99, "ISO 8859-9" },
  { LMP_CHARSET_UNICODE0xFF,    "Unicode" },
  { 0,                      NULL((void*)0) }
419};

421static const value_string iap_opcode_vals[] = {
422/* IrIAP Op-codes */
  { GET_INFO_BASE0x01,      "GetInfoBase" },
  { GET_OBJECTS0x02,        "GetObjects" },
  { GET_VALUE0x03,          "GetValue" },
  { GET_VALUE_BY_CLASS0x04, "GetValueByClass" },
  { GET_OBJECT_INFO0x05,    "GetObjectInfo" },
  { GET_ATTRIB_NAMES0x06,   "GetAttributeNames" },
  { 0,                  NULL((void*)0) }
430};

432static const value_string iap_return_vals[] = {
433/* IrIAP Return-codes */
  { IAS_SUCCESS0,        "Success" },
  { IAS_CLASS_UNKNOWN1,  "Class/Object Unknown" },
  { IAS_ATTRIB_UNKNOWN2, "Attribute Unknown" },
  { IAS_ATTR_TOO_LONG3,  "Attribute List Too Long" },
  { IAS_DISCONNECT10,     "Disconnect (Linux-IrDA only)" },
  { IAS_UNSUPPORTED0xFF,    "Unsupported Optional Operation" },
  { 0,                  NULL((void*)0) }
441};

443static const value_string iap_attr_type_vals[] = {
444/* LM-IAS Attribute types */
  { IAS_MISSING0, "Missing" },
  { IAS_INTEGER1, "Integer" },
  { IAS_OCT_SEQ2, "Octet Sequence" },
  { IAS_STRING3,  "String" },
  { 0,           NULL((void*)0) }
450};

452static ias_attr_dissector_t device_attr_dissector[] = {
453/* Device attribute dissectors */
454/*    { "IrLMPSupport", xxx },  not implemented yet... */
  { NULL((void*)0), NULL((void*)0) }
456};

458/* IAS class dissectors */
459static ias_class_dissector_t class_dissector[] = { CLASS_DISSECTORS{ "Device", device_attr_dissector }, { "IrDA:IrCOMM", ircomm_attr_dissector
 }, { "IrLPT", irlpt_attr_dissector }, { ((void*)0), ((void*)
0) } };


462/*
* Dissect parameter tuple
*/
465unsigned dissect_param_tuple(tvbuff_t* tvb, proto_tree* tree, unsigned offset)
466{
  uint8_t len = tvb_get_uint8(tvb, offset + 1);

  if (tree)
      proto_tree_add_item(tree, hf_param_pi, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
  offset++;

  if (tree)
      proto_tree_add_item(tree, hf_param_pl, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
  offset++;

  if (len > 0)
  {
      if (tree)
          proto_tree_add_item(tree, hf_param_pv, tvb, offset, len, ENC_NA0x00000000);
      offset += len;
  }

  return offset;
485}


488/*
* Dissect TTP
*/
491static unsigned dissect_ttp(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root, bool_Bool data)
492{
  unsigned  offset = 0;
  uint8_t head;
  char   buf[128];

  if (tvb_reported_length(tvb) == 0)
      return 0;

  /* Make entries in Protocol column on summary display */
  col_set_str(pinfo->cinfo, COL_PROTOCOL, "TTP");

  head = tvb_get_uint8(tvb, offset);

  snprintf(buf, 128, ", Credit=%d", head & ~TTP_PARAMETERS0x80);
  col_append_str(pinfo->cinfo, COL_INFO, buf);

  if (root)
  {
      /* create display subtree for the protocol */
      proto_item* ti   = proto_tree_add_item(root, proto_ttp, tvb, 0, -1, ENC_NA0x00000000);
      proto_tree* tree = proto_item_add_subtree(ti, ett_ttp);

      if (data)
      {
          proto_tree_add_item(tree, hf_ttp_m, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
          proto_tree_add_item(tree, hf_ttp_dcredit, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
          offset++;
      }
      else
      {
          proto_tree_add_item(tree, hf_ttp_p, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
          proto_tree_add_item(tree, hf_ttp_icredit, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
          offset++;
      }
      proto_item_set_len(tree, offset);
  }
  else
      offset++;

  return offset;
532}


535/*
* Dissect IAP request
*/
538static void dissect_iap_request(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root, uint8_t circuit_id)
539{
  unsigned            offset = 0;
  uint8_t             op;
  uint8_t             clen = 0;
  uint8_t             alen = 0;
  uint8_t             src;
  address             srcaddr;
  address             destaddr;
  conversation_t*     conv;
  iap_conversation_t* iap_conv;

  if (tvb_reported_length(tvb) == 0)
      return;

  /* Make entries in Protocol column on summary display */
  col_set_str(pinfo->cinfo, COL_PROTOCOL, "IAP");

  op = tvb_get_uint8(tvb, offset) & IAP_OP0x3F;

  switch (op)
  {
      case GET_VALUE_BY_CLASS0x04:
          clen = MIN(tvb_get_uint8(tvb, offset + 1), 60)(((tvb_get_uint8(tvb, offset + 1)) < (60)) ? (tvb_get_uint8
(tvb, offset + 1)) : (60));
          alen = MIN(tvb_get_uint8(tvb, offset + 1 + 1 + clen), 60)(((tvb_get_uint8(tvb, offset + 1 + 1 + clen)) < (60)) ? (tvb_get_uint8
(tvb, offset + 1 + 1 + clen)) : (60));

          /* create conversation entry */
          src = circuit_id ^ CMD_FRAME0x01;
          set_address(&srcaddr, irda_address_type, 1, &src);

          set_address(&destaddr, irda_address_type, 1, &circuit_id);

          conv = find_conversation(pinfo->num, &srcaddr, &destaddr, CONVERSATION_NONE, pinfo->srcport, pinfo->destport, 0);
          if (conv)
          {
              iap_conv = (iap_conversation_t*)conversation_get_proto_data(conv, proto_iap);
              while (iap_conv)
              {
                  if (iap_conv->iap_query_frame == pinfo->num)
                  {
                      iap_conv = NULL((void*)0);
                      break;
                  }
                  if (iap_conv->pnext == NULL((void*)0))
                  {
                      iap_conv->pnext = wmem_new0(wmem_file_scope(), iap_conversation_t)((iap_conversation_t*)wmem_alloc0((wmem_file_scope()), sizeof
(iap_conversation_t)));
                      iap_conv = iap_conv->pnext;
                      break;
                  }
                  iap_conv = iap_conv->pnext;
              }
          }
          else
          {
              conv = conversation_new(pinfo->num, &srcaddr, &destaddr, CONVERSATION_NONE, pinfo->srcport, pinfo->destport, 0);
              iap_conv = wmem_new0(wmem_file_scope(), iap_conversation_t)((iap_conversation_t*)wmem_alloc0((wmem_file_scope()), sizeof
(iap_conversation_t)));
              conversation_add_proto_data(conv, proto_iap, (void*)iap_conv);
          }
          if (iap_conv)
          {
              iap_conv->iap_query_frame = pinfo->num;
          }

          char   *class_name = (char *) tvb_get_string_enc(pinfo->pool, tvb, offset + 1 + 1, clen, ENC_ASCII0x00000000|ENC_NA0x00000000);
          char   *attr_name = (char *) tvb_get_string_enc(pinfo->pool, tvb, offset + 1 + 1 + clen + 1, alen, ENC_ASCII0x00000000|ENC_NA0x00000000);

          col_add_fstr(pinfo->cinfo, COL_INFO, "GetValueByClass: \"%s\" \"%s\"",
              format_text(pinfo->pool, class_name, strlen(class_name)),
              format_text(pinfo->pool, attr_name, strlen(attr_name)));

          /* Dissect IAP query if it is new */
          if (iap_conv)
          {
              int     i, j;

              /* Find the attribute dissector */
              for (i = 0; class_dissector[i].class_name != NULL((void*)0); i++)
                  if (strcmp(class_name, class_dissector[i].class_name) == 0)
                  {
                      for (j = 0; class_dissector[i].pattr_dissector[j].attr_name != NULL((void*)0); j++)
                          if (strcmp(attr_name, class_dissector[i].pattr_dissector[j].attr_name) == 0)
                          {
                              iap_conv->pattr_dissector = &class_dissector[i].pattr_dissector[j];
                              break;
                          }
                      break;
                  }
          }
  }

  if (root)
  {
      /* create display subtree for the protocol */
      proto_item* ti   = proto_tree_add_item(root, proto_iap, tvb, 0, -1, ENC_NA0x00000000);
      proto_tree* tree = proto_item_add_subtree(ti, ett_iap);

      proto_tree* ctl_tree;


      ti       = proto_tree_add_item(tree, hf_iap_ctl, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      ctl_tree = proto_item_add_subtree(ti, ett_iap_ctl);
      proto_tree_add_item(ctl_tree, hf_iap_ctl_lst, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      proto_tree_add_item(ctl_tree, hf_iap_ctl_ack, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      proto_tree_add_item(ctl_tree, hf_iap_ctl_opcode, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      offset++;

      switch (op)
      {
          case GET_VALUE_BY_CLASS0x04:
              proto_tree_add_item(tree, hf_iap_class_name, tvb, offset, 1, ENC_ASCII0x00000000|ENC_BIG_ENDIAN0x00000000);
              offset += 1 + clen;

              proto_tree_add_item(tree, hf_iap_attr_name, tvb, offset, 1, ENC_ASCII0x00000000|ENC_BIG_ENDIAN0x00000000);
              offset += 1 + alen;
              break;
      }
  }
  else
  {
      offset++;
      switch (op)
      {
          case GET_VALUE_BY_CLASS0x04:
              offset += 1 + clen + 1 + alen;
              break;
      }
  }

  /* If any bytes remain, send it to the generic data dissector */
  tvb = tvb_new_subset_remaining(tvb, offset);
  call_data_dissector(tvb, pinfo, root);
669}


672/*
* Dissect IAP result
*/
675static void dissect_iap_result(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root, uint8_t circuit_id)
676{
  unsigned            offset = 0;
  unsigned            len    = tvb_reported_length(tvb);
  unsigned            n      = 0;
  unsigned            list_len;
  uint8_t             op;
  uint8_t             retcode;
  uint8_t             type;
  uint16_t            attr_len;
  char                buf[300];
  uint8_t             src;
  address             srcaddr;
  address             destaddr;
  conversation_t*     conv;
  iap_conversation_t* cur_iap_conv;
  iap_conversation_t* iap_conv = NULL((void*)0);
  uint32_t            num;


  if (len == 0)
      return;

  /* Make entries in Protocol column on summary display */
  col_set_str(pinfo->cinfo, COL_PROTOCOL, "IAP");

  op      = tvb_get_uint8(tvb, offset) & IAP_OP0x3F;
  retcode = tvb_get_uint8(tvb, offset + 1);

  src = circuit_id ^ CMD_FRAME0x01;
  set_address(&srcaddr, irda_address_type, 1, &src);

  set_address(&destaddr, irda_address_type, 1, &circuit_id);

  /* Find result value dissector */
  conv = find_conversation(pinfo->num, &srcaddr, &destaddr, CONVERSATION_NONE, pinfo->srcport, pinfo->destport, 0);
  if (conv)
  {
      num = pinfo->num;

      iap_conv = (iap_conversation_t*)conversation_get_proto_data(conv, proto_iap);
      while (iap_conv && (iap_conv->iap_query_frame >= num))
          iap_conv = iap_conv->pnext;

      if (iap_conv)
      {
          cur_iap_conv = iap_conv->pnext;
          while (cur_iap_conv)
          {
              if ((cur_iap_conv->iap_query_frame < num) &&
                  (cur_iap_conv->iap_query_frame > iap_conv->iap_query_frame))
              {
                  iap_conv = cur_iap_conv;
              }

              cur_iap_conv = cur_iap_conv->pnext;
          }
      }
  }

  col_set_str(pinfo->cinfo, COL_INFO, "Result: ");
  col_append_str(pinfo->cinfo, COL_INFO, val_to_str(pinfo->pool, retcode, iap_return_vals, "0x%02X"));

  switch (op)
  {
      case GET_VALUE_BY_CLASS0x04:
          if (retcode == 0)
          {
              switch (tvb_get_uint8(tvb, offset + 6))
              {
                  case IAS_MISSING0:
                      col_append_str(pinfo->cinfo, COL_INFO, ", Missing");
                      break;

                  case IAS_INTEGER1:
                      col_append_fstr(pinfo->cinfo, COL_INFO, ", Integer: %d", tvb_get_ntohl(tvb, offset + 7));
                      break;

                  case IAS_OCT_SEQ2:
                      snprintf(buf, 300, ", %d Octets", tvb_get_ntohs(tvb, offset + 7));
                      break;

                  case IAS_STRING3:
                      n = tvb_get_uint8(tvb, offset + 8);
                      col_append_fstr(pinfo->cinfo, COL_INFO, ", \"%s\"", tvb_get_string_enc(pinfo->pool, tvb, offset + 9, n, ENC_ASCII0x00000000));
                      break;
                  default:
                      break;
              }
              if (tvb_get_ntohs(tvb, offset + 2) > 1)
                  col_append_str(pinfo->cinfo, COL_INFO, ", ...");
          }
          break;
  }

  if (root)
  {
      /* create display subtree for the protocol */
      proto_item* ti   = proto_tree_add_item(root, proto_iap, tvb, 0, -1, ENC_NA0x00000000);
      proto_tree* tree = proto_item_add_subtree(ti, ett_iap);

      proto_tree* ctl_tree;
      proto_tree* entry_tree;


      ti       = proto_tree_add_item(tree, hf_iap_ctl, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      ctl_tree = proto_item_add_subtree(ti, ett_iap_ctl);
      proto_tree_add_item(ctl_tree, hf_iap_ctl_lst, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      proto_tree_add_item(ctl_tree, hf_iap_ctl_ack, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      proto_tree_add_item(ctl_tree, hf_iap_ctl_opcode, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      offset++;

      proto_tree_add_item(tree, hf_iap_return, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      offset++;

      switch (op)
      {
          case GET_VALUE_BY_CLASS0x04:
              if (retcode == 0)
              {
                  proto_tree_add_item_ret_uint(tree, hf_iap_list_len, tvb, offset, 2, ENC_BIG_ENDIAN0x00000000, &list_len);
                  offset += 2;

                  while ((offset < len) && (n < list_len))
                  {
                      type = tvb_get_uint8(tvb, offset + 2);
                      switch (type)
                      {
                          case IAS_INTEGER1:
                              attr_len = 4;
                              break;

                          case IAS_OCT_SEQ2:
                              attr_len = tvb_get_ntohs(tvb, offset + 2 + 1) + 2;
                              break;

                          case IAS_STRING3:
                              attr_len = tvb_get_uint8(tvb, offset + 2 + 1 + 1) + 2;
                              break;

                          default:
                              attr_len = 0;
                      }

                      ti = proto_tree_add_item(tree, hf_iap_list_entry, tvb, offset, 2 + 1 + attr_len, ENC_NA0x00000000);
                      proto_item_append_text(ti, "%d", n + 1);
                      entry_tree = proto_item_add_subtree(ti, ett_iap_entry[MIN(n, MAX_IAP_ENTRIES - 1)(((n) < (32 - 1)) ? (n) : (32 - 1))]);

                      proto_tree_add_item(entry_tree, hf_iap_obj_id, tvb, offset, 2, ENC_BIG_ENDIAN0x00000000);
                      offset += 2;

                      proto_tree_add_item(entry_tree, hf_iap_attr_type, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
                      offset++;

                      switch (type)
                      {
                          case IAS_INTEGER1:
                              if (!iap_conv || !iap_conv->pattr_dissector ||
                                  !iap_conv->pattr_dissector->value_dissector(tvb, offset, pinfo, entry_tree,
                                                                              n, type, circuit_id))
                                  proto_tree_add_item(entry_tree, hf_iap_int, tvb, offset, 4, ENC_BIG_ENDIAN0x00000000);
                              break;

                          case IAS_OCT_SEQ2:
                              proto_tree_add_item(entry_tree, hf_iap_seq_len, tvb, offset, 2, ENC_BIG_ENDIAN0x00000000);
                              if (!iap_conv || !iap_conv->pattr_dissector ||
                                  !iap_conv->pattr_dissector->value_dissector(tvb, offset, pinfo, entry_tree,
                                                                              n, type, circuit_id))
                                  proto_tree_add_item(entry_tree, hf_iap_oct_seq, tvb, offset + 2,
                                                      attr_len - 2, ENC_NA0x00000000);
                              break;

                          case IAS_STRING3:
                              proto_tree_add_item(entry_tree, hf_iap_char_set, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
                              if (!iap_conv || !iap_conv->pattr_dissector ||
                                  !iap_conv->pattr_dissector->value_dissector(tvb, offset, pinfo, entry_tree,
                                                                              n, type, circuit_id))
                                  proto_tree_add_item(entry_tree, hf_iap_string, tvb, offset + 1, 1, ENC_ASCII0x00000000|ENC_BIG_ENDIAN0x00000000);
                              break;
                      }
                      offset += attr_len;

                      n++;
                  }
              }
              break;
      }
  }
  else
  {
      offset += 2;
      switch (op)
      {
          case GET_VALUE_BY_CLASS0x04:
              if (retcode == 0)
              {
                  offset += 2;

                  while (offset < len)
                  {
                      offset += 2;
                      type = tvb_get_uint8(tvb, offset);
                      offset++;

                      switch (type)
                      {
                          case IAS_INTEGER1:
                              attr_len = 4;
                              if (iap_conv && iap_conv->pattr_dissector)
                                  iap_conv->pattr_dissector->value_dissector(tvb, offset, pinfo, 0,
                                                                             n, type, circuit_id);
                              break;

                          case IAS_OCT_SEQ2:
                              attr_len = tvb_get_ntohs(tvb, offset) + 2;
                              if (iap_conv && iap_conv->pattr_dissector)
                                  iap_conv->pattr_dissector->value_dissector(tvb, offset, pinfo, 0,
                                                                             n, type, circuit_id);
                              break;

                          case IAS_STRING3:
                              attr_len = tvb_get_uint8(tvb, offset + 1) + 2;
                              if (iap_conv && iap_conv->pattr_dissector)
                                  iap_conv->pattr_dissector->value_dissector(tvb, offset, pinfo, 0,
                                                                             n, type, circuit_id);
                              break;

                          default:
                              attr_len = 0;
                      }
                      offset += attr_len;

                      n++;
                  }
              }
              break;
      }
  }

  /* If any bytes remain, send it to the generic data dissector */
  tvb = tvb_new_subset_remaining(tvb, offset);
  call_data_dissector(tvb, pinfo, root);
917}


920/*
* Check if IAP result is octet sequence
*/
923bool_Bool check_iap_octet_result(tvbuff_t* tvb, proto_tree* tree, unsigned offset,
                              const char* attr_name, uint8_t attr_type)
925{
  if (attr_type != IAS_OCT_SEQ2)
  {
      if (tree)
      {
          proto_item* ti = proto_tree_add_item(tree, hf_iap_invaloctet, tvb, offset, 0, ENC_NA0x00000000);
          proto_item_append_text(ti, "%s", attr_name);
          proto_item_append_text(ti, "\" attribute must be octet sequence!");
      }

      return false0;
  }
  else
      return true1;
939}


942/*
* Check if IAP result is correct LsapSel
*/
945uint8_t check_iap_lsap_result(tvbuff_t* tvb, proto_tree* tree, unsigned offset,
                           const char* attr_name, uint8_t attr_type)
947{
  uint32_t lsap;


  if ((attr_type != IAS_INTEGER1) || ((lsap = tvb_get_ntohl(tvb, offset)) < 0x01) ||
      (lsap > 0x6F))
  {
      if (tree)
      {
          proto_item* ti = proto_tree_add_item(tree, hf_iap_invallsap, tvb, offset, 0, ENC_NA0x00000000);
          proto_item_append_text(ti, "%s", attr_name);
          proto_item_append_text(ti, "\" attribute must be integer value between 0x01 and 0x6F!");
      }

      return 0;
  }
  else
      return lsap;
965}


968/*
* Dissect IrDA application protocol
*/
971static void dissect_appl_proto(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root, pdu_type_t pdu_type, uint8_t circuit_id)
972{
  unsigned            offset = 0;
  uint8_t             src;
  address             srcaddr;
  address             destaddr;
  conversation_t*     conv;
  lmp_conversation_t* cur_lmp_conv;
  lmp_conversation_t* lmp_conv = NULL((void*)0);
  uint32_t            num;


  src = circuit_id ^ CMD_FRAME0x01;
  set_address(&srcaddr, irda_address_type, 1, &src);

  set_address(&destaddr, irda_address_type, 1, &circuit_id);

  /* Find result value dissector */
  conv = find_conversation(pinfo->num, &srcaddr, &destaddr, CONVERSATION_NONE, pinfo->srcport, pinfo->destport, 0);
  if (conv)
  {
      num = pinfo->num;

      lmp_conv = (lmp_conversation_t*)conversation_get_proto_data(conv, proto_irlmp);
      while (lmp_conv && (lmp_conv->iap_result_frame >= num))
          lmp_conv = lmp_conv->pnext;

      if (lmp_conv)
      {
          cur_lmp_conv = lmp_conv->pnext;
          while (cur_lmp_conv)
          {
              if ((cur_lmp_conv->iap_result_frame < num) &&
                  (cur_lmp_conv->iap_result_frame > lmp_conv->iap_result_frame))
              {
                  lmp_conv = cur_lmp_conv;
              }

              cur_lmp_conv = cur_lmp_conv->pnext;
          }
      }
  }

  if (lmp_conv)
  {
1016/*ws_message("%x:%d->%x:%d = %p\n", src, pinfo->srcport, circuit_id, pinfo->destport, lmp_conv); */
1017/*ws_message("->%d: %d %d %p\n", pinfo->num, lmp_conv->iap_result_frame, lmp_conv->ttp, lmp_conv->proto_dissector); */
      if ((lmp_conv->ttp) && (pdu_type != DISCONNECT_PDU))
      {
          offset += dissect_ttp(tvb, pinfo, root, (pdu_type == DATA_PDU));

          tvb = tvb_new_subset_remaining(tvb, offset);
      }

      call_dissector_with_data(lmp_conv->dissector, tvb, pinfo, root, GUINT_TO_POINTER(pdu_type)((gpointer) (gulong) (pdu_type)));
  }
  else
      call_data_dissector(tvb, pinfo, root);
1029}


1032/*
* Dissect LMP
*/
1035static void dissect_irlmp(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root, uint8_t circuit_id)
1036{
  unsigned    offset = 0;
  uint8_t     dlsap;
  uint8_t     slsap;
  uint8_t     cbit;
  uint8_t     opcode = 0;


  /* Make entries in Protocol column on summary display */
  col_set_str(pinfo->cinfo, COL_PROTOCOL, "IrLMP");

  dlsap = tvb_get_uint8(tvb, offset);
  cbit  = dlsap & CONTROL_BIT0x80;
  dlsap &= ~CONTROL_BIT0x80;

  slsap = tvb_get_uint8(tvb, offset+1) & ~CONTROL_BIT0x80;

  /* save Lsaps in pinfo */
  pinfo->srcport  = slsap;
  pinfo->destport = dlsap;

  if (cbit != 0)
  {
      opcode = tvb_get_uint8(tvb, offset+2);

      col_add_fstr(pinfo->cinfo, COL_INFO, "%d > %d, ", slsap, dlsap);
      col_append_str(pinfo->cinfo, COL_INFO, val_to_str(pinfo->pool, opcode, lmp_opcode_vals, "0x%02X"));
      if ((opcode == ACCESSMODE_CMD0x03) || (opcode == ACCESSMODE_CNF0x83))
      {
          col_append_str(pinfo->cinfo, COL_INFO, " (");
          col_append_str(pinfo->cinfo, COL_INFO,
                         val_to_str(pinfo->pool, tvb_get_uint8(tvb, offset+4), lmp_mode_vals, "0x%02X"));
          col_append_str(pinfo->cinfo, COL_INFO, ")");
      }
  }
  else
      col_add_fstr(pinfo->cinfo, COL_INFO, "%d > %d, Len=%d", slsap, dlsap,
                   tvb_reported_length(tvb) - 2);

  if (root)
  {
      /* create display subtree for the protocol */
      proto_item* ti   = proto_tree_add_item(root, proto_irlmp, tvb, 0, -1, ENC_NA0x00000000);
      proto_tree* tree = proto_item_add_subtree(ti, ett_irlmp);

      proto_tree* dst_tree;
      proto_tree* src_tree;


      ti       = proto_tree_add_item(tree, hf_lmp_dst, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      dst_tree = proto_item_add_subtree(ti, ett_lmp_dst);
      proto_tree_add_item(dst_tree, hf_lmp_dst_control, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      proto_tree_add_item(dst_tree, hf_lmp_dst_lsap, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      offset++;

      ti       = proto_tree_add_item(tree, hf_lmp_src, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      src_tree = proto_item_add_subtree(ti, ett_lmp_src);
      proto_tree_add_item(src_tree, hf_lmp_src_r, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      proto_tree_add_item(src_tree, hf_lmp_src_lsap, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      offset++;

      if (cbit != 0)
      {
          proto_tree_add_item(tree, hf_lmp_opcode, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
          offset++;

          switch (opcode)
          {
              case CONNECT_CMD0x01:
              case CONNECT_CNF0x81:
                  if (offset < tvb_reported_length(tvb))
                  {
                      proto_tree_add_item(tree, hf_lmp_rsvd, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
                      offset++;
                  }
                  break;

              case DISCONNECT0x02:
                  proto_tree_add_item(tree, hf_lmp_reason, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
                  offset++;
                  break;

              case ACCESSMODE_CMD0x03:
                  proto_tree_add_item(tree, hf_lmp_rsvd, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
                  offset++;

                  proto_tree_add_item(tree, hf_lmp_mode, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
                  offset++;
                  break;

              case ACCESSMODE_CNF0x83:
                  proto_tree_add_item( tree, hf_lmp_status, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
                  offset++;

                  proto_tree_add_item(tree, hf_lmp_mode, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
                  offset++;
                  break;
          }
      }

      tvb = tvb_new_subset_remaining(tvb, offset);
      proto_item_set_len(tree, offset);
  }
  else
  {
      offset += 2;
      if (cbit != 0)
      {
          offset += 1;

          switch (opcode)
          {
              case CONNECT_CMD0x01:
              case CONNECT_CNF0x81:
                  if (offset < tvb_reported_length(tvb))
                      offset++;
                  break;

              case DISCONNECT0x02:
                  offset++;
                  break;

              case ACCESSMODE_CMD0x03:
              case ACCESSMODE_CNF0x83:
                  offset += 2;
                  break;
          }
      }

      tvb = tvb_new_subset_remaining(tvb, offset);
  }

  if (cbit == 0)
  {
      if (dlsap == LSAP_IAS0x00)
          dissect_iap_request(tvb, pinfo, root, circuit_id);
      else if (slsap == LSAP_IAS0x00)
          dissect_iap_result(tvb, pinfo, root, circuit_id);
      else
          dissect_appl_proto(tvb, pinfo, root, DATA_PDU, circuit_id);
  }
  else
  {
      if ((dlsap == LSAP_IAS0x00) || (slsap == LSAP_IAS0x00))
          call_data_dissector(tvb, pinfo, root);
      else
          switch (opcode)
          {
              case CONNECT_CMD0x01:
              case CONNECT_CNF0x81:
                  dissect_appl_proto(tvb, pinfo, root, CONNECT_PDU, circuit_id);
                  break;

              case DISCONNECT0x02:
                  dissect_appl_proto(tvb, pinfo, root, DISCONNECT_PDU, circuit_id);
                  break;

              default:
                  call_data_dissector(tvb, pinfo, root);
          }
  }
1197}


1200/*
* Add LMP conversation
*/
1203void add_lmp_conversation(packet_info* pinfo, uint8_t dlsap, bool_Bool ttp, dissector_handle_t dissector, uint8_t circuit_id)
1204{
  uint8_t             dest;
  address             srcaddr;
  address             destaddr;
  conversation_t*     conv;
  lmp_conversation_t* lmp_conv = NULL((void*)0);


1212/*ws_message("%d: add_lmp_conversation(%p, %d, %d, %p) = ", pinfo->num, pinfo, dlsap, ttp, proto_dissector); */
  set_address(&srcaddr, irda_address_type, 1, &circuit_id);
  dest = circuit_id ^ CMD_FRAME0x01;
  set_address(&destaddr, irda_address_type, 1, &dest);

  conv = find_conversation(pinfo->num, &destaddr, &srcaddr, CONVERSATION_NONE, dlsap, 0, NO_PORT_B0x00020000);
  if (conv)
1
Assuming 'conv' is non-null→
2
←
Taking true branch→
  {
      lmp_conv = (lmp_conversation_t*)conversation_get_proto_data(conv, proto_irlmp);
3
←
Value assigned to 'lmp_conv'→
      while (lmp_conv)
4
←
Assuming pointer value is null→
5
←
Loop condition is false. Execution continues on line 1243→
      {
          /* Does entry already exist? */
          if (lmp_conv->iap_result_frame == pinfo->num)
              return;

          if (lmp_conv->pnext == NULL((void*)0))
          {
              lmp_conv->pnext = wmem_new0(wmem_file_scope(), lmp_conversation_t)((lmp_conversation_t*)wmem_alloc0((wmem_file_scope()), sizeof
(lmp_conversation_t)));
              lmp_conv = lmp_conv->pnext;
              break;
          }
          lmp_conv = lmp_conv->pnext;
      }
  }
  else
  {
      conv = conversation_new(pinfo->num, &destaddr, &srcaddr, CONVERSATION_NONE, dlsap, 0, NO_PORT20x02);
      lmp_conv = wmem_new0(wmem_file_scope(), lmp_conversation_t)((lmp_conversation_t*)wmem_alloc0((wmem_file_scope()), sizeof
(lmp_conversation_t)));
      conversation_add_proto_data(conv, proto_irlmp, (void*)lmp_conv);
  }

  lmp_conv->iap_result_frame = pinfo->num;
6
←
Access to field 'iap_result_frame' results in a dereference of a null pointer (loaded from variable 'lmp_conv')
  lmp_conv->ttp              = ttp;
  lmp_conv->dissector        = dissector;

1247/*ws_message("%p\n", lmp_conv); */
1248}


1251/*
* Dissect Negotiation Parameters
*/
1254static unsigned dissect_negotiation(tvbuff_t* tvb, proto_tree* tree, unsigned offset)
1255{
  unsigned    n   = 0;
  proto_item* ti;
  proto_tree* p_tree;
  char        buf[256];
  uint8_t     pv;

  while (tvb_reported_length_remaining(tvb, offset) > 0)
  {
      uint8_t p_len = tvb_get_uint8(tvb, offset + 1);

      if (tree)
      {
          ti = proto_tree_add_item(tree, hf_negotiation_param, tvb, offset, p_len + 2, ENC_NA0x00000000);
          p_tree = proto_item_add_subtree(ti, ett_param[MIN(n, MAX_PARAMETERS - 1)(((n) < (32 - 1)) ? (n) : (32 - 1))]);

          pv = tvb_get_uint8(tvb, offset+2);
          buf[0] = 0;

          switch (tvb_get_uint8(tvb, offset))
          {
              case PI_BAUD_RATE0x01:
                  proto_item_append_text(ti, ": Baud Rate (");

                  if (pv & 0x01)
                      (void) g_strlcat(buf, ", 2400", 256);
                  if (pv & 0x02)
                      (void) g_strlcat(buf, ", 9600", 256);
                  if (pv & 0x04)
                      (void) g_strlcat(buf, ", 19200", 256);
                  if (pv & 0x08)
                      (void) g_strlcat(buf, ", 38400", 256);
                  if (pv & 0x10)
                      (void) g_strlcat(buf, ", 57600", 256);
                  if (pv & 0x20)
                      (void) g_strlcat(buf, ", 115200", 256);
                  if (pv & 0x40)
                      (void) g_strlcat(buf, ", 576000", 256);
                  if (pv & 0x80)
                      (void) g_strlcat(buf, ", 1152000", 256);
                  if ((p_len > 1) && (tvb_get_uint8(tvb, offset+3) & 0x01))
                      (void) g_strlcat(buf, ", 4000000", 256);

                  (void) g_strlcat(buf, " bps)", 256);

                  proto_item_append_text(ti, "%s", buf+2);

                  break;

              case PI_MAX_TURN_TIME0x82:
                  proto_item_append_text(ti, ": Maximum Turn Time (");

                  if (pv & 0x01)
                      (void) g_strlcat(buf, ", 500", 256);
                  if (pv & 0x02)
                      (void) g_strlcat(buf, ", 250", 256);
                  if (pv & 0x04)
                      (void) g_strlcat(buf, ", 100", 256);
                  if (pv & 0x08)
                      (void) g_strlcat(buf, ", 50", 256);

                  (void) g_strlcat(buf, " ms)", 256);

                  proto_item_append_text(ti, "%s", buf+2);

                  break;

              case PI_DATA_SIZE0x83:
                  proto_item_append_text(ti, ": Data Size (");

                  if (pv & 0x01)
                      (void) g_strlcat(buf, ", 64", 256);
                  if (pv & 0x02)
                      (void) g_strlcat(buf, ", 128", 256);
                  if (pv & 0x04)
                      (void) g_strlcat(buf, ", 256", 256);
                  if (pv & 0x08)
                      (void) g_strlcat(buf, ", 512", 256);
                  if (pv & 0x10)
                      (void) g_strlcat(buf, ", 1024", 256);
                  if (pv & 0x20)
                      (void) g_strlcat(buf, ", 2048", 256);

                  (void) g_strlcat(buf, " bytes)", 256);

                  proto_item_append_text(ti, "%s", buf+2);

                  break;

              case PI_WINDOW_SIZE0x84:
                  proto_item_append_text(ti, ": Window Size (");

                  if (pv & 0x01)
                      (void) g_strlcat(buf, ", 1", 256);
                  if (pv & 0x02)
                      (void) g_strlcat(buf, ", 2", 256);
                  if (pv & 0x04)
                      (void) g_strlcat(buf, ", 3", 256);
                  if (pv & 0x08)
                      (void) g_strlcat(buf, ", 4", 256);
                  if (pv & 0x10)
                      (void) g_strlcat(buf, ", 5", 256);
                  if (pv & 0x20)
                      (void) g_strlcat(buf, ", 6", 256);
                  if (pv & 0x40)
                      (void) g_strlcat(buf, ", 7", 256);

                  (void) g_strlcat(buf, " frame window)", 256);

                  proto_item_append_text(ti, "%s", buf+2);

                  break;

              case PI_ADD_BOFS0x85:
                  proto_item_append_text(ti, ": Additional BOFs (");

                  if (pv & 0x01)
                      (void) g_strlcat(buf, ", 48", 256);
                  if (pv & 0x02)
                      (void) g_strlcat(buf, ", 24", 256);
                  if (pv & 0x04)
                      (void) g_strlcat(buf, ", 12", 256);
                  if (pv & 0x08)
                      (void) g_strlcat(buf, ", 5", 256);
                  if (pv & 0x10)
                      (void) g_strlcat(buf, ", 3", 256);
                  if (pv & 0x20)
                      (void) g_strlcat(buf, ", 2", 256);
                  if (pv & 0x40)
                      (void) g_strlcat(buf, ", 1", 256);
                  if (pv & 0x80)
                      (void) g_strlcat(buf, ", 0", 256);

                  (void) g_strlcat(buf, " additional BOFs at 115200)", 256);

                  proto_item_append_text(ti, "%s", buf+2);

                  break;

              case PI_MIN_TURN_TIME0x86:
                  proto_item_append_text(ti, ": Minimum Turn Time (");

                  if (pv & 0x01)
                      (void) g_strlcat(buf, ", 10", 256);
                  if (pv & 0x02)
                      (void) g_strlcat(buf, ", 5", 256);
                  if (pv & 0x04)
                      (void) g_strlcat(buf, ", 1", 256);
                  if (pv & 0x08)
                      (void) g_strlcat(buf, ", 0.5", 256);
                  if (pv & 0x10)
                      (void) g_strlcat(buf, ", 0.1", 256);
                  if (pv & 0x20)
                      (void) g_strlcat(buf, ", 0.05", 256);
                  if (pv & 0x40)
                      (void) g_strlcat(buf, ", 0.01", 256);
                  if (pv & 0x80)
                      (void) g_strlcat(buf, ", 0", 256);

                  (void) g_strlcat(buf, " ms)", 256);

                  proto_item_append_text(ti, "%s", buf+2);

                  break;

              case PI_LINK_DISC0x08:
                  proto_item_append_text(ti, ": Link Disconnect/Threshold Time (");

                  if (pv & 0x01)
                      (void) g_strlcat(buf, ", 3/0", 256);
                  if (pv & 0x02)
                      (void) g_strlcat(buf, ", 8/3", 256);
                  if (pv & 0x04)
                      (void) g_strlcat(buf, ", 12/3", 256);
                  if (pv & 0x08)
                      (void) g_strlcat(buf, ", 16/3", 256);
                  if (pv & 0x10)
                      (void) g_strlcat(buf, ", 20/3", 256);
                  if (pv & 0x20)
                      (void) g_strlcat(buf, ", 25/3", 256);
                  if (pv & 0x40)
                      (void) g_strlcat(buf, ", 30/3", 256);
                  if (pv & 0x80)
                      (void) g_strlcat(buf, ", 40/3", 256);

                  (void) g_strlcat(buf, " s)", 256);

                  proto_item_append_text(ti, "%s", buf+2);

                  break;

              default:
                  proto_item_append_text(ti, ": unknown");
          }
      } else
          p_tree = NULL((void*)0);

      offset = dissect_param_tuple(tvb, p_tree, offset);
      n++;
  }

  return offset;
1457}


1460/*
* Dissect XID packet
*/
1463static void dissect_xid(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root, proto_tree* lap_tree, bool_Bool is_command)
1464{
  int         offset = 0;
  proto_item* ti = NULL((void*)0);
  proto_tree* i_tree = NULL((void*)0);
  proto_tree* flags_tree;
  uint32_t    saddr, daddr;
  uint8_t     s;
  proto_tree* lmp_tree = NULL((void*)0);

  if (lap_tree)
  {
      ti = proto_tree_add_item(lap_tree, hf_lap_i, tvb, offset, -1, ENC_NA0x00000000);
      i_tree = proto_item_add_subtree(ti, ett_lap_i);

      proto_tree_add_item(i_tree, hf_xid_ident, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
  }
  offset++;

  saddr = tvb_get_letohl(tvb, offset);
  col_add_fstr(pinfo->cinfo, COL_DEF_SRC, "0x%08X", saddr);
  if (lap_tree)
      proto_tree_add_uint(i_tree, hf_xid_saddr, tvb, offset, 4, saddr);
  offset += 4;

  daddr = tvb_get_letohl(tvb, offset);
  col_add_fstr(pinfo->cinfo, COL_DEF_DST, "0x%08X", daddr);
  if (lap_tree)
      proto_tree_add_uint(i_tree, hf_xid_daddr, tvb, offset, 4, daddr);
  offset += 4;

  if (lap_tree)
  {
      /* Discovery flags */
      ti = proto_tree_add_item(i_tree, hf_xid_flags, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      flags_tree = proto_item_add_subtree(ti, ett_xid_flags);
      proto_tree_add_item(flags_tree, hf_xid_s, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      proto_tree_add_item(flags_tree, hf_xid_conflict, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
  }
  offset++;

  if (is_command)
  {
      s = tvb_get_uint8(tvb, offset);
      if (s == 0xFF)
          col_append_str(pinfo->cinfo, COL_INFO, ", s=final");
      else
          col_append_fstr(pinfo->cinfo, COL_INFO, ", s=%u", s);
      if (lap_tree)
      {
          ti = proto_tree_add_uint(i_tree, hf_xid_slotnr, tvb, offset, 1, s);
          if (s == 0xFF)
              proto_item_append_text(ti, " (final)");
      }
  }
  /* Skip (empty?) byte even if no command.. Have seen non-zero values in a capture */
  offset++;

  if (lap_tree)
      proto_tree_add_item(i_tree, hf_xid_version, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
  offset++;

  if (lap_tree)
  {
      proto_item_set_end(lap_tree, tvb, offset);
      proto_item_set_end(i_tree, tvb, offset);
  }

  if (tvb_reported_length_remaining(tvb, offset) > 0)
  {
      unsigned hints_len;
      uint8_t     hint1 = 0;
      uint8_t     hint2 = 0;

      if (root)
      {
          ti = proto_tree_add_item(root, proto_irlmp, tvb, offset, -1, ENC_NA0x00000000);
          lmp_tree = proto_item_add_subtree(ti, ett_irlmp);
      }

      for (hints_len = 0;;)
      {
          uint8_t hint = tvb_get_uint8(tvb, offset + hints_len++);

          if (hints_len == 1)
              hint1 = hint;
          else if (hints_len == 2)
              hint2 = hint;

          if ((hint & 0x80) == 0)
              break;
      }

      if (root)
      {
          ti = proto_tree_add_item(lmp_tree, hf_lmp_xid_hints, tvb, offset, hints_len, ENC_NA0x00000000);
          if ((hint1 | hint2) != 0)
          {
              char    service_hints[256];

              service_hints[0] = 0;

              if (hint1 & 0x01)
                  (void) g_strlcat(service_hints, ", PnP Compatible", 256);
              if (hint1 & 0x02)
                  (void) g_strlcat(service_hints, ", PDA/Palmtop", 256);
              if (hint1 & 0x04)
                  (void) g_strlcat(service_hints, ", Computer", 256);
              if (hint1 & 0x08)
                  (void) g_strlcat(service_hints, ", Printer", 256);
              if (hint1 & 0x10)
                  (void) g_strlcat(service_hints, ", Modem", 256);
              if (hint1 & 0x20)
                  (void) g_strlcat(service_hints, ", Fax", 256);
              if (hint1 & 0x40)
                  (void) g_strlcat(service_hints, ", LAN Access", 256);
              if (hint2 & 0x01)
                  (void) g_strlcat(service_hints, ", Telephony", 256);
              if (hint2 & 0x02)
                  (void) g_strlcat(service_hints, ", File Server", 256);
              if (hint2 & 0x04)
                  (void) g_strlcat(service_hints, ", IrCOMM", 256);
              if (hint2 & 0x20)
                  (void) g_strlcat(service_hints, ", OBEX", 256);

              (void) g_strlcat(service_hints, ")", 256);
              service_hints[0] = ' ';
              service_hints[1] = '(';

              proto_item_append_text(ti, "%s", service_hints);
          }
      }
      offset += hints_len;

      if (tvb_reported_length_remaining(tvb, offset) > 0)
      {
          uint8_t cset;
          int name_len;
          char *name;
          bool_Bool have_encoding;
          unsigned  encoding;

          cset = tvb_get_uint8(tvb, offset);
          if (root)
              proto_tree_add_uint(lmp_tree, hf_lmp_xid_charset, tvb, offset, 1, cset);
          offset++;
          name_len = tvb_reported_length_remaining(tvb, offset);
          if (name_len > 0)
          {
              switch (cset) {

              case LMP_CHARSET_ASCII0:
                  encoding = ENC_ASCII0x00000000|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_ISO_8859_11:
                  encoding = ENC_ISO_8859_10x0000000A|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_ISO_8859_22:
                  encoding = ENC_ISO_8859_20x0000000C|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_ISO_8859_33:
                  encoding = ENC_ISO_8859_30x0000000E|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_ISO_8859_44:
                  encoding = ENC_ISO_8859_40x00000010|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_ISO_8859_55:
                  encoding = ENC_ISO_8859_50x00000012|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_ISO_8859_66:
                  encoding = ENC_ISO_8859_60x00000014|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_ISO_8859_77:
                  encoding = ENC_ISO_8859_70x00000016|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_ISO_8859_88:
                  encoding = ENC_ISO_8859_80x00000018|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_ISO_8859_99:
                  encoding = ENC_ISO_8859_90x0000001A|ENC_NA0x00000000;
                  have_encoding = true1;
                  break;

              case LMP_CHARSET_UNICODE0xFF:
                  /* Presumably big-endian; assume just UCS-2 for now */
                  encoding = ENC_UCS_20x00000006|ENC_BIG_ENDIAN0x00000000;
                  have_encoding = true1;
                  break;

              default:
                  encoding = 0;
                  have_encoding = false0;
                  break;
              }

              if (have_encoding)
              {
                  name = (char *) tvb_get_string_enc(pinfo->pool, tvb, offset, name_len, encoding);
                  col_append_fstr(pinfo->cinfo, COL_INFO, ", \"%s\"", format_text(pinfo->pool, name, strlen(name)));
                  if (root)
                      proto_tree_add_item(lmp_tree, hf_lmp_xid_name, tvb, offset,
                                          -1, encoding);
              }
              else
              {
                  if (root)
                      proto_tree_add_item(lmp_tree, hf_lmp_xid_name_no_encoding, tvb, offset,
                                          -1, ENC_NA0x00000000);
              }
          }
      }
  }
1693}


1696/*
* Dissect Log Messages
*/
1699static void dissect_log(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root)
1700{
  /* Make entries in Protocol column on summary display */
  col_set_str(pinfo->cinfo, COL_PROTOCOL, "Log");

  /* missed messages? */
  if (pinfo->pseudo_header->irda.pkttype == IRDA_MISSED_MSG0x0101)
  {
      col_set_str(pinfo->cinfo, COL_INFO, "WARNING: Missed one or more messages while capturing!");
  }
  else
  {
      unsigned   length;
      char   *buf;

      length = tvb_captured_length(tvb);
      buf = (char *) tvb_get_string_enc(pinfo->pool, tvb, 0, length, ENC_ASCII0x00000000|ENC_NA0x00000000);
      if (length > 0 && buf[length-1] == '\n')
          buf[length-1] = 0;
      else if (length > 1 && buf[length-2] == '\n')
          buf[length-2] = 0;

      col_add_str(pinfo->cinfo, COL_INFO, format_text(pinfo->pool, buf, strlen(buf)));
  }

  if (root)
  {
      proto_item* ti   = proto_tree_add_item(root, proto_log, tvb, 0, -1, ENC_NA0x00000000);
      proto_tree* tree = proto_item_add_subtree(ti, ett_log);

      if (pinfo->pseudo_header->irda.pkttype == IRDA_MISSED_MSG0x0101)
          proto_tree_add_item(tree, hf_log_missed, tvb, 0, 0, ENC_NA0x00000000);
      else
          proto_tree_add_item(tree, hf_log_msg, tvb, 0, -1, ENC_ASCII0x00000000);
  }
1734}


1737/*
* Dissect IrLAP
*/
1740static void dissect_irlap(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root)
1741{
  int      offset = 0;
  uint8_t  circuit_id, c;
  bool_Bool is_response;
  char     addr[9];
  proto_item* ti = NULL((void*)0);
  proto_tree* tree = NULL((void*)0);
  proto_tree* i_tree = NULL((void*)0);
  uint32_t saddr, daddr;
  uint8_t  ca;

  /* Make entries in Protocol column on summary display */
  col_set_str(pinfo->cinfo, COL_PROTOCOL, "IrLAP");

  /* Clear Info column */
  col_clear(pinfo->cinfo, COL_INFO);

  /* set direction column */
  switch (pinfo->pseudo_header->irda.pkttype)
  {
      case IRDA_OUTGOING0x0004:
          col_set_str(pinfo->cinfo, COL_IF_DIR, "Out");
          break;

      case IRDA_INCOMING0x0000:
          col_set_str(pinfo->cinfo, COL_IF_DIR, "In");
          break;
  }

  /* decode values used for demuxing */
  circuit_id = tvb_get_uint8(tvb, 0);

  /* initially set address columns to connection address */
  snprintf(addr, sizeof(addr)-1, "0x%02X", circuit_id >> 1);
  col_add_str(pinfo->cinfo, COL_DEF_SRC, addr);
  col_add_str(pinfo->cinfo, COL_DEF_DST, addr);

  if (root)
  {
      proto_tree* a_tree;
      proto_item* addr_item;

      /* create display subtree for the protocol */
      ti   = proto_tree_add_item(root, proto_irlap, tvb, 0, -1, ENC_NA0x00000000);
      tree = proto_item_add_subtree(ti, ett_irlap);

      /* create subtree for the address field */
      ti     = proto_tree_add_item(tree, hf_lap_a, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      a_tree = proto_item_add_subtree(ti, ett_lap_a);
      proto_tree_add_item(a_tree, hf_lap_a_cr, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      addr_item = proto_tree_add_item(a_tree, hf_lap_a_address, tvb, offset, 1, ENC_BIG_ENDIAN0x00000000);
      switch (circuit_id & ~CMD_FRAME0x01)
      {
          case 0:
              proto_item_append_text(addr_item, " (NULL Address)");
              break;
          case 0xFE:
              proto_item_append_text(addr_item, " (Broadcast)");
              break;
      }
  }
  is_response = ((circuit_id & CMD_FRAME0x01) == 0);
  offset++;

  /* process the control field */
  c = dissect_xdlc_control(tvb, offset, pinfo, tree, hf_lap_c,
          ett_lap_c, &irlap_cf_items, NULL((void*)0), lap_c_u_cmd_abbr_vals,
          lap_c_u_rsp_abbr_vals, is_response, false0, false0);
  offset++;

  if ((c & XDLC_I_MASK0x01) == XDLC_I0x00) {
      /* I frame */
      proto_item_set_len(tree, offset);
      tvb = tvb_new_subset_remaining(tvb, offset);
      dissect_irlmp(tvb, pinfo, root, circuit_id);
      return;
  }

  if ((c & XDLC_S_U_MASK0x03) == XDLC_U0x03) {
      /* U frame */
      switch (c & XDLC_U_MODIFIER_MASK0xEC)
      {
          case XDLC_SNRM0x80:
              if (root)
              {
                  ti = proto_tree_add_item(tree, hf_lap_i, tvb, offset, -1, ENC_NA0x00000000);
                  i_tree = proto_item_add_subtree(ti, ett_lap_i);
              }

              saddr = tvb_get_letohl(tvb, offset);
              if (!is_response)
              {
                  col_add_fstr(pinfo->cinfo, COL_DEF_SRC, "0x%08X", saddr);
              }
              if (root)
                  proto_tree_add_uint(i_tree, hf_snrm_saddr, tvb, offset, 4, saddr);
              offset += 4;

              daddr = tvb_get_letohl(tvb, offset);
              if (!is_response)
              {
                  col_add_fstr(pinfo->cinfo, COL_DEF_DST, "0x%08X", daddr);
              }
              if (root)
                  proto_tree_add_uint(i_tree, hf_snrm_daddr, tvb, offset, 4, daddr);
              offset += 4;

              ca = tvb_get_uint8(tvb, offset);
              if (!is_response)
              {
                  col_append_fstr(pinfo->cinfo, COL_INFO, ", ca=0x%02X",
                                      ca >> 1);
              }
              if (root)
                  proto_tree_add_uint(i_tree, hf_snrm_ca, tvb, offset, 1, ca >> 1);
              offset++;

              offset = dissect_negotiation(tvb, i_tree, offset);
              if (root)
                  proto_item_set_end(ti, tvb, offset);
              break;

          case IRDA_XID_CMD0x2c:
              tvb = tvb_new_subset_remaining(tvb, offset);
              dissect_xid(tvb, pinfo, root, tree, true1);
              return;

          case XDLC_UA0x60:
              if (tvb_reported_length_remaining(tvb, offset) > 0)
              {
                  if (root)
                  {
                      ti = proto_tree_add_item(tree, hf_lap_i, tvb, offset, -1, ENC_NA0x00000000);
                      i_tree = proto_item_add_subtree(ti, ett_lap_i);
                  }

                  saddr = tvb_get_letohl(tvb, offset);
                  col_add_fstr(pinfo->cinfo, COL_DEF_SRC, "0x%08X", saddr);
                  if (root)
                      proto_tree_add_uint(i_tree, hf_ua_saddr, tvb, offset, 4, saddr);
                  offset += 4;

                  daddr = tvb_get_letohl(tvb, offset);
                  col_add_fstr(pinfo->cinfo, COL_DEF_DST, "0x%08X", daddr);
                  if (root)
                      proto_tree_add_uint(i_tree, hf_ua_daddr, tvb, offset, 4, daddr);
                  offset += 4;

                  offset = dissect_negotiation(tvb, i_tree, offset);
                  if (root)
                      proto_item_set_end(ti, tvb, offset);
              }
              break;

          case XDLC_XID0xAC:
              tvb = tvb_new_subset_remaining(tvb, offset);
              dissect_xid(tvb, pinfo, root, tree, false0);
              return;
       }
  }

  /* If any bytes remain, send it to the generic data dissector */
  if (tvb_reported_length_remaining(tvb, offset) > 0)
  {
      tvb = tvb_new_subset_remaining(tvb, offset);
      call_data_dissector(tvb, pinfo, root);
  }
1908}


1911/*
* Dissect IrDA protocol
*/
1914static int dissect_irda(tvbuff_t* tvb, packet_info* pinfo, proto_tree* root, void* data _U___attribute__((unused)))
1915{
  /* check if log message */
  if ((pinfo->pseudo_header->irda.pkttype & IRDA_CLASS_MASK0xFF00) == IRDA_CLASS_LOG0x0100)
  {
      dissect_log(tvb, pinfo, root);
      return tvb_captured_length(tvb);
  }


  dissect_irlap(tvb, pinfo, root);
  return tvb_captured_length(tvb);
1926}

1928static int irda_addr_to_str(const address* addr, char *buf, int buf_len _U___attribute__((unused)))
1929{
  const uint8_t *addrdata = (const uint8_t *)addr->data;

  uint32_to_str_buf(*addrdata, buf, buf_len);
  return (int)strlen(buf);
1934}

1936static int irda_addr_str_len(const address* addr _U___attribute__((unused)))
1937{
  return 11; /* Leaves required space (10 bytes) for uint_to_str_back() */
1939}

1941static const char* irda_col_filter_str(const address* addr _U___attribute__((unused)), bool_Bool is_src _U___attribute__((unused)))
1942{
  return "irlap.a";
1944}

1946static int irda_addr_len(void)
1947{
  return 1;
1949}

1951/*
* Register the protocol with Wireshark
* This format is required because a script is used to build the C function
*  that calls all the protocol registrations.
*/
1956void proto_register_irda(void)
1957{
  unsigned i;

  /* Setup list of header fields */
  static hf_register_info hf_lap[] = {
      { &hf_lap_a,
          { "Address Field", "irlap.a",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_a_cr,
          { "C/R", "irlap.a.cr",
              FT_BOOLEAN, 8, TFS(&lap_cr_vals)((0 ? (const struct true_false_string*)0 : ((&lap_cr_vals
)))), CMD_FRAME0x01,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_a_address,
          { "Address", "irlap.a.address",
              FT_UINT8, BASE_HEX, NULL((void*)0), ~CMD_FRAME0x01,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c,
          { "Control Field", "irlap.c",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c_nr,
          { "N(R)", "irlap.c.n_r",
              FT_UINT8, BASE_DEC, NULL((void*)0), XDLC_N_R_MASK0xE0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c_ns,
          { "N(S)", "irlap.c.n_s",
              FT_UINT8, BASE_DEC, NULL((void*)0), XDLC_N_S_MASK0x0E,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c_p,
          { "Poll", "irlap.c.p",
              FT_BOOLEAN, 8, TFS(&set_notset)((0 ? (const struct true_false_string*)0 : ((&set_notset)
))), XDLC_P_F0x10,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c_f,
          { "Final", "irlap.c.f",
              FT_BOOLEAN, 8, TFS(&set_notset)((0 ? (const struct true_false_string*)0 : ((&set_notset)
))), XDLC_P_F0x10,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c_s,
          { "Supervisory frame type", "irlap.c.s_ftype",
              FT_UINT8, BASE_HEX, VALS(lap_c_s_vals)((0 ? (const struct _value_string*)0 : ((lap_c_s_vals)))), XDLC_S_FTYPE_MASK0x0C,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c_u_cmd,
          { "Command", "irlap.c.u_modifier_cmd",
              FT_UINT8, BASE_HEX, VALS(lap_c_u_cmd_vals)((0 ? (const struct _value_string*)0 : ((lap_c_u_cmd_vals)))), XDLC_U_MODIFIER_MASK0xEC,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c_u_rsp,
          { "Response", "irlap.c.u_modifier_resp",
              FT_UINT8, BASE_HEX, VALS(lap_c_u_rsp_vals)((0 ? (const struct _value_string*)0 : ((lap_c_u_rsp_vals)))), XDLC_U_MODIFIER_MASK0xEC,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c_i,
          { "Frame Type", "irlap.c.ftype",
              FT_UINT8, BASE_HEX, VALS(lap_c_ftype_vals)((0 ? (const struct _value_string*)0 : ((lap_c_ftype_vals)))), XDLC_I_MASK0x01,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_c_s_u,
          { "Frame Type", "irlap.c.ftype",
              FT_UINT8, BASE_HEX, VALS(lap_c_ftype_vals)((0 ? (const struct _value_string*)0 : ((lap_c_ftype_vals)))), XDLC_S_U_MASK0x03,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lap_i,
          { "Information Field", "irlap.i",
              FT_NONE, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_snrm_saddr,
          { "Source Device Address", "irlap.snrm.saddr",
              FT_UINT32, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_snrm_daddr,
          { "Destination Device Address", "irlap.snrm.daddr",
              FT_UINT32, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_snrm_ca,
          { "Connection Address", "irlap.snrm.ca",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_negotiation_param,
          { "Negotiation Parameter", "irlap.negotiation",
              FT_NONE, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_param_pi,
          { "Parameter Identifier", "irlap.pi",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_param_pl,
          { "Parameter Length", "irlap.pl",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_param_pv,
          { "Parameter Value", "irlap.pv",
              FT_BYTES, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_ua_saddr,
          { "Source Device Address", "irlap.ua.saddr",
              FT_UINT32, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_ua_daddr,
          { "Destination Device Address", "irlap.ua.daddr",
              FT_UINT32, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_xid_ident,
          { "Format Identifier", "irlap.xid.fi",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_xid_saddr,
          { "Source Device Address", "irlap.xid.saddr",
              FT_UINT32, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_xid_daddr,
          { "Destination Device Address", "irlap.xid.daddr",
              FT_UINT32, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_xid_flags,
          { "Discovery Flags", "irlap.xid.flags",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_xid_s,
          { "Number of Slots", "irlap.xid.s",
              FT_UINT8, BASE_DEC, VALS(xid_slot_numbers)((0 ? (const struct _value_string*)0 : ((xid_slot_numbers)))), S_MASK0x03,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_xid_conflict,
          { "Conflict", "irlap.xid.conflict",
              FT_BOOLEAN, 8, TFS(&set_notset)((0 ? (const struct true_false_string*)0 : ((&set_notset)
))), CONFLICT0x04,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_xid_slotnr,
          { "Slot Number", "irlap.xid.slotnr",
              FT_UINT8, BASE_DEC, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_xid_version,
          { "Version Number", "irlap.xid.version",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }}
  };

  static hf_register_info hf_log[] = {
      { &hf_log_msg,
          { "Message", "log.msg",
              FT_STRING, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_log_missed,
          { "WARNING: Missed one or more messages while capturing!", "log.missed",
              FT_NONE, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }}
  };

  static hf_register_info hf_lmp[] = {
      { &hf_lmp_xid_hints,
          { "Service Hints", "irlmp.xid.hints",
              FT_BYTES, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_xid_charset,
          { "Character Set", "irlmp.xid.charset",
              FT_UINT8, BASE_HEX, VALS(lmp_charset_vals)((0 ? (const struct _value_string*)0 : ((lmp_charset_vals)))), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_xid_name,
          { "Device Nickname", "irlmp.xid.name",
              FT_STRING, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_xid_name_no_encoding,
          { "Device Nickname (unsupported character set)", "irlmp.xid.name.no_encoding",
              FT_BYTES, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_dst,
          { "Destination", "irlmp.dst",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_dst_control,
          { "Control Bit", "irlmp.dst.c",
              FT_BOOLEAN, 8, TFS(&set_notset)((0 ? (const struct true_false_string*)0 : ((&set_notset)
))), CONTROL_BIT0x80,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_dst_lsap,
          { "Destination LSAP", "irlmp.dst.lsap",
              FT_UINT8, BASE_DEC, NULL((void*)0), ~CONTROL_BIT0x80,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_src,
          { "Source", "irlmp.src",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_src_r,
          { "reserved", "irlmp.src.r",
              FT_UINT8, BASE_DEC, NULL((void*)0), RESERVED_BIT0x80,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_src_lsap,
          { "Source LSAP", "irlmp.src.lsap",
              FT_UINT8, BASE_DEC, NULL((void*)0), ~RESERVED_BIT0x80,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_opcode,
          { "Opcode", "irlmp.opcode",
              FT_UINT8, BASE_HEX, VALS(lmp_opcode_vals)((0 ? (const struct _value_string*)0 : ((lmp_opcode_vals)))), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_rsvd,
          { "Reserved", "irlmp.rsvd",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_reason,
          { "Reason", "irlmp.reason",
              FT_UINT8, BASE_HEX, VALS(lmp_reason_vals)((0 ? (const struct _value_string*)0 : ((lmp_reason_vals)))), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_mode,
          { "Mode", "irlmp.mode",
              FT_UINT8, BASE_HEX, VALS(lmp_mode_vals)((0 ? (const struct _value_string*)0 : ((lmp_mode_vals)))), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_lmp_status,
          { "Status", "irlmp.status",
              FT_UINT8, BASE_HEX, VALS(lmp_status_vals)((0 ? (const struct _value_string*)0 : ((lmp_status_vals)))), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }}
  };

  static hf_register_info hf_iap[] = {
      { &hf_iap_ctl,
          { "Control Field", "iap.ctl",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_ctl_lst,
          { "Last Frame", "iap.ctl.lst",
              FT_BOOLEAN, 8, TFS(&set_notset)((0 ? (const struct true_false_string*)0 : ((&set_notset)
))), IAP_LST0x80,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_ctl_ack,
          { "Acknowledge", "iap.ctl.ack",
              FT_BOOLEAN, 8, TFS(&set_notset)((0 ? (const struct true_false_string*)0 : ((&set_notset)
))), IAP_ACK0x40,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_ctl_opcode,
          { "Opcode", "iap.ctl.opcode",
              FT_UINT8, BASE_HEX, VALS(iap_opcode_vals)((0 ? (const struct _value_string*)0 : ((iap_opcode_vals)))), IAP_OP0x3F,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_class_name,
          { "Class Name", "iap.classname",
              FT_UINT_STRING, BASE_NONE, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_attr_name,
          { "Attribute Name", "iap.attrname",
              FT_UINT_STRING, BASE_NONE, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_return,
          { "Return", "iap.return",
              FT_UINT8, BASE_HEX, VALS(iap_return_vals)((0 ? (const struct _value_string*)0 : ((iap_return_vals)))), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_list_len,
          { "List Length", "iap.listlen",
              FT_UINT16, BASE_DEC, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_list_entry,
          { "List Entry", "iap.listentry",
              FT_NONE, BASE_NONE, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_obj_id,
          { "Object Identifier", "iap.objectid",
              FT_UINT16, BASE_HEX, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_attr_type,
          { "Type", "iap.attrtype",
              FT_UINT8, BASE_DEC, VALS(iap_attr_type_vals)((0 ? (const struct _value_string*)0 : ((iap_attr_type_vals))
)), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_int,
          { "Value", "iap.int",
              FT_INT32, BASE_DEC, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_seq_len,
          { "Sequence Length", "iap.seqlen",
              FT_UINT16, BASE_DEC, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_oct_seq,
          { "Sequence", "iap.octseq",
              FT_BYTES, BASE_NONE, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_char_set,
          { "Character Set", "iap.charset",
              FT_UINT8, BASE_HEX, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_string,
          { "String", "iap.string",
              FT_UINT_STRING, BASE_NONE, NULL((void*)0), 0x0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_invaloctet,
          { "Malformed IAP result: \"", "iap.invaloctet",
              FT_NONE, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_iap_invallsap,
          { "Malformed IAP result: \"", "iap.invallsap",
              FT_NONE, BASE_NONE, NULL((void*)0), 0,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }}
  };

  static hf_register_info hf_ttp[] = {
      { &hf_ttp_p,
          { "Parameter Bit", "ttp.p",
              FT_BOOLEAN, 8, TFS(&set_notset)((0 ? (const struct true_false_string*)0 : ((&set_notset)
))), TTP_PARAMETERS0x80,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_ttp_icredit,
          { "Initial Credit", "ttp.icredit",
              FT_UINT8, BASE_DEC, NULL((void*)0), ~TTP_PARAMETERS0x80,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_ttp_m,
          { "More Bit", "ttp.m",
              FT_BOOLEAN, 8, TFS(&set_notset)((0 ? (const struct true_false_string*)0 : ((&set_notset)
))), TTP_MORE0x80,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }},
      { &hf_ttp_dcredit,
          { "Delta Credit", "ttp.dcredit",
              FT_UINT8, BASE_DEC, NULL((void*)0), ~TTP_MORE0x80,
              NULL((void*)0), HFILL-1, 0, HF_REF_TYPE_NONE, -1, ((void*)0) }}
  };

  /* Setup protocol subtree arrays */
  static int* ett[] = {
      &ett_irlap,
      &ett_lap_a,
      &ett_lap_c,
      &ett_lap_i,
      &ett_xid_flags,
      &ett_log,
      &ett_irlmp,
      &ett_lmp_dst,
      &ett_lmp_src,
      &ett_iap,
      &ett_iap_ctl,
      &ett_ttp
  };

  int* ett_p[MAX_PARAMETERS32];
  int* ett_iap_e[MAX_IAP_ENTRIES32];


  /* Register protocol names and descriptions */
  proto_irlap = proto_register_protocol("IrDA Link Access Protocol", "IrLAP", "irlap");
  proto_log   = proto_register_protocol("Log Message", "Log", "log");
  proto_irlmp = proto_register_protocol("IrDA Link Management Protocol", "IrLMP", "irlmp");
  proto_iap   = proto_register_protocol("Information Access Protocol", "IAP", "iap");
  proto_ttp   = proto_register_protocol("Tiny Transport Protocol", "TTP", "ttp");

  /* Register the dissector */
  irda_handle = register_dissector("irda", dissect_irda, proto_irlap);

  /* Required function calls to register the header fields */
  proto_register_field_array(proto_irlap, hf_lap, array_length(hf_lap)(sizeof (hf_lap) / sizeof (hf_lap)[0]));
  proto_register_field_array(proto_log, hf_log, array_length(hf_log)(sizeof (hf_log) / sizeof (hf_log)[0]));
  proto_register_field_array(proto_irlmp, hf_lmp, array_length(hf_lmp)(sizeof (hf_lmp) / sizeof (hf_lmp)[0]));
  proto_register_field_array(proto_iap, hf_iap, array_length(hf_iap)(sizeof (hf_iap) / sizeof (hf_iap)[0]));
  proto_register_field_array(proto_ttp, hf_ttp, array_length(hf_ttp)(sizeof (hf_ttp) / sizeof (hf_ttp)[0]));

  /* Register subtrees */
  proto_register_subtree_array(ett, array_length(ett)(sizeof (ett) / sizeof (ett)[0]));
  for (i = 0; i < MAX_PARAMETERS32; i++)
  {
      ett_p[i]     = &ett_param[i];
  }
  proto_register_subtree_array(ett_p, MAX_PARAMETERS32);
  for (i = 0; i < MAX_IAP_ENTRIES32; i++)
  {
      ett_iap_e[i]     = &ett_iap_entry[i];
  }
  proto_register_subtree_array(ett_iap_e, MAX_IAP_ENTRIES32);

  irda_address_type = address_type_dissector_register("AT_IRDA", "IRDA Address", irda_addr_to_str, irda_addr_str_len, NULL((void*)0), irda_col_filter_str, irda_addr_len, NULL((void*)0), NULL((void*)0));
2307}


2310/* 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.
2313*/

2315void proto_reg_handoff_irda(void)
2316{
  dissector_add_uint("wtap_encap", WTAP_ENCAP_IRDA44, irda_handle);
  dissector_add_uint("sll.ltype", LINUX_SLL_P_IRDA_LAP0x0017, irda_handle);
2319}

2321/*
* Editor modelines  -  https://www.wireshark.org/tools/modelines.html
*
* Local variables:
* c-basic-offset: 4
* tab-width: 8
* indent-tabs-mode: nil
* End:
*
* vi: set shiftwidth=4 tabstop=8 expandtab:
* :indentSize=4:tabSize=8:noTabs=true:
*/