GeoNetworking codecs ongoing

Add GeoNetworkingLayer

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.cc

 #include <string>
 #include <typeinfo>
 
-#include "TTCN3.hh"
+#//include <TTCN3.hh>
 
 #include "GeoNetworkingCodec.hh"
 #include "loggers.hh"
 
 #include "LibItsGeoNetworking_TypesAndValues.hh"
 
+template <typename T_type> class OPTIONAL;
+class TTCN_EncDec;
+
 int GeoNetworkingCodec::encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data)
 {
     loggers::loggers::log_msg(">>> GeoNetworkingCodec::encode: ", (const Base_Type&)msg);
     TTCN_Buffer encoding_buffer;
     encode_(msg, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu_descr_, encoding_buffer);
     data = OCTETSTRING(encoding_buffer.get_len(), encoding_buffer.get_data());
+    // Overwrite the payload length
+    if (_ec.plLength_position != (unsigned int)-1) {
+        loggers::loggers::log("GeoNetworkingCodec::encode: length=%d - plLength_position = %d - plLength = %d", data.lengthof(), _ec.plLength_position, _ec.plLength);
+        unsigned char b[] = { (unsigned char)((_ec.plLength & 0x0000FF00) >> 8), (unsigned char)_ec.plLength };
+        OCTETSTRING rpl(sizeof(b), b);
+        data = replace(data, _ec.plLength_position, rpl.lengthof(), rpl);
+    }
+
     return 0;
 }
 
 int GeoNetworkingCodec::decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg)
 {
-    loggers::loggers::log(">>> GeoNetworkingCodec::decode");
+    TTCN_Buffer decoding_buffer(data);
+    loggers::loggers::log_to_hexa(">>> GeoNetworkingCodec::decode: decoding_buffer=", decoding_buffer);
+    decode_(msg, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu_descr_, decoding_buffer);
+    loggers::loggers::log_msg("<<< GeoNetworkingCodec::decode: ", (const Base_Type&)msg);
+    return 0;
+}
+
+int GeoNetworkingCodec::decode_ (Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& decoding_buffer)
+{
+    loggers::loggers::log(">>> GeoNetworkingCodec::decode_: processing %s/%s", type.get_descriptor()->name, field_descriptor.name);
+
+    if (dynamic_cast<Record_Type *>(&type) != NULL) {
+        Record_Type& r = (Record_Type &)type;
+        loggers::loggers::log("GeoNetworkingCodec::decode_: processing Record_Type %s", r.get_descriptor()->name);
+        for(int i = 0; i < r.get_count(); i++) {
+            loggers::loggers::log("GeoNetworkingCodec::decode_: processing %s/%s/%s", r.fld_name(i), r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name);
+//            Base_Type *b = ((Base_Type *)(r.get_at(i)));
+//            ((Base_Type *)(r.get_at(i)))->decode_((const TTCN_Typedescriptor_t&)*r.fld_descr(i), decoding_buffer, TTCN_EncDec::CT_RAW);
+            if (decode_(*((Base_Type *)(r.get_at(i))), *(r.fld_descr(i)), decoding_buffer) == -1) {
+                return -1;
+            }
+        } // End of 'for' statement
+    } else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.ExtendedHeader") == 0) {
+        if (_dc.next_header < 4) {
+            LibItsGeoNetworking__TypesAndValues::ExtendedHeader extendedHeader;
+            if (decode_extendedHeader(extendedHeader, decoding_buffer) == -1) {
+                return -1;
+            }
+            type.set_value(extendedHeader.clone());
+        } else {
+        	type.set_to_omit();
+        }
+    } else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.Payload") == 0) {
+        if (_dc.plLength != 0) {
+            const OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &v = dynamic_cast<const OPTIONAL<LibItsGeoNetworking__TypesAndValues::Payload> &>(type);
+            loggers::loggers::log("GeoNetworkingCodec::decode_: Payload present: %d", v.is_present());
+//            if (decode_(static_cast<LibItsGeoNetworking__TypesAndValues::Payload &>(*v.get_opt_value()), LibItsGeoNetworking__TypesAndValues::Payload_descr_, decoding_buffer) == -1) {
+//                return -1;
+//            }
+        } else {
+            type.set_to_omit();
+        }
+    } else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.DecodedPayload") == 0) {
+        const OPTIONAL<LibItsGeoNetworking__TypesAndValues::DecodedPayload> &v = dynamic_cast<const OPTIONAL<LibItsGeoNetworking__TypesAndValues::DecodedPayload> &>(type);
+        loggers::loggers::log("GeoNetworkingCodec::decode_: DecodedPayload present: %d", v.is_present());
+        // TODO
+//        if (decode_decodedPayload(static_cast<const LibItsGeoNetworking__TypesAndValues::DecodedPayload &>(*v.get_opt_value()), encoding_buffer) == -1) {
+//            return -1;
+//        }
+    } else {
+        loggers::loggers::log("GeoNetworkingCodec::decode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);
+        if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.nextHeader") == 0) {
+            // Store NextHeader field value and continue decoding
+            _dc.next_header = (unsigned int)dynamic_cast<const Enum_Type &>(type).as_int();
+            loggers::loggers::log("GeoNetworkingCodec::decode_: Storing next_header %d for %s", _dc.next_header, field_descriptor.name);
+        } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {
+            // Store playload length and continue decoding
+            type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
+            _dc.plLength = dynamic_cast<const OCTETSTRING &>(type).lengthof();
+            loggers::loggers::log("GeoNetworkingCodec::decode_: Storing position payload length: %d", _dc.plLength);
+        } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.Payload.rawPayload") == 0) {
+            // Store playload length and continue decoding
+            _dc.plLength = dynamic_cast<const OCTETSTRING &>(type).lengthof();
+            loggers::loggers::log("GeoNetworkingCodec::decode_: Storing payload length %d for %s", _dc.plLength, field_descriptor.name);
+        } else {
+            type.decode(field_descriptor, decoding_buffer, TTCN_EncDec::CT_RAW);
+        }
+    }
+
+    loggers::loggers::log_msg("<<< GeoNetworkingCodec::decode_: ", type);
+    loggers::loggers::log_to_hexa("<<< GeoNetworkingCodec::decode_: decoding_buffer=", decoding_buffer);
+
     return 0;
 }
 
@@ -34,9 +116,9 @@ int GeoNetworkingCodec::encode_ (const Base_Type& type, const TTCN_Typedescripto
         for(int i = 0; i < r.get_count(); i++) {
             loggers::loggers::log("GeoNetworkingCodec::encode_: processing %s/%s/%s - %d (1 ==> use dynamic_cast<const OPTIONAL<...>) - %d", r.fld_name(i), r.fld_descr(i)->name, r.get_at(i)->get_descriptor()->name, r.get_at(i)->is_optional(), r.get_at(i)->is_present());
             if (r.get_at(i)->is_present()) {
-            	if (encode_(*r.get_at(i), *r.fld_descr(i), encoding_buffer) == -1) {
-            		return -1;
-            	}
+                if (encode_(*r.get_at(i), *r.fld_descr(i), encoding_buffer) == -1) {
+                    return -1;
+                }
             }
         } // End of 'for' statement
     } else if (std::string(type.get_descriptor()->name).compare("@LibItsGeoNetworking_TypesAndValues.ExtendedHeader") == 0) {
@@ -65,15 +147,23 @@ int GeoNetworkingCodec::encode_ (const Base_Type& type, const TTCN_Typedescripto
         }
     } else {
         loggers::loggers::log("GeoNetworkingCodec::encode_ (else): processing type %s/%s", type.get_descriptor()->name, field_descriptor.name);
-        if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {
+        if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.nextHeader") == 0) {
+            // Store NextHeader field value and continue encoding
+            _ec.next_header = (unsigned int)dynamic_cast<const Enum_Type &>(type).as_int();
+            loggers::loggers::log("GeoNetworkingCodec::encode_: Storing next_header %d for %s", _ec.next_header, field_descriptor.name);
+        } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.CommonHeader.plLength") == 0) {
             // Store TTCN_Buffer position and continue encoding
-            _plLength_position = encoding_buffer.get_pos_bit();
-            loggers::loggers::log("GeoNetworkingCodec::encode_: Storing position %d for %s", _plLength_position, field_descriptor.name);
+            _ec.plLength_position = encoding_buffer.get_len();
+            loggers::loggers::log("GeoNetworkingCodec::encode_: Storing position %d for %s", _ec.plLength_position, field_descriptor.name);
+        } else if (std::string(field_descriptor.name).compare("@LibItsGeoNetworking_TypesAndValues.Payload.rawPayload") == 0) {
+            // Store playload length and continue encoding
+            _ec.plLength = dynamic_cast<const OCTETSTRING &>(type).lengthof();
+            loggers::loggers::log("GeoNetworkingCodec::encode_: Storing payload length %d for %s", _ec.plLength, field_descriptor.name);
         }
         type.encode(field_descriptor, encoding_buffer, TTCN_EncDec::CT_RAW);
     }
-    loggers::loggers::log_to_hexa("GeoNetworkingCodec::encode_: encoding_buffer=", encoding_buffer);
 
+    loggers::loggers::log_to_hexa("<<<GeoNetworkingCodec::encode_: encoding_buffer=", encoding_buffer);
     return 0;
 }
 
@@ -127,6 +217,56 @@ int GeoNetworkingCodec::encode_extendedHeader(const LibItsGeoNetworking__TypesAn
     return result;
 }
 
+int GeoNetworkingCodec::decode_extendedHeader(LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& decoding_buffer) {
+    loggers::loggers::log(">>> GeoNetworkingCodec::decode_extendedHeader: processing %s", u.get_descriptor()->name);
+
+    int result = -1;
+//    switch (u.get_selection()) {
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::UNBOUND_VALUE:
+//            TTCN_error("GeoNetworkingCodec::decode_extendedHeader: Invalid selection in unbound union");
+//            break;
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoUnicastHeader:
+//            loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.geoUnicastHeader().get_descriptor()->name);
+//            result = decode_(u.geoUnicastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoUnicastHeader_descr_, encoding_buffer);
+//            break;
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_tsbHeader:
+//            loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.tsbHeader().get_descriptor()->name);
+//            result = decode_(u.tsbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_tsbHeader_descr_, encoding_buffer);
+//            break;
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_shbHeader:
+//            loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.shbHeader().get_descriptor()->name);
+//            result = decode_(u.shbHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_shbHeader_descr_, encoding_buffer);
+//            break;
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoBroadcastHeader:
+//            loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.geoBroadcastHeader().get_descriptor()->name);
+//            result = decode_(u.geoBroadcastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoBroadcastHeader_descr_, encoding_buffer);
+//            break;
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_geoAnycastHeader:
+//            loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.geoAnycastHeader().get_descriptor()->name);
+//            result = decode_(u.geoAnycastHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_geoAnycastHeader_descr_, encoding_buffer);
+//            break;
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_beaconHeader:
+//            loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.beaconHeader().get_descriptor()->name);
+//            result = decode_(u.beaconHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_beaconHeader_descr_, encoding_buffer);
+//            break;
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_anyHeader:
+//            loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.anyHeader().get_descriptor()->name);
+//            result = decode_(u.anyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_anyHeader_descr_, encoding_buffer);
+//            break;
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsRequestHeader:
+//            loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.lsRequestHeader().get_descriptor()->name);
+//            result = decode_(u.lsRequestHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsRequestHeader_descr_, encoding_buffer);
+//            break;
+//        case LibItsGeoNetworking__TypesAndValues::ExtendedHeader::ALT_lsReplyHeader:
+//            loggers::loggers::log("GeoNetworkingCodec::decode_extendedHeader: processing type %s", u.lsReplyHeader().get_descriptor()->name);
+//            result = decode_(u.lsReplyHeader(), LibItsGeoNetworking__TypesAndValues::ExtendedHeader_lsReplyHeader_descr_, encoding_buffer);
+//            break;
+//        default: TTCN_error("GeoNetworkingCodec::decode_extendedHeader: Invalid selection in union is_bound");
+//    } // End of 'switch' statement
+
+    return result;
+}
+
 int GeoNetworkingCodec::encode_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, TTCN_Buffer& encoding_buffer) {
     loggers::loggers::log(">>> GeoNetworkingCodec::encode_decodedPayload: processing %s", u.get_descriptor()->name);
 

ccsrc/Protocols/GeoNetworking/GeoNetworkingCodec.hh

@@ -2,25 +2,51 @@
 #define GNCODEC_H
 #include "Codec.hh"
 
+class Base_Type;
+class OCTETSTRING;
+class TTCN_Typedescriptor_t;
+class TTCN_Buffer;
+
+
 namespace LibItsGeoNetworking__TypesAndValues {
-	class GeoNetworkingPdu;
-	class ExtendedHeader;
-	class DecodedPayload;
+    class GeoNetworkingPdu;
+    class ExtendedHeader;
+    class DecodedPayload;
 }
 
+struct Encoding_Context {
+    unsigned char next_header; // FIXME Useless?
+    unsigned int plLength_position;
+    unsigned int plLength;
+
+    Encoding_Context() { next_header = 0xff; plLength_position = -1; plLength = -1; }
+};
+
+struct Decoding_Context {
+    unsigned char next_header; // FIXME Useless?
+    unsigned int plLength;
+
+    Decoding_Context() { next_header = 0xff; plLength = -1; }
+};
+
 class GeoNetworkingCodec : public Codec<LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu> {
 
-	unsigned int _plLength_position;
+    Encoding_Context _ec;
+    Decoding_Context _dc;
+
+    int encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer);
+    int encode_extendedHeader(const LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& encoding_buffer);
+    int encode_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, TTCN_Buffer& encoding_buffer);
+
+    int decode_ (Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& decoding_buffer);
+    int decode_extendedHeader(LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& decoding_buffer);
 
-	int encode_ (const Base_Type& type, const TTCN_Typedescriptor_t& field_descriptor, TTCN_Buffer& encoding_buffer);
-	int encode_extendedHeader(const LibItsGeoNetworking__TypesAndValues::ExtendedHeader& u, TTCN_Buffer& encoding_buffer);
-	int encode_decodedPayload(const LibItsGeoNetworking__TypesAndValues::DecodedPayload& u, TTCN_Buffer& encoding_buffer);
 
 public:
-	GeoNetworkingCodec() : _plLength_position(0) {};
+    GeoNetworkingCodec() : _ec(), _dc() {};
 
-    virtual int encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu&, OCTETSTRING& data);
-    virtual int decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu&);
+    virtual int encode (const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg, OCTETSTRING& data);
+    virtual int decode (const OCTETSTRING& data, LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu& msg);
 };
 
 #endif

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.cc

+#include "GeoNetworkingLayer.hh"
+#include "GeoNetworkingTypes.hh"
+
+#include "loggers.hh"
+
+void GeoNetworkingLayer::sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq& p, const Params& params) {
+    loggers::loggers::log(">>> GeoNetworkingLayer::sendMsg");
+    const LibItsGeoNetworking__TypesAndValues::GeoNetworkingPdu & pdu = p.msgOut();
+    OCTETSTRING data;
+    _codec.encode(pdu, data);
+    const unsigned char mac_address[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+    data += OCTETSTRING(sizeof(mac_address), static_cast<const unsigned char *>(mac_address));
+    sendData(data, params);
+}
+
+void GeoNetworkingLayer::sendData(const OCTETSTRING& data, const Params& params) {
+    sendToAllLayers(data, params);
+}
+
+void GeoNetworkingLayer::receiveData(const OCTETSTRING& data, const Params& info) {
+    LibItsGeoNetworking__TestSystem::GeoNetworkingInd p;
+//    _codec.decode(data, p);
+
+    toAllUpperPorts(p, info);
+
+//    if (p.payload().is_present()) {
+//        toAllUpperLayers(p.payload()().rawPayload(), info);
+//    }
+}
+
+class GeoNetworkingFactory: public LayerFactory {
+    static GeoNetworkingFactory _f;
+public:
+    GeoNetworkingFactory();
+    virtual Layer * createLayer(const std::string & type,
+            const std::string & param);
+};
+
+GeoNetworkingFactory::GeoNetworkingFactory() {
+    // register factory
+    LayerStackBuilder::RegisterLayerFactory("GeoNetworking", this);
+}
+
+Layer * GeoNetworkingFactory::createLayer(const std::string & type, const std::string & param) {
+    return new GeoNetworkingLayer();
+}
+
+GeoNetworkingFactory GeoNetworkingFactory::_f;

ccsrc/Protocols/GeoNetworking/GeoNetworkingLayer.hh

+#ifndef GEONETWORKING_LAYER_H
+#define GEONETWORKING_LAYER_H
+#include "Layer.hh"
+#include "GeoNetworkingCodec.hh"
+
+namespace LibItsGeoNetworking__TestSystem {
+	class GeoNetworkingPort;
+	class GeoNetworkingReq;
+}
+
+class GeoNetworkingLayer : public TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort> {
+	GeoNetworkingCodec _codec;
+  public:
+    inline GeoNetworkingLayer():TLayer<LibItsGeoNetworking__TestSystem::GeoNetworkingPort>(){}
+    virtual ~GeoNetworkingLayer(){}
+
+    void sendMsg(const LibItsGeoNetworking__TestSystem::GeoNetworkingReq&, const Params& param);
+
+    virtual void sendData(const OCTETSTRING& data, const Params& params);
+    virtual void receiveData(const OCTETSTRING& data, const Params& info);
+};
+
+#endif

ccsrc/Protocols/GeoNetworking/Makefile

+PROJECTROOT  = ..
+BUILDROOT    = ../../bin
+PROJECT      = its-framework
+DEBUG        = yes
+testdir      = tests
+srcdir       = .
+ccflags      += -O0 -ggdb -std=c++11 -DTITAN_RUNTIME_2
+
+alibs        = $(PROJECT)
+
+sources       := ../../Framework/src/LayerFactory.cc GeoNetworkingCodec.cc GeoNetworkingLayer.cc
+headers       := Codec.hh Layer.hh GeoNetworkingTypes.hh GeoNetworkingCodec.hh  GeoNetworkingLayer.hh
+includes      := . .. ../../Framework ../../loggers ../../../../bin
+
+include ../../common.mk