/*********************************************************************
*
* AUTHORIZATION TO USE AND DISTRIBUTE
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that:
*
* (1) source code distributions retain this paragraph in its entirety,
*
* (2) distributions including binary code include this paragraph in
* its entirety in the documentation or other materials provided
* with the distribution, and
*
* (3) all advertising materials mentioning features or use of this
* software display the following acknowledgment:
*
* "This product includes software written and developed
* by Brian Adamson and Joe Macker of the Naval Research
* Laboratory (NRL)."
*
* The name of NRL, the name(s) of NRL employee(s), or any entity
* of the United States Government may not be used to endorse or
* promote products derived from this software, nor does the
* inclusion of the NRL written and developed software directly or
* indirectly suggest NRL or United States Government endorsement
* of this product.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
********************************************************************/
#include "mgenMsg.h"
#include "mgen.h"
#include <string.h>
#include <time.h>
MgenMsg::MgenMsg()
: version(VERSION), flags(0), msg_len(0), packet_header_len(0),
gps_status(INVALID_GPS), payload_len(0), msg_error(ERROR_NONE)
{
}
// (TBD) we should add a "bufferLen" parameter to this?
unsigned int MgenMsg::Pack(char* buffer, bool includeChecksum)
{
register unsigned int len = 0;
// If these assertions fail, the code base needs some reworking
// for compiler with different size settings (or set compiler
// settings so these values work)
ASSERT(sizeof(char) == 1);
ASSERT(sizeof(short) == 2);
ASSERT(sizeof(long) == 4);
// msg_len
unsigned short temp16 = htons(msg_len);
memcpy(buffer+len, &temp16, sizeof(short));
len += sizeof(short);
// version
buffer[len++] = (char)version;
// flags
buffer[len++] = (char)flags;
// flow_id
unsigned long temp32 = htonl(flow_id);
memcpy(buffer+len, &temp32, sizeof(long));
len += sizeof(long);
// seq_num
temp32 = htonl(seq_num);
memcpy(buffer+len, &temp32, sizeof(long));
len += sizeof(long);
// tx_time(seconds)
temp32 = htonl(tx_time.tv_sec);
memcpy(buffer+len, &temp32, sizeof(long));
len += sizeof(long);
// tx_time(microseconds)
temp32 = htonl(tx_time.tv_usec);
memcpy(buffer+len, &temp32, sizeof(long));
len += sizeof(long);
// dst_port
temp16 = htons(dst_addr.GetPort());
memcpy(buffer+len, &temp16, sizeof(short));
len += sizeof(short);
// dst_addr fields
AddressType addrType;
switch (dst_addr.GetType())
{
case ProtoAddress::IPv4:
addrType = IPv4;
break;
case ProtoAddress::IPv6:
addrType = IPv6;
break;
#ifdef SIMULATE
case ProtoAddress::SIM:
addrType = SIM;
break;
#endif // SIMULATE
default:
DMSG(0, "MgenMsg::Pack() Error: unsupported address type\n");
return 0;
}
unsigned char addrLen = dst_addr.GetLength();
// dst_addr(type)
buffer[len++] = (char)addrType;
// dst_addr(len)
buffer[len++] = (char)addrLen;
// dst_addr(addr)
memcpy(buffer+len, dst_addr.GetRawHostAddress(), addrLen);
len += addrLen;
// The fields below are optional and only
// packed if the msg_len permits
unsigned short msgLen = msg_len;
// host_addr fields (not yet supported - TBD)
switch (host_addr.GetType())
{
case ProtoAddress::IPv4:
addrType = IPv4;
break;
case ProtoAddress::IPv6:
addrType = IPv6;
break;
#ifdef SIMULATE
case ProtoAddress::SIM:
addrType = SIM;
break;
#endif // SIMULATE
default:
addrType = INVALID_ADDRESS;
}
if (host_addr.IsValid())
addrLen = host_addr.GetLength();
else
addrLen = 0;
// Is there room for the host_port and host_addr?
if (msgLen >= (len + addrLen + 4))
{
// host_port
if (host_addr.IsValid())
temp16 = htons(host_addr.GetPort());
else
temp16 = 0;
memcpy(buffer+len, &temp16, sizeof(short));
len += sizeof(short);
// host_addr(type)
buffer[len++] = (char)addrType;
// host_addr(len)
buffer[len++] = (char)addrLen;
// host_addr(addr)
if (addrLen)
memcpy(buffer+len, host_addr.GetRawHostAddress(), addrLen);
len += addrLen;
}
else
{
if (msgLen < len)
{
DMSG(0, "MgenMsg::Pack() Error: minimum MGEN message size not met\n");
return 0;
}
memset(buffer+len, 0, msgLen-len);
packet_header_len = len;
return msgLen;
}
// GPS position information
// Is there room for the GPS info?
if (msgLen >= (len + 13))
{
// latitude
temp32 = htonl((unsigned long)((latitude + 180.0)*60000.0));
memcpy(buffer+len, &temp32, sizeof(long));
len += sizeof(long);
// longitude
temp32 = htonl((unsigned long)((longitude + 180.0)*60000.0));
memcpy(buffer+len, &temp32, sizeof(long));
len += sizeof(long);
// altitude
temp32 = htonl(altitude);
memcpy(buffer+len, &temp32, sizeof(long));
len += sizeof(long);
// status
buffer[len++] = (char) gps_status;
}
else
{
memset(buffer+len, 0, msgLen-len);
packet_header_len = len;
return msgLen;
}
// "reserved" field
buffer[len++] = 0;
packet_header_len = len;
// Optional user-defined payload
if (msgLen >= (len + sizeof(short) + payload_len))
{
// payload_len
temp16 = htons(payload_len);
memcpy(buffer+len, &temp16, sizeof(short));
len += sizeof(short);
// payload
memcpy(buffer+len, payload, payload_len);
len += payload_len;
}
else
{
// payload_len (payload didn't fit)
memset(buffer+len, 0, msgLen - len);
return msgLen;
}
if (includeChecksum)
{
if (msgLen > (len + 4))
{
buffer[FLAGS_OFFSET] |= CHECKSUM; // set "CHECKSUM" flag
UINT32 checksumPosition = msgLen - 4;
// Compute checksum (not incl. checksum itself)
UINT32 checksum = ComputeCRC32((unsigned char*)buffer, msgLen-4);
checksum = htonl(checksum); // convert to network byte order
memcpy(buffer+checksumPosition, &checksum, 4);
}
else
{
DMSG(0, "MgenMsg::Pack() no room for checksum\n");
}
}
return msgLen;
} // end MgenMsg::Pack()
bool MgenMsg::Unpack(const char* buffer, UINT16 bufferLen, bool forceChecksum)
{
// init optional fields
host_addr.Invalidate();
gps_status = INVALID_GPS;
reserved = 0;
payload_len = 0;
payload = NULL;
register unsigned int len = 0;
if (bufferLen < MIN_SIZE)
{
DMSG(0, "MgenMsg::Unpack() error: short message\n");
msg_error = ERROR_LENGTH;
return false;
}
// Unpack "user specified" msg_len
unsigned short temp16;
memcpy(&temp16, buffer+len, sizeof(short));
msg_len = ntohs(temp16);
len += sizeof(short);
// version
version = (unsigned char)buffer[len++];
// flags
flags = (unsigned char)buffer[len++];
// Use checksum if forced or available
if (forceChecksum || (0 != (flags & CHECKSUM)))
{
UINT32 checksumPosition = bufferLen - 4;
UINT32 recvdChecksum;
memcpy(&recvdChecksum, buffer+checksumPosition, 4);
recvdChecksum = ntohl(recvdChecksum);
// Compute checksum (not incl. checksum itself)
UINT32 calculatedChecksum = ComputeCRC32((unsigned char*)buffer, bufferLen-4);
if (calculatedChecksum != recvdChecksum)
{
DMSG(0, "MgenMsg::Unpack() error: checksum failure\n");
msg_error = ERROR_CHECKSUM;
return false;
}
}
if (version != VERSION)
{
DMSG(0, "MgenMsg::Unpack() error: bad protocol version\n");
msg_error = ERROR_VERSION;
return false;
}
// flow_id
unsigned long temp32;
memcpy(&temp32, buffer+len, sizeof(long));
flow_id = ntohl(temp32);
len += sizeof(long);
// seq_num
memcpy(&temp32, buffer+len, sizeof(long));
seq_num = ntohl(temp32);
len += sizeof(long);
// tx_sec(seconds)
memcpy(&temp32, buffer+len, sizeof(long));
tx_time.tv_sec = ntohl(temp32);
len += sizeof(long);
// tx_usec(microseconds)
memcpy(&temp32, buffer+len, sizeof(long));
tx_time.tv_usec = ntohl(temp32);
len += sizeof(long);
// dst_port
memcpy(&temp16, buffer+len, sizeof(short));
unsigned short dstPort = ntohs(temp16);
len += sizeof(short);
// dst_addr(type)
ProtoAddress::Type addrType;
switch (buffer[len++])
{
case IPv4:
addrType = ProtoAddress::IPv4;
break;
case IPv6:
addrType = ProtoAddress::IPv6;
break;
#ifdef SIMULATE
case SIM:
addrType = ProtoAddress::SIM;
break;
#endif // SIMULATE
default:
DMSG(0, "MgenMsg::Unpack() unsupported address type\n");
msg_error = ERROR_DSTADDR;
return false;
}
// dst_addr(len)
unsigned int addrLen = (unsigned char)buffer[len++];
// dst_addr(addr)
dst_addr.SetRawHostAddress(addrType, buffer+len, addrLen);
dst_addr.SetPort(dstPort);
len += addrLen;
// host_addr fields
if ((len+4) <= bufferLen)
{
// host_port
memcpy(&temp16, buffer+len, sizeof(short));
unsigned short hostPort = ntohs(temp16);
len += sizeof(short);
// host_addr(type)
switch (buffer[len++])
{
case IPv4:
addrType = ProtoAddress::IPv4;
break;
case IPv6:
addrType = ProtoAddress::IPv6;
break;
default:
addrType = ProtoAddress::INVALID;
//DMSG(0, "MgenMsg::Unpack() unsupported host_addr type\n");
//return false;
break;
}
// host_addr(len)
addrLen = (unsigned char)buffer[len++];
// host_addr(addr)
if ((len+addrLen) <= bufferLen)
{
if (ProtoAddress::INVALID != addrType)
{
host_addr.SetRawHostAddress(addrType, buffer+len, addrLen);
host_addr.SetPort(hostPort);
}
len += addrLen;
}
else
{
// Not enough room
packet_header_len = len;
return true;
}
}
else
{
// Not enough room
packet_header_len = len;
return true;
}
// GPS position information
if ((len+13) <= bufferLen)
{
// latitude
memcpy(&temp32, buffer+len, sizeof(long));
latitude = ((double)ntohl(temp32))/60000.0 - 180.0;
len += sizeof(long);
// longitude
memcpy(&temp32, buffer+len, sizeof(long));
longitude = ((double)ntohl(temp32))/60000.0 - 180.0;
len += sizeof(long);
// altitude
memcpy(&temp32, buffer+len, sizeof(long));
altitude = ntohl(temp32);
len += sizeof(long);
// status
gps_status = (GPSStatus)buffer[len++];
}
else
{
packet_header_len = len;
return true;
}
// "reserved" field
if (len < bufferLen)
{
reserved = buffer[len++];
}
else
{
packet_header_len = len;
return true;
}
// payload_len
if ((len+sizeof(short)) <= bufferLen)
{
memcpy(&temp16, buffer+len, sizeof(short));
payload_len = ntohs(temp16);
len += sizeof(short);
if (0 != payload_len) payload = buffer + len;
// Was the payload truncated?
if (payload_len > (bufferLen - len))
{
payload_len = bufferLen - len;
len = bufferLen;
}
else
{
len += payload_len;
}
}
else
{
packet_header_len = len;
return true;
}
packet_header_len = len;
return true;
} // end MgenMsg::Unpack()
UINT32 MgenMsg::ComputeCRC32(const unsigned char* buffer,
UINT32 bufferLength)
{
UINT32 result = CRC32_XINIT;
for (UINT32 i = 0; i < bufferLength; i++)
result = CRC32_TABLE[(result ^ *buffer++) & 0xFFL] ^ (result >> 8);
// return XOR out value
return (result ^ CRC32_XOROT);
} // end MgenMsg::ComputeCRC()
const UINT32 MgenMsg::CRC32_XINIT = 0xFFFFFFFFL; // initial value
const UINT32 MgenMsg::CRC32_XOROT = 0xFFFFFFFFL; // final xor value
/*****************************************************************/
/* */
/* CRC LOOKUP TABLE */
/* ================ */
/* The following CRC lookup table was generated automagically */
/* by the Rocksoft^tm Model CRC Algorithm Table Generation */
/* Program V1.0 using the following model parameters: */
/* */
/* Width : 4 bytes. */
/* Poly : 0x04C11DB7L */
/* Reverse : TRUE. */
/* */
/* For more information on the Rocksoft^tm Model CRC Algorithm, */
/* see the document titled "A Painless Guide to CRC Error */
/* Detection Algorithms" by Ross Williams */
/* (ross@guest.adelaide.edu.au.). This document is likely to be */
/* in the FTP archive "ftp.adelaide.edu.au/pub/rocksoft". */
/* */
/*****************************************************************/
const UINT32 MgenMsg::CRC32_TABLE[256] =
{
0x00000000L, 0x77073096L, 0xEE0E612CL, 0x990951BAL,
0x076DC419L, 0x706AF48FL, 0xE963A535L, 0x9E6495A3L,
0x0EDB8832L, 0x79DCB8A4L, 0xE0D5E91EL, 0x97D2D988L,
0x09B64C2BL, 0x7EB17CBDL, 0xE7B82D07L, 0x90BF1D91L,
0x1DB71064L, 0x6AB020F2L, 0xF3B97148L, 0x84BE41DEL,
0x1ADAD47DL, 0x6DDDE4EBL, 0xF4D4B551L, 0x83D385C7L,
0x136C9856L, 0x646BA8C0L, 0xFD62F97AL, 0x8A65C9ECL,
0x14015C4FL, 0x63066CD9L, 0xFA0F3D63L, 0x8D080DF5L,
0x3B6E20C8L, 0x4C69105EL, 0xD56041E4L, 0xA2677172L,
0x3C03E4D1L, 0x4B04D447L, 0xD20D85FDL, 0xA50AB56BL,
0x35B5A8FAL, 0x42B2986CL, 0xDBBBC9D6L, 0xACBCF940L,
0x32D86CE3L, 0x45DF5C75L, 0xDCD60DCFL, 0xABD13D59L,
0x26D930ACL, 0x51DE003AL, 0xC8D75180L, 0xBFD06116L,
0x21B4F4B5L, 0x56B3C423L, 0xCFBA9599L, 0xB8BDA50FL,
0x2802B89EL, 0x5F058808L, 0xC60CD9B2L, 0xB10BE924L,
0x2F6F7C87L, 0x58684C11L, 0xC1611DABL, 0xB6662D3DL,
0x76DC4190L, 0x01DB7106L, 0x98D220BCL, 0xEFD5102AL,
0x71B18589L, 0x06B6B51FL, 0x9FBFE4A5L, 0xE8B8D433L,
0x7807C9A2L, 0x0F00F934L, 0x9609A88EL, 0xE10E9818L,
0x7F6A0DBBL, 0x086D3D2DL, 0x91646C97L, 0xE6635C01L,
0x6B6B51F4L, 0x1C6C6162L, 0x856530D8L, 0xF262004EL,
0x6C0695EDL, 0x1B01A57BL, 0x8208F4C1L, 0xF50FC457L,
0x65B0D9C6L, 0x12B7E950L, 0x8BBEB8EAL, 0xFCB9887CL,
0x62DD1DDFL, 0x15DA2D49L, 0x8CD37CF3L, 0xFBD44C65L,
0x4DB26158L, 0x3AB551CEL, 0xA3BC0074L, 0xD4BB30E2L,
0x4ADFA541L, 0x3DD895D7L, 0xA4D1C46DL, 0xD3D6F4FBL,
0x4369E96AL, 0x346ED9FCL, 0xAD678846L, 0xDA60B8D0L,
0x44042D73L, 0x33031DE5L, 0xAA0A4C5FL, 0xDD0D7CC9L,
0x5005713CL, 0x270241AAL, 0xBE0B1010L, 0xC90C2086L,
0x5768B525L, 0x206F85B3L, 0xB966D409L, 0xCE61E49FL,
0x5EDEF90EL, 0x29D9C998L, 0xB0D09822L, 0xC7D7A8B4L,
0x59B33D17L, 0x2EB40D81L, 0xB7BD5C3BL, 0xC0BA6CADL,
0xEDB88320L, 0x9ABFB3B6L, 0x03B6E20CL, 0x74B1D29AL,
0xEAD54739L, 0x9DD277AFL, 0x04DB2615L, 0x73DC1683L,
0xE3630B12L, 0x94643B84L, 0x0D6D6A3EL, 0x7A6A5AA8L,
0xE40ECF0BL, 0x9309FF9DL, 0x0A00AE27L, 0x7D079EB1L,
0xF00F9344L, 0x8708A3D2L, 0x1E01F268L, 0x6906C2FEL,
0xF762575DL, 0x806567CBL, 0x196C3671L, 0x6E6B06E7L,
0xFED41B76L, 0x89D32BE0L, 0x10DA7A5AL, 0x67DD4ACCL,
0xF9B9DF6FL, 0x8EBEEFF9L, 0x17B7BE43L, 0x60B08ED5L,
0xD6D6A3E8L, 0xA1D1937EL, 0x38D8C2C4L, 0x4FDFF252L,
0xD1BB67F1L, 0xA6BC5767L, 0x3FB506DDL, 0x48B2364BL,
0xD80D2BDAL, 0xAF0A1B4CL, 0x36034AF6L, 0x41047A60L,
0xDF60EFC3L, 0xA867DF55L, 0x316E8EEFL, 0x4669BE79L,
0xCB61B38CL, 0xBC66831AL, 0x256FD2A0L, 0x5268E236L,
0xCC0C7795L, 0xBB0B4703L, 0x220216B9L, 0x5505262FL,
0xC5BA3BBEL, 0xB2BD0B28L, 0x2BB45A92L, 0x5CB36A04L,
0xC2D7FFA7L, 0xB5D0CF31L, 0x2CD99E8BL, 0x5BDEAE1DL,
0x9B64C2B0L, 0xEC63F226L, 0x756AA39CL, 0x026D930AL,
0x9C0906A9L, 0xEB0E363FL, 0x72076785L, 0x05005713L,
0x95BF4A82L, 0xE2B87A14L, 0x7BB12BAEL, 0x0CB61B38L,
0x92D28E9BL, 0xE5D5BE0DL, 0x7CDCEFB7L, 0x0BDBDF21L,
0x86D3D2D4L, 0xF1D4E242L, 0x68DDB3F8L, 0x1FDA836EL,
0x81BE16CDL, 0xF6B9265BL, 0x6FB077E1L, 0x18B74777L,
0x88085AE6L, 0xFF0F6A70L, 0x66063BCAL, 0x11010B5CL,
0x8F659EFFL, 0xF862AE69L, 0x616BFFD3L, 0x166CCF45L,
0xA00AE278L, 0xD70DD2EEL, 0x4E048354L, 0x3903B3C2L,
0xA7672661L, 0xD06016F7L, 0x4969474DL, 0x3E6E77DBL,
0xAED16A4AL, 0xD9D65ADCL, 0x40DF0B66L, 0x37D83BF0L,
0xA9BCAE53L, 0xDEBB9EC5L, 0x47B2CF7FL, 0x30B5FFE9L,
0xBDBDF21CL, 0xCABAC28AL, 0x53B39330L, 0x24B4A3A6L,
0xBAD03605L, 0xCDD70693L, 0x54DE5729L, 0x23D967BFL,
0xB3667A2EL, 0xC4614AB8L, 0x5D681B02L, 0x2A6F2B94L,
0xB40BBE37L, 0xC30C8EA1L, 0x5A05DF1BL, 0x2D02EF8DL
}; // end MgenMsg::CRC32_TABLE
bool MgenMsg::LogRecvError(FILE* logFile,
const struct timeval& theTime,
const ProtoAddress& srcAddr,
bool logBinary,
MgenMsg::Error errorType,
bool flush)
{
if (logBinary)
{
char header[128];
unsigned int index = 0;
// set "eventType"
header[index++] = (char)Mgen::RERR_EVENT;
// zero "reserved" field
header[index++] = '\0';
// set "recordLength" (Note we don't save payload for SEND events)
unsigned short recordLength = 12 + srcAddr.GetLength() + sizeof(long);
unsigned short temp16 = htons(recordLength);
memcpy(header+index, &temp16, sizeof(short));
index += sizeof(short);
// set "eventTime" fields
unsigned long temp32 = htonl(theTime.tv_sec);
memcpy(header+index, &temp32, sizeof(long));
index += sizeof(long);
temp32 = htonl(theTime.tv_usec);
memcpy(header+index, &temp32, sizeof(long));
index += sizeof(long);
// set "srcPort"
temp16 = htons(srcAddr.GetPort());
memcpy(header+index, &temp16, sizeof(short));
index += sizeof(short);
// set "srcAddrType"
switch(srcAddr.GetType())
{
case ProtoAddress::IPv4:
header[index++] = IPv4;
break;
case ProtoAddress::IPv6:
header[index++] = IPv6;
break;
default:
DMSG(0, "MgenMsg::LogRecvEvent() unknown srcAddr type\n");
header[index++] = INVALID_ADDRESS;
break;
}
// set "srcAddrLen"
unsigned int addrLen = srcAddr.GetLength();
header[index++] = (char)addrLen;
// set "srcAddr"
memcpy(header+index, srcAddr.GetRawHostAddress(), addrLen);
index += addrLen;
// set "errorCode"
long errorCode = (long)errorType;
errorCode = ntohl(errorCode);
memcpy(header+index, &errorCode, sizeof(long));
index += sizeof(long);
// write record
if (fwrite(header, sizeof(char), index, logFile) < index)
{
DMSG(0, "MgenMsg::LogRecvEvent() fwrite() error: %s\n", GetErrorString());
return false;
}
}
else
{
const char* errorString = NULL;
switch (errorType)
{
case ERROR_NONE:
errorString = "none";
break;
case ERROR_VERSION:
errorString = "version";
break;
case ERROR_CHECKSUM:
errorString = "checksum";
break;
case ERROR_LENGTH:
errorString = "length";
break;
case ERROR_DSTADDR:
errorString = "dstAddr";
break;
}
#ifdef _WIN32_WCE
struct tm timeStruct;
timeStruct.tm_hour = theTime.tv_sec / 3600;
unsigned long hourSecs = 3600 * timeStruct.tm_hour;
timeStruct.tm_min = (theTime.tv_sec - hourSecs) / 60;
timeStruct.tm_sec = theTime.tv_sec - hourSecs - (60*timeStruct.tm_min);
timeStruct.tm_hour = timeStruct.tm_hour % 24;
struct tm* timePtr = &timeStruct;
#else
struct tm* timePtr = gmtime((time_t*)&theTime.tv_sec);
#endif // if/else _WIN32_WCE
Mgen::Log(logFile, "%02d:%02d:%02d.%06lu RERR type>%s src>%s/%hu\n",
timePtr->tm_hour, timePtr->tm_min, timePtr->tm_sec,
(unsigned long)theTime.tv_usec, errorString,
srcAddr.GetHostString(), srcAddr.GetPort());
}
if (flush) fflush(logFile);
return true;
} // end MgenMsg::LogRecvError()
bool MgenMsg::LogRecvEvent(FILE* logFile,
const struct timeval& theTime,
const ProtoAddress& srcAddr,
bool logBinary,
char* msgBuffer,
bool flush)
{
if (logBinary)
{
char header[128];
unsigned int index = 0;
// set "eventType"
header[index++] = (char)Mgen::RECV_EVENT;
// zero "reserved" field
header[index++] = '\0';
// set "recordLength" (Note we don't save payload for SEND events)
unsigned short recordLength = 12 + srcAddr.GetLength() + packet_header_len +
payload_len;
unsigned short temp16 = htons(recordLength);
memcpy(header+index, &temp16, sizeof(short));
index += sizeof(short);
// set "eventTime" fields
unsigned long temp32 = htonl(theTime.tv_sec);
memcpy(header+index, &temp32, sizeof(long));
index += sizeof(long);
temp32 = htonl(theTime.tv_usec);
memcpy(header+index, &temp32, sizeof(long));
index += sizeof(long);
// set "srcPort"
temp16 = htons(srcAddr.GetPort());
memcpy(header+index, &temp16, sizeof(short));
index += sizeof(short);
// set "srcAddrType"
switch(srcAddr.GetType())
{
case ProtoAddress::IPv4:
header[index++] = IPv4;
break;
case ProtoAddress::IPv6:
header[index++] = IPv6;
break;
default:
DMSG(0, "MgenMsg::LogRecvEvent() unknown srcAddr type\n");
header[index++] = INVALID_ADDRESS;
break;
}
// set "srcAddrLen"
unsigned int addrLen = srcAddr.GetLength();
header[index++] = (char)addrLen;
// set "srcAddr"
memcpy(header+index, srcAddr.GetRawHostAddress(), addrLen);
index += addrLen;
// write record header
if (fwrite(header, sizeof(char), index, logFile) < index)
{
DMSG(0, "MgenMsg::LogRecvEvent() fwrite() error: %s\n", GetErrorString());
return false;
}
// write message content as remainder of record
unsigned short msgLength = recordLength - index + 4;
// Clear CHECKSUM flag for binary logging
msgBuffer[FLAGS_OFFSET] &= ~CHECKSUM;
if (fwrite(msgBuffer, sizeof(char), msgLength, logFile) < msgLength)
{
DMSG(0, "MgenMsg::LogRecvEvent() fwrite() error: %s\n", GetErrorString());
return false;
}
}
else
{
#ifdef _WIN32_WCE
struct tm timeStruct;
timeStruct.tm_hour = theTime.tv_sec / 3600;
unsigned long hourSecs = 3600 * timeStruct.tm_hour;
timeStruct.tm_min = (theTime.tv_sec - hourSecs) / 60;
timeStruct.tm_sec = theTime.tv_sec - hourSecs - (60*timeStruct.tm_min);
timeStruct.tm_hour = timeStruct.tm_hour % 24;
struct tm* timePtr = &timeStruct;
#else
struct tm* timePtr = gmtime((time_t*)&theTime.tv_sec);
#endif // if/else _WIN32_WCE
Mgen::Log(logFile, "%02d:%02d:%02d.%06lu RECV flow>%lu seq>%lu src>%s/%hu ",
timePtr->tm_hour, timePtr->tm_min, timePtr->tm_sec,
(unsigned long)theTime.tv_usec,
flow_id, seq_num, srcAddr.GetHostString(), srcAddr.GetPort());
#ifdef _WIN32_WCE
timeStruct.tm_hour = tx_time.tv_sec / 3600;
hourSecs = 3600 * timeStruct.tm_hour;
timeStruct.tm_min = (tx_time.tv_sec - hourSecs) / 60;
timeStruct.tm_sec = tx_time.tv_sec - hourSecs - (60*timeStruct.tm_min);
timeStruct.tm_hour = timeStruct.tm_hour % 24;
timePtr = &timeStruct;
#else
timePtr = gmtime((time_t*)&tx_time.tv_sec);
#endif // if/else _WIN32_WCE
Mgen::Log(logFile, "dst>%s/%hu sent>%02d:%02d:%02d.%06lu size>%u ",
dst_addr.GetHostString(), dst_addr.GetPort(),
timePtr->tm_hour, timePtr->tm_min, timePtr->tm_sec,
(unsigned long)tx_time.tv_usec, msg_len);
if (host_addr.IsValid())
{
Mgen::Log(logFile, "host>%s/%hu ", host_addr.GetHostString(),
host_addr.GetPort());
}
// (TBD) only output GPS info if INVALID_GPS != gps_status
const char* statusString = NULL;
switch (gps_status)
{
case INVALID_GPS:
statusString = "INVALID";
break;
case STALE:
statusString = "STALE";
break;
case CURRENT:
statusString = "CURRENT";
break;
default:
DMSG(0, "MgenMsg::LogRecvEvent() invalid GPS status\n");
Mgen::Log(logFile, "\n");
return false;
}
Mgen::Log(logFile, "gps>%s,%f,%f,%ld ", statusString,
latitude, longitude, altitude);
if (payload_len)
{
Mgen::Log(logFile, "data>%hu:", payload_len);
for (unsigned int i = 0; i < payload_len; i++)
Mgen::Log(logFile, "%02x", (unsigned char)payload[i]);
}
Mgen::Log(logFile, "\n");
}
if (flush) fflush(logFile);
return true;
} // end MgenMsg::LogRecvEvent()
bool MgenMsg::LogSendEvent(FILE* logFile,
bool logBinary,
char* msgBuffer,
bool flush)
{
if (logBinary)
{
char header[4];
// set "eventType"
header[0] = (char)Mgen::SEND_EVENT;
// zero "reserved" field
header[1] = '\0';
// set "recordLength"
// Note we don't save option payload for SEND event logging
unsigned short temp16 = htons(packet_header_len);
memcpy(header+2, &temp16, sizeof(short));
// write header
if (fwrite(header, sizeof(char), 4, logFile) < 4)
{
DMSG(0, "MgenMsg::LogSendEvent() fwrite() error: %s\n", GetErrorString());
return false;
}
// write message content
ASSERT(msgBuffer);
if (fwrite(msgBuffer, sizeof(char), packet_header_len, logFile) < packet_header_len)
{
DMSG(0, "MgenMsg::LogSendEvent() fwrite() error: %s\n", GetErrorString());
return false;
}
}
else
{
#ifdef _WIN32_WCE
struct tm timeStruct;
timeStruct.tm_hour = tx_time.tv_sec / 3600;
unsigned long hourSecs = 3600 * timeStruct.tm_hour;
timeStruct.tm_min = (tx_time.tv_sec - hourSecs) / 60;
timeStruct.tm_sec = tx_time.tv_sec - hourSecs - (60*timeStruct.tm_min);
timeStruct.tm_hour = timeStruct.tm_hour % 24;
struct tm* timePtr = &timeStruct;
#else
struct tm* timePtr = gmtime((time_t*)&tx_time.tv_sec);
#endif // if/else _WIN32_WCE
Mgen::Log(logFile, "%02d:%02d:%02d.%06lu SEND flow>%lu seq>%lu dst>%s/%hu size>%u",
timePtr->tm_hour, timePtr->tm_min, timePtr->tm_sec,
(unsigned long)tx_time.tv_usec, flow_id, seq_num,
dst_addr.GetHostString(), dst_addr.GetPort(), msg_len);
if (host_addr.IsValid())
{
Mgen::Log(logFile, " host>%s/%hu\n", host_addr.GetHostString(),
host_addr.GetPort());
}
else
{
Mgen::Log(logFile, "\n");
}
}
if (flush) fflush(logFile);
return true;
} // end MgenMsg::LogSendEvent()
syntax highlighted by Code2HTML, v. 0.9.1