Fix various typos and spelling errors.
[obnox/wireshark/wip.git] / epan / dissectors / packet-ppi-antenna.c
1 /* packet-ppi-antenna.c
2  * Routines for PPI-GEOLOCATION-ANNTENNA  dissection
3  * Copyright 2010, Harris Corp, jellch@harris.com
4  *
5  * $Id$
6  *
7  * Wireshark - Network traffic analyzer
8  * By Gerald Combs <gerald@wireshark.org>
9  * Copyright 1998 Gerald Combs
10  *
11  * Copied from packet-radiotap.c
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License along
24  * with this program; if not, write to the Free Software Foundation, Inc.,
25  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26  */
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31
32 #include <glib.h>
33 #include <string.h>
34
35 #include <epan/packet.h>
36 #include <epan/ptvcursor.h>
37 #include <epan/prefs.h>
38 #include <epan/reassemble.h>
39 #include <epan/dissectors/packet-ppi-geolocation-common.h>
40
41 enum ppi_antenna_type {
42     PPI_ANTENNA_ANTFLAGS    = 0, /* Various flags about the antenna in use, Polarity, etc */
43     PPI_ANTENNA_GAINDB      = 1, /* Antenna gain, in dBi */
44     PPI_ANTENNA_HORIZBW     = 2, /* Antenna beamwidth, horizontal */
45     PPI_ANTENNA_VERTBW      = 3, /* Antenna beamwidth, vertical */
46     PPI_ANTENNA_PGAIN       = 4, /* precision gain */
47     PPI_ANTENNA_BEAMID      = 5, /* beam identifier (electrically steerable only) */
48     PPI_ANTENNA_RES6        = 6,
49     PPI_ANTENNA_RES7        = 7,
50     PPI_ANTENNA_SERIALNUM   = 26,
51     PPI_ANTENNA_MODELSTR    = 27, /*32 bytes, fixed length, null terminated model of antenna */
52     PPI_ANTENNA_DESCSTR     = 28, /*32 bytes, fixed length, null terminated description of what the antenna is for */
53     PPI_ANTENNA_APPID       = 29, /*4-byte identifier*/
54     PPI_ANTENNA_APPDATA     = 30, /* 60-byte app-id specific data*/
55     PPI_ANTENNA_EXT         = 31  /* Indicates n extended bitmap follows */
56 };
57
58
59
60 /* protocol */
61 static int proto_ppi_antenna = -1;
62
63 static int hf_ppi_antenna_version = -1;
64 static int hf_ppi_antenna_pad = -1;
65 static int hf_ppi_antenna_length = -1;
66 static int hf_ppi_antenna_present = -1;
67 static int hf_ppi_antenna_flags = -1;
68 static int hf_ppi_antenna_gaindb = -1;
69 static int hf_ppi_antenna_horizbw = -1;
70 static int hf_ppi_antenna_vertbw = -1;
71 static int hf_ppi_antenna_pgain= -1;
72 static int hf_ppi_antenna_beamid= -1;
73 static int hf_ppi_antenna_serialnum= -1;
74 static int hf_ppi_antenna_modelname = -1;
75 static int hf_ppi_antenna_descstr = -1;
76 static int hf_ppi_antenna_appspecific_num = -1; /* 4-byte tag no */
77 static int hf_ppi_antenna_appspecific_data = -1; /* 60 byte arbitrary data */
78
79
80 /* "Present" flags */
81 /* These represent decoded-bits in the gui */
82 static int hf_ppi_antenna_present_flags= -1;
83 static int hf_ppi_antenna_present_gaindb = -1;
84 static int hf_ppi_antenna_present_horizbw = -1;
85 static int hf_ppi_antenna_present_vertbw= -1;
86 static int hf_ppi_antenna_present_pgain= -1;
87 static int hf_ppi_antenna_present_beamid= -1;
88 static int hf_ppi_antenna_present_serialnum= -1;
89 static int hf_ppi_antenna_present_modelname = -1;
90 static int hf_ppi_antenna_present_descstr = -1;
91 static int hf_ppi_antenna_present_appspecific_num = -1;
92 static int hf_ppi_antenna_present_appspecific_data = -1;
93 static int hf_ppi_antenna_present_ext = -1;
94
95 /*These are the few defined AntennaFlags bits*/
96 static int hf_ppi_antennaflags_mimo= -1;
97 static int hf_ppi_antennaflags_horizpol= -1;
98 static int hf_ppi_antennaflags_vertpol= -1;
99 static int hf_ppi_antennaflags_circpol_l= -1;
100 static int hf_ppi_antennaflags_circpol_r= -1;
101 static int hf_ppi_antennaflags_steer_elec= -1;
102 static int hf_ppi_antennaflags_steer_mech= -1;
103
104 /* These represent arrow-dropdownthings in the gui */
105 static gint ett_ppi_antenna = -1;
106 static gint ett_ppi_antenna_present = -1;
107 static gint ett_ppi_antennaflags= -1;
108
109
110 static void
111 dissect_ppi_antenna(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
112
113 void
114 proto_register_ppi_antenna(void) {
115     /* The following array initializes those header fields declared above to the values displayed */
116     static hf_register_info hf[] = {
117         { &hf_ppi_antenna_version,
118           { "Header revision", "ppi_antenna.version",
119             FT_UINT8, BASE_DEC, NULL, 0x0,
120             "Version of ppi_antenna header format", HFILL } },
121         { &hf_ppi_antenna_pad,
122           { "Header pad", "ppi_antenna.pad",
123             FT_UINT8, BASE_DEC, NULL, 0x0,
124             "Padding", HFILL } },
125         { &hf_ppi_antenna_length,
126           { "Header length", "ppi_antenna.length",
127             FT_UINT16, BASE_DEC, NULL, 0x0,
128             "Length of header including version, pad, length and data fields", HFILL } },
129         /* This setups the "Antenna flags" hex dropydown thing */
130         { &hf_ppi_antenna_flags,
131           { "Antenna flags", "ppi_antenna.antenna_flags",
132             FT_UINT32, BASE_HEX, NULL, 0x0, "Bitmask indicating polarity, etc", HFILL } },
133         { &hf_ppi_antenna_present,
134           { "Present", "ppi_antenna.present",
135             FT_UINT32, BASE_HEX, NULL, 0x0, "Bitmask indicating which fields are present", HFILL } },
136
137         /* This first set is for the base_tag_header.it_present bitfield */
138 #define PPI_ANTENNA_MASK_FLAGS      0x00000001  /* 0 */
139 #define PPI_ANTENNA_MASK_GAINDB     0x00000002  /* 1 */
140 #define PPI_ANTENNA_MASK_HORIZBW    0x00000004  /* 2 */
141 #define PPI_ANTENNA_MASK_VERTBW     0x00000008  /* 3 */
142 #define PPI_ANTENNA_MASK_PGAIN      0x00000020  /* 5 */
143 #define PPI_ANTENNA_MASK_BEAMID     0x00000040  /* 6 */
144 #define PPI_ANTENNA_MASK_RES7       0x00000080  /* 7 */
145 #define PPI_ANTENNA_MASK_SERIALNUM  0x04000000  /* 26 */
146 #define PPI_ANTENNA_MASK_MODELSTR   0x08000000  /* 27 */
147 #define PPI_ANTENNA_MASK_DESCSTR    0x10000000  /* 28 */
148 #define PPI_ANTENNA_MASK_APPID      0x20000000  /* 29 */
149 #define PPI_ANTENNA_MASK_APPDATA     0x40000000  /* 30 */
150 #define PPI_ANTENNA_MASK_EXT        0x80000000  /* 31 */
151
152         /*This second set is for the AntennaFlags bitfield. */
153 #define PPI_ANTENNAFLAGS_MASK_MIMO              0x00000001  /* 0 */
154 #define PPI_ANTENNAFLAGS_MASK_HPOL              0x00000002  /* 1 */
155 #define PPI_ANTENNAFLAGS_MASK_VPOL              0x00000004  /* 2 */
156 #define PPI_ANTENNAFLAGS_MASK_CPOL_L            0x00000008  /* 3 */
157 #define PPI_ANTENNAFLAGS_MASK_CPOL_R            0x00000010  /* 4 */
158 #define PPI_ANTENNAFLAGS_MASK_STEER_ELEC        0x00010000  /* 16 */
159 #define PPI_ANTENNAFLAGS_MASK_STEER_MECH        0x00020000  /* 17 */
160
161
162         /* Boolean 'present' flags */
163         { &hf_ppi_antenna_present_flags,
164           { "flags", "ppi_antenna.present.flags",
165             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_FLAGS,
166             "Specifies if the flags bitfield is present", HFILL } },
167         { &hf_ppi_antenna_present_gaindb,
168           { "gaindb", "ppi_antenna.present.gaindb",
169             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_GAINDB,
170             "Specifies if the antenna gain field  is present", HFILL } },
171         { &hf_ppi_antenna_present_horizbw,
172           { "horizbw", "ppi_antenna.present.horizbw",
173             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_HORIZBW,
174             "Specifies if the horizontal beamwidth field is present", HFILL } },
175         { &hf_ppi_antenna_present_vertbw,
176           { "vertbw", "ppi_antenna.present.vertbw",
177             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_VERTBW,
178             "Specifies if the vertical beamwidth field is present", HFILL } },
179         { &hf_ppi_antenna_present_pgain,
180           { "pgain", "ppi_antenna.present.pgain",
181             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_PGAIN,
182             "Specifies if the precision gain field is present", HFILL } },
183         { &hf_ppi_antenna_present_beamid,
184           { "beamid", "ppi_antenna.present.beamid",
185             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_BEAMID,
186             "Specifies if the BeamID field is present", HFILL } },
187         { &hf_ppi_antenna_present_serialnum,
188           { "serialnum", "ppi_antenna.present.serialnum",
189             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_SERIALNUM,
190             "Specifies if the serial num is present", HFILL } },
191         { &hf_ppi_antenna_present_modelname,
192           { "modelname", "ppi_antenna.present.modelname",
193             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_MODELSTR,
194             "Specifies if the model name is present", HFILL } },
195         { &hf_ppi_antenna_present_descstr,
196           { "Description", "ppi_antenna.present.descr",
197             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_DESCSTR,
198             "Specifies if the description string is present", HFILL } },
199
200         { &hf_ppi_antenna_present_appspecific_num,
201           { "appid", "ppi_antenna.present.appid",
202             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_APPID,
203             "Specifies if the application specific field id is present", HFILL } },
204
205         { &hf_ppi_antenna_present_appspecific_data,
206           { "appdata", "ppi_antenna.present.appdata",
207             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_APPDATA,
208             "Specifies if the application specific data field  is present", HFILL } },
209
210         { &hf_ppi_antenna_present_ext,
211           { "ext", "ppi_antenna.present.ext",
212             FT_BOOLEAN, 32, NULL, PPI_ANTENNA_MASK_EXT,
213             "Specifies if there are any extensions to the header present", HFILL } },
214
215         /*Here we switch to the antennflags bits*/
216         /* Boolean AntennaFlags' flags */
217         { &hf_ppi_antennaflags_mimo,
218           { "mimo", "ppi_antenna.antennaflags.mimo",
219             FT_BOOLEAN, 32, NULL, PPI_ANTENNAFLAGS_MASK_MIMO,
220             "Antena is part of MIMO system", HFILL } },
221         { &hf_ppi_antennaflags_horizpol,
222           { "horizontally polarized", "ppi_antenna.antennaflags.horizpol",
223             FT_BOOLEAN, 32, NULL, PPI_ANTENNAFLAGS_MASK_HPOL,
224             "Specifies if the antenna is horizontally polarized", HFILL } },
225
226         { &hf_ppi_antennaflags_vertpol,
227           { "vertically polarized", "ppi_antenna.antennaflags.vertpol",
228             FT_BOOLEAN, 32, NULL, PPI_ANTENNAFLAGS_MASK_VPOL,
229             "Specifies if the antenna is vertically polarized", HFILL } },
230
231         { &hf_ppi_antennaflags_circpol_l,
232           { "circularly polarized left", "ppi_antenna.antennaflags.circpol_l",
233             FT_BOOLEAN, 32, NULL, PPI_ANTENNAFLAGS_MASK_CPOL_L,
234             "Specifies if the antenna is circularly polarized, left handed", HFILL } },
235
236         { &hf_ppi_antennaflags_circpol_r,
237           { "circularly polarized right", "ppi_antenna.antennaflags.circpol_r",
238             FT_BOOLEAN, 32, NULL, PPI_ANTENNAFLAGS_MASK_CPOL_R,
239             "Specifies if the antenna is circularly polarized, right handed", HFILL } },
240
241         { &hf_ppi_antennaflags_steer_elec,
242           { "electrically steerable", "ppi_antenna.antennaflags.steer_elec",
243             FT_BOOLEAN, 32, NULL, PPI_ANTENNAFLAGS_MASK_STEER_ELEC,
244             "Specifies if the antenna is electrically steerable", HFILL } },
245
246         { &hf_ppi_antennaflags_steer_mech,
247           { "mechanically steerable", "ppi_antenna.antennaflags.steer_mech",
248             FT_BOOLEAN, 32, NULL, PPI_ANTENNAFLAGS_MASK_STEER_MECH,
249             "Specifies if the antenna is mechanically steerable", HFILL } },
250
251         /* Now we get to the actual data fields */
252         { &hf_ppi_antenna_gaindb,
253           { "Gain (dBi)", "ppi_antenna.gaindb",
254             FT_UINT8, BASE_DEC, NULL, 0x0,
255             "Gain of antenna (dBi)", HFILL } },
256         { &hf_ppi_antenna_horizbw,
257           { "HorizBw", "ppi_antenna.horizbw",
258             FT_DOUBLE, BASE_NONE, NULL, 0x0,
259             "Horizontal beamwidth", HFILL } },
260         { &hf_ppi_antenna_vertbw,
261           { "VertBw", "ppi_antenna.vertbw",
262             FT_DOUBLE, BASE_NONE, NULL, 0x0,
263             "Vertical beamwidth", HFILL } },
264         { &hf_ppi_antenna_pgain,
265           { "Precision Gain (dBi)", "ppi_antenna.pgain",
266             FT_DOUBLE, BASE_NONE, NULL, 0x0,
267             "Precision Gain", HFILL } },
268         { &hf_ppi_antenna_beamid,
269           { "BeamID", "ppi_antenna.beamid",
270             FT_UINT16, BASE_HEX, NULL, 0x0,
271             "Beam ID", HFILL } },
272
273         { &hf_ppi_antenna_serialnum,
274           { "SerialNumber", "ppi_antenna.serialnum",
275             FT_STRING,  BASE_NONE, NULL, 0x0,
276             "Serial number", HFILL } } ,
277         { &hf_ppi_antenna_modelname,
278           { "ModelName", "ppi_antenna.modelname",
279             FT_STRING,  BASE_NONE, NULL, 0x0,
280             "Model name", HFILL } } ,
281         { &hf_ppi_antenna_descstr,
282           { "Description", "ppi_antenna.descr",
283             FT_STRING,  BASE_NONE, NULL, 0x0,
284             NULL, HFILL } } ,
285         { &hf_ppi_antenna_appspecific_num,
286           { "Application Specific id", "ppi_antenna.appid",
287             FT_UINT32, BASE_HEX, NULL, 0x0,
288             "Application-specific identifier", HFILL } },
289         { &hf_ppi_antenna_appspecific_data,
290           { "Application specific data", "ppi_antenna.appdata",
291             FT_BYTES, BASE_NONE, NULL, 0x0,
292             "Application-specific data", HFILL } },
293     };
294     static gint *ett[] = {
295         &ett_ppi_antenna,
296         &ett_ppi_antenna_present,
297         &ett_ppi_antennaflags
298     };
299
300     proto_ppi_antenna = proto_register_protocol("PPI antenna decoder", "PPI antenna Decoder", "ppi_antenna");
301     proto_register_field_array(proto_ppi_antenna, hf, array_length(hf));
302     proto_register_subtree_array(ett, array_length(ett));
303     register_dissector("ppi_antenna", dissect_ppi_antenna, proto_ppi_antenna);
304
305 }
306 void dissect_ppi_antenna(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
307     /* The fixed values up front */
308     guint32 version;
309     guint length;
310     guint length_remaining;
311
312     proto_tree *ppi_antenna_tree = NULL;
313     proto_tree *present_tree = NULL;
314     proto_tree *antennaflags_tree = NULL;
315     proto_tree *pt, *my_pt;
316     proto_item *ti = NULL;
317
318
319     /* bits */
320     int bit;
321     guint32 present, next_present;
322     /* values actually read out, for displaying */
323     guint8 gaindb;
324     guint16 beamid;
325     guint32 t_hbw, t_vbw, t_pgain, t_appspecific_num; /* temporary conversions */
326     gdouble horizbw, vertbw, pgain;
327     guint32 flags;
328     char  *curr_str; /* used for modelname, serialnum, etc */
329
330     int offset = 0;
331
332     /* Clear out stuff in the info column */
333     if (check_col(pinfo->cinfo,COL_INFO)) {
334         col_clear(pinfo->cinfo,COL_INFO);
335     }
336     version = tvb_get_guint8(tvb, offset);
337     length = tvb_get_letohs(tvb, offset+2);
338     present = tvb_get_letohl(tvb, offset+4);
339     if (check_col(pinfo->cinfo, COL_INFO))
340         col_add_fstr(pinfo->cinfo, COL_INFO, "PPI Antenna info v%u, Length %u",
341                      version, length);
342
343     /* Dissect the packet */
344     if (tree) {
345         ti = proto_tree_add_protocol_format(tree, proto_ppi_antenna,
346                                             tvb, 0, length, "PPI Antenna Header v%u, Length %u", version, length);
347         ppi_antenna_tree= proto_item_add_subtree(ti, ett_ppi_antenna);
348         proto_tree_add_uint(ppi_antenna_tree, hf_ppi_antenna_version,
349                             tvb, offset, 1, version);
350         proto_tree_add_item(ppi_antenna_tree, hf_ppi_antenna_pad,
351                             tvb, offset + 1, 1, FALSE);
352         ti = proto_tree_add_uint(ppi_antenna_tree, hf_ppi_antenna_length,
353                                  tvb, offset + 2, 2, length);
354     }
355     length_remaining = length;
356     /*
357      * FIXME: This only works if there is exactly 1 it_present
358      *        field in the header
359      */
360     if (length_remaining < PPI_GEOBASE_MIN_HEADER_LEN) {
361         /*
362          * Radiotap header is shorter than the fixed-length portion
363          * plus one "present" bitset.
364          */
365         if (tree)
366             proto_item_append_text(ti, " (bogus - minimum length is 8)");
367         return;
368     }
369     /* Subtree for the "present flags" bitfield. */
370     if (tree) {
371         pt = proto_tree_add_uint(ppi_antenna_tree, hf_ppi_antenna_present, tvb, offset + 4, 4, present);
372         present_tree = proto_item_add_subtree(pt, ett_ppi_antenna_present);
373
374         proto_tree_add_item(present_tree, hf_ppi_antenna_present_flags, tvb, 4, 4, TRUE);
375         proto_tree_add_item(present_tree, hf_ppi_antenna_present_gaindb, tvb, 4, 4, TRUE);
376         proto_tree_add_item(present_tree, hf_ppi_antenna_present_horizbw, tvb, 4, 4, TRUE);
377         proto_tree_add_item(present_tree, hf_ppi_antenna_present_vertbw, tvb, 4, 4, TRUE);
378         proto_tree_add_item(present_tree, hf_ppi_antenna_present_pgain, tvb, 4, 4, TRUE);
379         proto_tree_add_item(present_tree, hf_ppi_antenna_present_beamid, tvb, 4, 4, TRUE);
380         proto_tree_add_item(present_tree, hf_ppi_antenna_present_serialnum, tvb, 4, 4, TRUE);
381         proto_tree_add_item(present_tree, hf_ppi_antenna_present_modelname, tvb, 4, 4, TRUE);
382         proto_tree_add_item(present_tree, hf_ppi_antenna_present_descstr, tvb, 4, 4, TRUE);
383         proto_tree_add_item(present_tree, hf_ppi_antenna_present_appspecific_num, tvb, 4, 4, TRUE);
384         proto_tree_add_item(present_tree, hf_ppi_antenna_present_appspecific_data, tvb, 4, 4, TRUE);
385
386         proto_tree_add_item(present_tree, hf_ppi_antenna_present_ext, tvb, 4, 4, TRUE);
387     }
388     offset += PPI_GEOBASE_MIN_HEADER_LEN;
389     length_remaining -= PPI_GEOBASE_MIN_HEADER_LEN;
390
391     /* Now all of the fixed length, fixed location stuff is over. Loop over the bits */
392     for (; present; present = next_present) {
393         /* clear the least significant bit that is set */
394         next_present = present & (present - 1);
395         /* extract the least significant bit that is set */
396         bit = BITNO_32(present ^ next_present);
397         switch (bit) {
398         case  PPI_ANTENNA_ANTFLAGS:
399             if (length_remaining < 4)
400                 break;
401             flags = tvb_get_letohl(tvb, offset);
402             if (tree) {
403                 my_pt = proto_tree_add_uint(ppi_antenna_tree, hf_ppi_antenna_flags, tvb, offset , 4, flags);
404                 /*Add antenna_flags bitfields here */
405                 antennaflags_tree= proto_item_add_subtree(my_pt, ett_ppi_antennaflags);
406
407                 proto_tree_add_item(antennaflags_tree, hf_ppi_antennaflags_mimo, tvb, offset, 4, TRUE);
408                 proto_tree_add_item(antennaflags_tree, hf_ppi_antennaflags_horizpol, tvb, offset, 4, TRUE);
409                 proto_tree_add_item(antennaflags_tree, hf_ppi_antennaflags_vertpol, tvb, offset, 4, TRUE);
410                 proto_tree_add_item(antennaflags_tree, hf_ppi_antennaflags_circpol_l, tvb, offset, 4, TRUE);
411                 proto_tree_add_item(antennaflags_tree, hf_ppi_antennaflags_circpol_r, tvb, offset, 4, TRUE);
412                 proto_tree_add_item(antennaflags_tree, hf_ppi_antennaflags_steer_elec, tvb, offset, 4, TRUE);
413                 proto_tree_add_item(antennaflags_tree, hf_ppi_antennaflags_steer_mech, tvb, offset, 4, TRUE);
414             }
415             offset+=4;
416             length_remaining-=4;
417             break;
418         case PPI_ANTENNA_GAINDB:
419             if (length_remaining < 1)
420                 break;
421             gaindb=  tvb_get_guint8(tvb, offset);
422             if (tree) {
423                 proto_tree_add_uint(ppi_antenna_tree, hf_ppi_antenna_gaindb, tvb, offset, 1, gaindb);
424             }
425             offset+=1;
426             length_remaining-=1;
427             break;
428         case  PPI_ANTENNA_HORIZBW:
429             if (length_remaining < 4)
430                 break;
431             t_hbw = tvb_get_letohl(tvb, offset);
432             horizbw =  fixed3_6_to_gdouble(t_hbw);
433             if (tree) {
434                 proto_tree_add_double(ppi_antenna_tree, hf_ppi_antenna_horizbw, tvb, offset, 4, horizbw);
435             }
436             offset+=4;
437             length_remaining-=4;
438             break;
439         case  PPI_ANTENNA_VERTBW:
440             if (length_remaining < 4)
441                 break;
442             t_vbw = tvb_get_letohl(tvb, offset);
443             vertbw =  fixed3_6_to_gdouble(t_vbw);
444             if (tree) {
445                 proto_tree_add_double(ppi_antenna_tree, hf_ppi_antenna_vertbw, tvb, offset, 4, vertbw);
446             }
447             offset+=4;
448             length_remaining-=4;
449             break;
450         case  PPI_ANTENNA_PGAIN:
451             if (length_remaining < 4)
452                 break;
453             t_pgain = tvb_get_letohl(tvb, offset);
454             pgain =  fixed3_6_to_gdouble(t_pgain);
455             if (tree) {
456                 proto_tree_add_double(ppi_antenna_tree, hf_ppi_antenna_pgain, tvb, offset, 4, pgain);
457             }
458             offset+=4;
459             length_remaining-=4;
460             break;
461         case  PPI_ANTENNA_BEAMID:
462             if (length_remaining < 2)
463                 break;
464             beamid= tvb_get_letohs(tvb, offset); /* convert endianess */
465             if (tree) {
466                 proto_tree_add_uint(ppi_antenna_tree, hf_ppi_antenna_beamid, tvb, offset, 2, beamid);
467             }
468             offset+=2;
469             length_remaining-=2;
470             break;
471         case  PPI_ANTENNA_SERIALNUM:
472             if (length_remaining < 32)
473                 break;
474             if (tree) {
475                 curr_str= (char *)  tvb_get_ptr(tvb, offset, 32);
476                 proto_tree_add_string(ppi_antenna_tree, hf_ppi_antenna_serialnum, tvb, offset, 32, curr_str);;
477             }
478             offset+=32;
479             length_remaining-=32;
480             break;
481
482         case  PPI_ANTENNA_MODELSTR:
483             if (length_remaining < 32)
484                 break;
485             if (tree) {
486                 curr_str = (char *)  tvb_get_ptr(tvb, offset, 32);
487                 proto_tree_add_string(ppi_antenna_tree, hf_ppi_antenna_modelname, tvb, offset, 32,  curr_str);
488             }
489             offset+=32;
490             length_remaining-=32;
491             break;
492         case  PPI_ANTENNA_DESCSTR:
493             if (length_remaining < 32)
494                 break;
495             if (tree) {
496                 curr_str= (char *)  tvb_get_ptr(tvb, offset, 32);
497                 proto_tree_add_string(ppi_antenna_tree, hf_ppi_antenna_descstr, tvb, offset, 32, curr_str);
498             }
499             offset+=32;
500             length_remaining-=32;
501             break;
502         case  PPI_ANTENNA_APPID:
503             if (length_remaining < 4)
504                 break;
505             t_appspecific_num  = tvb_get_letohl(tvb, offset); /* application specific parsers may switch on this later */
506             if (tree) {
507                 proto_tree_add_uint(ppi_antenna_tree, hf_ppi_antenna_appspecific_num, tvb, offset, 4, t_appspecific_num);
508             }
509             offset+=4;
510             length_remaining-=4;
511             break;
512         case  PPI_ANTENNA_APPDATA:
513             if (length_remaining < 60)
514                 break;
515             if (tree) {
516                 proto_tree_add_item(ppi_antenna_tree, hf_ppi_antenna_appspecific_data, tvb, offset, 60,  FALSE);
517             }
518             offset+=60;
519             length_remaining-=60;
520             break;
521         default:
522             /*
523              * This indicates a field whose size we do not
524              * know, so we cannot proceed.
525              */
526             proto_tree_add_text(ppi_antenna_tree, tvb, offset, 0,  "Error: PPI-ANTENNA: unknown bit (%d) set in present field.\n", bit);
527             next_present = 0;
528             continue;
529         }
530
531     };
532     return;
533 }
534
535