GermanAirlines/GermanAirlinesVA-GAConnector
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Start on Logbook

Browse Source
This commit is contained in:
Kilian Hofmann 2022-09-08 02:02:09 +02:00
parent 2bda541bce
commit 8b9f5d0406
15 changed files with 453 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.vscode/settings.json vendored
View File

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

1
TODO.md Normal file
View File

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

38
file/include/logbook.h Normal file
View File

@ -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

167
file/include/logbookEntry.h Normal file
View File

@ -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

18
file/include/pathRecording.h
View File

@ -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 Recording
*
* Path Segments (n)
* 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);

1
file/include/pathSegment.h
View File

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

2
file/pathRecording.cpp
View File

@ -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

8
file/pathSegment.cpp
View File

@ -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

170
openSSL/win64/include/openssl/engine.h
View File

@ -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
* any handles/connections
#define ENGINE_CTRL_HUP \
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
* when calling the password
* callback and the user
#define ENGINE_CTRL_SET_CALLBACK_DATA \
5 /* User-specific data, used \
* when calling the password \
* callback and the user \
* interface */
# define ENGINE_CTRL_LOAD_CONFIGURATION 6/* Load a configuration,
* given a string that
* represents a file name
#define ENGINE_CTRL_LOAD_CONFIGURATION \
6 /* Load a configuration, \
* given a string that \
* represents a file name \
* or so */
# define ENGINE_CTRL_LOAD_SECTION 7/* Load data from a given
* section in the already
#define ENGINE_CTRL_LOAD_SECTION \
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 *,
void (*f) (void));
typedef int (
*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 **,
const int **, int);
typedef int (*ENGINE_DIGESTS_PTR) (ENGINE *, const EVP_MD **, const int **,
typedef int (*ENGINE_CIPHERS_PTR)(ENGINE *,
const EVP_CIPHER **,
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() \
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, NULL)
# define ENGINE_load_afalg() \
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL)
#define ENGINE_load_capi() OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CAPI, 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_unregister_***(e) - unregister the implementation from 'e'
* ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the list
* Cleanup is automatically registered from each table when required.
* ENGINE_register_***(e) - registers the implementation from 'e' (if it has
* one) ENGINE_unregister_***(e) - unregister the implementation from 'e'
* ENGINE_register_all_***() - call ENGINE_register_***() for each 'e' in the
* 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,
long i, void *p, void (*f) (void), int cmd_optional);
int ENGINE_ctrl_cmd(ENGINE *e,
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,
ENGINE_LOAD_KEY_PTR loadpriv_f);
int ENGINE_set_load_privkey_function(ENGINE *e, 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,
ENGINE_SSL_CLIENT_CERT_PTR
loadssl_f);
int ENGINE_set_load_ssl_client_cert_function(
ENGINE *e,
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
*e);
ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE *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 char *str,
int len);
const EVP_PKEY_ASN1_METHOD *ENGINE_pkey_asn1_find_str(ENGINE **pe,
const char *str,
int len);
const EVP_PKEY_ASN1_METHOD *
ENGINE_get_pkey_asn1_meth_str(ENGINE *e, const char *str, int len);
const EVP_PKEY_ASN1_METHOD *
ENGINE_pkey_asn1_find_str(ENGINE **pe, 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,
UI_METHOD *ui_method, void *callback_data);
EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
UI_METHOD *ui_method, 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);
EVP_PKEY *ENGINE_load_private_key(ENGINE *e,
const char *key_id,
UI_METHOD *ui_method,
void *callback_data);
EVP_PKEY *ENGINE_load_public_key(ENGINE *e,
const char *key_id,
UI_METHOD *ui_method,
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) { \
if (v >= OSSL_DYNAMIC_OLDEST) return OSSL_DYNAMIC_VERSION; \
return 0; }
OPENSSL_EXPORT unsigned long v_check(unsigned long v) \
{ \
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
* the structure, and (c) the shared library will be unloaded. So
* will be aborted, (b) the previous ENGINE state will be std::memcpy'd back
* 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) { \
if (ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \
int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) \
{ \
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; \
return 1; }
if (!fn(e, id)) \
return 0; \
return 1; \
}
/*
* If the loading application (or library) and the loaded ENGINE library

12
simdata/gate.cpp
View File

@ -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

6
simdata/include/simulatorDatabase.hpp
View File

@ -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
std::uint8_t header[] = {'V', 'G', 'A', 'S', 0, CURRENT_VERSION};
// File Header, Last member is 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();

20
simdata/runway.cpp
View File

@ -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

1
websocket/include/websocket.h
View File

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

1
xplugin/include/main.h
View File

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

4
xplugin/main.cpp
View File

@ -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(