Wireshark-dev: Re: [Wireshark-dev] wireshark GUI vs tshark
From: Brian Oleksa <oleksab@xxxxxxxxxxxxxxxxxxxxxx>
Date: Mon, 23 Nov 2009 14:22:06 -0500
JaapEventually this might get licensed...but just not sure what direction we will be going.
I have tracked down many many problems before when my code crashed within the GUI...because I would get some what of a decent error. But I am having a hard time tracking down this bug as it runs fine in the GUI but not in tshark.
Doesn't tshark run off the same base code as the GUI does..?? If so...then you think if it would crash in one that it would crash in the other....wouldn't you think..??
Attached is my code. Any help is greatly appreciated. Thank you Brian Jaap Keuter wrote:
Hi,Well, your assumption is probably right, that your dissector has something to do with it.You can post it, but we prefer to spend our time on GPL'ed code. I don't know what you license will be. If you prefer not to publish your code you can probably find enough clues in the documentation in the doc directory.Thanks, Jaap Brian Oleksa wrote:Chris and Jaap Well.... I guess I can point out the obvious here:I wrote a dissector that works fine with the GUI with no problem...but it crashes when I use tshark.HOWEVER... if I remove my dissector....then my pcap file loads fine within tshark.So the problem has to be with my dissector....correct..?? Is there anyway I can post my code so you can take a look..??This is hard to track down as again everything works fine in the GUI and I get NO real error message within tshark.What do you think..? Thanks, Brian Maynard, Chris wrote:The file may not be corrupt but might contain packet(s) which are exposing a tshark bug. If you can post the capture file, that would probably help. If you don't wish to post it on the mailing list, you can open a bug report and post it there instead, marking the file as private if you so desire so only the core developers have access to it. - Chris -----Original Message----- From: wireshark-dev-bounces@xxxxxxxxxxxxx [mailto:wireshark-dev-bounces@xxxxxxxxxxxxx] On Behalf Of Brian Oleksa Sent: Monday, November 23, 2009 12:59 PM To: Developer support list for Wireshark Subject: Re: [Wireshark-dev] wireshark GUI vs tshark Jaap and Chris I am running this on Win XP service pack 2. I am using wireshark Version 1.2.4 (SVN Rev 30978).The test.pcap file has been around for a while...so chances are it is not corrupt. It never crashes using the GUI...it just crashes and gives me that pop up when I run it with that tshark command.This is about all the information that I can provide....unless you can think of something else that you need..??Thanks, Brian Jaap Keuter wrote:Hi Brian, Thanks for including the error report. It in itself doesn't tellanything,other than that a problem was detected. That's why Chris asked yousomemore questions on the whole situation. Maybe we can help you furtherwhenyou look into them. Thanks, Jaap On Mon, 23 Nov 2009 12:02:17 -0500, Brian Oleksa <oleksab@xxxxxxxxxxxxxxxxxxxxxx> wrote:Chris I have attached the error this time....sorry about that. :-) I get this error when I run with tshark using the following command:tshark -nr test.pcap ip.dst==x.x.x.xBut when I filter in the GUI ... I have no problems. Thanks, Brian Maynard, Chris wrote:Any thoughts..??My first thought was, "I guess you forgot to include the error." :) In addition to the error, you might want to include some Wireshark version information, what OS you're running on and any otherinformationthat you think might be relevant. By the way, I tried a similar tshark command using Wireshark 1.2.4onWindows XP SP3 with no problems. Maybe you are running an olderversionof Wireshark with a known bug that has been fixed, or maybe your test.pcap file is corrupt or exposes a Wireshark bug, in which caseabug report might be in order with the attached test.pcap fileincludedso the core developers can analyze the error and find & fix the bug. - Chris -----Original Message----- From: wireshark-dev-bounces@xxxxxxxxxxxxx [mailto:wireshark-dev-bounces@xxxxxxxxxxxxx] On Behalf Of BrianOleksaSent: Sunday, November 22, 2009 10:49 PM To: Developer support list for Wireshark Subject: [Wireshark-dev] wireshark GUI vs tshark Wiresharkers When I use my dissector with the GUI... everything works fine. Thepcapfile that I load comes right up with NO problems. I can filter (ip.dst==x.x.x.x) with no problems.But if I try to open that same pcap file with tshark using thefollowingcommand:tshark -nr test.pcap ip.dst==x.x.x.xThe files appears to start loading.. then I get the following error. Any thoughts..?? Thanks, Brian___________________________________________________________________________ Sent via: Wireshark-dev mailing list <wireshark-dev@xxxxxxxxxxxxx> Archives: http://www.wireshark.org/lists/wireshark-dev Unsubscribe: https://wireshark.org/mailman/options/wireshark-dev mailto:wireshark-dev-request@xxxxxxxxxxxxx?subject=unsubscribe
/* packet-helen.c
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdio.h>
#include <glib.h>
#include <epan/packet.h>
#include <epan/tvbuff.h>
#include <time.h>
#include <string.h>
#define PROTO_TAG_HELEN "HELEN"
#define PROTO_TAG_NETALIVE "NETALIVE"
/* Wireshark ID of the HELEN protocol */
static int proto_helen = -1;
static int proto_netalive = -1;
/* These are the handles of our subdissectors */
static dissector_handle_t data_handle = NULL;
static dissector_handle_t netalivedata_handle = NULL;
static dissector_handle_t helen_handle;
static dissector_handle_t netalive_handle;
void dissect_helen(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
void dissect_netalive(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
//You now put your ports in the ports file
//this port can be changed to whatever port SA is running on.
//static int global_helen_port = 7636;
static int ports[16] = {5000, 5220, 42250, 50000, 5221, 5222, 49901, 49501, 49510, 42251, 42250, 56797, 5226, 47001, 5227, 7636};
static int global_netalive_port = 56797;
static const value_string packettypenames[] = {
{ 0, "TEXT"
},
{ 1, "SOMETHING_ELSE"
},
{ 0, NULL
}
};
// Declarations:
int numBytesInMode(int numBits);
int numBytesInBitmask(int numBits);
char * translateWFMode(int val);
/* The following hf_* variables are used to hold the Wireshark IDs of
* our header fields; they are filled out when we call
* proto_register_field_array() in proto_register_helen()
*/
/** Kts attempt at defining the protocol */
static gint hf_helen = -1;
//static gint hf_helen_header = -1;
static gint hf_helen_length = -1;
static gint hf_helen_type = -1;
static gint hf_helen_text = -1;
static gint hf_helen_Flowname = -1;
static gint hf_netalive = -1;
//static gint hf_helen_header = -1;
static gint hf_netalive_length = -1;
static gint hf_netalive_type = -1;
static gint hf_netalive_text = -1;
static gint hf_helen_magic = -1;
static gint hf_helen_checksum = -1;
static gint hf_helen_txTime = -1;
/* These are the ids of the subtrees that we may be creating */
static gint ett_helen = -1;
static gint ett_helen_header = -1;
static gint ett_helen_length = -1;
static gint ett_helen_type = -1;
static gint ett_helen_text = -1;
static gint ett_helen_Flowname = -1;
static gint ett_netalive = -1;
static gint ett_netalive_header = -1;
static gint ett_netalive_length = -1;
static gint ett_netalive_type = -1;
static gint ett_netalive_text = -1;
void proto_reg_handoff_helen(void) {
static gboolean initialized = FALSE;
//int portnumber;
int i;
//FILE *fp;
//#if defined(_WIN32)
//fp = fopen("ports.txt", "r");
//#else
//fp = fopen("ports", "r");
//#endif
//if (fp == NULL) {
// printf("Can't open the ports file! \n");
// printf("Make sure the file exists where the wireshark executable lives at \n");
// exit(1);
//}
//while (fscanf(fp, "%d\n", &portnumber) != EOF) {
//for (int i = 0; i < 15; i++)
for(i=0; i<15; i++){
//printf("Port number = %d\n", portnumber);
if (!initialized) {
data_handle = find_dissector("data");
helen_handle = create_dissector_handle(dissect_helen, proto_helen);
//This is to be used for hard coded ports (see static variable above)
//dissector_add("udp.port", global_helen_port, helen_handle);
//This line read the port number from the file.
dissector_add("udp.port", ports[i], helen_handle);
}
}
//fclose(fp);
}
void proto_reg_handoff_netalive(void) {
static gboolean isinitialized = FALSE;
//gboolean isnetalivefilehere = TRUE;
//int netaliveportnumber;
int i;
//FILE *fpnetalive;
//#if defined(_WIN32)
// fpnetalive = fopen("netaliveport.txt", "r");
//#else
// fpnetalive = fopen("netaliveport", "r");
//#endif
// if (fpnetalive == NULL) {
// printf("Can't open the netalive ports file! \n");
// printf("Make sure the file exists where the wireshark executable lives at \n");
// isnetalivefilehere = FALSE;
//exit(1);
// }
//if netalive ports file is there....then go into this loop.
//if it is not there then just continue on.
// if(isnetalivefilehere)
// {
// while (fscanf(fpnetalive, "%d\n", &netaliveportnumber) != EOF) {
for(i=0; i<1; i++)
{
// printf("Net Alive Port number = %d\n", netaliveportnumber);
if (!isinitialized) {
netalivedata_handle = find_dissector("data");
netalive_handle = create_dissector_handle(dissect_netalive, proto_netalive);
}
//This line read the port number from the file.
dissector_add("udp.port", global_netalive_port, netalive_handle);
//}
}
// fclose(fpnetalive);
}
//fclose(fpnetalive);
//isinitialized = TRUE;
//}
void proto_register_helen(void) {
/* A header field is something you can search/filter on.
*
* This creates a structure to register our fields. It consists of an
* array of hf_register_info structures, each of which are of the format
* {&(field id), {name, abbrev, type, display, strings, bitmask, blurb, HFILL}}.
*/
static hf_register_info hf[] = {
{ &hf_helen,
{ "Data", "helen.data", FT_NONE, BASE_NONE, NULL, 0x0,
"HELEN PDU", HFILL
}
},
{ &hf_helen_magic,
{ "Magic Number", "helen.header", FT_BYTES, BASE_HEX, NULL, 0x0,
"HELEN Header", HFILL
}
},
{ &hf_helen_checksum,
{ "Checksum", "helen.header", FT_UINT64, BASE_DEC, NULL, 0x0,
"HELEN Header", HFILL
}
},
{ &hf_helen_txTime,
{ "System Tx Time", "helen.header", FT_UINT64, BASE_DEC, NULL, 0x0,
"HELEN Header", HFILL
}
},
{ &hf_helen_length,
{ "Package Length2", "helen.len", FT_UINT32, BASE_DEC, NULL, 0x0,
"Package Length3", HFILL
}
},
{ &hf_helen_type,
{ "Type", "helen.type", FT_UINT8, BASE_DEC, VALS(packettypenames), 0x0,
"Package Type", HFILL
}
},
{ &hf_helen_text,
{ "Text", "helen.text", FT_STRING, BASE_NONE, NULL, 0x0,
"Text", HFILL
}
},
{ &hf_helen_Flowname,
{ "Flowname", "helen.flowname", FT_STRING, BASE_NONE, NULL, 0x0,
"HELEN Header", HFILL
}
}
};
static gint * ett[] = {
&ett_helen,
&ett_helen_header,
&ett_helen_length,
&ett_helen_type,
&ett_helen_text,
&ett_helen_Flowname,
};
proto_helen = proto_register_protocol("HELEN", "HELEN", "helen");
proto_register_field_array(proto_helen, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("helen", dissect_helen, proto_helen); }
void proto_register_netalive(void) {
/* A header field is something you can search/filter on.
*
* This creates a structure to register our fields. It consists of an
* array of hf_register_info structures, each of which are of the format
* {&(field id), {name, abbrev, type, display, strings, bitmask, blurb, HFILL}}.
*/
static hf_register_info hf[] = {
{ &hf_netalive,
{ "Data", "netalive.data", FT_NONE, BASE_NONE, NULL, 0x0,
"NETALIVE PDU", HFILL
}
},
{ &hf_netalive_length,
{ "Net Alive Header", "netalive.len", FT_UINT16, BASE_DEC, NULL, 0x0,
"Package Length3", HFILL
}
},
{ &hf_netalive_type,
{ "Type", "helen.type", FT_UINT8, BASE_DEC, VALS(packettypenames), 0x0,
"Package Type", HFILL
}
},
{ &hf_netalive_text,
{ "Text", "netalive.text", FT_STRING, BASE_NONE, NULL, 0x0,
"Text", HFILL
}
}
};
static gint * ett[] = {
&ett_netalive,
&ett_netalive_header,
&ett_netalive_length,
&ett_netalive_type,
&ett_netalive_text,
};
proto_netalive = proto_register_protocol("NETALIVE", "NETALIVE", "netalive");
proto_register_field_array(proto_netalive, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
register_dissector("netalive", dissect_netalive, proto_netalive);
}
static const value_string helen_vals[] = {
{1, "GPS"},
{2, "Flow Extension"},
{3, "Host"},
{1000, "Minotaur SA Extension"},
{1002, "Minotaur SA Status Extension"},
{1003, "Minotaur SA Redline Aspect Extension"},
{1013, "Leger Extension"},
{1024, "Alares Data Extension"},
{1025, "Alares Control Extension"},
{2000, "Channel Advertisement Packets"},
{2001, "Interest Packets"},
{2004, "Satcom Extension"},
{2013, "Wave Relay Extension"},
{2014, "Chat Extension"}
};
guint16 swap16(guint16 in) {
guint8 high = (in >> 8) & 0xff;
guint8 low = in & 0xff;
guint16 newVal = (low << 8) | high;
return newVal;
}
guint32 swap24(guint32 in) {
guint8 b2 = (in >> 16) & 0xff;
guint8 b3 = (in >> 8) & 0xff;
guint8 b4 = in & 0xff;
guint32 newVal = (b4 << 16) | (b3 << 8) | b2;
return newVal;
}
guint32 swap32(guint32 in) {
guint8 b1 = (in >> 24) & 0xff;
guint8 b2 = (in >> 16) & 0xff;
guint8 b3 = (in >> 8) & 0xff;
guint8 b4 = in & 0xff;
guint32 newVal = (b4 << 24) | (b3 << 16) | (b2 << 8) | b1;
return newVal;
}
//time converter method here
//int txTime()
//{
// time_t now;
// struct tm *ts;
// char buf[80];
// now = time(NULL);
// ts = localtime(&now);
// return strftime(buf, sizeof (buf), "%a %Y-%m-%d %H:%M:%S %Z", ts);
//return value;
//}
void dissect_netalive(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
proto_item *netalive_item = NULL;
proto_item *netalive_sub_item = NULL;
proto_tree *netalive_tree = NULL;
proto_tree *netalive_header_tree = NULL;
guint16 type = 0;
guint8 * startOfWFBitmask;
if (check_col(pinfo->cinfo, COL_PROTOCOL))
col_set_str(pinfo->cinfo, COL_PROTOCOL, PROTO_TAG_NETALIVE);
/* Clear out stuff in the info column */
if (check_col(pinfo->cinfo, COL_INFO)) {
col_clear(pinfo->cinfo, COL_INFO);
}
// This is not a good way of dissecting packets. The tvb length should
// be sanity checked so we aren't going past the actual size of the buffer.
type = tvb_get_guint8(tvb, 4); // Get the type byte
if (check_col(pinfo->cinfo, COL_INFO)) {
col_add_fstr(pinfo->cinfo, COL_INFO, "%d > %d Info Type:[%s]",
pinfo->srcport, pinfo->destport,
val_to_str(type, packettypenames, "Unknown Type:0x%02x"));
}
if (tree) { /* we are being asked for details */
guint32 offset = 0;
netalive_item = proto_tree_add_item(tree, proto_netalive, tvb, 0, -1, FALSE);
netalive_tree = proto_item_add_subtree(netalive_item, ett_netalive);
netalive_header_tree = proto_item_add_subtree(netalive_item, ett_netalive);
netalive_sub_item = proto_tree_add_item(netalive_tree, hf_netalive_length, tvb, offset, 2, FALSE);
netalive_header_tree = proto_item_add_subtree(netalive_sub_item, ett_netalive);
{
guint8 * ptr = (guint8*) tvb->real_data;
guint8 * packet_header = ptr;
char * packet_name = "Net Alive Extension";
proto_tree *netalive_sub_tree = NULL;
int swap = 1;
guint8 designator;
guint8 version;
guint8 updaterate;
guint8 nodeId;
char buf[100];
//glong timestamp;
//gfloat longitude;
//gfloat latitude;
guint32 longitude;
guint32 latitude;
//gfloat lat_n;
//gfloat altitude;
guint32 altitude;
guint8 altitudetype;
guint8 radiostatus;
guint8 networksize;
guint16 inbound;
guint16 outbound;
guint32 wfModeOffset;
guint32 wfModeNumBytes;
int numOneBitsInMask;
char * statusStr = "";
char * tempStr = "";
int codeOffset;
ptr = packet_header;
offset = (ptr - tvb->real_data);
codeOffset = offset;
strcpy(buf, " ");
strcat(buf, packet_name);
netalive_item = proto_tree_add_text(tree, tvb, codeOffset, 2, "%s", buf);
netalive_sub_tree = proto_item_add_subtree(netalive_item, ett_netalive);
// Hardcoding to ALWAYS SWAP as we don't know how to detect when to swap!
// if (swap) {
// code = swap16(code);
// }
//
// ptr += 1;
// offset += 1;
// numBytes = *((guint16*) ptr);
// if (swap) {
// numBytes = swap16(numBytes);
// }
//NetAlive
//NetAlive designator
designator = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 1, 0,
"Net Alive Designator : %d", designator);
offset += 1;
//NetAlive version
version = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 1, 0,
"Net Alive version : %d", version);
offset += 1;
//NetAlive update rate
updaterate = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 1, 0,
"Net Alive update rate : %d", updaterate);
offset += 1;
//Source node ID
nodeId = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 1, 0,
"Source Node ID : %d", nodeId);
offset += 1;
//Time Stamp....
//this is just getting system time....and not the time off the radio.
//However...the radios time should be the same at the system time
//time_t now;
//struct tm *ts;
//char buf[80];
// now = time(NULL);
ptr += 8;
// ts = localtime(&now);
// strftime(buf, sizeof (buf), "%a %Y-%m-%d %H:%M:%S %Z", ts);
// proto_tree_add_uint_format(netalive_sub_tree, hf_helen_length, tvb, offset, 8, 0,
// "%s", buf);
offset += 8;
//GPS Latitude
latitude = *((guint32*) ptr);
if (swap) {
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
latitude = *((guint32*) & temp);
//this needs to be tested
latitude = latitude/10000 - 180;
//don't think this is the right calculation
//latitude = (latitude+180) *10000;
}
ptr += 4;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 4, 0,
"Latitude: %d", latitude);
offset += 4;
//GPS Longitude
//longitude = *((gfloat*) ptr);
longitude = *((guint32*) ptr);
if (swap) {
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
//longitude = *((gfloat*) & temp);
longitude = *((guint32*) & temp);
//this needs to be tested
longitude = longitude/10000 - 180;
}
ptr += 4;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 4, 0,
"Longitude: %d", longitude);
//"Longitude: %f", longitude);
offset += 4;
//GPS Altitude:
//altitude = *((gfloat*) ptr);
altitude = *((guint32*) ptr);
if (swap) {
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
//altitude = *((gfloat*) & temp);
altitude = *((guint32*) & temp);
altitude = altitude/100;
}
ptr += 4;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 4, 0,
"Altitude: %d", altitude);
//"Altitude: %f", altitude);
offset += 4;
//GPS Altitude type
altitudetype = * ((guint8*) ptr);
if ( (altitudetype & 1) == 0) {
statusStr = "Sea Level in ";
} else {
statusStr = "High above ellipsoid (HAE) in ";
}
if ( (altitudetype & 2) == 0) {
tempStr = "meters";
} else {
tempStr = "feet";
}
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 1, 0,
"%s%s", statusStr, tempStr);
ptr += 1;
offset += 1;
//Radio status and alerts
radiostatus = * ((guint8*) ptr);
buf[0] = (char)0;
if ((radiostatus & 1) == 1) {
strcat(buf,"BIT Fail");
} else if ((radiostatus & 2) == 1) {
strcat(buf,"No GPS");
} else if ((radiostatus & 4) == 1) {
strcat(buf,"Login Alert");
} else if (radiostatus == 0) {
strcat(buf,"no read");
}
// We could rip out the ending comma (if it exists!) by trying the following:
//{
//char* p2; // Put this at the top!
//if (strlen(buf) > 0) {
// p2 = buf + strlen(buf) - 1;
// *p2 = (char)0;
//}
//}
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 1, 0,
"%s", buf);
ptr += 1;
offset += 1;
//Network size
networksize = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 1, 0,
"Network size : %d", networksize);
offset += 1;
//SPARE....so I am skipping this slot.
ptr += 1;
offset += 1;
//Inbound throughput
inbound = * ((guint16*) ptr);
if (swap) {
inbound = swap16(inbound);
}
ptr += 2;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 2, 0,
"Inbound throughput : %d", inbound);
offset += 2;
//Outbound throughput
outbound = * ((guint16*) ptr);
if (swap) {
outbound = swap16(outbound);
}
ptr += 2;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, 2, 0,
"Outbound throughput : %d", outbound);
offset += 2;
//Waveform Bitmask
startOfWFBitmask = ptr;
numOneBitsInMask = 0;
{
int i;
char buf2[10];
int numBytes = numBytesInBitmask(networksize);
buf[0] = (char)0;
for (i = 0; i < numBytes; i++) {
guint8 val = *((guint8*)ptr);
if (val & 1) numOneBitsInMask++;
if (val & 2) numOneBitsInMask++;
if (val & 4) numOneBitsInMask++;
if (val & 8) numOneBitsInMask++;
if (val & 16) numOneBitsInMask++;
if (val & 32) numOneBitsInMask++;
if (val & 64) numOneBitsInMask++;
if (val & 128) numOneBitsInMask++;
sprintf(buf2,"%x",val);
strcat(buf,buf2);
ptr++;
}
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, numBytes, 0,
"Waveform Bitmask : %s", buf);
offset += numBytes;
}
//Waveform Mode
{
int i;
char buf2[10];
int numBytes = numBytesInMode(numOneBitsInMask);
buf[0] = (char)0;
for (i = 0; i < numBytes; i++) {
guint8 val = *((guint8*)ptr);
// This would be nice:
// 17: BPSK 4
sprintf(buf2,"%x",val);
strcat(buf,buf2);
ptr++;
}
wfModeOffset = offset;
wfModeNumBytes = numBytes;
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, offset, numBytes, 0,
"Waveform Mode : %s", buf);
offset += numBytes;
}
{
guint8 *p2 = startOfWFBitmask;
unsigned char maskByte;
char * buf3;
//hard coding networkSize
// int networkSize = 26;
int bitmaskSize = (networksize -1)/8+1;
int i;
int counter = 0;
int *indexes = malloc(sizeof(int)*bitmaskSize);
//need to loop through size
for (i = 0; i < bitmaskSize; i++)
{
maskByte=*p2;
p2++;
if ((maskByte & 0x1) > 0)
{
indexes[counter++] = 1 + 8*i;
//printf("Read in maskByte of 0x%x\n",maskByte);
}
if ((maskByte & 0x2) > 0)
{
indexes[counter++] = 2 + 8*i;
//printf("Read in maskByte of 0x%x\n",maskByte);
}
if ((maskByte & 0x4) > 0)
{
indexes[counter++] = 3 + 8*i;
//printf("Read in maskByte of 0x%x\n",maskByte);
}
if ((maskByte & 0x8) > 0)
{
indexes[counter++] = 4 + 8*i;
//printf("Read in maskByte of 0x%x\n",maskByte);
}
if ((maskByte & 0x10) > 0)
{
indexes[counter++] = 5 + 8*i;
//printf("Read in maskByte of 0x%x\n",maskByte);
}
if ((maskByte & 0x20) > 0)
{
indexes[counter++] = 6 + 8*i;
//printf("Read in maskByte of 0x%x\n",maskByte);
}
if ((maskByte & 0x40) > 0)
{
indexes[counter++] = 7 + 8*i;
//printf("Read in maskByte of 0x%x\n",maskByte);
}
if ((maskByte & 0x80) > 0)
{
indexes[counter++] = 8 + 8*i;
//printf("Read in maskByte of 0x%x\n",maskByte);
}
}
//printf("We have %d nodes, and here they are:\n", counter);
//for (i = 0; i < counter; i++){
// printf("\t%d\n", indexes[i]);
//}
#define MAX_WFMode_LEN 30
buf3 = malloc(counter * (MAX_WFMode_LEN));
*(buf3) = (char)0;
if (counter > 0) {
int j;
char buf4[30];
int bytesToRead = (counter -1) / 2+1;
for (j = 0; j < bytesToRead; j++ ) {
//printf("counter = %d, and j = %d, bytesToRead = %d\n", counter, j, bytesToRead);
if (counter > j*2 + 1) //read whole byte counter
{
int lowerByte = *p2 & 0x0F;
int upperByte = (*p2 & 0xF0) >> 4;
sprintf(buf4,"Node #%d: %s\n", indexes[j*2], translateWFMode(lowerByte));
strcat(buf3,buf4);
sprintf(buf4,"Node #%d: %s\n", indexes[j*2+1], translateWFMode(upperByte));
strcat(buf3,buf4);
}
else //read only first 4 bits
{
int lowerByte = *p2 & 0x0F;
sprintf(buf4,"Node #%d: %s\n", indexes[j*2], translateWFMode(lowerByte));
strcat(buf3,buf4);
}
p2++;
}
}
proto_tree_add_uint_format(netalive_sub_tree, hf_netalive_length, tvb, wfModeOffset, wfModeNumBytes, 0,
"Additional Information:\n%s", buf3);
free(buf3);
free(indexes);
}
}
}
}
char * translateWFMode(int val) {
if (val == 0) return "(0) BPSK 1(1/2)";
if (val == 1) return "(1) BPSK 1(3/4)";
if (val == 2) return "(2) BPSK 2";
if (val == 3) return "(3) BPSK 4";
if (val == 4) return "(4) QPSK 4";
if (val == 5) return "(5) QPSK 6";
if (val == 15) return "None";
return "Unknown Waveform Mode";
}
int numBytesInBitmask(int numBits){
int q = numBits / 8;
int extraBits = numBits % 8;
if (extraBits > 0) {
q++;
}
return q;
}
int numBytesInMode(int numBits){
int q = numBits / 2;
int extraBits = numBits % 2;
if (extraBits > 0) {
q++;
}
return q;
}
void dissect_helen(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
proto_item *helen_item = NULL;
proto_item *helen_sub_item = NULL;
proto_tree *helen_tree = NULL;
proto_tree *helen_header_tree = NULL;
guint16 type = 0;
if (check_col(pinfo->cinfo, COL_PROTOCOL))
col_set_str(pinfo->cinfo, COL_PROTOCOL, PROTO_TAG_HELEN);
/* Clear out stuff in the info column */
if (check_col(pinfo->cinfo, COL_INFO)) {
col_clear(pinfo->cinfo, COL_INFO);
}
// This is not a good way of dissecting packets. The tvb length should
// be sanity checked so we aren't going past the actual size of the buffer.
type = tvb_get_guint8(tvb, 4); // Get the type byte
if (check_col(pinfo->cinfo, COL_INFO)) {
col_add_fstr(pinfo->cinfo, COL_INFO, "%d > %d Info Type:[%s]",
pinfo->srcport, pinfo->destport,
val_to_str(type, packettypenames, "Unknown Type:0x%02x"));
}
if (tree) { /* we are being asked for details */
guint32 offset = 0;
helen_item = proto_tree_add_item(tree, proto_helen, tvb, 0, -1, FALSE);
helen_tree = proto_item_add_subtree(helen_item, ett_helen);
helen_header_tree = proto_item_add_subtree(helen_item, ett_helen);
//helen_sub_item = proto_tree_add_item(helen_tree, hf_helen_header, tvb, offset, -1, FALSE);
helen_sub_item = proto_tree_add_item(helen_tree, hf_helen_magic, tvb, 0, 2, FALSE);
helen_sub_item = proto_tree_add_item(helen_tree, hf_helen_checksum, tvb, 2, 8, FALSE);
//helen_sub_item = proto_tree_add_item(helen_tree, hf_helen_txTime, tvb, 10, 8, FALSE);
//need to format the time..!!
helen_sub_item = proto_tree_add_item(helen_tree, hf_helen_txTime, tvb, 10, 8, FALSE);
helen_header_tree = proto_item_add_subtree(helen_sub_item, ett_helen);
{
guint8 * ptr = (guint8*) tvb->real_data;
guint8 * packet_header = ptr;
guint16 bead;
//might need this in the netalive code..??
char buf[1000];
char * packet_name = "";
proto_tree *helen_sub_tree = NULL;
int swap = 0;
bead = *((guint16*) packet_header);
if (bead != 0xBEAD) {
swap = 1;
}
offset += 18;
ptr += 18; /* Skip the header.*/
packet_header = ptr;
for (;;) {
guint16 code = *((guint16*) packet_header);
guint16 numBytes = 0;
int unknownPacket = 0;
int codeOffset;
ptr = packet_header;
// Must re-set the offset because of Flow control messages that specify only 12 bytes, but actually contain 16:
offset = (ptr - tvb->real_data);
codeOffset = offset;
if (swap) {
code = swap16(code);
}
ptr += 2;
offset += 2;
numBytes = *((guint16*) ptr);
if (swap) {
numBytes = swap16(numBytes);
}
ptr += 2;
offset += 2;
switch (code) {
case 0: packet_name = "End of Packet";
break;
case 1: packet_name = "GPS Extension";
break;
case 2: packet_name = "Flow Extension";
break;
case 3: packet_name = "Host Extension";
break;
case 1000: packet_name = "Minotaur SA";
break;
case 1002: packet_name = "Minotaur SA Status Ext";
break;
case 1003: packet_name = "Minotaur SA Redline Aspect Ext";
break;
case 1013: packet_name = "Leger Ext";
break;
case 1024: packet_name = "Alares Data Ext";
break;
case 1025: packet_name = "Alares Control Ext";
break;
case 2000: packet_name = "Channel Advertisement Packets";
break;
case 2001: packet_name = "Interest Packets";
break;
case 2004: packet_name = "Satcom Extension";
break;
case 2013: packet_name = "Wave Relay Ext";
break;
case 2014: packet_name = "Chat Ext";
break;
default: packet_name = "Unknown code";
unknownPacket = 1;
break;
}
//strcpy(buf, "Packet Code ");
strcpy(buf, " ");
strcat(buf, packet_name);
if (unknownPacket) {
sprintf(buf, "Unknown packet: %d", code);
}
//might need this in the net alive code..??
helen_item = proto_tree_add_text(tree, tvb, codeOffset, 2, "%s", buf);
helen_sub_tree = proto_item_add_subtree(helen_item, ett_helen);
if (code == 0) {
break;
}
// GPS:
if (code == 1) {
guint8 fieldsAvail;
fieldsAvail = *((guint8*) ptr);
ptr += 1;
offset += 1;
//printf("%s \n", "This is the GPS Extension");
// Status:
if ((fieldsAvail & 1) != 0) {
guint8 status;
char * statusStr = "";
status = *((guint8*) ptr);
if (status == 0) {
statusStr = "Good";
} else if (status == 1) {
statusStr = "No Fix";
} else if (status == 2) {
statusStr = "Bad GPS Read";
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"%s", statusStr);
ptr += 1;
offset += 1;
}
// Time: ...This is the first attempt at time
//if ( (fieldsAvail & 2) != 0) {
//guint32 halfTime1, halfTime2;
//halfTime1 = *((guint32*)ptr);
//ptr += 4;
//halfTime2 = *((guint32*)ptr);
//ptr += 4;
//scanf("%X",halfTime1);
//printf("%f",halfTime1);
//proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
// "Time: %X %X", halfTime1, halfTime2);
//offset += 8;
//}
// Time:
//this is just getting system time....and not the time of the GPS.
//However...the GPS time should be the same at the system time
if ((fieldsAvail & 2) != 0) {
time_t now;
struct tm *ts;
char buf[80];
now = time(NULL);
ptr += 8;
ts = localtime(&now);
strftime(buf, sizeof (buf), "%a %Y-%m-%d %H:%M:%S %Z", ts);
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
"%s", buf);
offset += 8;
}
// Longitude:
if ((fieldsAvail & 4) != 0) {
gfloat longitude;
longitude = *((gfloat*) ptr);
if (swap) {
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
longitude = *((gfloat*) & temp);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Longitude: %f", longitude);
offset += 4;
}
// Latitude:
if ((fieldsAvail & 8) != 0) {
gfloat latitude;
latitude = *((gfloat*) ptr);
if (swap) {
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
latitude = *((gfloat*) & temp);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Latitude: %f", latitude);
offset += 4;
}
// Altitude:
if ((fieldsAvail & 16) != 0) {
gfloat altitude;
altitude = *((gfloat*) ptr);
if (swap) {
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
altitude = *((gfloat*) & temp);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Altitude: %f", altitude);
offset += 4;
}
// Bearing:
if ((fieldsAvail & 32) != 0) {
gfloat bearing;
bearing = *((gfloat*) ptr);
if (swap) {
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
bearing = *((gfloat*) & temp);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Bearing: %f", bearing);
offset += 4;
}
// Speed:
if ((fieldsAvail & 64) != 0) {
gfloat speed;
speed = *((gfloat*) ptr);
if (swap) {
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
speed = *((gfloat*) & temp);
}
ptr += 4;
//If speed is NOT available or less than or equal to zero...then do not display it.
if (speed != 0.0) {
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Speed: %f", speed);
}
offset += 4;
}
// Number of Satellites:
if ((fieldsAvail & 128) != 0) {
guint8 nos;
nos = *((guint8*) ptr);
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Number of Satellites: %d", nos);
ptr += 1;
offset += 1;
}
}
// FLOW:
if (code == 2) {
char flowname[9];
guint32 seq;
guint32 src;
//printf("This is the Flow Extension\n");
strncpy(flowname, ptr, 8);
flowname[8] = '\0';
ptr += 8;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
"Flowname: %s", flowname);
offset += 8;
// Sequence number:
seq = *((guint32*) ptr);
if (swap) {
seq = swap32(seq);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Sequence #: %d", seq);
offset += 4;
if (numBytes == 16) {
// Source:
src = *((guint32*) ptr);
if (swap) {
src = swap32(src);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Source : %d", src);
offset += 4;
}
}
// HOST:
if (code == 3) {
guint8 size;
//printf("%s \n", "This is the Host Extension");
// Size:
size = *((guint8*) ptr);
ptr += 1;
offset += 1;
if (size == 4) {
guint32 addr;
addr = *((guint32*) ptr);
if (swap) {
addr = swap32(addr);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Address: %d.%d.%d.%d", addr >> 24, (addr >> 16) & 0xff, (addr >> 8) & 0xff, addr & 0xff);
offset += 4;
}
//I was board so I added the IPv6 address translation here in this else statement....However..I cannot test it..but it should work.
else {
guint32 addr1, addr2, addr3, addr4;
addr1 = *((guint32*) ptr);
ptr += 4;
addr2 = *((guint32*) ptr);
ptr += 4;
addr3 = *((guint32*) ptr);
ptr += 4;
addr4 = *((guint32*) ptr);
ptr += 4;
if (swap) {
addr1 = swap32(addr1);
addr2 = swap32(addr2);
addr3 = swap32(addr3);
addr4 = swap32(addr4);
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 16, 0,
"Address: %d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d",
addr1 >> 24, (addr1 >> 16) & 0xff, (addr1 >> 8) & 0xff, addr1 & 0xff,
addr2 >> 24, (addr2 >> 16) & 0xff, (addr2 >> 8) & 0xff, addr2 & 0xff,
addr3 >> 24, (addr3 >> 16) & 0xff, (addr3 >> 8) & 0xff, addr3 & 0xff,
addr4 >> 24, (addr4 >> 16) & 0xff, (addr4 >> 8) & 0xff, addr4 & 0xff
);
offset += 16;
}
}
//Minotaur SA Ext:
if (code == 1000) {
guint32 id;
//printf("%s \n", "This is the Minotaur SA Ext");
id = *((guint32*) ptr);
if (swap) {
id = swap32(id);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Harmonice ID #: %d", id);
offset += 4;
}
//Minotaur SA Status Ext:
if (code == 1002) {
guint32 stuff;
//printf("%s \n", "This is the Minotaur SA Status Ext");
stuff = *((guint32*) ptr);
//if (swap){
// id = swap32(id);
//}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, numBytes, 0,
"Minotaur Status Ext:");
offset += numBytes;
}
//Minotaur SA Redline Aspect Ext:
//Need more info.. Need size and data types
if (code == 1003) {
guint32 stuff;
//printf("%s \n", "This is the Minotaur SA Redline Aspect Ext");
stuff = *((guint32*) ptr);
//if (swap){
// id = swap32(id);
//}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Minotaur SA Redline Aspect:");
offset += 4;
}
//Leger Ext:
//Need more info.. Need size and data types
if (code == 1013) {
guint32 stuff;
//printf("%s \n", "This is the Leger Ext");
stuff = *((guint32*) ptr);
//if (swap){
// id = swap32(id);
//}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Leger Ext:");
offset += 4;
}
//Alares Data Ext:
if (code == 1024) {
glong key;
guint32 id;
guint32 messageId;
guint32 totalBlks;
guint32 blockId;
glong theTime;
guint8 repairStatus;
char * repairStatusStr = "";
//time_t rightnow;
//struct tme *tss;
//char buff[80];
//rightnow = time(NULL);
//tss = localtime(&rightnow);
//printf("%s \n", "This is the Alares Data Ext");
//Alares Session Key
if (swap) {
// 64-bit swap, done as 2 32-bit swaps in the
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
*((guint32*) ptr) = temp;
temp = *((guint32*) (ptr + 4));
temp = swap32(temp);
*((guint32*) ptr + 4) = temp;
}
key = *((glong*) ptr);
ptr += 8;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
"Alares Session Key: %ld", key);
offset += 8;
//ID for Source
id = *((guint32*) ptr);
if (swap) {
id = swap32(id);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"ID for source #: %d", id);
offset += 4;
//Message ID
messageId = *((guint32*) ptr);
if (swap) {
messageId = swap32(messageId);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Message ID: %d", messageId);
offset += 4;
//Total Blocks
totalBlks = *((guint32*) ptr);
if (swap) {
totalBlks = swap32(totalBlks);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Total Blocks: %d", totalBlks);
offset += 4;
//Tx Time
if (swap) {
// 64-bit swap, done as 2 32-bit swaps in the
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
*((guint32*) ptr) = temp;
temp = *((guint32*) (ptr + 4));
temp = swap32(temp);
*((guint32*) ptr + 4) = temp;
}
theTime = *((glong*) ptr);
ptr += 8;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
"Tx Time: %ld", theTime);
offset += 8;
//Block ID
blockId = *((guint32*) ptr);
if (swap) {
blockId = swap32(blockId);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Block ID #: %d", blockId);
offset += 4;
//Is Repair
repairStatus = *((guint8*) ptr);
if (repairStatus == 0) {
repairStatusStr = "Not Repair";
} else if (repairStatus == 1) {
repairStatusStr = "Repair";
}
ptr += 1;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"%s", repairStatusStr);
offset += 1;
}
//Chat
if (code == 2014)
{
guint32 nodeid;
guint8 messagetype;
guint8 messagepriority;
char * statusStr = "";
guint16 sizeofroomname;
char roomname[50];
char message[1000];
guint16 sizeofmessagestring;
int i;
buf[0] = (char)0;
//printf("%s \n", "This is the CHAT Ext");
//Node ID
nodeid = *((guint32*) ptr);
if (swap) {
nodeid = swap32(nodeid);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Node ID: %d", nodeid);
offset += 4;
//Message Type
messagetype = * ((guint8*) ptr);
if (messagetype == 1) {
statusStr = "This is a Message";
} else if (messagetype == 2) {
statusStr = "This is a New Room";
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"%s", statusStr);
ptr += 1;
offset += 1;
//Message Payload
if (messagetype == 1) {
//Size of room name
sizeofroomname = * ((guint16*) ptr);
if (swap) {
sizeofroomname = swap16(sizeofroomname);
}
ptr += 2;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 2, 0,
"Size of Room Name : %d", sizeofroomname);
offset += 2;
//Room Name
for (i = 0; i < sizeofroomname; i++)
{
guint8 val = *((guint8*)ptr);
roomname[0] = val;
roomname[1] = (char)0;
strcat(buf,roomname);
ptr++;
}
//ptr ++;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, sizeofroomname, 0,
"Room Name : %s", buf);
offset += sizeofroomname;
//Size of message string
sizeofmessagestring = * ((guint16*) ptr);
if (swap) {
sizeofmessagestring = swap16(sizeofmessagestring);
}
ptr += 2;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 2, 0,
"Size of Message String : %d", sizeofmessagestring);
offset += 2;
//Message Text:
buf[0] = (char)0;
for (i = 0; i < sizeofmessagestring; i++)
{
guint8 val = *((guint8*)ptr);
message[0] = val;
message[1] = (char)0;
if (sizeofmessagestring < 1000) {
strcat(buf,message);
} else {
message[1000-1] = (char)0;
strcat(buf,message);
}
ptr++;
}
//ptr ++;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, sizeofmessagestring, 0,
"Message Text: %s", buf);
offset += sizeofmessagestring;
//Message Priority
messagepriority = * ((guint8*) ptr);
if (messagepriority == 0) {
statusStr = "Routine";
} else if (messagepriority == 2) {
statusStr = "Immediate";
} else if (messagepriority == 5) {
statusStr = "Priority";
} else if (messagepriority == 7) {
statusStr = "Flash";
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Message Priority: %s", statusStr);
ptr += 1;
offset += 1;
}
else if (messagetype ==2) {
//Size of room name
sizeofroomname = * ((guint16*) ptr);
if (swap) {
sizeofroomname = swap16(sizeofroomname);
}
ptr += 2;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 2, 0,
"Size of New Room Name : %d", sizeofroomname);
offset += 2;
//Room Name
for (i = 0; i < sizeofroomname; i++)
{
guint8 val = *((guint8*)ptr);
roomname[0] = val;
roomname[1] = (char)0;
strcat(buf,roomname);
ptr++;
}
//ptr ++;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, sizeofroomname, 0,
"Room Name : %s", buf);
offset += sizeofroomname;
}
}
//Channel Advertisement Packets
if (code == 2000) {
guint32 serverId;
guint8 numofchannels;
int i;
int j;
int k;
int l;
int m;
//Server ID
serverId = * ((guint32*) ptr);
if (swap) {
serverId = swap32(serverId);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Server ID : %d", serverId);
offset += 4;
//Number of channels
numofchannels = * ((guint8*) ptr);
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Number of channels: %d", numofchannels);
ptr += 1;
offset += 1;
//Channel Description
for (i = 0; i < numofchannels; i++)
{
guint16 uuidmostsign1;
guint16 uuidmostsign2;
//guint16 uuidmostsign3;
//guint16 uuidmostsign4;
//guint16 uuidmostsign5;
//guint32 uuidmostsign6;
guint16 uuidlesssign1;
guint16 uuidlesssign2;
//guint16 uuidlesssign3;
//guint16 uuidlesssign4;
//guint16 uuidlesssign5;
//guint32 uuidlesssign6;
guint8 errorprotectiontype;
char * errorprotectiontypeStr = "";
guint8 namesize;
char name[25];
guint8 groupsize;
char multicastgroup[25];
guint32 port;
guint8 serverdatasize;
char serverdata[50];
guint8 numofusers;
guint32 userid;
//UUID Most Significant
uuidmostsign1 = *((guint16*) ptr);
ptr+= 4;
uuidmostsign2 = *((guint16*) ptr);
ptr+= 4;
//uuidmostsign3 = *((guint16*) ptr);
//ptr+= 2;
//uuidmostsign4 = *((guint16*) ptr);
//ptr+= 2;
//uuidmostsign5 = *((guint16*) ptr);
//ptr+= 2;
//uuidmostsign6 = *((guint32*) ptr);
//ptr+= 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
"UUID Most Significant: %04x-%04x",uuidmostsign1,uuidmostsign2);
offset += 8;
//UUID Less Significant
uuidlesssign1 = *((guint16*) ptr);
ptr+= 4;
uuidlesssign2 = *((guint16*) ptr);
ptr+= 4;
//uuidlesssign3 = *((guint16*) ptr);
//ptr+= 2;
//uuidlesssign4 = *((guint16*) ptr);
//ptr+= 2;
//uuidlesssign5 = *((guint16*) ptr);
//ptr+= 2;
//uuidlesssign6 = *((guint32*) ptr);
//ptr+= 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
"UUID Least Significant: %04x-%04x",uuidlesssign1,uuidlesssign2);
offset += 8;
//Error protection type
errorprotectiontype = *((guint8*) ptr);
if (errorprotectiontype == 0) {
errorprotectiontypeStr = "None";
} else if (errorprotectiontype == 1) {
errorprotectiontypeStr = "Norm";
} else if (errorprotectiontype == 2) {
errorprotectiontypeStr = "DFCore";
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Error Protection Type is: %s", errorprotectiontypeStr);
ptr += 1;
offset += 1;
//Name size
namesize = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Channel Name size : %d", namesize);
offset += 1;
//NAME
buf[0] = (char)0;
for (j = 0; j < namesize; j++)
{
guint8 val = *((guint8*)ptr);
name[0] = val;
name[1] = (char)0;
strcat(buf,name);
ptr++;
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, namesize, 0,
"Channel Advertisement Name : %s", buf);
offset += namesize;
//Group size
groupsize = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Multicast Group size : %d", groupsize);
offset += 1;
//Multicast Group
buf[0] = (char)0;
for (k = 0; k < groupsize; k++)
{
guint8 val = *((guint8*)ptr);
multicastgroup[0] = val;
multicastgroup[1] = (char)0;
strcat(buf,multicastgroup);
ptr++;
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, groupsize, 0,
"Channel Advertisement Multicast Group : %s", buf);
offset += groupsize;
//Port
port = * ((guint32*) ptr);
if (swap) {
port = swap32(port);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Channel Advertisement Port : %d", port);
offset += 4;
//Server data size
serverdatasize = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Server Data Size : %d", serverdatasize);
offset += 1;
//Server Data
buf[0] = (char)0;
for (l = 0; l < serverdatasize; l++)
{
guint8 val = *((guint8*)ptr);
serverdata[0] = val;
serverdata[1] = (char)0;
strcat(buf,serverdata);
ptr++;
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, serverdatasize, 0,
"Server Data : %s", buf);
offset += serverdatasize;
//Number of Users
numofusers = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Number of Users : %d", numofusers);
offset += 1;
for (m = 0; m < numofusers; m++)
{
//User ID
userid = * ((guint32*) ptr);
if (swap) {
userid = swap32(userid);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"ID(s) of User subscribed: %d", userid);
offset += 4;
}
}
}
//Interest Packets
if (code == 2001) {
guint32 clientid;
guint8 numofchanofinterest;
guint32 channelidofinterest;
guint8 numofchanofuninterest;
guint32 channelidofuninterest;
//Client ID
clientid = * ((guint32*) ptr);
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Client ID : %d", clientid);
offset += 4;
//Number of channels of interest
numofchanofinterest = * ((guint8*) ptr);
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Number of channels of interest: %d", numofchanofinterest);
ptr += 1;
offset += 1;
//Channel ID of Interest
channelidofinterest = * ((guint32*) ptr);
ptr += 16;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 16, 0,
"Channel ID of Interest: %d", channelidofinterest);
offset += 16;
//Number of channels of uninterest
numofchanofuninterest = * ((guint8*) ptr);
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Number of channels of uninterest: %d", numofchanofuninterest);
ptr += 1;
offset += 1;
//Channel ID of Uninterest
channelidofuninterest = * ((guint32*) ptr);
ptr += 16;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 16, 0,
"Channel ID of Uninterest: %d", channelidofuninterest);
offset += 16;
}
//Satcom Extension
if (code == 2004) {
guint8 status;
char * statusStr = "";
char * statusStr1 = "";
guint16 numberoflinks;
guint16 i;
//temp time variables.
time_t now;
struct tm *ts;
char buf[80];
now = time(NULL);
ts = localtime(&now);
strftime(buf, sizeof (buf), "%a %Y-%m-%d %H:%M:%S %Z", ts);
//status
status = * ((guint8*) ptr);
if (status == 0) {
statusStr = "Good Satcom link";
} else if (status == 1) {
statusStr = "Satcom link is Stale / Not Read";
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"%s", statusStr);
ptr += 1;
offset += 1;
//Time since satcom was last read
//this is just getting system time....and not the time of the last read from the packet.
//this needs to be fixed but am having problems with the formatting of the time from the packet
ptr += 8;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
"Time satcom was last read: %s", buf);
offset += 8;
//Number of links
numberoflinks = * ((guint16*) ptr);
if (swap) {
numberoflinks = swap16(numberoflinks);
}
ptr += 2;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 2, 0,
"Number of Links : %d", numberoflinks);
offset += 2;
//Harmonice ID that has satcom link
for (i = 0; i < numberoflinks; i++)
{
guint32 hassatcomlink;
hassatcomlink = * ((guint32*) ptr);
if (swap) {
hassatcomlink = swap32(hassatcomlink);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Harmonice ID that has satcom link: %d",hassatcomlink);
offset += 4;
}
}
//Wave Relay
if (code == 2013) {
guint8 status;
guint32 mac;
guint8 numofrec;
//guint32 nodeinfo;
guint32 macaddr;
guint32 snr;
char * statusStr = "";
int i;
//printf("%s \n", "This is the Wave Relay Ext");
//status
status = * ((guint8*) ptr);
if (status == 0) {
statusStr = "Status is Good";
} else if (status == 1) {
statusStr = "Status is Stale / Not Read";
}
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"%s", statusStr);
ptr += 1;
offset += 1;
//Reporting MAC
mac = * ((guint32*) (ptr - 1));
mac >>= 8;
if (swap) {
mac = swap24(mac);
}
ptr += 3;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 3, 0,
"Reporting Nodes MAC : %06x", mac);
offset += 3;
//Number of records
numofrec = * ((guint8*) ptr);
ptr += 1;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Number of Records : %d", numofrec);
offset += 1;
//OLSR Node Information
for (i = 0; i < numofrec; i++) {
//MAC address
macaddr = * ((guint32*) ptr);
//macaddr = macaddr & 0xffffff;
if (swap) {
macaddr = swap24(macaddr);
}
mac >>= 8;
ptr += 3;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 3, 0,
"MAC Address of Remote Node: %06x", macaddr);
offset += 3;
//SNR
snr = * ((guint32*) ptr);
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"SNR : %d", snr);
offset += 4;
}
}
//Alares Control Ext:
if (code == 1025) {
glong key;
guint32 id;
//guint32 healFac;
gdouble healFac;
guint8 noem;
guint8 noe;
guint32 src;
guint32 message;
guint32 start;
guint32 end;
int index1, index2;
//printf("%s \n", "This is the Alares Control Ext");
//Alares Session Key
if (swap) {
// 64-bit swap, done as 2 32-bit swaps in the
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
*((guint32*) ptr) = temp;
temp = *((guint32*) (ptr + 4));
temp = swap32(temp);
*((guint32*) ptr + 4) = temp;
}
key = *((glong*) ptr);
ptr += 8;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
"Alares Session Key: %ld", key);
offset += 8;
//Unique ID for Source
id = *((guint32*) ptr);
if (swap) {
id = swap32(id);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Unique ID for source: %d", id);
offset += 4;
//Healing Factor
if (swap) {
guint32 temp = *((guint32*) ptr);
temp = swap32(temp);
*((guint32*) ptr) = temp;
temp = *((guint32*) (ptr + 4));
temp = swap32(temp);
*((guint32*) ptr + 4) = temp;
}
healFac = *((gdouble*) ptr);
ptr += 8;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 8, 0,
"Healing Factor: %e", healFac);
offset += 8;
//Number of Erasures in Message
noem = *((guint8*) ptr);
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Number of Erasures in Message: %d", noem);
ptr += 1;
offset += 1;
for (index1 = 0; index1 < noem; index1++) {
//Missing Data
//Source
src = *((guint32*) ptr);
if (swap) {
src = swap32(src);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Source of Missing Data: %d", src);
offset += 4;
//Message
//guint32 stuff;
message = *((guint32*) ptr);
//printf("%s \n", "This is the Missing Data Message");
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, numBytes, 0,
"Missing Data Message:");
offset += numBytes;
//message = *((guint32*) ptr);
//if (swap) {
// message = swap32(message);
//}
//ptr += 4;
//proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
// "Missing Data Message: %d", message);
//offset += 4;
//offset += numBytes;
//Number of Erasures
noe = *((guint8*) ptr);
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 1, 0,
"Number of Erasures: %d", noe);
ptr += 1;
offset += 1;
for (index2 = 0; index2 < noe; index2++) {
//Erasures
//Starting Block
start = *((guint32*) ptr);
if (swap) {
start = swap32(start);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Starting Block: %d", start);
offset += 4;
//Ending Block
end = *((guint32*) ptr);
if (swap) {
end = swap32(end);
}
ptr += 4;
proto_tree_add_uint_format(helen_sub_tree, hf_helen_length, tvb, offset, 4, 0,
"Ending Block: %d", end);
offset += 4;
} // end of for j
} /* end of for i */
}
packet_header += numBytes + 4;
}
}
offset += 4;
offset += 1;
}
}
- Follow-Ups:
- Re: [Wireshark-dev] wireshark GUI vs tshark
- From: Jaap Keuter
- Re: [Wireshark-dev] wireshark GUI vs tshark
- References:
- [Wireshark-dev] wireshark GUI vs tshark
- From: Brian Oleksa
- Re: [Wireshark-dev] wireshark GUI vs tshark
- From: Maynard, Chris
- Re: [Wireshark-dev] wireshark GUI vs tshark
- From: Brian Oleksa
- Re: [Wireshark-dev] wireshark GUI vs tshark
- From: Jaap Keuter
- Re: [Wireshark-dev] wireshark GUI vs tshark
- From: Brian Oleksa
- Re: [Wireshark-dev] wireshark GUI vs tshark
- From: Maynard, Chris
- Re: [Wireshark-dev] wireshark GUI vs tshark
- From: Brian Oleksa
- Re: [Wireshark-dev] wireshark GUI vs tshark
- From: Jaap Keuter
- [Wireshark-dev] wireshark GUI vs tshark
- Prev by Date: Re: [Wireshark-dev] wireshark GUI vs tshark
- Next by Date: Re: [Wireshark-dev] wireshark GUI vs tshark
- Previous by thread: Re: [Wireshark-dev] wireshark GUI vs tshark
- Next by thread: Re: [Wireshark-dev] wireshark GUI vs tshark
- Index(es):