ccsrc/Protocols/UpperTester/uppertester_geonetworking_codec.cc

@@ -4,7 +4,8 @@
 #include "uppertester_geonetworking_codec.hh"
 #include "loggers.hh"
 
-#include "uppertester_types.hh"
+#include "LibItsGeoNetworking_TypesAndValues.hh"
+#include "LibItsGeoNetworking_TestSystem.hh"
 
 template <typename T_type> class OPTIONAL;
 class TTCN_EncDec;

ccsrc/Protocols/UpperTester/uppertester_geonetworking_layer.cc

 #include "uppertester_geonetworking_factory.hh"
 
-#include "uppertester_types.hh"
+#include "LibItsGeoNetworking_TypesAndValues.hh"
+#include "LibItsGeoNetworking_TestSystem.hh"
 
 #include "loggers.hh"
 

ccsrc/Protocols/UpperTester/uppertester_ivim_codec.cc

@@ -4,7 +4,8 @@
 #include "uppertester_ivim_codec.hh"
 #include "loggers.hh"
 
-#include "uppertester_types.hh"
+#include "LibItsIvim_TypesAndValues.hh"
+#include "LibItsIvim_TestSystem.hh"
 
 #include "ivim_codec.hh"
 

ccsrc/Protocols/UpperTester/uppertester_ivim_layer.cc

 #include "uppertester_ivim_factory.hh"
 
-#include "uppertester_types.hh"
+#include "LibItsIvim_TypesAndValues.hh"
+#include "LibItsIvim_TestSystem.hh"
 
 #include "loggers.hh"
 

ccsrc/Protocols/UpperTester/uppertester_mapem_spatem_codec.cc

@@ -4,7 +4,8 @@
 #include "uppertester_mapem_spatem_codec.hh"
 #include "loggers.hh"
 
-#include "uppertester_types.hh"
+#include "LibItsMapemSpatem_TypesAndValues.hh"
+#include "LibItsMapemSpatem_TestSystem.hh"
 
 #include "mapem_codec.hh"
 #include "spatem_codec.hh"

ccsrc/Protocols/UpperTester/uppertester_mapem_spatem_layer.cc

 #include "uppertester_mapem_spatem_factory.hh"
 
-#include "uppertester_types.hh"
+#include "LibItsMapemSpatem_TypesAndValues.hh"
+#include "LibItsMapemSpatem_TestSystem.hh"
 
 #include "loggers.hh"
 

ccsrc/Protocols/UpperTester/uppertester_pki_codec.cc

@@ -4,7 +4,8 @@
 #include "uppertester_pki_codec.hh"
 #include "loggers.hh"
 
-#include "uppertester_types.hh"
+#include "LibItsPki_TypesAndValues.hh"
+#include "LibItsPki_TestSystem.hh"
 
 //#include "pki_codec.hh"
 

ccsrc/Protocols/UpperTester/uppertester_pki_layer.cc

 #include "uppertester_pki_layer_factory.hh"
 
-#include "uppertester_types.hh"
+#include "LibItsPki_TypesAndValues.hh"
+#include "LibItsPki_TestSystem.hh"
 
 #include "loggers.hh"
 

ccsrc/Protocols/UpperTester/uppertester_types.hh

-#ifndef UpperTesterTYPES_H
-#define UpperTesterTYPES_H
-
-using namespace std; // Required for isnan()
-#include "LibItsGeoNetworking_TypesAndValues.hh"
-#include "LibItsGeoNetworking_TestSystem.hh"
-
-#include "LibItsDenm_TypesAndValues.hh"
-#include "LibItsDenm_TestSystem.hh"
-
-#include "LibItsCam_TypesAndValues.hh"
-#include "LibItsCam_TestSystem.hh"
-
-#include "LibItsIvim_TypesAndValues.hh"
-#include "LibItsIvim_TestSystem.hh"
-
-#include "LibItsMapemSpatem_TypesAndValues.hh"
-#include "LibItsMapemSpatem_TestSystem.hh"
-
-#include "LibItsSremSsem_TypesAndValues.hh"
-#include "LibItsSremSsem_TestSystem.hh"
-
-#include "LibItsRtcmem_TypesAndValues.hh"
-#include "LibItsRtcmem_TestSystem.hh"
-
-#include "LibItsPki_TypesAndValues.hh"
-#include "LibItsPki_TestSystem.hh"
-
-#endif

ccsrc/geospacial/geospacial.cc

+#include "geospacial.hh"
+
+coordinates::coordinates() {
+  latitude = .0;
+  longitude = .0;
+  altitude = .0;
+}
+
+coordinates::coordinates(const double p_latitude, const double p_longitude, const double p_altitude) {
+  latitude = p_latitude;
+  longitude = p_longitude;
+  altitude = p_altitude;
+}
+
+const bool coordinates::is_valid_coordinates() const {
+  if (latitude > -90.0L && latitude < 90.L && longitude > -180.0L && longitude < 180L) {
+    return true;
+  } else if (latitude > -HALFPI && latitude < HALFPI && longitude > -PI && longitude < PI) {
+    return true;
+    }
+  return false;
+}
+
+const double coordinates::distance_less_than_1km(const coordinates& p) const { // this position has origin
+  double a = HALFPI - latitude;
+  double b = HALFPI - p.latitude;
+  double c = sqrt(a * a + b * b - 2 * a * b * cos(p.longitude - longitude));
+    return (double)(R * c);
+}
+
+const double coordinates::distance(const coordinates& p) const { // this position has origin
+  double dlon = p.longitude - longitude;
+  double dlat = p.latitude - latitude;
+  double s1 = sin(dlat / 2);
+  double s2 = sin(dlon /2 );
+  double a = (s1 * s1) + cos(latitude) * cos(p.latitude) * (s2 * s2);
+  double c = 2 * asin(std::min((double)1.0L, sqrt(a)));
+  return (double)(R * c);
+}
+
+point::point() {
+  x = .0;
+  y = .0;
+  z = .0;
+}
+
+point::point(const double p_x, const double p_y, const double p_z) {
+  x = p_x;
+  y = p_y;
+    z = p_z;
+}
+
+int geospacial::load_countries_map(const std::string& p_file) {
+  std::ifstream ifs;
+  ifs.open(p_file);
+  if (ifs.fail()) {
+    ifs.close();
+    return -1;
+  }
+
+  Json::CharReaderBuilder builder;
+  builder["collectComments"] = true;
+  JSONCPP_STRING errs;
+  Json::Value root;
+  if (!parseFromStream(builder, ifs, &root, &errs)) {
+    std::cerr << errs << std::endl;
+    ifs.close();
+    return -1;
+  }
+  // Get the value of the member of root named 'encoding', return a 'null' value if there is no such member.
+  const Json::Value plugins = root["features"];
+  for (Json::Value::const_iterator it = plugins.begin() ; it != plugins.end() ; it++ ) {
+    const Json::Value v = *it;
+    Json::Value::Members m = v.getMemberNames();
+    std::string key;
+    std::vector<polygon> coord;
+    for (std::vector<std::string>::const_iterator i = m.cbegin(); i != m.cend(); ++i) {
+      if (std::string(*i).compare("properties") == 0) {
+        key = process_properties(v[*i]);
+      } else if (std::string(*i).compare("geometry") == 0) {
+        coord = process_geometry(v[*i]);
+      }
+    }
+    std::pair<std::map<std::string, std::vector<polygon>>::iterator, bool> ret = _countries.insert(std::pair<std::string, std::vector<polygon>>(key, coord));
+    if (ret.second == false) {
+      // Element already exist, add update it
+      //std::cerr << "element already existed: " << key << " - " << coord.size() << std::endl;
+      _countries[key].insert(_countries[key].end(), coord.begin(), coord.end());
+    }
+  } // End of 'for' statement
+  ifs.close();
+
+  return 0;
+}
+
+const int geospacial::is_in_country(const std::string& p_country, const coordinates& p_position) {
+  if (_countries.size() == 0) {
+    return -1;
+  }
+  std::map<std::string, std::vector<polygon>>::const_iterator it = _countries.find(p_country);
+  if (it == _countries.cend()) {
+    return -1;
+  }
+
+  point p = wgs84_to_point(p_position.latitude, p_position.longitude);
+  for (auto ik = it->second.cbegin(); ik != it->second.cend(); ++ik) {
+    if (is_inside_polygon(*ik, p) == 0) {
+      return 0;
+    }
+  } // End of 'for' statement
+
+  return -1;
+}
+
+const std::string geospacial::process_properties(const Json::Value p_properties) {
+  return p_properties["iso_n3"].asString();
+}
+
+const std::vector<polygon> geospacial::process_geometry(const Json::Value p_geometry) {
+  std::vector<polygon> ar;
+  for (Json::Value::const_iterator it = p_geometry["coordinates"].begin() ; it != p_geometry["coordinates"].end() ; it++ ) {
+    std::vector<polygon> polygons = extract_polygons(*it);
+    ar.insert(ar.end(), polygons.begin(), polygons.end());
+  }
+
+  return ar;
+}
+
+const std::vector<polygon> geospacial::extract_polygons(const Json::Value p_polygon) {
+  std::vector<polygon> l;
+  Json::Value::const_iterator it = p_polygon.begin();
+  Json::Value::const_iterator ik = static_cast<const Json::Value>(*it).begin();
+  if (static_cast<const Json::Value>(*ik).isArray()) {
+    l = extract_polygons(*it);
+  } else if (static_cast<const Json::Value>(*ik).isDouble()) {
+    polygon p;
+    for ( ; it != p_polygon.end() ; it++ ) {
+      ik = static_cast<const Json::Value>(*it).begin();
+      coordinates c(
+                    static_cast<const Json::Value>(*++ik).asDouble(), // latitude
+                    static_cast<const Json::Value>(*ik).asDouble(), // longitude
+                    .0
+                    );
+        p.push_back(std::make_tuple(c, wgs84_to_point(c.latitude, c.longitude)));
+    } // End of 'for' statement
+    l.push_back(p);
+  } else {
+    std::cerr << "extract_polygons: wrong type" << std::endl;
+  }
+
+  return l;
+}
+
+const point geospacial::wgs84_to_point(const double p_latitude, const double p_longitude) const {
+  double latitude_rad = p_latitude * PI / 180.0L;
+  double longitude_rad = p_longitude * PI / 180.0L;
+  return point(
+               (double)(R * cos(latitude_rad) * cos(longitude_rad)),
+               (double)(R * cos(latitude_rad) * sin(longitude_rad)),
+               (double)(R * sin(latitude_rad))
+               );
+}
+
+const int geospacial::is_inside_polygon(const polygon& p_polygon, const point& q) const {
+  int i;
+  double angle = .0L;
+  point p1;
+  point p2;
+  int n = p_polygon.size();
+
+  for (i = 0; i < n; i++) {
+    //std::clog << "is_inside_polygon: Processing vertex " << i << " -> " << (i + 1) % n << std::endl;
+    point p = std::get<1>(p_polygon[i]);
+    point pnext = std::get<1>(p_polygon[(i + 1) % n]);
+    p1.x = p.x - q.x;
+    p1.y = p.y - q.y;
+    p2.x = pnext.x - q.x;
+    p2.y = pnext.y - q.y;
+    angle += CalcAngleSum_2d(p1, p2);
+    //std::clog << "is_inside_polygon: New angle " << angle << std::endl;
+  }
+  //std::clog << "is_inside_polygon: Final angle " << fabs(angle) << std::endl;
+
+  if (fabs(angle) < PI)
+    return -1;
+  else
+    return 0;
+}
+
+const double geospacial::CalcAngleSum_2d(const point& p1, const point& p2) const {
+  double theta1 = atan2(p1.y, p1.x);
+  double theta2 = atan2(p2.y, p2.x);
+  double dtheta = theta2 - theta1;
+  while (dtheta > PI)
+    dtheta -= TWOPI;
+  while (dtheta < -PI)
+      dtheta += TWOPI;
+
+  return(dtheta);
+}

ccsrc/geospacial/geospacial.hh

+#pragma once
+
+#include <memory>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <tuple>
+#include <map>
+
+#include <cmath>
+
+#include <json/json.h>
+
+#define EPSILON  0.0000001
+#define MODULUS(p) (sqrt(p.x * p.x + p.y * p.y + p.z * p.z))
+#define PI 3.1415926535897932384626435
+#define HALFPI 1.5707963267948966192313216916398
+#define TWOPI 6.283185307179586476925287
+//#define RTOD 57.2957795
+#define R 6378140.0 // Radius of the earth in meters
+
+class coordinates {
+public:
+  double latitude;
+  double longitude;
+  double altitude;
+public:
+  coordinates();
+  coordinates(const double p_latitude, const double p_longitude, const double p_altitude);
+  virtual ~coordinates() { };
+  inline const coordinates to_radian() const { return coordinates(latitude * PI / 180, longitude * PI / 180, altitude); };
+  const bool is_valid_coordinates() const;;
+  const double distance_less_than_1km(const coordinates& p) const; // this position has origin
+  const double distance(const coordinates& p) const; // this position has origin
+};
+
+class point {
+public:
+  double x, y, z;
+public:
+  point();
+  point(const double p_x, const double p_y, const double p_z);
+};
+
+typedef std::vector<std::tuple<coordinates, point>> polygon;
+
+class geospacial {
+  std::map<std::string, std::vector<polygon>> _countries;
+  const point wgs84_to_point(const double p_latitude, const double p_longitude) const;
+  const std::string process_properties(const Json::Value p_properties);
+  const std::vector<polygon> process_geometry(const Json::Value p_geometry);
+  const std::vector<polygon> extract_polygons(const Json::Value p_polygon);
+  const double CalcAngleSum_2d(const point& p1, const point& p2) const;
+  const int is_inside_polygon(const polygon& p_polygon, const point& q) const;
+public:
+  geospacial() { };
+  virtual ~geospacial() { };
+  int load_countries_map(const std::string& p_file);
+  const int is_in_country(const std::string& p_country, const coordinates& p_position);
+};

ccsrc/geospacial/module.mk

+sources := geospacial.cc
+includes := .
+

ccsrc/loggers/module.mk

+sources := loggers.cc 
+includes := .
+

config.mk

+TTCN3_DIR      := /cygdrive/c/Tools/Titan
+WPCAP_DLL_PATH := /cygdrive/c/windows/system32/npcap/wpcap.dll
+NPCAP_INCLUDE  := /cygdrive/c/PROGRA~1/Npcap/sdk/include

data/v3/profiles/CERT_IUT_A_B33_AT.xml

 <certificate>
 	<version>3</version>
-	<signer type="digest" name="CERT_IUT_A_B3_AA"/>
+	<signer type="digest" alg="sha384" name="CERT_IUT_A_B3_AA"/>
 	<subject type="AT" name="">
 		<!-- verification_key -->
 		<attribute type="verification_key">

data/v3/profiles/CERT_IUT_CAM_BO_02_AT.xml

@@ -17,7 +17,7 @@
 		</attribute>
 		<!-- its_aid_ssp_list -->
 		<attribute type="its_aid_ssp_list">
-			<ssp aid="CAM">01 BF FF</ssp>  <!-- CAM: no publicTransport  -->
+			<ssp aid="CAM">01 BF FC</ssp>  <!-- CAM: no publicTransport  -->
 		</attribute>
 	</subject>
 	<validity>

data/v3/profiles/CERT_IUT_CAM_BO_03_AT.xml

@@ -17,7 +17,7 @@
 		</attribute>
 		<!-- its_aid_ssp_list -->
 		<attribute type="its_aid_ssp_list">
-			<ssp aid="CAM">01 DF FF</ssp>  <!-- CAM: no specialTransport   -->
+			<ssp aid="CAM">01 DF FC</ssp>  <!-- CAM: no specialTransport   -->
 		</attribute>
 	</subject>
 	<validity>

data/v3/profiles/CERT_IUT_C_AT.xml

@@ -20,7 +20,7 @@
 		</attribute>
 		<!-- its_aid_ssp_list -->
 		<attribute type="its_aid_ssp_list">
-			<ssp aid="CAM">01 FF FF </ssp>  <!-- CAM -->
+			<ssp aid="CAM">01 FF FC </ssp>  <!-- CAM -->
 			<ssp aid="DENM">01 FF FF FF </ssp>  <!-- DENM -->
 			<ssp aid="GN-MGMT"></ssp> <!--ssp aid="GN-MGMT">00</ssp-->  <!-- GN-MGMT -->
 		</attribute>

data/v3/profiles/CERT_IUT_C_RCA.xml

@@ -28,6 +28,8 @@
 			<aid value="SREM"/> <!-- TLC REQUEST-->
 			<aid value="SSEM"/> <!-- TLC RESPONSE -->
 			<aid value="GN-MGMT"/> <!-- GN-MGMT -->
+		</attribute>
+		<attribute type="its_aid_list" minChainLength="1">
 			<aid value="CRT-REQ">01 FE/FF 01</aid> <!-- Cert request: any -->
 		</attribute>
 		<attribute type="its_aid_ssp_list">

data/v3/profiles/CERT_TS_CAM_BO_02_AT.xml

@@ -18,7 +18,7 @@
 		</attribute>
 		<!-- its_aid_ssp_list -->
 		<attribute type="its_aid_ssp_list">
-			<ssp aid="CAM">01 BF FF</ssp>  <!-- CAM: no publicTransport  -->
+			<ssp aid="CAM">01 BF FC</ssp>  <!-- CAM: no publicTransport  -->
 		</attribute>
 	</subject>
 	<validity>