Start on Logbook

.vscode/settings.json

@@ -1,7 +1,3 @@
 {
   "cmake.generator": "Unix Makefiles",
-  "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
-  "files.associations": {
-    "cmath": "cpp"
-  }
 }

TODO.md

@@ -0,0 +1 @@
+- Reverse engineer FSUIPC .NET onRunway Check

file/include/logbook.h

@@ -0,0 +1,38 @@
+#ifndef GERMANAIRLINESVA_GACONNECTOR_LOGBOOK_H
+#define GERMANAIRLINESVA_GACONNECTOR_LOGBOOK_H
+
+#include <cstdint>
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "logbookEntry.h"
+
+namespace germanairlinesva_logbook
+{
+  /*
+   * Logbook Header (6)
+   * CHAR[5] | UINT8
+   * --------+--------
+   * VGAL    | VERSION
+   *
+   * Logbook Entries (n)
+   * LOGBOOKENTRY[]
+   */
+  class Logbook
+  {
+    private:
+      std::ifstream fileStream;
+      std::vector<std::uint8_t> file{'V', 'G', 'A', 'L', '\0', 1};
+
+      void fromFile();
+      void readVersion1();
+
+    public:
+      Logbook(std::ifstream &logbook);
+      void addEntry(LogbookEntry entry);
+      void toFile(std::ofstream &logbook);
+  };
+} // namespace germanairlinesva_logbook
+
+#endif

file/include/logbookEntry.h

@@ -0,0 +1,167 @@
+#ifndef GERMANAIRLINESVA_GACONNECTOR_LOGBOOKENTRY_H
+#define GERMANAIRLINESVA_GACONNECTOR_LOHBOOKENTRY_H
+
+#include <cstdint>
+#include <cstring>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace germanairlinesva_logbook
+{
+  /*
+   * Preamble (24)
+   * CHAR[10] | CHAR[4]       | CHAR[4]  | CHAR[6]
+   * ---------+---------------+----------+-------------
+   * DATE     | FLIGHT NUMBER | AIRCRAFT | REGISTRATION
+
+   * Departure Airport Name (2...256)
+   * UINT8  | CHAR[]
+   * -------+-------
+   * STRLEN | STRING
+
+   * Departure Gate Name (2...256)
+   * UINT8  | CHAR[]
+   * -------+-------
+   * STRLEN | STRING
+
+   * Departure Runway Name (2...256)
+   * UINT8  | CHAR[]
+   * -------+-------
+   * STRLEN | STRING
+
+   * Arrival Airport Name (2...256)
+   * UINT8  | CHAR[]
+   * -------+-------
+   * STRLEN | STRING
+
+   * Arrival Gate Name (2...256)
+   * UINT8  | CHAR[]
+   * -------+-------
+   * STRLEN | STRING
+
+   * Arrival Runway Name (2...256)
+   * UINT8  | CHAR[]
+   * -------+-------
+   * STRLEN | STRING
+
+   * Times (24)
+   * CHAR[5]   | CHAR[5]       | CHAR[5]      | CHAR[4]       | FLOAT
+   * ----------+---------------+--------------+---------------+------
+   * OFF BLOCK | TAKEOFF (OUT) | LANDING (ON) | ON BLOCK (IN) | TOTAL
+
+   * Fuels (16)
+   * FLOAT    | FLOAT     | FLOAT   | FLOAT
+   * ---------+-----------+---------+------
+   * TAXI OUT | IN FLIGHT | TAXI IN | TOTAL
+
+   * Distances (16)
+   * FLOAT    | FLOAT     | FLOAT   |FLOAT
+   * ---------+-----------+---------+-----
+   * TAXI OUT | IN FLIGHT | TAXI IN |TOTAL
+
+   * Landing (9)
+   * FLOAT    | CHAR       | FLOAT
+   * ---------+----------  +------------
+   * MAX RATE | TOUCHDOWNS | MAX G-FORCE
+
+   * Recording Filename (2...256)
+   * UINT8  | CHAR[]
+   * -------+-------
+   * STRLEN | STRING
+
+   * Postamble (5)
+   * FLOAT32 | BITFIELD
+   * --------------+---
+   * POINTS  | FLAGS
+
+   * Flags Bitfield
+   * 7 | 6 | 5 | 4 | 3 | 2 | 1 |   0
+   * ---+---+---+---+---+---+---+-----
+   * NIL|NIL|NIL|NIL|NIL|NIL|NIL|FILED
+   */
+  class LogbookEntry
+  {
+    private:
+      std::string date;
+      std::string flightNumber;
+      std::string aircraftType;
+      std::string aircraftRegistration;
+      std::string departureAirport;
+      std::string departureGate;
+      std::string departureRunway;
+      std::string arrivalAirport;
+      std::string arrivaleGate;
+      std::string arrivalRunway;
+      std::string offBlockTime;
+      std::string outTime;
+      std::string inTime;
+      std::string onBlockTime;
+      float totalFlightTime;
+      float taxiOutFuel;
+      float inFlightFuel;
+      float taxiInFuel;
+      float totalFuel;
+      float taxiOutDistance;
+      float inFlightDistance;
+      float taxiInDistance;
+      float totalDistance;
+      float maxLandingRate;
+      std::uint8_t touchdowns;
+      float maxLandingGees;
+      std::string recordingFilename;
+      float points;
+      std::uint8_t flags;
+      std::vector<std::uint8_t> file;
+
+    public:
+      LogbookEntry(std::string date,
+                   std::string flightNumber,
+                   std::string aircraftType,
+                   std::string aircraftRegistration,
+                   std::string departureAirport,
+                   std::string departureGate,
+                   std::string departureRunway,
+                   std::string arrivalAirport,
+                   std::string arrivaleGate,
+                   std::string arrivalRunway,
+                   std::string offBlockTime,
+                   std::string outTime,
+                   std::string inTime,
+                   std::string onBlockTime,
+                   float totalFlightTime,
+                   float taxiOutFuel,
+                   float inFlightFuel,
+                   float taxiInFuel,
+                   float totalFuel,
+                   float taxiOutDistance,
+                   float inFlightDistance,
+                   float taxiInDistance,
+                   float totalDistance,
+                   float maxLandingRate,
+                   std::uint8_t touchdowns,
+                   float maxLandingGees,
+                   std::string recordingFilename,
+                   float points,
+                   std::uint8_t flags,
+                   std::vector<std::uint8_t> file);
+
+      inline std::uint8_t *getBinaryData() { return file.data(); }
+      inline std::size_t getBinaryLength() { return file.size(); }
+
+      std::string to_string() const
+      {
+        std::ostringstream str;
+        // TO STR
+        return str.str();
+      }
+
+      friend inline std::ostream &operator<<(std::ostream &os,
+                                             const LogbookEntry &gate)
+      {
+        return os << gate.to_string();
+      }
+  };
+} // namespace germanairlinesva_logbook
+
+#endif

file/include/pathRecording.h

@@ -7,29 +7,25 @@
 
 #include "pathSegment.h"
 
-#define CURRENT_VERSION 1
-
 namespace germanairlinesva_recording
 {
   /*
-   * Header
+   * Path Recording (6 + n * 24)
-   *
+   * HEADER | SEGMENTS
+
+   * Header (6)
    * CHAR[5] | UINT8
    * --------+--------
    * VGAR    | VERSION
-   */
+
-  /*
+   * Path Segments (n)
-   * Path Recording
-   *
    * PATHSEGMENT[]
-   * -------------
-   * SEGMENTS
    */
   class PathRecording
   {
     private:
       std::uint64_t count = 0;
-      std::vector<std::uint8_t> file{'V', 'G', 'A', 'R', 0, CURRENT_VERSION};
+      std::vector<std::uint8_t> file{'V', 'G', 'A', 'R', '\0', 1};
 
     public:
       void addSegment(PathSegment segment);

file/include/pathSegment.h

@@ -10,6 +10,7 @@
 namespace germanairlinesva_recording
 {
   /*
+   * Path Segment (24)
    * UINT32 | UINT16   | UINT16      | POINT
    * -------+----------+-------------+------------
    * TIME   | ALTITUDE | GROUNDSPEED | COORDINATES

file/pathRecording.cpp

@@ -6,7 +6,7 @@ namespace germanairlinesva_recording
   {
     file.resize(file.size() + segment.getBinaryLength());
     std::uint8_t *bufPtr = 6 + file.data() + count * segment.getBinaryLength();
-    memcpy(bufPtr, segment.getBinaryData(), segment.getBinaryLength());
+    std::memcpy(bufPtr, segment.getBinaryData(), segment.getBinaryLength());
     count++;
   }
 } // namespace germanairlinesva_recording

file/pathSegment.cpp

@@ -17,12 +17,12 @@ namespace germanairlinesva_recording
             sizeof(this->groundSpeed) + sizeof(this->coordinates),
         0);
     std::uint8_t *bufPtr = file.data();
-    memcpy(bufPtr, &this->time, sizeof(this->time));
+    std::memcpy(bufPtr, &this->time, sizeof(this->time));
     bufPtr += sizeof(this->time);
-    memcpy(bufPtr, &this->altitude, sizeof(this->altitude));
+    std::memcpy(bufPtr, &this->altitude, sizeof(this->altitude));
     bufPtr += sizeof(this->altitude);
-    memcpy(bufPtr, &this->groundSpeed, sizeof(this->groundSpeed));
+    std::memcpy(bufPtr, &this->groundSpeed, sizeof(this->groundSpeed));
     bufPtr += sizeof(this->groundSpeed);
-    memcpy(bufPtr, &this->coordinates, sizeof(this->coordinates));
+    std::memcpy(bufPtr, &this->coordinates, sizeof(this->coordinates));
   };
 } // namespace germanairlinesva_recording

openSSL/win64/include/openssl/engine.h

@@ -16,18 +16,18 @@
 #ifndef OPENSSL_NO_ENGINE
 #if OPENSSL_API_COMPAT < 0x10100000L
 #include <openssl/bn.h>
-#  include <openssl/rsa.h>
-#  include <openssl/dsa.h>
 #include <openssl/dh.h>
+#include <openssl/dsa.h>
 #include <openssl/ec.h>
-#  include <openssl/rand.h>
-#  include <openssl/ui.h>
 #include <openssl/err.h>
+#include <openssl/rand.h>
+#include <openssl/rsa.h>
+#include <openssl/ui.h>
 #endif
+#include <openssl/engineerr.h>
 #include <openssl/ossl_typ.h>
 #include <openssl/symhacks.h>
 #include <openssl/x509.h>
-# include <openssl/engineerr.h>
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -139,20 +139,24 @@ extern "C" {
  */
 #define ENGINE_CTRL_SET_LOGSTREAM 1
 #define ENGINE_CTRL_SET_PASSWORD_CALLBACK 2
-# define ENGINE_CTRL_HUP                         3/* Close and reinitialise
+#define ENGINE_CTRL_HUP                                                        \
-                                                   * any handles/connections
+  3                                      /* Close and reinitialise             \
+                                          * any handles/connections            \
                                           * etc. */
 #define ENGINE_CTRL_SET_USER_INTERFACE 4 /* Alternative to callback */
-# define ENGINE_CTRL_SET_CALLBACK_DATA           5/* User-specific data, used
+#define ENGINE_CTRL_SET_CALLBACK_DATA                                          \
-                                                   * when calling the password
+  5 /* User-specific data, used                                                \
-                                                   * callback and the user
+     * when calling the password                                               \
+     * callback and the user                                                   \
      * interface */
-# define ENGINE_CTRL_LOAD_CONFIGURATION          6/* Load a configuration,
+#define ENGINE_CTRL_LOAD_CONFIGURATION                                         \
-                                                   * given a string that
+  6 /* Load a configuration,                                                   \
-                                                   * represents a file name
+     * given a string that                                                     \
+     * represents a file name                                                  \
      * or so */
-# define ENGINE_CTRL_LOAD_SECTION                7/* Load data from a given
+#define ENGINE_CTRL_LOAD_SECTION                                               \
-                                                   * section in the already
+  7 /* Load data from a given                                                  \
+     * section in the already                                                  \
      * loaded configuration */
 
 /*
@@ -260,15 +264,18 @@ typedef int (*ENGINE_GEN_FUNC_PTR) (void);
 /* Generic function pointer taking no arguments */
 typedef int (*ENGINE_GEN_INT_FUNC_PTR)(ENGINE *);
 /* Specific control function pointer */
-typedef int (*ENGINE_CTRL_FUNC_PTR) (ENGINE *, int, long, void *,
+typedef int (
-                                     void (*f) (void));
+    *ENGINE_CTRL_FUNC_PTR)(ENGINE *, int, long, void *, void (*f)(void));
 /* Generic load_key function pointer */
-typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *, const char *,
+typedef EVP_PKEY *(*ENGINE_LOAD_KEY_PTR)(ENGINE *,
+                                         const char *,
                                          UI_METHOD *ui_method,
                                          void *callback_data);
-typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl,
+typedef int (*ENGINE_SSL_CLIENT_CERT_PTR)(ENGINE *,
+                                          SSL *ssl,
                                           STACK_OF(X509_NAME) * ca_dn,
-                                           X509 **pcert, EVP_PKEY **pkey,
+                                          X509 **pcert,
+                                          EVP_PKEY **pkey,
                                           STACK_OF(X509) * *pother,
                                           UI_METHOD *ui_method,
                                           void *callback_data);
@@ -287,14 +294,19 @@ typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl,
  * Returns to a pointer to the array of supported cipher 'nid's. If the
  * second parameter is non-NULL it is set to the size of the returned array.
  */
-typedef int (*ENGINE_CIPHERS_PTR) (ENGINE *, const EVP_CIPHER **,
+typedef int (*ENGINE_CIPHERS_PTR)(ENGINE *,
-                                   const int **, int);
+                                  const EVP_CIPHER **,
-typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **,
+                                  const int **,
+                                  int);
+typedef int (*ENGINE_DIGESTS_PTR)(ENGINE *, const EVP_MD **, const int **, int);
+typedef int (*ENGINE_PKEY_METHS_PTR)(ENGINE *,
+                                     EVP_PKEY_METHOD **,
+                                     const int **,
+                                     int);
+typedef int (*ENGINE_PKEY_ASN1_METHS_PTR)(ENGINE *,
+                                          EVP_PKEY_ASN1_METHOD **,
+                                          const int **,
                                           int);
-typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **,
-                                      const int **, int);
-typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **,
-                                           const int **, int);
 /*
  * STRUCTURE functions ... all of these functions deal with pointers to
  * ENGINE structures where the pointers have a "structural reference". This
@@ -328,10 +340,8 @@ ENGINE *ENGINE_by_id(const char *id);
 #ifndef OPENSSL_NO_STATIC_ENGINE
 #define ENGINE_load_padlock()                                                  \
   OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_PADLOCK, NULL)
-#  define ENGINE_load_capi() \
+#define ENGINE_load_capi() OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL)
-    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL)
+#define ENGINE_load_afalg() OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL)
-#  define ENGINE_load_afalg() \
-    OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL)
 #endif
 #define ENGINE_load_cryptodev()                                                \
   OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL)
@@ -349,10 +359,10 @@ void ENGINE_set_table_flags(unsigned int flags);
 
 /*- Manage registration of ENGINEs per "table". For each type, there are 3
  * functions;
- *   ENGINE_register_***(e) - registers the implementation from 'e' (if it has one)
+ *   ENGINE_register_***(e) - registers the implementation from 'e' (if it has
- *   ENGINE_unregister_***(e) - unregister the implementation from 'e'
+ * one) ENGINE_unregister_***(e) - unregister the implementation from 'e'
- *   ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list
+ *   ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the
- * Cleanup is automatically registered from each table when required.
+ * list Cleanup is automatically registered from each table when required.
  */
 
 int ENGINE_register_RSA(ENGINE *e);
@@ -426,8 +436,12 @@ int ENGINE_cmd_is_executable(ENGINE *e, int cmd);
  * commands. See the comment on ENGINE_ctrl_cmd_string() for an explanation
  * on how to use the cmd_name and cmd_optional.
  */
-int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
+int ENGINE_ctrl_cmd(ENGINE *e,
-                    long i, void *p, void (*f) (void), int cmd_optional);
+                    const char *cmd_name,
+                    long i,
+                    void *p,
+                    void (*f)(void),
+                    int cmd_optional);
 
 /*
  * This function passes a command-name and argument to an ENGINE. The
@@ -451,7 +465,9 @@ int ENGINE_ctrl_cmd(ENGINE *e, const char *cmd_name,
  * applications can work consistently with the same configuration for the
  * same ENGINE-enabled devices, across applications.
  */
-int ENGINE_ctrl_cmd_string(ENGINE *e, const char *cmd_name, const char *arg,
+int ENGINE_ctrl_cmd_string(ENGINE *e,
+                           const char *cmd_name,
+                           const char *arg,
                            int cmd_optional);
 
 /*
@@ -476,12 +492,11 @@ int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f);
 int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
 int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
 int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f);
-int ENGINE_set_load_privkey_function(ENGINE *e,
+int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f);
-                                     ENGINE_LOAD_KEY_PTR loadpriv_f);
 int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f);
-int ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
+int ENGINE_set_load_ssl_client_cert_function(
-                                             ENGINE_SSL_CLIENT_CERT_PTR
+    ENGINE *e,
-                                             loadssl_f);
+    ENGINE_SSL_CLIENT_CERT_PTR loadssl_f);
 int ENGINE_set_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
 int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
 int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f);
@@ -499,7 +514,9 @@ void *ENGINE_get_ex_data(const ENGINE *e, int idx);
  * This function previously cleaned up anything that needs it. Auto-deinit will
  * now take care of it so it is no longer required to call this function.
  */
-# define ENGINE_cleanup() while(0) continue
+#define ENGINE_cleanup()                                                       \
+  while (0)                                                                    \
+  continue
 #endif
 
 /*
@@ -521,8 +538,7 @@ ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
 ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e);
 ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e);
 ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e);
-ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE
+ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE *e);
-                                                               *e);
 ENGINE_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
 ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
 ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(const ENGINE *e);
@@ -531,12 +547,10 @@ const EVP_CIPHER *ENGINE_get_cipher(ENGINE *e, int nid);
 const EVP_MD *ENGINE_get_digest(ENGINE *e, int nid);
 const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(ENGINE *e, int nid);
 const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth(ENGINE *e, int nid);
-const EVP_PKEY_ASN1_METHOD *ENGINE_get_pkey_asn1_meth_str(ENGINE *e,
+const EVP_PKEY_ASN1_METHOD *
-                                                          const char *str,
+    ENGINE_get_pkey_asn1_meth_str(ENGINE *e, const char *str, int len);
-                                                          int len);
+const EVP_PKEY_ASN1_METHOD *
-const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe,
+    ENGINE_pkey_asn1_find_str(ENGINE **pe, const char *str, int len);
-                                                      const char *str,
-                                                      int len);
 const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
 int ENGINE_get_flags(const ENGINE *e);
 
@@ -571,14 +585,22 @@ int ENGINE_finish(ENGINE *e);
  * location, handled by the engine.  The storage may be on a card or
  * whatever.
  */
-EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
+EVP_PKEY *ENGINE_load_private_key(ENGINE *e,
-                                  UI_METHOD *ui_method, void *callback_data);
+                                  const char *key_id,
-EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
+                                  UI_METHOD *ui_method,
-                                 UI_METHOD *ui_method, void *callback_data);
+                                  void *callback_data);
-int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s,
+EVP_PKEY *ENGINE_load_public_key(ENGINE *e,
-                                STACK_OF(X509_NAME) *ca_dn, X509 **pcert,
+                                 const char *key_id,
-                                EVP_PKEY **ppkey, STACK_OF(X509) **pother,
+                                 UI_METHOD *ui_method,
-                                UI_METHOD *ui_method, void *callback_data);
+                                 void *callback_data);
+int ENGINE_load_ssl_client_cert(ENGINE *e,
+                                SSL *s,
+                                STACK_OF(X509_NAME) * ca_dn,
+                                X509 **pcert,
+                                EVP_PKEY **ppkey,
+                                STACK_OF(X509) * *pother,
+                                UI_METHOD *ui_method,
+                                void *callback_data);
 
 /*
  * This returns a pointer for the current ENGINE structure that is (by
@@ -689,16 +711,19 @@ typedef struct st_dynamic_fns {
 typedef unsigned long (*dynamic_v_check_fn)(unsigned long ossl_version);
 #define IMPLEMENT_DYNAMIC_CHECK_FN()                                           \
   OPENSSL_EXPORT unsigned long v_check(unsigned long v);                       \
-        OPENSSL_EXPORT unsigned long v_check(unsigned long v) { \
+  OPENSSL_EXPORT unsigned long v_check(unsigned long v)                        \
-                if (v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \
+  {                                                                            \
-                return 0; }
+    if (v >= OSSL_DYNAMIC_OLDEST)                                              \
+      return OSSL_DYNAMIC_VERSION;                                             \
+    return 0;                                                                  \
+  }
 
 /*
  * This function is passed the ENGINE structure to initialise with its own
  * function and command settings. It should not adjust the structural or
  * functional reference counts. If this function returns zero, (a) the load
- * will be aborted, (b) the previous ENGINE state will be memcpy'd back onto
+ * will be aborted, (b) the previous ENGINE state will be std::memcpy'd back
- * the structure, and (c) the shared library will be unloaded. So
+ * onto the structure, and (c) the shared library will be unloaded. So
  * implementations should do their own internal cleanup in failure
  * circumstances otherwise they could leak. The 'id' parameter, if non-NULL,
  * represents the ENGINE id that the loader is looking for. If this is NULL,
@@ -711,21 +736,26 @@ typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version);
  * returns an int value (zero for failure). 'fn' should have prototype;
  * [static] int fn(ENGINE *e, const char *id);
  */
-typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id,
+typedef int (*dynamic_bind_engine)(ENGINE *e,
+                                   const char *id,
                                    const dynamic_fns *fns);
 #define IMPLEMENT_DYNAMIC_BIND_FN(fn)                                          \
   OPENSSL_EXPORT                                                               \
   int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns);          \
   OPENSSL_EXPORT                                                               \
-        int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) { \
+  int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns)           \
-            if (ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \
+  {                                                                            \
+    if (ENGINE_get_static_state() == fns->static_state)                        \
+      goto skip_cbs;                                                           \
     CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn,                           \
                              fns->mem_fns.realloc_fn,                          \
                              fns->mem_fns.free_fn);                            \
     OPENSSL_init_crypto(OPENSSL_INIT_NO_ATEXIT, NULL);                         \
   skip_cbs:                                                                    \
-            if (!fn(e, id)) return 0; \
+    if (!fn(e, id))                                                            \
-            return 1; }
+      return 0;                                                                \
+    return 1;                                                                  \
+  }
 
 /*
  * If the loading application (or library) and the loaded ENGINE library

simdata/gate.cpp

@@ -19,11 +19,11 @@ namespace germanairlinesva_simdata
            static_cast<std::uint8_t>(this->designator.length()),
            sizeof(std::uint8_t));
     bufPtr++;
-    memcpy(bufPtr, this->designator.c_str(), this->designator.length());
+    std::memcpy(bufPtr, this->designator.c_str(), this->designator.length());
     bufPtr += this->designator.length() + 1;
-    memcpy(bufPtr, &this->center, sizeof(this->center));
+    std::memcpy(bufPtr, &this->center, sizeof(this->center));
     bufPtr += sizeof(this->center);
-    memcpy(bufPtr, &this->radius, sizeof(this->radius));
+    std::memcpy(bufPtr, &this->radius, sizeof(this->radius));
   }
 
   // From database
@@ -43,10 +43,10 @@ namespace germanairlinesva_simdata
            static_cast<std::uint8_t>(this->designator.length()),
            sizeof(std::uint8_t));
     bufPtr++;
-    memcpy(bufPtr, this->designator.c_str(), this->designator.length());
+    std::memcpy(bufPtr, this->designator.c_str(), this->designator.length());
     bufPtr += this->designator.length() + 1;
-    memcpy(bufPtr, &this->center, sizeof(this->center));
+    std::memcpy(bufPtr, &this->center, sizeof(this->center));
     bufPtr += sizeof(this->center);
-    memcpy(bufPtr, &this->radius, sizeof(this->radius));
+    std::memcpy(bufPtr, &this->radius, sizeof(this->radius));
   }
 } // namespace germanairlinesva_simdata

simdata/include/simulatorDatabase.hpp

@@ -12,8 +12,6 @@
 #include "gate.h"
 #include "runway.h"
 
-#define CURRENT_VERSION 1
-
 /*
  * Header
  *
@@ -41,8 +39,8 @@ namespace germanairlinesva_simdata
     std::uint8_t null = 0;
     std::ofstream out(file, std::fstream::binary);
 
-    // File Header
+    // File Header, Last member is version
-    std::uint8_t header[] = {'V', 'G', 'A', 'S', 0, CURRENT_VERSION};
+    std::uint8_t header[] = {'V', 'G', 'A', 'S', '\0', 1};
     out.write(reinterpret_cast<const char *>(header), 6);
     // Num Airports
     std::uint16_t numAirports = airports.size();

simdata/runway.cpp

@@ -35,15 +35,15 @@ namespace germanairlinesva_simdata
            static_cast<std::uint8_t>(this->designator.length()),
            sizeof(std::uint8_t));
     bufPtr++;
-    memcpy(bufPtr, this->designator.c_str(), this->designator.length());
+    std::memcpy(bufPtr, this->designator.c_str(), this->designator.length());
     bufPtr += this->designator.length() + 1;
-    memcpy(bufPtr, &this->bounds, sizeof(this->bounds));
+    std::memcpy(bufPtr, &this->bounds, sizeof(this->bounds));
     bufPtr += sizeof(this->bounds);
-    memcpy(bufPtr, &this->width, sizeof(this->width));
+    std::memcpy(bufPtr, &this->width, sizeof(this->width));
     bufPtr += sizeof(this->width);
-    memcpy(bufPtr, &this->length, sizeof(this->length));
+    std::memcpy(bufPtr, &this->length, sizeof(this->length));
     bufPtr += sizeof(this->length);
-    memcpy(bufPtr, &this->trueHeading, sizeof(this->trueHeading));
+    std::memcpy(bufPtr, &this->trueHeading, sizeof(this->trueHeading));
   }
 
   Runway::Runway(std::string designator,
@@ -68,14 +68,14 @@ namespace germanairlinesva_simdata
            static_cast<std::uint8_t>(this->designator.length()),
            sizeof(std::uint8_t));
     bufPtr++;
-    memcpy(bufPtr, this->designator.c_str(), this->designator.length());
+    std::memcpy(bufPtr, this->designator.c_str(), this->designator.length());
     bufPtr += this->designator.length() + 1;
-    memcpy(bufPtr, &this->bounds, sizeof(this->bounds));
+    std::memcpy(bufPtr, &this->bounds, sizeof(this->bounds));
     bufPtr += sizeof(this->bounds);
-    memcpy(bufPtr, &this->width, sizeof(this->width));
+    std::memcpy(bufPtr, &this->width, sizeof(this->width));
     bufPtr += sizeof(this->width);
-    memcpy(bufPtr, &this->length, sizeof(this->length));
+    std::memcpy(bufPtr, &this->length, sizeof(this->length));
     bufPtr += sizeof(this->length);
-    memcpy(bufPtr, &this->trueHeading, sizeof(this->trueHeading));
+    std::memcpy(bufPtr, &this->trueHeading, sizeof(this->trueHeading));
   }
 } // namespace germanairlinesva_simdata

websocket/include/websocket.h

@@ -12,7 +12,6 @@
 #include "types.h"
 #include "util.hpp"
 
-#include <cstring>
 #include <functional>
 #include <iostream>
 #include <sstream>

xplugin/include/main.h

@@ -22,6 +22,7 @@
 #include <mutex>
 #include <queue>
 #include <sstream>
+#include <string>
 #include <thread>
 
 float flightLoop(float elapsedMe, float elapsedSim, int counter, void *refcon);

xplugin/main.cpp

@@ -254,7 +254,7 @@ void serverWorker()
     {
       const std::lock_guard<std::mutex> lock(mutex);
 
-      memcpy(&copy, &toSend, sizeof(germanairlinesva_websocket::data));
+      std::memcpy(&copy, &toSend, sizeof(germanairlinesva_websocket::data));
     }
 
     connector->sendData(copy);
@@ -275,7 +275,7 @@ void recordingWorker()
     {
       const std::lock_guard<std::mutex> lock(mutex);
 
-      memcpy(&copy, &toSend, sizeof(germanairlinesva_websocket::data));
+      std::memcpy(&copy, &toSend, sizeof(germanairlinesva_websocket::data));
     }
 
     germanairlinesva_recording::PathSegment currentPath(