PUD: use the wireformat library
authorFerry Huberts <ferry.huberts@pelagic.nl>
Fri, 5 Aug 2011 14:59:26 +0000 (16:59 +0200)
committerFerry Huberts <f.huberts@mindef.nl>
Tue, 18 Oct 2011 10:08:27 +0000 (12:08 +0200)
Signed-off-by: Ferry Huberts <ferry.huberts@pelagic.nl>
lib/pud/src/configuration.c
lib/pud/src/configuration.h
lib/pud/src/gpsConversion.c
lib/pud/src/nodeIdConversion.c [deleted file]
lib/pud/src/nodeIdConversion.h [deleted file]
lib/pud/src/receiver.c
lib/pud/src/wireFormat.c [deleted file]
lib/pud/src/wireFormat.h [deleted file]

index 2878f44..ae98669 100644 (file)
@@ -307,78 +307,6 @@ int setNodeId(const char *value, void *data __attribute__ ((unused)), set_plugin
        return false;
 }
 
-/*
- * nodeId Cache
- */
-
-/** The size of the cached nodeId buffer */
-#define PUD_CACHED_NODEID_BUFFER_SIZE 16
-
-/** The cached nodeId buffer: contains a pre-processed version of the nodeId
- in order to improve performance. It is currently used for nodeIdTypes
- PUD_NODEIDTYPE_MSISDN, PUD_NODEIDTYPE_TETRA, PUD_NODEIDTYPE_192,
- PUD_NODEIDTYPE_193 (so basically for numbers that will not change) */
-static unsigned char cachedNodeIdBuffer[PUD_CACHED_NODEID_BUFFER_SIZE];
-
-/** The number of bytes stored in cachedNodeIdBuffer */
-static unsigned int cachedNodeIdBufferLength = 0;
-
-/**
- @param buffer
- A pointer to the location in which to store a pointer to the nodeId cache
- buffer
- @param length
- A pointer to the location in which to store the number of bytes in the buffer
- */
-void getNodeIdNumberForOlsrCache(unsigned char ** buffer, unsigned int * length) {
-       *buffer = &cachedNodeIdBuffer[0];
-       *length = cachedNodeIdBufferLength;
-}
-
-/**
- Check a nodeId number for validity and if valid set it up in the
- cachedNodeIdBuffer. The valid range for the number is [min, max].
-
- @param min
- The lower bound for a valid number
- @param max
- The upper bound for a valid number
- @param bytes
- The number of bytes used by the number in the wire format
-
- @return
- - true when the number is valid
- - false otherwise
- */
-static bool setupNodeIdNumberForOlsrCache(unsigned long long min,
-               unsigned long long max, unsigned int bytes) {
-       unsigned long long val;
-
-       assert (bytes <= PUD_CACHED_NODEID_BUFFER_SIZE);
-
-       if (!getNodeIdAsNumber(&val)) {
-               return false;
-       }
-
-       if ((val >= min) && (val <= max)) {
-               int i = bytes - 1;
-               while (i >= 0) {
-                       cachedNodeIdBuffer[i] = val & 0xff;
-                       val >>= 8;
-                       i--;
-               }
-
-               assert(val == 0);
-
-               cachedNodeIdBufferLength = bytes;
-               return true;
-       }
-
-       pudError(false, "%s value %llu is out of range [%llu,%llu]",
-                       PUD_NODE_ID_NAME, val, min, max);
-       return false;
-}
-
 /*
  * nodeId Validation
  */
@@ -392,6 +320,11 @@ static bool setupNodeIdNumberForOlsrCache(unsigned long long min,
  - false on failure
  */
 static bool setupNodeIdNumberForOlsrCacheAndValidate(NodeIdType nodeIdTypeNumber) {
+       unsigned long long val = 0LL;
+       unsigned long long min = 0LL;
+       unsigned long long max = 0LL;
+       unsigned int bytes = 0;
+
        switch (nodeIdTypeNumber) {
                case PUD_NODEIDTYPE_IPV4: /* IPv4 address */
                case PUD_NODEIDTYPE_IPV6: /* IPv6 address */
@@ -400,12 +333,16 @@ static bool setupNodeIdNumberForOlsrCacheAndValidate(NodeIdType nodeIdTypeNumber
                        return true;
 
                case PUD_NODEIDTYPE_MSISDN: /* an MSISDN number */
-                       return setupNodeIdNumberForOlsrCache(0LL, 999999999999999LL,
-                                       PUD_NODEIDTYPE_MSISDN_BYTES);
+                       min = 0LL;
+                       max = 999999999999999LL;
+                       bytes = PUD_NODEIDTYPE_MSISDN_BYTES;
+                       break;
 
                case PUD_NODEIDTYPE_TETRA: /* a Tetra number */
-                       return setupNodeIdNumberForOlsrCache(0LL, 99999999999999999LL,
-                                       PUD_NODEIDTYPE_TETRA_BYTES);
+                       min = 0LL;
+                       max = 99999999999999999LL;
+                       bytes = PUD_NODEIDTYPE_TETRA_BYTES;
+                       break;
 
                case PUD_NODEIDTYPE_DNS: /* DNS name */
                {
@@ -421,16 +358,22 @@ static bool setupNodeIdNumberForOlsrCacheAndValidate(NodeIdType nodeIdTypeNumber
                }
 
                case PUD_NODEIDTYPE_192:
-                       return setupNodeIdNumberForOlsrCache(0LL, 9999999LL,
-                                       PUD_NODEIDTYPE_192_BYTES);
+                       min = 0LL;
+                       max = 9999999LL;
+                       bytes = PUD_NODEIDTYPE_192_BYTES;
+                       break;
 
                case PUD_NODEIDTYPE_193:
-                       return setupNodeIdNumberForOlsrCache(0LL, 999999LL,
-                                       PUD_NODEIDTYPE_193_BYTES);
+                       min = 0LL;
+                       max = 999999LL;
+                       bytes = PUD_NODEIDTYPE_193_BYTES;
+                       break;
 
                case PUD_NODEIDTYPE_194:
-                       return setupNodeIdNumberForOlsrCache(1LL, 8191LL,
-                                       PUD_NODEIDTYPE_194_BYTES);
+                       min = 1LL;
+                       max = 8191LL;
+                       bytes = PUD_NODEIDTYPE_194_BYTES;
+                       break;
 
                default: /* unsupported */
                        /* explicit return: configured nodeId is not relevant, will
@@ -438,6 +381,17 @@ static bool setupNodeIdNumberForOlsrCacheAndValidate(NodeIdType nodeIdTypeNumber
                        return true;
        }
 
+
+       if (!getNodeIdAsNumber(&val)) {
+               return false;
+       }
+
+       if (setupNodeIdNumberForOlsrCache(val, min, max, bytes) ) {
+               return true;
+       }
+
+       pudError(false, "%s value %llu is out of range [%llu,%llu]",
+                       PUD_NODE_ID_NAME, val, min, max);
        return false;
 }
 
index c9a7d5a..f03b6e6 100644 (file)
@@ -2,7 +2,6 @@
 #define _PUD_CONFIGURATION_H_
 
 /* Plugin includes */
-#include "wireFormat.h"
 
 /* OLSR includes */
 #include "olsrd_plugin.h"
@@ -10,6 +9,7 @@
 /* System includes */
 #include <stdbool.h>
 #include <sys/socket.h>
+#include <OlsrdPudWireFormat/wireFormat.h>
 
 /*
  * Global Parameters
@@ -36,8 +36,6 @@ bool getNodeIdAsNumber(unsigned long long * value);
 unsigned char * getNodeIdWithLength(size_t *length);
 int setNodeId(const char *value, void *data, set_plugin_parameter_addon addon);
 
-void getNodeIdNumberForOlsrCache(unsigned char ** buffer, unsigned int * length);
-
 /*
  * RX Parameters
  */
index c2c57cd..0023909 100644 (file)
@@ -1,9 +1,7 @@
 #include "gpsConversion.h"
 
 /* Plugin includes */
-#include "wireFormat.h"
 #include "pud.h"
-#include "nodeIdConversion.h"
 #include "configuration.h"
 #include "compiler.h"
 
@@ -16,6 +14,8 @@
 #include <nmea/info.h>
 #include <netinet/in.h>
 #include <stdio.h>
+#include <OlsrdPudWireFormat/wireFormat.h>
+#include <OlsrdPudWireFormat/nodeIdConversion.h>
 
 /* ************************************************************************
  * OLSR --> External
@@ -48,6 +48,7 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
        char speedString[PUD_TX_SPEED_DIGITS + 1];
        char trackString[PUD_TX_TRACK_DIGITS + 1];
        char hdopString[PUD_TX_HDOP_DIGITS + 1];
+       uint8_t smask;
 
        char nodeIdTypeString[PUD_TX_NODEIDTYPE_DIGITS + 1];
        char nodeIdString[PUD_TX_NODEID_BUFFERSIZE + 1];
@@ -55,28 +56,27 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
 
        unsigned int transmitStringLength;
 
-       GpsInfo* gpsMessage;
-       PudOlsrWireFormat * olsrGpsMessage =
+       PudOlsrPositionUpdate * olsrGpsMessage =
                        getOlsrMessagePayload(olsr_cnf->ip_version, olsrMessage);
 
-       if (unlikely(olsrGpsMessage->version != PUD_WIRE_FORMAT_VERSION)) {
+       if (unlikely(getPositionUpdateVersion(olsrGpsMessage) != PUD_WIRE_FORMAT_VERSION)) {
                /* currently we can only handle our own version */
                pudError(false, "Can not handle version %u OLSR PUD messages"
-                       " (only version %u): message ignored", olsrGpsMessage->version,
-                               PUD_WIRE_FORMAT_VERSION);
+                       " (only version %u): message ignored",
+                       getPositionUpdateVersion(olsrGpsMessage), PUD_WIRE_FORMAT_VERSION);
                return 0;
        }
 
-       validityTime = getValidityTimeFromOlsr(olsrGpsMessage->validityTime);
+       validityTime = getValidityTime(&olsrGpsMessage->validityTime);
 
-       gpsMessage = &olsrGpsMessage->gpsInfo;
+       smask = getPositionUpdateSmask(olsrGpsMessage);
 
        /* time is ALWAYS present so we can just use it */
-       getTimeFromOlsr(gpsMessage->time, &timeStruct);
+       getPositionUpdateTime(olsrGpsMessage, time(NULL), &timeStruct);
 
-       if (likely(nmea_INFO_has_field(olsrGpsMessage->smask, LAT))) {
+       if (likely(nmea_INFO_has_field(smask, LAT))) {
                int chars;
-               double latitude = getLatitudeFromOlsr(gpsMessage->lat);
+               double latitude = getPositionUpdateLatitude(olsrGpsMessage);
 
                if (latitude >= 0) {
                        latitudeHemisphere = "N";
@@ -98,9 +98,9 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
                latitudeString[0] = '\0';
        }
 
-       if (likely(nmea_INFO_has_field(olsrGpsMessage->smask, LON))) {
+       if (likely(nmea_INFO_has_field(smask, LON))) {
                int chars;
-               double longitude = getLongitudeFromOlsr(gpsMessage->lon);
+               double longitude = getPositionUpdateLongitude(olsrGpsMessage);
 
                if (longitude >= 0) {
                        longitudeHemisphere = "E";
@@ -122,9 +122,9 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
                longitudeString[0] = '\0';
        }
 
-       if (likely(nmea_INFO_has_field(olsrGpsMessage->smask, ELV))) {
+       if (likely(nmea_INFO_has_field(smask, ELV))) {
                int chars = snprintf(&altitudeString[0], PUD_TX_ALTITUDE_DIGITS, "%ld",
-                               getAltitudeFromOlsr(gpsMessage->alt));
+                               getPositionUpdateAltitude(olsrGpsMessage));
                if (likely(chars < PUD_TX_ALTITUDE_DIGITS)) {
                        altitudeString[chars] = '\0';
                } else {
@@ -134,9 +134,9 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
                altitudeString[0] = '\0';
        }
 
-       if (likely(nmea_INFO_has_field(olsrGpsMessage->smask, SPEED))) {
+       if (likely(nmea_INFO_has_field(smask, SPEED))) {
                int chars = snprintf(&speedString[0], PUD_TX_SPEED_DIGITS, "%lu",
-                               getSpeedFromOlsr(gpsMessage->speed));
+                               getPositionUpdateSpeed(olsrGpsMessage));
                if (likely(chars < PUD_TX_SPEED_DIGITS)) {
                        speedString[chars] = '\0';
                } else {
@@ -146,9 +146,9 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
                speedString[0] = '\0';
        }
 
-       if (likely(nmea_INFO_has_field(olsrGpsMessage->smask, DIRECTION))) {
+       if (likely(nmea_INFO_has_field(smask, DIRECTION))) {
                int chars = snprintf(&trackString[0], PUD_TX_TRACK_DIGITS, "%lu",
-                               getTrackFromOlsr(gpsMessage->track));
+                               getPositionUpdateTrack(olsrGpsMessage));
                if (likely(chars < PUD_TX_TRACK_DIGITS)) {
                        trackString[chars] = '\0';
                } else {
@@ -158,10 +158,10 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
                trackString[0] = '\0';
        }
 
-       if (likely(nmea_INFO_has_field(olsrGpsMessage->smask, HDOP))) {
+       if (likely(nmea_INFO_has_field(smask, HDOP))) {
                int chars = snprintf(&hdopString[0], PUD_TX_HDOP_DIGITS,
-                               "%." PUD_TX_HDOP_DECIMALS "f", nmea_meters2dop(getHdopFromOlsr(
-                                               gpsMessage->hdop)));
+                               "%." PUD_TX_HDOP_DECIMALS "f", nmea_meters2dop(getPositionUpdateHdop(
+                                               olsrGpsMessage)));
                if (likely(chars < PUD_TX_HDOP_DIGITS)) {
                        hdopString[chars] = '\0';
                } else {
@@ -171,7 +171,7 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
                hdopString[0] = '\0';
        }
 
-       getNodeTypeStringFromOlsr(olsr_cnf->ip_version, olsrMessage,
+       getNodeTypeStringFromOlsr(olsr_cnf->ip_version, olsrGpsMessage,
                        &nodeIdTypeString[0], sizeof(nodeIdTypeString));
        getNodeIdStringFromOlsr(olsr_cnf->ip_version, olsrMessage, &nodeId,
                        &nodeIdString[0], sizeof(nodeIdString));
@@ -190,7 +190,7 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
                "%s," /* track (optional) */
                "%s" /* hdop (optional) */
        , getTxNmeaMessagePrefix(), PUD_TX_SENTENCE_VERSION, &nodeIdTypeString[0],
-                       nodeId, timeStruct.tm_mday, timeStruct.tm_mon, (timeStruct.tm_year
+                       nodeId, timeStruct.tm_mday, timeStruct.tm_mon + 1, (timeStruct.tm_year
                                        % 100), timeStruct.tm_hour, timeStruct.tm_min,
                        timeStruct.tm_sec, validityTime, &latitudeString[0],
                        latitudeHemisphere, &longitudeString[0], longitudeHemisphere,
@@ -216,82 +216,6 @@ unsigned int gpsFromOlsr(union olsr_message *olsrMessage,
  * External --> OLSR
  * ************************************************************************ */
 
-/**
- Convert the node information to the node information for an OLSR message and
- put it in the PUD message in the OLSR message. Also updates the PUD message
- smask.
-
- @param olsrGpsMessage
- A pointer to the PUD message in the OLSR message
- @param olsrMessageSize
- The maximum number of bytes available for the olsrMessage
- @param nodeIdType
- The nodeIdType
-
- @return
- The number of bytes written in the PUD message in the OLSR message (for ALL
- the node information)
- */
-static size_t setupNodeInfoForOlsr(PudOlsrWireFormat * olsrGpsMessage,
-               unsigned int olsrMessageSize, NodeIdType nodeIdType) {
-       unsigned char * buffer;
-       unsigned int length = 0;
-
-       olsrGpsMessage->nodeInfo.nodeIdType = nodeIdType;
-       switch (nodeIdType) {
-               case PUD_NODEIDTYPE_MAC: /* hardware address */
-                       /* handled when the message is actually sent into OLSR, in the
-                        * pre-transmit hook */
-                       length = PUD_NODEIDTYPE_MAC_BYTES;
-                       break;
-
-               case PUD_NODEIDTYPE_MSISDN: /* an MSISDN number */
-               case PUD_NODEIDTYPE_TETRA: /* a Tetra number */
-               case PUD_NODEIDTYPE_192:
-               case PUD_NODEIDTYPE_193:
-               case PUD_NODEIDTYPE_194:
-                       getNodeIdNumberForOlsrCache(&buffer, &length);
-                       memcpy(&olsrGpsMessage->nodeInfo.nodeId, buffer, length);
-                       break;
-
-               case PUD_NODEIDTYPE_DNS: /* DNS name */
-               {
-                       size_t nodeIdLength;
-                       unsigned char * nodeId = getNodeIdWithLength(&nodeIdLength);
-                       long charsAvailable = olsrMessageSize - (PUD_OLSRWIREFORMATSIZE
-                                       + sizeof(NodeInfo)
-                                       - sizeof(olsrGpsMessage->nodeInfo.nodeId)) - 1;
-
-                       length = nodeIdLength + 1;
-                       if (unlikely((long) length > charsAvailable)) {
-                               length = charsAvailable;
-                       }
-
-                       memcpy(&olsrGpsMessage->nodeInfo.nodeId, nodeId, length);
-                       (&olsrGpsMessage->nodeInfo.nodeId)[length] = '\0';
-               }
-                       break;
-
-               case PUD_NODEIDTYPE_IPV4: /* IPv4 address */
-               case PUD_NODEIDTYPE_IPV6: /* IPv6 address */
-                       /* explicit return: no nodeId information in message */
-                       return 0;
-
-               default: /* unsupported */
-                       /* fallback to IP address */
-                       olsrGpsMessage->nodeInfo.nodeIdType = (olsr_cnf->ip_version
-                                       == AF_INET) ? PUD_NODEIDTYPE_IPV4 : PUD_NODEIDTYPE_IPV6;
-
-                       /* explicit return: no nodeId information in message */
-                       return 0;
-       }
-
-       olsrGpsMessage->smask |= PUD_FLAGS_ID;
-       return ((sizeof(NodeInfo)
-                       - (sizeof(olsrGpsMessage->nodeInfo.nodeId) /* nodeId placeholder */))
-                       + length);
-}
-
 /**
  Convert a nmeaINFO structure into an OLSR message.
 
@@ -302,7 +226,7 @@ static size_t setupNodeInfoForOlsr(PudOlsrWireFormat * olsrGpsMessage,
  @param olsrMessageSize
  The maximum number of bytes available for the olsrMessage
  @param validityTime
- the validity time of the message
+ the validity time of the message in seconds
 
  @return
  - the aligned size of the converted information
@@ -312,60 +236,64 @@ unsigned int gpsToOlsr(nmeaINFO *nmeaInfo, union olsr_message *olsrMessage,
                unsigned int olsrMessageSize, unsigned long long validityTime) {
        unsigned int aligned_size;
        unsigned int aligned_size_remainder;
+       unsigned char * nodeId;
+       size_t nodeIdLength;
        size_t nodeLength;
-       PudOlsrWireFormat * olsrGpsMessage =
+
+       PudOlsrPositionUpdate * olsrGpsMessage =
                        getOlsrMessagePayload(olsr_cnf->ip_version, olsrMessage);
 
        /*
         * Compose message contents
         */
 
-       olsrGpsMessage->version = PUD_WIRE_FORMAT_VERSION;
-       olsrGpsMessage->validityTime = getValidityTimeForOlsr(validityTime);
-       olsrGpsMessage->smask = nmeaInfo->smask;
+       setPositionUpdateVersion(olsrGpsMessage, PUD_WIRE_FORMAT_VERSION);
+       setValidityTime(&olsrGpsMessage->validityTime, validityTime);
+       setPositionUpdateSmask(olsrGpsMessage, nmeaInfo->smask);
 
-       /* utc is always present, we make sure of that, so just use it */
-       olsrGpsMessage->gpsInfo.time = getTimeForOlsr(nmeaInfo->utc.hour,
-                       nmeaInfo->utc.min, nmeaInfo->utc.sec);
+       /* utc is always present, we make sure of that elsewhere, so just use it */
+       setPositionUpdateTime(olsrGpsMessage, nmeaInfo->utc.hour, nmeaInfo->utc.min,
+                       nmeaInfo->utc.sec);
 
        if (likely(nmea_INFO_has_field(nmeaInfo->smask, LAT))) {
-               olsrGpsMessage->gpsInfo.lat = getLatitudeForOlsr(nmeaInfo->lat);
+               setPositionUpdateLatitude(olsrGpsMessage, nmeaInfo->lat);
        } else {
-               olsrGpsMessage->gpsInfo.lat = (1 << (PUD_LATITUDE_BITS - 1));
+               setPositionUpdateLatitude(olsrGpsMessage, 0.0);
        }
 
        if (likely(nmea_INFO_has_field(nmeaInfo->smask, LON))) {
-               olsrGpsMessage->gpsInfo.lon = getLongitudeForOlsr(nmeaInfo->lon);
+               setPositionUpdateLongitude(olsrGpsMessage, nmeaInfo->lon);
        } else {
-               olsrGpsMessage->gpsInfo.lon = (1 << (PUD_LONGITUDE_BITS - 1));
+               setPositionUpdateLongitude(olsrGpsMessage, 0.0);
        }
 
        if (likely(nmea_INFO_has_field(nmeaInfo->smask, ELV))) {
-               olsrGpsMessage->gpsInfo.alt = getAltitudeForOlsr(nmeaInfo->elv);
+               setPositionUpdateAltitude(olsrGpsMessage, nmeaInfo->elv);
        } else {
-               olsrGpsMessage->gpsInfo.alt = -PUD_ALTITUDE_MIN;
+               setPositionUpdateAltitude(olsrGpsMessage, 0.0);
        }
 
        if (likely(nmea_INFO_has_field(nmeaInfo->smask, SPEED))) {
-               olsrGpsMessage->gpsInfo.speed = getSpeedForOlsr(nmeaInfo->speed);
+               setPositionUpdateSpeed(olsrGpsMessage, nmeaInfo->speed);
        } else {
-               olsrGpsMessage->gpsInfo.speed = 0;
+               setPositionUpdateSpeed(olsrGpsMessage, 0.0);
        }
 
        if (likely(nmea_INFO_has_field(nmeaInfo->smask, DIRECTION))) {
-               olsrGpsMessage->gpsInfo.track = getTrackForOlsr(nmeaInfo->direction);
+               setPositionUpdateTrack(olsrGpsMessage, nmeaInfo->direction);
        } else {
-               olsrGpsMessage->gpsInfo.track = 0;
+               setPositionUpdateTrack(olsrGpsMessage, 0);
        }
 
        if (likely(nmea_INFO_has_field(nmeaInfo->smask, HDOP))) {
-               olsrGpsMessage->gpsInfo.hdop = getHdopForOlsr(nmeaInfo->HDOP);
+               setPositionUpdateHdop(olsrGpsMessage, nmeaInfo->HDOP);
        } else {
-               olsrGpsMessage->gpsInfo.hdop = PUD_HDOP_MAX;
+               setPositionUpdateHdop(olsrGpsMessage, PUD_HDOP_MAX);
        }
 
-       nodeLength = setupNodeInfoForOlsr(olsrGpsMessage, olsrMessageSize,
-                       getNodeIdTypeNumber());
+       nodeId = getNodeIdWithLength(&nodeIdLength);
+       nodeLength = setPositionUpdateNodeInfo(olsr_cnf->ip_version, olsrGpsMessage,
+                       olsrMessageSize, getNodeIdTypeNumber(), nodeId, nodeIdLength);
 
        /*
         * Messages in OLSR are 4-byte aligned: align
diff --git a/lib/pud/src/nodeIdConversion.c b/lib/pud/src/nodeIdConversion.c
deleted file mode 100644 (file)
index 372a280..0000000
+++ /dev/null
@@ -1,181 +0,0 @@
-#include "nodeIdConversion.h"
-
-/* Plugin includes */
-#include "compiler.h"
-
-/* OLSR includes */
-
-/* System includes */
-#include <assert.h>
-#include <arpa/inet.h>
-#include <nmea/util.h>
-#include <net/if.h>
-
-/* ************************************************************************
- * Node Information
- * ************************************************************************ */
-
-/**
- Convert the nodeIdType of an OLSR message into a string.
-
- @param ipVersion
- The ip version, either AF_INET or AF_INET6
- @param olsrMessage
- A pointer to the OLSR message. Used to be able to retrieve the IP address of
- the sender.
- @param nodeIdTypeBuffer
- A pointer to the buffer in which the nodeIdType string representation is
- written (the buffer needs to be at least PUD_TX_NODEIDTYPE_DIGITS + 1 bytes).
- When NULL then the nodeIdType string is not written.
- @param nodeIdTypeBufferSize
- The size of the nodeIdTypeBuffer
- */
-void getNodeTypeStringFromOlsr(int ipVersion, union olsr_message * olsrMessage,
-               char * nodeIdTypeBuffer, int nodeIdTypeBufferSize) {
-       int chars;
-
-       if (unlikely(!nodeIdTypeBuffer || (nodeIdTypeBufferSize == 0))) {
-               return;
-       }
-
-       assert(nodeIdTypeBufferSize >= (PUD_TX_NODEIDTYPE_DIGITS + 1));
-
-       /* message has NO nodeId information */
-       chars = snprintf(&nodeIdTypeBuffer[0], nodeIdTypeBufferSize, "%u",
-                       getNodeIdType(ipVersion, olsrMessage));
-       if (likely(chars < nodeIdTypeBufferSize)) {
-               nodeIdTypeBuffer[chars] = '\0';
-       } else {
-               nodeIdTypeBuffer[nodeIdTypeBufferSize] = '\0';
-       }
-
-       return;
-}
-
-/**
- Get a nodeId number (in string representation), using a certain number of
- bytes, from the message of an OLSR message.
-
- @param buffer
- A pointer to the buffer that holds the nodeId
- @param bufferSize
- The number of bytes used by the number in the buffer
- @param nodeIdBuffer
- The buffer in which to place the nodeId number in string representation
- @param nodeIdBufferSize
- The size of the nodeIdbuffer
-
- @return
- A pointer to the nodeId string representation (&nodeIdBuffer[0])
- */
-static char *getNodeIdNumberFromOlsr(unsigned char * buffer,
-               unsigned int bufferSize, char *nodeIdBuffer, socklen_t nodeIdBufferSize) {
-       unsigned long long val = 0;
-       unsigned int i = 0;
-       int chars;
-
-       while (i < bufferSize) {
-               val <<= 8;
-               val += buffer[i];
-               i++;
-       }
-
-       chars = snprintf(nodeIdBuffer, nodeIdBufferSize, "%llu", val);
-       if (likely(chars < (int) nodeIdBufferSize)) {
-               nodeIdBuffer[chars] = '\0';
-       } else {
-               nodeIdBuffer[nodeIdBufferSize] = '\0';
-       }
-       return &nodeIdBuffer[0];
-}
-
-/**
- Convert the nodeId of an OLSR message into a string.
-
- @param ipVersion
- The ip version, either AF_INET or AF_INET6
- @param olsrMessage
- A pointer to the OLSR message. Used to be able to retrieve the IP address of
- the sender.
- @param nodeIdStr
- A pointer to a variable in which to store the pointer to the buffer in which
- the nodeId string representation is written (the buffer needs to be at least
- PUD_TX_NODEIDTYPE_DIGITS + 1 bytes). Not written to when nodeIdStrBuffer or
- nodeIdStr is NULL or when nodeIdStrBufferSize is zero. Can point to
- nodeIdStrBuffer or straight into the olsrMessage
- @param nodeIdStrBuffer
- A pointer to the buffer in which the nodeId string representation can be
- written. Not written to when nodeIdStrBuffer or nodeIdStr is NULL or when
- nodeIdStrBufferSize is zero.
- @param nodeIdStrBufferSize
- The size of the nodeIdStrBuffer. When zero then nodeIdStrBuffer and nodeIdStr
- are not written to.
- */
-void getNodeIdStringFromOlsr(int ipVersion, union olsr_message *olsrMessage,
-               const char **nodeIdStr, char *nodeIdStrBuffer,
-               unsigned int nodeIdStrBufferSize) {
-       PudOlsrWireFormat * olsrGpsMessage;
-       unsigned char * buffer;
-       unsigned int bufferSize;
-
-       if (unlikely(!nodeIdStrBuffer || (nodeIdStrBufferSize == 0) || !nodeIdStr)) {
-               return;
-       }
-
-       assert(nodeIdStrBufferSize >= (PUD_TX_NODEID_BUFFERSIZE + 1));
-
-       olsrGpsMessage = getOlsrMessagePayload(ipVersion, olsrMessage);
-
-       getNodeIdPointers(ipVersion, olsrMessage, &buffer, &bufferSize);
-
-       if (olsrGpsMessage->smask & PUD_FLAGS_ID) {
-               switch (olsrGpsMessage->nodeInfo.nodeIdType) {
-                       case PUD_NODEIDTYPE_MAC: /* hardware address */
-                       {
-                               int chars;
-
-                               assert(bufferSize == 6);
-
-                               chars = snprintf(nodeIdStrBuffer, nodeIdStrBufferSize,
-                                               "%02x:%02x:%02x:%02x:%02x:%02x", buffer[0], buffer[1],
-                                               buffer[2], buffer[3], buffer[4], buffer[5]);
-                               if (likely(chars < (int) nodeIdStrBufferSize)) {
-                                       nodeIdStrBuffer[chars] = '\0';
-                               } else {
-                                       nodeIdStrBuffer[nodeIdStrBufferSize - 1] = '\0';
-                               }
-                               *nodeIdStr = &nodeIdStrBuffer[0];
-                       }
-                               break;
-
-                       case PUD_NODEIDTYPE_DNS: /* DNS name */
-                               *nodeIdStr = (char *) &olsrGpsMessage->nodeInfo.nodeId;
-                               break;
-
-                       case PUD_NODEIDTYPE_MSISDN: /* an MSISDN number */
-                       case PUD_NODEIDTYPE_TETRA: /* a Tetra number */
-                       case PUD_NODEIDTYPE_192:
-                       case PUD_NODEIDTYPE_193:
-                       case PUD_NODEIDTYPE_194:
-                               *nodeIdStr = getNodeIdNumberFromOlsr(buffer, bufferSize,
-                                               nodeIdStrBuffer, nodeIdStrBufferSize);
-                               break;
-
-                       case PUD_NODEIDTYPE_IPV4: /* IPv4 address */
-                       case PUD_NODEIDTYPE_IPV6: /* IPv6 address */
-                       default: /* unsupported */
-                               goto noId;
-               }
-
-               return;
-       }
-
-       /* message has NO nodeId information */
-       noId: {
-               void * addr = getOlsrMessageOriginator(ipVersion, olsrMessage);
-               *nodeIdStr = inet_ntop(ipVersion, addr, nodeIdStrBuffer,
-                               nodeIdStrBufferSize);
-       }
-
-       return;
-}
diff --git a/lib/pud/src/nodeIdConversion.h b/lib/pud/src/nodeIdConversion.h
deleted file mode 100644 (file)
index 36f97de..0000000
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef _PUD_NODEIDCONVERSION_H_
-#define _PUD_NODEIDCONVERSION_H_
-
-/* Plugin includes */
-#include "wireFormat.h"
-
-/* OLSR includes */
-#include "olsr_protocol.h"
-
-/* System includes */
-#include <stddef.h>
-
-void getNodeTypeStringFromOlsr(int ipVersion, union olsr_message * olsrMessage,
-               char * nodeIdTypeBuffer, int nodeIdTypeBufferSize);
-
-void getNodeIdStringFromOlsr(int ipVersion, union olsr_message *olsrMessage,
-               const char **nodeIdStr, char *nodeIdStrBuffer,
-               unsigned int nodeIdStrBufferSize);
-
-#endif /* _PUD_NODEIDCONVERSION_H_ */
index 2c81764..9b2a4f3 100644 (file)
@@ -72,7 +72,11 @@ typedef struct _StateType {
 } StateType;
 
 /** The state */
-static StateType state = { .internalState = MOVING, .externalState = MOVING, .hysteresisCounter = 0 };
+static StateType state = {
+               .internalState = MOVING,
+               .externalState = MOVING,
+               .hysteresisCounter = 0
+};
 
 /** Type describing movement calculations */
 typedef struct _MovementType {
@@ -124,6 +128,9 @@ static TransmitGpsInformation transmitGpsInformation;
  * mutexes. */
 static PositionUpdateEntry txPosition;
 
+/** The size of the buffer in which the OLSR and uplink messages are assembled */
+#define TX_BUFFER_SIZE_FOR_OLSR 1024
+
 /*
  * Functions
  */
@@ -145,16 +152,19 @@ static void nodeIdPreTransmitHook(union olsr_message *olsrMessage,
        /* set the MAC address in the message when needed */
        if (unlikely(getNodeIdTypeNumber() == PUD_NODEIDTYPE_MAC)) {
                TOLSRNetworkInterface * olsrIf = getOlsrNetworkInterface(ifn);
-               PudOlsrWireFormat * olsrGpsMessage =
+               PudOlsrPositionUpdate * olsrGpsMessage =
                                getOlsrMessagePayload(olsr_cnf->ip_version, olsrMessage);
 
                if (likely(olsrIf != NULL)) {
-                       memcpy(&olsrGpsMessage->nodeInfo.nodeId, &olsrIf->hwAddress[0],
-                                       PUD_NODEIDTYPE_MAC_BYTES);
+                       setPositionUpdateNodeId(olsrGpsMessage, &olsrIf->hwAddress[0],
+                                       PUD_NODEIDTYPE_MAC_BYTES, false);
                } else {
+                       unsigned char buffer[PUD_NODEIDTYPE_MAC_BYTES] = { 0 };
+                       setPositionUpdateNodeId(olsrGpsMessage, &buffer[0],
+                                       PUD_NODEIDTYPE_MAC_BYTES, false);
+
                        pudError(false, "Could not find OLSR interface %s, cleared its"
                                " MAC address in the OLSR message\n", ifn->int_name);
-                       memset(&olsrGpsMessage->nodeInfo.nodeId, 0, PUD_NODEIDTYPE_MAC_BYTES);
                }
        }
 }
@@ -169,7 +179,7 @@ static void nodeIdPreTransmitHook(union olsr_message *olsrMessage,
  - true when valid
  - false otherwise
  */
-static bool positionValid(PositionUpdateEntry * position){
+static bool positionValid(PositionUpdateEntry * position) {
        return (nmea_INFO_has_field(position->nmeaInfo.smask, FIX)
                        && (position->nmeaInfo.fix != NMEA_FIX_BAD));
 }
@@ -181,8 +191,16 @@ static bool positionValid(PositionUpdateEntry * position){
  a bitmap defining which interfaces to send over
  */
 static void txToAllOlsrInterfaces(TimedTxInterface interfaces) {
-       UplinkWireFormat uplinkWireFormat;
-       union olsr_message * olsrMessage = (union olsr_message *)&uplinkWireFormat.msg.olsrMessage;
+       /** buffer used to fill in the OLSR and uplink messages */
+       unsigned char txBuffer[TX_BUFFER_SIZE_FOR_OLSR];
+       UplinkMessage * message1 = (UplinkMessage *) &txBuffer[0];
+
+       unsigned int txBufferSpaceTaken = 0;
+       #define txBufferSpaceFree       (sizeof(txBuffer) - txBufferSpaceTaken)
+
+       /* the first message in the buffer is an OLSR position update */
+       union olsr_message * olsrMessage =
+                       (union olsr_message *) &message1->msg.olsrMessage;
        unsigned int aligned_size = 0;
 
        /* convert nmeaINFO to wireformat olsr message */
@@ -191,10 +209,13 @@ static void txToAllOlsrInterfaces(TimedTxInterface interfaces) {
                        && positionValid(&transmitGpsInformation.txPosition)) {
                nmea_time_now(&transmitGpsInformation.txPosition.nmeaInfo.utc);
        }
+
+       txBufferSpaceTaken += sizeof(UplinkHeader);
        aligned_size = gpsToOlsr(&transmitGpsInformation.txPosition.nmeaInfo,
-                       olsrMessage, sizeof(uplinkWireFormat.msg),
+                       olsrMessage, txBufferSpaceFree,
                        ((state.externalState == MOVING) ? getUpdateIntervalMoving()
                                                : getUpdateIntervalStationary()));
+       txBufferSpaceTaken += aligned_size;
        transmitGpsInformation.updated = false;
        (void) pthread_mutex_unlock(&transmitGpsInformation.mutex);
 
@@ -224,52 +245,106 @@ static void txToAllOlsrInterfaces(TimedTxInterface interfaces) {
                                }
 #endif
                        }
+
+                       /* loopback to tx interface when so configured */
+                       if (getUseLoopback()) {
+                               (void) packetReceivedFromOlsr(olsrMessage, NULL, NULL);
+                       }
                }
 
                /* push out over uplink when an uplink is configured */
                if (((interfaces & UPLINK) != 0) && isUplinkAddrSet()) {
                        int fd = getUplinkSocketFd();
                        if (fd != -1) {
+                               /* FIXME until we have gateway selection we just send ourselves
+                                * as cluster leader */
+                               union olsr_ip_addr * gwAddr = &olsr_cnf->main_addr;
+
+                               UplinkMessage * message2 =
+                                               (UplinkMessage *) &txBuffer[aligned_size
+                                                               + sizeof(UplinkHeader)];
+                               UplinkClusterLeader * clusterLeaderMessage =
+                                               &message2->msg.clusterLeader;
+                               unsigned int message2Size;
+                               union olsr_ip_addr * clOriginator;
+                               union olsr_ip_addr * clClusterLeader;
+
+                               /*
+                                * position update message (message1)
+                                */
+
                                union olsr_sockaddr * address = getUplinkAddr();
-                               PudOlsrWireFormat * olsrGpsMessage =
-                                               getOlsrMessagePayload(olsr_cnf->ip_version, olsrMessage);
+                               PudOlsrPositionUpdate * olsrGpsMessage = getOlsrMessagePayload(
+                                               olsr_cnf->ip_version, olsrMessage);
 
-                               /* set TLV fields */
-                               uplinkWireFormat.type = POSITION;
-                               uplinkWireFormat.length = htons(aligned_size);
-                               uplinkWireFormat.ipv6 = (olsr_cnf->ip_version == AF_INET) ? 0 : 1;
-                               uplinkWireFormat.pad = 0;
+                               /* set header fields */
+                               setUplinkMessageType(&message1->header, POSITION);
+                               setUplinkMessageLength(&message1->header, aligned_size);
+                               setUplinkMessageIPv6(&message1->header,
+                                               (olsr_cnf->ip_version != AF_INET));
+                               setUplinkMessagePadding(&message1->header, 0);
 
                                /* fixup validity time */
-                               olsrGpsMessage->validityTime = getValidityTimeForOlsr(
-                                               ((state.externalState == MOVING) ?
-                                                               getUplinkUpdateIntervalMoving() :
-                                                               getUplinkUpdateIntervalStationary()));
+                               setValidityTime(&olsrGpsMessage->validityTime,
+                                               (state.externalState == MOVING) ?
+                                               getUplinkUpdateIntervalMoving() :
+                                               getUplinkUpdateIntervalStationary());
+
+                               /*
+                                * cluster leader message (message2)
+                                */
+
+                               clOriginator = getClusterLeaderOriginator(olsr_cnf->ip_version,
+                                               clusterLeaderMessage);
+                               clClusterLeader = getClusterLeaderClusterLeader(
+                                               olsr_cnf->ip_version, clusterLeaderMessage);
+                               if (olsr_cnf->ip_version == AF_INET) {
+                                       message2Size = sizeof(clusterLeaderMessage->version)
+                                                       + sizeof(clusterLeaderMessage->validityTime)
+                                                       + sizeof(clusterLeaderMessage->leader.v4);
+                               } else {
+                                       message2Size = sizeof(clusterLeaderMessage->version)
+                                                       + sizeof(clusterLeaderMessage->validityTime)
+                                                       + sizeof(clusterLeaderMessage->leader.v6);
+                               }
+
+                               /* set header fields */
+                               setUplinkMessageType(&message2->header, CLUSTERLEADER);
+                               setUplinkMessageLength(&message2->header, message2Size);
+                               setUplinkMessageIPv6(&message2->header,
+                                               (olsr_cnf->ip_version != AF_INET));
+                               setUplinkMessagePadding(&message2->header, 0);
+                               txBufferSpaceTaken += sizeof(UplinkHeader);
+
+                               /* setup validity time */
+                               setClusterLeaderVersion(clusterLeaderMessage, PUD_WIRE_FORMAT_VERSION);
+                               setValidityTime(&clusterLeaderMessage->validityTime,
+                                               (state.externalState == MOVING) ?
+                                               getUplinkUpdateIntervalMoving() :
+                                               getUplinkUpdateIntervalStationary());
+
+                               memcpy(clOriginator, &olsr_cnf->main_addr, olsr_cnf->ipsize);
+                               memcpy(clClusterLeader, gwAddr, olsr_cnf->ipsize);
+
+                               txBufferSpaceTaken += message2Size;
 
                                errno = 0;
-                               if (sendto(fd, &uplinkWireFormat, (sizeof(uplinkWireFormat) -
-                                               sizeof(uplinkWireFormat.msg)) + aligned_size, 0,
-                                               (struct sockaddr *) &address->in,
-                                               sizeof(address->in)) < 0) {
+                               if (sendto(fd, &txBuffer, txBufferSpaceTaken, 0,
+                                       (struct sockaddr *) &address->in, sizeof(address->in)) < 0) {
                                        pudError(true, "Could not send to uplink"
-                                                       " (aligned_size=%u)", aligned_size);
+                                                       " (aligned_size=%u)", txBufferSpaceTaken);
                                }
 #ifdef PUD_DUMP_GPS_PACKETS_TX_UPLINK
                                else {
                                        olsr_printf(0, "%s: packet sent to uplink (%d bytes)\n",
                                                        PUD_PLUGIN_ABBR, aligned_size);
-                                       dump_packet((unsigned char *)&uplinkWireFormat,
-                                                       (sizeof(uplinkWireFormat) -
-                                                        sizeof(uplinkWireFormat.msg)) + aligned_size);
+                                       dump_packet((unsigned char *)&txBuffer,
+                                                       (sizeof(txBuffer) -
+                                                        sizeof(txBuffer.msg)) + aligned_size);
                                }
 #endif
                        }
                }
-
-               /* loopback to tx interface when so configured */
-               if (getUseLoopback()) {
-                       (void) packetReceivedFromOlsr(olsrMessage, NULL, NULL);
-               }
        }
 }
 
diff --git a/lib/pud/src/wireFormat.c b/lib/pud/src/wireFormat.c
deleted file mode 100644 (file)
index 115effd..0000000
+++ /dev/null
@@ -1,599 +0,0 @@
-#include "wireFormat.h"
-
-/* Plugin includes */
-#include "compiler.h"
-
-/* System includes */
-#include <stdlib.h>
-#include <stdbool.h>
-#include <math.h>
-#include <assert.h>
-
-/*
- * GPS Information Conversion Functions For OLSR GPS Wire Format
- */
-
-/* ************************************************************************
- * OLSR Header
- * ************************************************************************ */
-
-/**
- Determine the originator of an OLSR message
-
- @param ipVersion
- The IP version
- @param olsrMessage
- A pointer to the OLSR message
- @return
- A pointer to the originator address
- */
-inline union olsr_ip_addr * getOlsrMessageOriginator(int ipVersion,
-               union olsr_message * olsrMessage) {
-       if (ipVersion == AF_INET) {
-               return (union olsr_ip_addr *) &olsrMessage->v4.originator;
-       }
-
-       return (union olsr_ip_addr *) &olsrMessage->v6.originator;
-}
-
-/**
- Determine the size of an OLSR message
-
- @param ipVersion
- The IP version
- @param olsrMessage
- A pointer to the OLSR message
- @return
- The size of the OLSR message
- */
-inline unsigned short getOlsrMessageSize(int ipVersion,
-               union olsr_message * olsrMessage) {
-       if (ipVersion == AF_INET) {
-               return ntohs(olsrMessage->v4.olsr_msgsize);
-       }
-
-       return ntohs(olsrMessage->v6.olsr_msgsize);
-}
-
-/**
- Determine the address of the position update message in an OLSR message
-
- @param ipVersion
- The IP version
- @param olsrMessage
- A pointer to the OLSR message
- @return
- A pointer to the position update message
- */
-inline PudOlsrWireFormat * getOlsrMessagePayload(int ipVersion,
-               union olsr_message * olsrMessage) {
-       if (ipVersion == AF_INET) {
-               return (PudOlsrWireFormat *) &olsrMessage->v4.message;
-       }
-
-       return (PudOlsrWireFormat *) &olsrMessage->v6.message;
-}
-
-/* ************************************************************************
- * VALIDITY TIME
- * ************************************************************************ */
-
-/** Determine the validity time in seconds from the OLSR wire format value */
-#define PUD_VALIDITY_TIME_FROM_OLSR(msn, lsn) ((((lsn) + 16) * (1 << (msn))) - 16)
-
-static unsigned long long cachedValidityTimeMsn[16];
-
-static bool cachedValidityTimeMsnValid = false;
-
-/**
- Setup of cache of calculated most significant nibble results of the validity
- time calculation to speed up run-time calculations. This method has to be
- called once upon first use of ValidityTime functions.
- */
-static void setupCachedValidityTimeMsn(void) {
-       unsigned int msn;
-       for (msn = 0; msn < 16; msn++) {
-               cachedValidityTimeMsn[msn] = PUD_VALIDITY_TIME_FROM_OLSR(msn, 0);
-       }
-       cachedValidityTimeMsnValid = true;
-}
-
-/**
- Convert the validity time to the validity time for an OLSR message
-
- @param validityTime
- The validity time (in seconds)
-
- @return
- The validity time converted to the format for the wire format
- */
-unsigned char getValidityTimeForOlsr(unsigned long long validityTime) {
-       unsigned int msn = 1;
-       unsigned long long lsn = 0;
-       unsigned long long upperBound;
-
-       if (!cachedValidityTimeMsnValid) {
-               setupCachedValidityTimeMsn();
-       }
-       upperBound = cachedValidityTimeMsn[msn];
-       while ((msn < 16) && (validityTime >= upperBound)) {
-               msn++;
-               upperBound = cachedValidityTimeMsn[msn];
-       }
-       msn--;
-
-       if (unlikely(validityTime >= upperBound)) {
-               lsn = 15;
-       } else {
-               unsigned long lowerBound = PUD_VALIDITY_TIME_FROM_OLSR(msn, 0);
-               unsigned long resolution = (1 << msn);
-               lsn = ((validityTime - lowerBound + (resolution >> 1)) / resolution);
-       }
-
-       assert(msn <= 15);
-       assert(lsn <= 15);
-
-       return (msn << 4) | lsn;
-}
-
-/**
- Convert the validity time of an OLSR message to the validity time for internal
- use.
-
- @param internal
- The validity time as contained in the wire format
-
- @return
- The validity time converted to seconds
- */
-unsigned long getValidityTimeFromOlsr(unsigned char internal) {
-       return PUD_VALIDITY_TIME_FROM_OLSR(internal >> 4, internal % 16);
-}
-
-/* ************************************************************************
- * TIME
- * ************************************************************************ */
-
-/**
- Convert the time to the time for an OLSR message (the number of seconds after
- midnight).
-
- @param hour
- The hours
- @param min
- The minutes
- @param sec
- The seconds
-
- @return
- The time converted to the format for the wire format
- */
-unsigned long getTimeForOlsr(int hour, int min, int sec) {
-       return ((hour * 60 * 60) + (min * 60) + sec);
-}
-
-/**
- Convert the time of an OLSR message (the number of seconds after midnight) to
- a time structure, based on midnight of the current day.
-
- @param olsrTime
- The time from the wire format
- @param nowStruct
- A pointer to the time structure into which to put the converted time
- */
-void getTimeFromOlsr(uint32_t olsrTime, struct tm *nowStruct) {
-       unsigned int secNow;
-
-       time_t now = time(NULL);
-       gmtime_r(&now, nowStruct);
-
-       secNow = ((nowStruct->tm_hour * 60 * 60) + (nowStruct->tm_min * 60)
-                       + nowStruct->tm_sec);
-
-       if (secNow <= (12 * 60 * 60)) {
-               /* we are now in the first 12h of the day */
-               if (unlikely(olsrTime > (secNow + (12 * 60 * 60)))) {
-                       /* the message was sent more than 12h later in time:
-                        the message was sent yesterday: adjust the date by -1 day */
-                       now -= (24 * 60 * 60);
-                       gmtime_r(&now, nowStruct);
-               }
-       } else {
-               /* we are now in the last 12h of the day */
-               if (unlikely(olsrTime < (secNow - (12 * 60 * 60)))) {
-                       /* the message was sent more than 12h earlier in time:
-                        the message was sent tomorrow: adjust the date by +1 day */
-                       now += (24 * 60 * 60);
-                       gmtime_r(&now, nowStruct);
-               }
-       }
-
-       nowStruct->tm_mon++;
-       nowStruct->tm_hour = ((olsrTime % (24 * 60 * 60)) / 3600);
-       nowStruct->tm_min = ((olsrTime % (60 * 60)) / 60);
-       nowStruct->tm_sec = (olsrTime % 60);
-}
-
-/* ************************************************************************
- * LATITUDE
- * ************************************************************************ */
-
-/**
- Convert the latitude of a nmeaINFO structure to the latitude for an OLSR
- message
-
- @param infoLat
- The latitude as contained in an NMEA info structure (in degrees)
-
- @return
- The latitude converted to the format for the wire format
- */
-unsigned long getLatitudeForOlsr(double infoLat) {
-       double lat = infoLat;
-
-       /* lat is in [-90, 90] */
-       assert(lat >= -90.0);
-       assert(lat <= 90.0);
-
-       lat /= 180.0;
-       /* lat is now in [-0.5, 0.5] */
-
-       lat += 0.5;
-       /* lat is now in [0, 1] */
-
-       lat *= (double) (1 << PUD_LATITUDE_BITS);
-       /* lat is now in [0, LATITUDE_BITS] */
-
-       /* clip max */
-       if (unlikely(lat > (double)((1 << PUD_LATITUDE_BITS) - 1))) {
-               lat = (double) ((1 << PUD_LATITUDE_BITS) - 1);
-       }
-       /* lat is now in [0, 2^LATITUDE_BITS> */
-
-       return lrint(lat);
-}
-
-/**
- Convert the latitude of an OLSR message to the latitude for a nmeaINFO
- structure
-
- @param olsrLat
- The latitude as contained in the wire format
-
- @return
- The latitude converted to the format for an NMEA info structure (in degrees)
- */
-double getLatitudeFromOlsr(uint32_t olsrLat) {
-       double lat = (double) olsrLat;
-
-       /* lat is in [0, 2^LATITUDE_BITS> */
-
-       /* take half of the rounding error */
-       lat += 0.5;
-
-       lat /= (double) (1 << PUD_LATITUDE_BITS);
-       /* lat is now in [0, 1> */
-
-       lat -= 0.5;
-       /* lat is now in [-0.5, 0.5> */
-
-       lat *= 180.0;
-       /* lat is now in [-90, 90> */
-
-       return lat;
-}
-
-/* ************************************************************************
- * LONGITUDE
- * ************************************************************************ */
-
-/**
- Convert the longitude of a nmeaINFO structure to the longitude for an OLSR
- message
-
- @param infoLon
- The longitude as contained in an NMEA info structure (in degrees)
-
- @return
- The longitude converted to the format for the wire format
- */
-unsigned long getLongitudeForOlsr(double infoLon) {
-       double lon = infoLon;
-
-       /* lon is in [-180, 180] */
-       assert(lon >= -180.0);
-       assert(lon <= 180.0);
-
-       lon /= 360.0;
-       /* lon is now in [-0.5, 0.5] */
-
-       lon += 0.5;
-       /* lon is now in [0, 1] */
-
-       lon *= (double) (1 << PUD_LONGITUDE_BITS);
-       /* lon is now in [0, LONGITUDE_BITS] */
-
-       /* clip max */
-       if (unlikely(lon > (double)((1 << PUD_LATITUDE_BITS) - 1))) {
-               lon = (double) ((1 << PUD_LATITUDE_BITS) - 1);
-       }
-
-       /* lon is now in [0, 2^LONGITUDE_BITS> */
-
-       return lrint(lon);
-}
-
-/**
- Convert the longitude of an OLSR message to the longitude for a nmeaINFO
- structure
-
- @param olsrLon
- The longitude as contained in the wire format
-
- @return
- The longitude converted to the format for an NMEA info structure (in degrees)
- */
-double getLongitudeFromOlsr(uint32_t olsrLon) {
-       double lon = (double) olsrLon;
-
-       /* lon is in [0, 2^LONGITUDE_BITS> */
-
-       /* take half of the rounding error */
-       lon += 0.5;
-
-       lon /= (1 << PUD_LONGITUDE_BITS);
-       /* lon is now in [0, 1> */
-
-       lon -= 0.5;
-       /* lon is now in [-0.5, 0.5> */
-
-       lon *= 360.0;
-       /* lon is now in [-180, 180> */
-
-       return lon;
-}
-
-/* ************************************************************************
- * ALTITIDE
- * ************************************************************************ */
-
-/**
- Convert the altitude of a nmeaINFO structure to the altitude for an OLSR
- message
-
- @param infoElv
- The altitude as contained in an NMEA info structure
-
- @return
- The altitude converted to the format for the wire format
- */
-long getAltitudeForOlsr(double infoElv) {
-       double elv = infoElv;
-
-       if (unlikely(elv > PUD_ALTITUDE_MAX)) {
-               elv = PUD_ALTITUDE_MAX;
-       } else if (unlikely(elv < PUD_ALTITUDE_MIN)) {
-               elv = PUD_ALTITUDE_MIN;
-       }
-
-       elv -= PUD_ALTITUDE_MIN;
-
-       return lrint(elv);
-}
-
-/**
- Convert the altitude of an OLSR message to the altitude for a nmeaINFO
- structure
-
- @param olsrAlt
- The altitude as contained in the wire format
-
- @return
- The altitude converted to the format for an NMEA info structure
- */
-long getAltitudeFromOlsr(uint32_t olsrAlt) {
-       return (olsrAlt + PUD_ALTITUDE_MIN);
-}
-
-/* ************************************************************************
- * SPEED
- * ************************************************************************ */
-
-/**
- Convert the speed of a nmeaINFO structure to the speed for an OLSR message
-
- @param infoSpeed
- The speed as contained in an NMEA info structure
-
- @return
- The speed converted to the format for the wire format
- */
-long getSpeedForOlsr(double infoSpeed) {
-       if (unlikely(infoSpeed < 0)) {
-               return 0;
-       }
-       if (unlikely(infoSpeed > PUD_SPEED_MAX)) {
-               return PUD_SPEED_MAX;
-       }
-
-       return lrint(infoSpeed);
-}
-
-/**
- Convert the speed of an OLSR message to the speed for a nmeaINFO structure
-
- @param olsrSpeed
- The speed as contained in the wire format
-
- @return
- The speed converted to the format for an NMEA info structure
- */
-unsigned long getSpeedFromOlsr(uint32_t olsrSpeed) {
-       return olsrSpeed;
-}
-
-/* ************************************************************************
- * TRACK
- * ************************************************************************ */
-
-/**
- Convert the track angle of a nmeaINFO structure to the track angle for an OLSR
- message
-
- @param infoTrack
- The track angle as contained in an NMEA info structure
-
- @return
- The track angle converted to the format for the wire format
- */
-long getTrackForOlsr(double infoTrack) {
-       return lrint(infoTrack);
-}
-
-/**
- Convert the track angle of an OLSR message to the track angle for a nmeaINFO
- structure
-
- @param olsrTrack
- The track angle as contained in the wire format
-
- @return
- The track angle converted to the format for an NMEA info structure
- */
-unsigned long getTrackFromOlsr(uint32_t olsrTrack) {
-       return olsrTrack;
-}
-
-/* ************************************************************************
- * HDOP
- * ************************************************************************ */
-
-/**
- Convert the HDOP of a nmeaINFO structure to the HDOP for an OLSR message
-
- @param infoHdop
- The HDOP as contained in an NMEA info structure
-
- @return
- The HDOP converted to the format for the wire format
- */
-long getHdopForOlsr(double infoHdop) {
-       double infoHdopInternal = infoHdop;
-
-       if (unlikely(infoHdopInternal > PUD_HDOP_MAX)) {
-               infoHdopInternal = PUD_HDOP_MAX;
-       }
-
-       return lrint(infoHdopInternal / PUD_HDOP_RESOLUTION);
-}
-
-/**
- Convert the HDOP of an OLSR message to the HDOP for a nmeaINFO structure
-
- @param olsrHdop
- The HDOP as contained in the wire format
-
- @return
- The HDOP converted to the format for an NMEA info structure
- */
-double getHdopFromOlsr(uint32_t olsrHdop) {
-       return (olsrHdop * PUD_HDOP_RESOLUTION);
-}
-
-/* ************************************************************************
- * NodeInfo
- * ************************************************************************ */
-
-/**
- Get the nodeIdType, accounting for nodeId presence
-
- @param ipVersion
- The ip version, either AF_INET or AF_INET6
- @param olsrMessage
- A pointer to the OLSR message
-
- @return
- The nodeIdType
- */
-NodeIdType getNodeIdType(int ipVersion, union olsr_message * olsrMessage) {
-       PudOlsrWireFormat *olsrGpsMessage = getOlsrMessagePayload(ipVersion,
-                       olsrMessage);
-
-       if (olsrGpsMessage->smask & PUD_FLAGS_ID) {
-               return olsrGpsMessage->nodeInfo.nodeIdType;
-       }
-
-       return ((ipVersion == AF_INET) ? PUD_NODEIDTYPE_IPV4 : PUD_NODEIDTYPE_IPV6);
-}
-
-/**
- Get the nodeId and its size, accounting for nodeId presence
-
- @param ipVersion
- The ip version, either AF_INET or AF_INET6
- @param olsrMessage
- A pointer to the OLSR message
- @param buffer
- A pointer to the location where a pointer to the nodeId (as contained in the
- olsrMessage) can be stored
- @param bufferSize
- A pointer to the location where the number of bytes in the buffer can be
- stored
- */
-void getNodeIdPointers(int ipVersion, union olsr_message * olsrMessage,
-               unsigned char ** buffer, unsigned int * bufferSize) {
-       PudOlsrWireFormat * olsrGpsMessage = getOlsrMessagePayload(ipVersion, olsrMessage);
-
-       if (olsrGpsMessage->smask & PUD_FLAGS_ID) {
-               *buffer = &olsrGpsMessage->nodeInfo.nodeId;
-
-               switch (olsrGpsMessage->nodeInfo.nodeIdType) {
-                       case PUD_NODEIDTYPE_MAC: /* hardware address */
-                               *bufferSize = PUD_NODEIDTYPE_MAC_BYTES;
-                               break;
-
-                       case PUD_NODEIDTYPE_MSISDN: /* an MSISDN number */
-                               *bufferSize = PUD_NODEIDTYPE_MSISDN_BYTES;
-                               break;
-
-                       case PUD_NODEIDTYPE_TETRA: /* a Tetra number */
-                               *bufferSize = PUD_NODEIDTYPE_TETRA_BYTES;
-                               break;
-
-                       case PUD_NODEIDTYPE_DNS: /* DNS name */
-                               *buffer = (unsigned char *) &olsrGpsMessage->nodeInfo.nodeId;
-                               *bufferSize = strlen((char *)*buffer);
-                               break;
-
-                       case PUD_NODEIDTYPE_192:
-                               *bufferSize = PUD_NODEIDTYPE_192_BYTES;
-                               break;
-
-                       case PUD_NODEIDTYPE_193:
-                               *bufferSize = PUD_NODEIDTYPE_193_BYTES;
-                               break;
-
-                       case PUD_NODEIDTYPE_194:
-                               *bufferSize = PUD_NODEIDTYPE_194_BYTES;
-                               break;
-
-                       case PUD_NODEIDTYPE_IPV4: /* IPv4 address */
-                       case PUD_NODEIDTYPE_IPV6: /* IPv6 address */
-                       default: /* unsupported */
-                               olsrGpsMessage->smask &= ~PUD_FLAGS_ID;
-                               goto noId;
-               }
-
-               return;
-       }
-
-       /* message has NO nodeId information */
-       noId: {
-               *buffer = (unsigned char *) getOlsrMessageOriginator(ipVersion,
-                               olsrMessage);
-               *bufferSize = (ipVersion == AF_INET) ? PUD_NODEIDTYPE_IPV4_BYTES :
-                               PUD_NODEIDTYPE_IPV6_BYTES;
-       }
-
-       return;
-}
diff --git a/lib/pud/src/wireFormat.h b/lib/pud/src/wireFormat.h
deleted file mode 100644 (file)
index 0f094bb..0000000
+++ /dev/null
@@ -1,305 +0,0 @@
-#ifndef _PUD_WIREFORMAT_H_
-#define _PUD_WIREFORMAT_H_
-
-/* OLSRD includes */
-#include "olsr_protocol.h"
-
-/* System includes */
-#include <stdint.h>
-#include <time.h>
-#include <net/if.h>
-
-#include "olsr_protocol.h"
-
-/** The size of the buffer in which the OLSR message is assembled */
-#define TX_BUFFER_SIZE_FOR_OLSR 512
-
-/*
- * Version
- */
-
-/** The version of the wire format */
-#define PUD_WIRE_FORMAT_VERSION                0
-
-/*
- * Flags
- * We use the smask of nmeaINFO and the flags below on top of that
- */
-
-/** Flags that the GPS information contains the nodeId */
-#define PUD_FLAGS_ID                           0x80
-
-/*
- * Time
- */
-
-/** The number of bits for the time field */
-#define PUD_TIME_BITS                          17
-
-/*
- * Latitude
- */
-
-/** The number of bits for the latitude field */
-#define PUD_LATITUDE_BITS                      28
-
-/** The maximum size of the string representation of the latitude
- * sign [0,90] [0,59] dot [0,59] [0,999] */
-#define PUD_TX_LATITUDE_DIGITS         (1 + 2 + 2 + 1 + 2 + 3)
-
-/** The number of decimals of the latitude in the transmit sentence */
-#define PUD_TX_LATITUDE_DECIMALS       "5"
-
-/*
- * Longitude
- */
-
-/** The number of bits for the longitude field */
-#define PUD_LONGITUDE_BITS                     27
-
-/** The maximum size of the string representation of the longitude
- * sign [0,180] [0,59] dot [0,59] [0,999] */
-#define PUD_TX_LONGITUDE_DIGITS                (1 + 3 + 2 + 1 + 2 + 3)
-
-/** The number of decimals of the longitude in the transmit sentence */
-#define PUD_TX_LONGITUDE_DECIMALS      "5"
-
-/*
- * Altitude
- */
-
-/** The number of bits for the altitude field */
-#define PUD_ALTITUDE_BITS                      16
-
-/** The minimum altitude */
-#define PUD_ALTITUDE_MIN                       (-400)
-
-/** The maximum altitude */
-#define PUD_ALTITUDE_MAX       (((1 << PUD_ALTITUDE_BITS) - 1) + PUD_ALTITUDE_MIN)
-
-/** The maximum size of the string representation of the altitude */
-#define PUD_TX_ALTITUDE_DIGITS         6
-
-/*
- * Speed
- */
-
-/** The number of bits for the speed field */
-#define PUD_SPEED_BITS                         12
-
-/** The maximum speed value */
-#define PUD_SPEED_MAX                          ((1 << PUD_SPEED_BITS) - 1)
-
-/** The maximum size of the string representation of the speed */
-#define PUD_TX_SPEED_DIGITS                    4
-
-/*
- * Track
- */
-
-/** The number of bits for the track angle field */
-#define PUD_TRACK_BITS                         9
-
-/** The maximum size of the string representation of the track angle */
-#define PUD_TX_TRACK_DIGITS                    3
-
-/*
- * HDOP
- */
-
-/** The number of bits for the HDOP field */
-#define PUD_HDOP_BITS                          11
-
-/** The HDOP resolution (in m) */
-#define PUD_HDOP_RESOLUTION                    (0.1)
-
-/** The maximum HDOP value (in m) */
-#define PUD_HDOP_MAX           (((1 << PUD_HDOP_BITS) - 1) * PUD_HDOP_RESOLUTION)
-
-/** The maximum size of the string representation of the HDOP */
-#define PUD_TX_HDOP_DIGITS                     5
-
-/** The number of decimals of the HDOP in the transmit sentence */
-#define PUD_TX_HDOP_DECIMALS           "3"
-
-/*
- * Node ID Type
- */
-
-/** nodeIdType legal values */
-typedef enum _NodeIdType {
-       /** MAC address, 48 bits, 6 bytes */
-       PUD_NODEIDTYPE_MAC = 0,
-
-       /** MSISDN number, 15 digits, 50 bits, 7 bytes */
-       PUD_NODEIDTYPE_MSISDN = 1,
-
-       /** TETRA number, 17 digits, 57 bits, 8 bytes */
-       PUD_NODEIDTYPE_TETRA = 2,
-
-       /** DNS name, variable length */
-       PUD_NODEIDTYPE_DNS = 3,
-
-       /** IPv4 address, 32 bits, 4 bytes */
-       PUD_NODEIDTYPE_IPV4 = 4,
-
-       /** IPv6 address, 128 bits, 16 bytes */
-       PUD_NODEIDTYPE_IPV6 = 6,
-
-       /** Brandweer number, 7 digits, 24 bits, 3 bytes */
-       PUD_NODEIDTYPE_192 = 192,
-
-       /** Ambulance number, 6 digits, 20 bits, 3 bytes */
-       PUD_NODEIDTYPE_193 = 193,
-
-       /** Number in the range [1, 8191], 4 digits, 13 bits, 2 bytes */
-       PUD_NODEIDTYPE_194 = 194
-} NodeIdType;
-
-/** the number of nodeId bytes for PUD_NODEIDTYPE_MAC */
-#define PUD_NODEIDTYPE_MAC_BYTES               IFHWADDRLEN
-
-/** the number of nodeId bytes for PUD_NODEIDTYPE_MSISDN */
-#define PUD_NODEIDTYPE_MSISDN_BYTES            7
-
-/** the number of nodeId bytes for PUD_NODEIDTYPE_TETRA */
-#define PUD_NODEIDTYPE_TETRA_BYTES             8
-
-/** the number of nodeId bytes for PUD_NODEIDTYPE_192 */
-#define PUD_NODEIDTYPE_192_BYTES               3
-
-/** the number of nodeId bytes for PUD_NODEIDTYPE_193 */
-#define PUD_NODEIDTYPE_193_BYTES               3
-
-/** the number of nodeId bytes for PUD_NODEIDTYPE_194 */
-#define PUD_NODEIDTYPE_194_BYTES               2
-
-/** the number of nodeId bytes for PUD_NODEIDTYPE_IPV4 */
-#define PUD_NODEIDTYPE_IPV4_BYTES              sizeof(struct in_addr)
-
-/** the number of nodeId bytes for PUD_NODEIDTYPE_IPV6 */
-#define PUD_NODEIDTYPE_IPV6_BYTES              sizeof(struct in6_addr)
-
-/** The maximum size of the string representation of the nodeIdType */
-#define PUD_TX_NODEIDTYPE_DIGITS       3
-
-/*
- * Node ID
- */
-
-/** The maximum size of the string representation of the nodeId */
-#define PUD_TX_NODEID_BUFFERSIZE       1023
-
-/*
- * Wire Format Structures
- */
-
-/** Sub-format GPS information, 120 bits = 15 bytes */
-typedef struct _GpsInfo {
-               uint32_t time :PUD_TIME_BITS; /**< the number of seconds since midnight, ALWAYS present */
-               uint32_t lat :PUD_LATITUDE_BITS; /**< latitude */
-               uint32_t lon :PUD_LONGITUDE_BITS; /**< longitude */
-               uint32_t alt :PUD_ALTITUDE_BITS; /**< altitude */
-               uint32_t speed :PUD_SPEED_BITS; /**< speed */
-               uint32_t track :PUD_TRACK_BITS; /**< track angle */
-               uint32_t hdop :PUD_HDOP_BITS; /**< HDOP */
-}__attribute__((__packed__)) GpsInfo;
-
-/** Sub-format Node information, 8 + variable bits = 1 + variable bytes */
-typedef struct _NodeInfo {
-               uint8_t nodeIdType; /**< the nodeIdType */
-               unsigned char nodeId; /**< placeholder for variable length nodeId string */
-}__attribute__((__packed__)) NodeInfo;
-
-/** Complete format, 8+8+8+120+(8+variable) bits =  18+(1+variable) bytes*/
-typedef struct _PudOlsrWireFormat {
-               uint8_t version; /**< the version of the sentence */
-               uint8_t validityTime; /**< the validity time of the sentence */
-               uint8_t smask; /**< mask signaling the contents of the sentence */
-               GpsInfo gpsInfo; /**< the GPS information (MANDATORY) */
-               NodeInfo nodeInfo; /**< placeholder for node information (OPTIONAL) */
-}__attribute__((__packed__)) PudOlsrWireFormat;
-
-/** The size of the wire format, minus the size of the node information */
-#define PUD_OLSRWIREFORMATSIZE (sizeof(PudOlsrWireFormat) - sizeof(NodeInfo))
-
-/*
- * Uplink
- */
-
-/** the type of the uplink position update message */
-typedef enum _UplinkMessageType {
-       POSITION = 0
-} UplinkMessageType;
-
-/** TLV structure for uplink messages */
-typedef struct _UplinkWireFormat {
-               uint8_t type; /**< stores a UplinkMessageType */
-               uint16_t length; /**< the length of the payload in txBuffer */
-               uint8_t ipv6:1; /**< clear when IPv4, set when IPv6 */
-               uint8_t pad:7; /**< padding to align to 4 bytes */
-               union _msg {
-                       union olsr_message olsrMessage; /**< the olsr message */
-                       unsigned char txBuffer[TX_BUFFER_SIZE_FOR_OLSR]; /**< payload */
-               } msg;
-}__attribute__((__packed__)) UplinkWireFormat;
-
-/* ************************************************************************
- * FUNCTIONS
- * ************************************************************************ */
-
-/*
- * OLSR header
- */
-
-union olsr_ip_addr * getOlsrMessageOriginator(int ipVersion,
-               union olsr_message * olsrMessage);
-
-unsigned short getOlsrMessageSize(int ipVersion,
-               union olsr_message * olsrMessage);
-
-PudOlsrWireFormat * getOlsrMessagePayload(int ipVersion,
-               union olsr_message * olsrMessage);
-
-/*
- * PudOlsrWireFormat
- */
-
-unsigned char getValidityTimeForOlsr(unsigned long long validityTime);
-unsigned long getValidityTimeFromOlsr(unsigned char internal);
-
-/*
- * GpsInfo
- */
-
-unsigned long getTimeForOlsr(int hour, int min, int sec);
-void getTimeFromOlsr(uint32_t olsrTime, struct tm *nowStruct);
-
-unsigned long getLatitudeForOlsr(double infoLat);
-double getLatitudeFromOlsr(uint32_t olsrLat);
-
-unsigned long getLongitudeForOlsr(double infoLon);
-double getLongitudeFromOlsr(uint32_t olsrLon);
-
-long getAltitudeForOlsr(double infoElv);
-long getAltitudeFromOlsr(uint32_t olsrAlt);
-
-long getSpeedForOlsr(double infoSpeed);
-unsigned long getSpeedFromOlsr(uint32_t olsrSpeed);
-
-long getTrackForOlsr(double infoTrack);
-unsigned long getTrackFromOlsr(uint32_t olsrTrack);
-
-long getHdopForOlsr(double infoHdop);
-double getHdopFromOlsr(uint32_t olsrHdop);
-
-/*
- * NodeInfo
- */
-
-NodeIdType getNodeIdType(int ipVersion, union olsr_message * olsrMessage);
-
-void getNodeIdPointers(int ipVersion, union olsr_message * olsrMessage,
-               unsigned char ** buffer, unsigned int * bufferSize);
-
-#endif /* _PUD_WIREFORMAT_H_ */