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", "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" #include "pathSegment.h"
#define CURRENT_VERSION 1
namespace germanairlinesva_recording namespace germanairlinesva_recording
{ {
/* /*
* Header * Path Recording (6 + n * 24)
* * HEADER | SEGMENTS
* Header (6)
* CHAR[5] | UINT8 * CHAR[5] | UINT8
* --------+-------- * --------+--------
* VGAR | VERSION * VGAR | VERSION
*/
/* * Path Segments (n)
* Path Recording
*
* PATHSEGMENT[] * PATHSEGMENT[]
* -------------
* SEGMENTS
*/ */
class PathRecording class PathRecording
{ {
private: private:
std::uint64_t count = 0; 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: public:
void addSegment(PathSegment segment); void addSegment(PathSegment segment);

1
file/include/pathSegment.h
View File

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

2
file/pathRecording.cpp
View File

@ -6,7 +6,7 @@ namespace germanairlinesva_recording
{ {
file.resize(file.size() + segment.getBinaryLength()); file.resize(file.size() + segment.getBinaryLength());
std::uint8_t *bufPtr = 6 + file.data() + count * 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++; count++;
} }
} // namespace germanairlinesva_recording } // namespace germanairlinesva_recording

8
file/pathSegment.cpp
View File

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

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

@ -9,45 +9,45 @@
*/ */
#ifndef HEADER_ENGINE_H #ifndef HEADER_ENGINE_H
# define HEADER_ENGINE_H #define HEADER_ENGINE_H
# include <openssl/opensslconf.h> #include <openssl/opensslconf.h>
# ifndef OPENSSL_NO_ENGINE #ifndef OPENSSL_NO_ENGINE
# if OPENSSL_API_COMPAT < 0x10100000L #if OPENSSL_API_COMPAT < 0x10100000L
# include <openssl/bn.h> #include <openssl/bn.h>
# include <openssl/rsa.h> #include <openssl/dh.h>
# include <openssl/dsa.h> #include <openssl/dsa.h>
# include <openssl/dh.h> #include <openssl/ec.h>
# include <openssl/ec.h> #include <openssl/err.h>
# include <openssl/rand.h> #include <openssl/rand.h>
# include <openssl/ui.h> #include <openssl/rsa.h>
# include <openssl/err.h> #include <openssl/ui.h>
# endif #endif
# include <openssl/ossl_typ.h> #include <openssl/engineerr.h>
# include <openssl/symhacks.h> #include <openssl/ossl_typ.h>
# include <openssl/x509.h> #include <openssl/symhacks.h>
# include <openssl/engineerr.h> #include <openssl/x509.h>
# ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
# endif #endif
/* /*
* These flags are used to control combinations of algorithm (methods) by * These flags are used to control combinations of algorithm (methods) by
* bitwise "OR"ing. * bitwise "OR"ing.
*/ */
# define ENGINE_METHOD_RSA (unsigned int)0x0001 #define ENGINE_METHOD_RSA (unsigned int)0x0001
# define ENGINE_METHOD_DSA (unsigned int)0x0002 #define ENGINE_METHOD_DSA (unsigned int)0x0002
# define ENGINE_METHOD_DH (unsigned int)0x0004 #define ENGINE_METHOD_DH (unsigned int)0x0004
# define ENGINE_METHOD_RAND (unsigned int)0x0008 #define ENGINE_METHOD_RAND (unsigned int)0x0008
# define ENGINE_METHOD_CIPHERS (unsigned int)0x0040 #define ENGINE_METHOD_CIPHERS (unsigned int)0x0040
# define ENGINE_METHOD_DIGESTS (unsigned int)0x0080 #define ENGINE_METHOD_DIGESTS (unsigned int)0x0080
# define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200 #define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200
# define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400 #define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400
# define ENGINE_METHOD_EC (unsigned int)0x0800 #define ENGINE_METHOD_EC (unsigned int)0x0800
/* Obvious all-or-nothing cases. */ /* Obvious all-or-nothing cases. */
# define ENGINE_METHOD_ALL (unsigned int)0xFFFF #define ENGINE_METHOD_ALL (unsigned int)0xFFFF
# define ENGINE_METHOD_NONE (unsigned int)0x0000 #define ENGINE_METHOD_NONE (unsigned int)0x0000
/* /*
* This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used * This(ese) flag(s) controls behaviour of the ENGINE_TABLE mechanism used
@ -55,7 +55,7 @@ extern "C" {
* set by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to * set by ENGINE_set_table_flags(). The "NOINIT" flag prevents attempts to
* initialise registered ENGINEs if they are not already initialised. * initialise registered ENGINEs if they are not already initialised.
*/ */
# define ENGINE_TABLE_FLAG_NOINIT (unsigned int)0x0001 #define ENGINE_TABLE_FLAG_NOINIT (unsigned int)0x0001
/* ENGINE flags that can be set by ENGINE_set_flags(). */ /* ENGINE flags that can be set by ENGINE_set_flags(). */
/* Not used */ /* Not used */
@ -67,7 +67,7 @@ extern "C" {
* these control commands on behalf of the ENGINE using their "cmd_defns" * these control commands on behalf of the ENGINE using their "cmd_defns"
* data. * data.
*/ */
# define ENGINE_FLAGS_MANUAL_CMD_CTRL (int)0x0002 #define ENGINE_FLAGS_MANUAL_CMD_CTRL (int)0x0002
/* /*
* This flag is for ENGINEs who return new duplicate structures when found * This flag is for ENGINEs who return new duplicate structures when found
@ -79,7 +79,7 @@ extern "C" {
* ENGINE_by_id() just increments the existing ENGINE's structural reference * ENGINE_by_id() just increments the existing ENGINE's structural reference
* count. * count.
*/ */
# define ENGINE_FLAGS_BY_ID_COPY (int)0x0004 #define ENGINE_FLAGS_BY_ID_COPY (int)0x0004
/* /*
* This flag if for an ENGINE that does not want its methods registered as * This flag if for an ENGINE that does not want its methods registered as
@ -87,7 +87,7 @@ extern "C" {
* usable as default methods. * usable as default methods.
*/ */
# define ENGINE_FLAGS_NO_REGISTER_ALL (int)0x0008 #define ENGINE_FLAGS_NO_REGISTER_ALL (int)0x0008
/* /*
* ENGINEs can support their own command types, and these flags are used in * ENGINEs can support their own command types, and these flags are used in
@ -102,23 +102,23 @@ extern "C" {
*/ */
/* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */ /* accepts a 'long' input value (3rd parameter to ENGINE_ctrl) */
# define ENGINE_CMD_FLAG_NUMERIC (unsigned int)0x0001 #define ENGINE_CMD_FLAG_NUMERIC (unsigned int)0x0001
/* /*
* accepts string input (cast from 'void*' to 'const char *', 4th parameter * accepts string input (cast from 'void*' to 'const char *', 4th parameter
* to ENGINE_ctrl) * to ENGINE_ctrl)
*/ */
# define ENGINE_CMD_FLAG_STRING (unsigned int)0x0002 #define ENGINE_CMD_FLAG_STRING (unsigned int)0x0002
/* /*
* Indicates that the control command takes *no* input. Ie. the control * Indicates that the control command takes *no* input. Ie. the control
* command is unparameterised. * command is unparameterised.
*/ */
# define ENGINE_CMD_FLAG_NO_INPUT (unsigned int)0x0004 #define ENGINE_CMD_FLAG_NO_INPUT (unsigned int)0x0004
/* /*
* Indicates that the control command is internal. This control command won't * Indicates that the control command is internal. This control command won't
* be shown in any output, and is only usable through the ENGINE_ctrl_cmd() * be shown in any output, and is only usable through the ENGINE_ctrl_cmd()
* function. * function.
*/ */
# define ENGINE_CMD_FLAG_INTERNAL (unsigned int)0x0008 #define ENGINE_CMD_FLAG_INTERNAL (unsigned int)0x0008
/* /*
* NB: These 3 control commands are deprecated and should not be used. * NB: These 3 control commands are deprecated and should not be used.
@ -137,23 +137,27 @@ extern "C" {
* sense to some engines. In such a case, they do nothing but return the * sense to some engines. In such a case, they do nothing but return the
* error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED. * error ENGINE_R_CTRL_COMMAND_NOT_IMPLEMENTED.
*/ */
# define ENGINE_CTRL_SET_LOGSTREAM 1 #define ENGINE_CTRL_SET_LOGSTREAM 1
# define ENGINE_CTRL_SET_PASSWORD_CALLBACK 2 #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 \
* etc. */ * any handles/connections \
# define ENGINE_CTRL_SET_USER_INTERFACE 4/* Alternative to callback */ * etc. */
# define ENGINE_CTRL_SET_CALLBACK_DATA 5/* User-specific data, used #define ENGINE_CTRL_SET_USER_INTERFACE 4 /* Alternative to callback */
* when calling the password #define ENGINE_CTRL_SET_CALLBACK_DATA \
* callback and the user 5 /* User-specific data, used \
* interface */ * when calling the password \
# define ENGINE_CTRL_LOAD_CONFIGURATION 6/* Load a configuration, * callback and the user \
* given a string that * interface */
* represents a file name #define ENGINE_CTRL_LOAD_CONFIGURATION \
* or so */ 6 /* Load a configuration, \
# define ENGINE_CTRL_LOAD_SECTION 7/* Load data from a given * given a string that \
* section in the already * represents a file name \
* loaded configuration */ * or so */
#define ENGINE_CTRL_LOAD_SECTION \
7 /* Load data from a given \
* section in the already \
* loaded configuration */
/* /*
* These control commands allow an application to deal with an arbitrary * These control commands allow an application to deal with an arbitrary
@ -175,22 +179,22 @@ extern "C" {
* worth checking this first if the caller is trying to "discover" the * worth checking this first if the caller is trying to "discover" the
* engine's capabilities and doesn't want errors generated unnecessarily. * engine's capabilities and doesn't want errors generated unnecessarily.
*/ */
# define ENGINE_CTRL_HAS_CTRL_FUNCTION 10 #define ENGINE_CTRL_HAS_CTRL_FUNCTION 10
/* /*
* Returns a positive command number for the first command supported by the * Returns a positive command number for the first command supported by the
* engine. Returns zero if no ctrl commands are supported. * engine. Returns zero if no ctrl commands are supported.
*/ */
# define ENGINE_CTRL_GET_FIRST_CMD_TYPE 11 #define ENGINE_CTRL_GET_FIRST_CMD_TYPE 11
/* /*
* The 'long' argument specifies a command implemented by the engine, and the * The 'long' argument specifies a command implemented by the engine, and the
* return value is the next command supported, or zero if there are no more. * return value is the next command supported, or zero if there are no more.
*/ */
# define ENGINE_CTRL_GET_NEXT_CMD_TYPE 12 #define ENGINE_CTRL_GET_NEXT_CMD_TYPE 12
/* /*
* The 'void*' argument is a command name (cast from 'const char *'), and the * The 'void*' argument is a command name (cast from 'const char *'), and the
* return value is the command that corresponds to it. * return value is the command that corresponds to it.
*/ */
# define ENGINE_CTRL_GET_CMD_FROM_NAME 13 #define ENGINE_CTRL_GET_CMD_FROM_NAME 13
/* /*
* The next two allow a command to be converted into its corresponding string * The next two allow a command to be converted into its corresponding string
* form. In each case, the 'long' argument supplies the command. In the * form. In each case, the 'long' argument supplies the command. In the
@ -199,23 +203,23 @@ extern "C" {
* string buffer large enough, and it will be populated with the name of the * string buffer large enough, and it will be populated with the name of the
* command (WITH a trailing EOL). * command (WITH a trailing EOL).
*/ */
# define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD 14 #define ENGINE_CTRL_GET_NAME_LEN_FROM_CMD 14
# define ENGINE_CTRL_GET_NAME_FROM_CMD 15 #define ENGINE_CTRL_GET_NAME_FROM_CMD 15
/* The next two are similar but give a "short description" of a command. */ /* The next two are similar but give a "short description" of a command. */
# define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD 16 #define ENGINE_CTRL_GET_DESC_LEN_FROM_CMD 16
# define ENGINE_CTRL_GET_DESC_FROM_CMD 17 #define ENGINE_CTRL_GET_DESC_FROM_CMD 17
/* /*
* With this command, the return value is the OR'd combination of * With this command, the return value is the OR'd combination of
* ENGINE_CMD_FLAG_*** values that indicate what kind of input a given * ENGINE_CMD_FLAG_*** values that indicate what kind of input a given
* engine-specific ctrl command expects. * engine-specific ctrl command expects.
*/ */
# define ENGINE_CTRL_GET_CMD_FLAGS 18 #define ENGINE_CTRL_GET_CMD_FLAGS 18
/* /*
* ENGINE implementations should start the numbering of their own control * ENGINE implementations should start the numbering of their own control
* commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc). * commands from this value. (ie. ENGINE_CMD_BASE, ENGINE_CMD_BASE + 1, etc).
*/ */
# define ENGINE_CMD_BASE 200 #define ENGINE_CMD_BASE 200
/* /*
* NB: These 2 nCipher "chil" control commands are deprecated, and their * NB: These 2 nCipher "chil" control commands are deprecated, and their
@ -226,17 +230,17 @@ extern "C" {
*/ */
/* Flags specific to the nCipher "chil" engine */ /* Flags specific to the nCipher "chil" engine */
# define ENGINE_CTRL_CHIL_SET_FORKCHECK 100 #define ENGINE_CTRL_CHIL_SET_FORKCHECK 100
/* /*
* Depending on the value of the (long)i argument, this sets or * Depending on the value of the (long)i argument, this sets or
* unsets the SimpleForkCheck flag in the CHIL API to enable or * unsets the SimpleForkCheck flag in the CHIL API to enable or
* disable checking and workarounds for applications that fork(). * disable checking and workarounds for applications that fork().
*/ */
# define ENGINE_CTRL_CHIL_NO_LOCKING 101 #define ENGINE_CTRL_CHIL_NO_LOCKING 101
/* /*
* This prevents the initialisation function from providing mutex * This prevents the initialisation function from providing mutex
* callbacks to the nCipher library. * callbacks to the nCipher library.
*/ */
/* /*
* If an ENGINE supports its own specific control commands and wishes the * If an ENGINE supports its own specific control commands and wishes the
@ -249,29 +253,32 @@ extern "C" {
* has cmd_num set to zero and/or cmd_name set to NULL. * has cmd_num set to zero and/or cmd_name set to NULL.
*/ */
typedef struct ENGINE_CMD_DEFN_st { typedef struct ENGINE_CMD_DEFN_st {
unsigned int cmd_num; /* The command number */ unsigned int cmd_num; /* The command number */
const char *cmd_name; /* The command name itself */ const char *cmd_name; /* The command name itself */
const char *cmd_desc; /* A short description of the command */ const char *cmd_desc; /* A short description of the command */
unsigned int cmd_flags; /* The input the command expects */ unsigned int cmd_flags; /* The input the command expects */
} ENGINE_CMD_DEFN; } ENGINE_CMD_DEFN;
/* Generic function pointer */ /* Generic function pointer */
typedef int (*ENGINE_GEN_FUNC_PTR) (void); typedef int (*ENGINE_GEN_FUNC_PTR)(void);
/* Generic function pointer taking no arguments */ /* Generic function pointer taking no arguments */
typedef int (*ENGINE_GEN_INT_FUNC_PTR) (ENGINE *); typedef int (*ENGINE_GEN_INT_FUNC_PTR)(ENGINE *);
/* Specific control function pointer */ /* 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 */ /* 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, UI_METHOD *ui_method,
void *callback_data); void *callback_data);
typedef int (*ENGINE_SSL_CLIENT_CERT_PTR) (ENGINE *, SSL *ssl, typedef int (*ENGINE_SSL_CLIENT_CERT_PTR)(ENGINE *,
STACK_OF(X509_NAME) *ca_dn, SSL *ssl,
X509 **pcert, EVP_PKEY **pkey, STACK_OF(X509_NAME) * ca_dn,
STACK_OF(X509) **pother, X509 **pcert,
UI_METHOD *ui_method, EVP_PKEY **pkey,
void *callback_data); STACK_OF(X509) * *pother,
UI_METHOD *ui_method,
void *callback_data);
/*- /*-
* These callback types are for an ENGINE's handler for cipher and digest logic. * These callback types are for an ENGINE's handler for cipher and digest logic.
* These handlers have these prototypes; * These handlers have these prototypes;
@ -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 * 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. * 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); int);
typedef int (*ENGINE_PKEY_METHS_PTR) (ENGINE *, EVP_PKEY_METHOD **, typedef int (*ENGINE_DIGESTS_PTR)(ENGINE *, const EVP_MD **, const int **, int);
const int **, int); typedef int (*ENGINE_PKEY_METHS_PTR)(ENGINE *,
typedef int (*ENGINE_PKEY_ASN1_METHS_PTR) (ENGINE *, EVP_PKEY_ASN1_METHOD **, EVP_PKEY_METHOD **,
const int **, int); 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 * STRUCTURE functions ... all of these functions deal with pointers to
* ENGINE structures where the pointers have a "structural reference". This * ENGINE structures where the pointers have a "structural reference". This
@ -321,22 +333,20 @@ int ENGINE_remove(ENGINE *e);
ENGINE *ENGINE_by_id(const char *id); ENGINE *ENGINE_by_id(const char *id);
#if OPENSSL_API_COMPAT < 0x10100000L #if OPENSSL_API_COMPAT < 0x10100000L
# define ENGINE_load_openssl() \ #define ENGINE_load_openssl() \
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_OPENSSL, NULL) OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_OPENSSL, NULL)
# define ENGINE_load_dynamic() \ #define ENGINE_load_dynamic() \
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL) OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_DYNAMIC, NULL)
# ifndef OPENSSL_NO_STATIC_ENGINE #ifndef OPENSSL_NO_STATIC_ENGINE
# define ENGINE_load_padlock() \ #define ENGINE_load_padlock() \
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_PADLOCK, NULL) 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() \ #endif
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_AFALG, NULL) #define ENGINE_load_cryptodev() \
# endif OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL)
# define ENGINE_load_cryptodev() \ #define ENGINE_load_rdrand() \
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_CRYPTODEV, NULL) OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_RDRAND, NULL)
# define ENGINE_load_rdrand() \
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_RDRAND, NULL)
#endif #endif
void ENGINE_load_builtin_engines(void); void ENGINE_load_builtin_engines(void);
@ -349,10 +359,10 @@ void ENGINE_set_table_flags(unsigned int flags);
/*- Manage registration of ENGINEs per "table". For each type, there are 3 /*- Manage registration of ENGINEs per "table". For each type, there are 3
* functions; * 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); int ENGINE_register_RSA(ENGINE *e);
@ -410,7 +420,7 @@ int ENGINE_register_all_complete(void);
* commands that require an operational ENGINE, and only use functional * commands that require an operational ENGINE, and only use functional
* references in such situations. * references in such situations.
*/ */
int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void)); int ENGINE_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f)(void));
/* /*
* This function tests if an ENGINE-specific command is usable as a * This function tests if an ENGINE-specific command is usable as a
@ -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 * commands. See the comment on ENGINE_ctrl_cmd_string() for an explanation
* on how to use the cmd_name and cmd_optional. * 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 * 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 * applications can work consistently with the same configuration for the
* same ENGINE-enabled devices, across applications. * 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); 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_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_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_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_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_ciphers(ENGINE *e, ENGINE_CIPHERS_PTR f);
int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f); int ENGINE_set_digests(ENGINE *e, ENGINE_DIGESTS_PTR f);
int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f); int ENGINE_set_pkey_meths(ENGINE *e, ENGINE_PKEY_METHS_PTR f);
@ -489,8 +504,8 @@ int ENGINE_set_pkey_asn1_meths(ENGINE *e, ENGINE_PKEY_ASN1_METHS_PTR f);
int ENGINE_set_flags(ENGINE *e, int flags); int ENGINE_set_flags(ENGINE *e, int flags);
int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns); int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns);
/* These functions allow control over any per-structure ENGINE data. */ /* These functions allow control over any per-structure ENGINE data. */
#define ENGINE_get_ex_new_index(l, p, newf, dupf, freef) \ #define ENGINE_get_ex_new_index(l, p, newf, dupf, freef) \
CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ENGINE, l, p, newf, dupf, freef) CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_ENGINE, l, p, newf, dupf, freef)
int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg); int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg);
void *ENGINE_get_ex_data(const ENGINE *e, int idx); void *ENGINE_get_ex_data(const ENGINE *e, int idx);
@ -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 * 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. * 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 #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_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_privkey_function(const ENGINE *e);
ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_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_CIPHERS_PTR ENGINE_get_ciphers(const ENGINE *e);
ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e); ENGINE_DIGESTS_PTR ENGINE_get_digests(const ENGINE *e);
ENGINE_PKEY_METHS_PTR ENGINE_get_pkey_meths(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_MD *ENGINE_get_digest(ENGINE *e, int nid);
const EVP_PKEY_METHOD *ENGINE_get_pkey_meth(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(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); const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e);
int ENGINE_get_flags(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 * location, handled by the engine. The storage may be on a card or
* whatever. * 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 * This returns a pointer for the current ENGINE structure that is (by
@ -638,12 +660,12 @@ void ENGINE_add_conf_module(void);
/**************************/ /**************************/
/* Binary/behaviour compatibility levels */ /* Binary/behaviour compatibility levels */
# define OSSL_DYNAMIC_VERSION (unsigned long)0x00030000 #define OSSL_DYNAMIC_VERSION (unsigned long)0x00030000
/* /*
* Binary versions older than this are too old for us (whether we're a loader * Binary versions older than this are too old for us (whether we're a loader
* or a loadee) * or a loadee)
*/ */
# define OSSL_DYNAMIC_OLDEST (unsigned long)0x00030000 #define OSSL_DYNAMIC_OLDEST (unsigned long)0x00030000
/* /*
* When compiling an ENGINE entirely as an external shared library, loadable * When compiling an ENGINE entirely as an external shared library, loadable
@ -656,9 +678,9 @@ void ENGINE_add_conf_module(void);
* same static data as the calling application (or library), and thus whether * same static data as the calling application (or library), and thus whether
* these callbacks need to be set or not. * these callbacks need to be set or not.
*/ */
typedef void *(*dyn_MEM_malloc_fn) (size_t, const char *, int); typedef void *(*dyn_MEM_malloc_fn)(size_t, const char *, int);
typedef void *(*dyn_MEM_realloc_fn) (void *, size_t, const char *, int); typedef void *(*dyn_MEM_realloc_fn)(void *, size_t, const char *, int);
typedef void (*dyn_MEM_free_fn) (void *, const char *, int); typedef void (*dyn_MEM_free_fn)(void *, const char *, int);
typedef struct st_dynamic_MEM_fns { typedef struct st_dynamic_MEM_fns {
dyn_MEM_malloc_fn malloc_fn; dyn_MEM_malloc_fn malloc_fn;
dyn_MEM_realloc_fn realloc_fn; dyn_MEM_realloc_fn realloc_fn;
@ -686,19 +708,22 @@ typedef struct st_dynamic_fns {
* implementation can be fully instantiated with * implementation can be fully instantiated with
* IMPLEMENT_DYNAMIC_CHECK_FN(). * IMPLEMENT_DYNAMIC_CHECK_FN().
*/ */
typedef unsigned long (*dynamic_v_check_fn) (unsigned long ossl_version); typedef unsigned long (*dynamic_v_check_fn)(unsigned long ossl_version);
# define IMPLEMENT_DYNAMIC_CHECK_FN() \ #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) { \ 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 * This function is passed the ENGINE structure to initialise with its own
* function and command settings. It should not adjust the structural or * function and command settings. It should not adjust the structural or
* functional reference counts. If this function returns zero, (a) the load * 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 * implementations should do their own internal cleanup in failure
* circumstances otherwise they could leak. The 'id' parameter, if non-NULL, * 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, * 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; * returns an int value (zero for failure). 'fn' should have prototype;
* [static] int fn(ENGINE *e, const char *id); * [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 dynamic_fns *fns); const char *id,
# define IMPLEMENT_DYNAMIC_BIND_FN(fn) \ const dynamic_fns *fns);
OPENSSL_EXPORT \ #define IMPLEMENT_DYNAMIC_BIND_FN(fn) \
int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns); \ OPENSSL_EXPORT \
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) { \ OPENSSL_EXPORT \
if (ENGINE_get_static_state() == fns->static_state) goto skip_cbs; \ int bind_engine(ENGINE *e, const char *id, const dynamic_fns *fns) \
CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn, \ { \
fns->mem_fns.realloc_fn, \ if (ENGINE_get_static_state() == fns->static_state) \
fns->mem_fns.free_fn); \ goto skip_cbs; \
OPENSSL_init_crypto(OPENSSL_INIT_NO_ATEXIT, NULL); \ CRYPTO_set_mem_functions(fns->mem_fns.malloc_fn, \
skip_cbs: \ fns->mem_fns.realloc_fn, \
if (!fn(e, id)) return 0; \ fns->mem_fns.free_fn); \
return 1; } OPENSSL_init_crypto(OPENSSL_INIT_NO_ATEXIT, NULL); \
skip_cbs: \
if (!fn(e, id)) \
return 0; \
return 1; \
}
/* /*
* If the loading application (or library) and the loaded ENGINE library * If the loading application (or library) and the loaded ENGINE library
@ -740,13 +770,13 @@ typedef int (*dynamic_bind_engine) (ENGINE *e, const char *id,
*/ */
void *ENGINE_get_static_state(void); void *ENGINE_get_static_state(void);
# if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) #if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
DEPRECATEDIN_1_1_0(void ENGINE_setup_bsd_cryptodev(void)) DEPRECATEDIN_1_1_0(void ENGINE_setup_bsd_cryptodev(void))
# endif #endif
# ifdef __cplusplus #ifdef __cplusplus
} }
# endif #endif
# endif #endif
#endif #endif

12
simdata/gate.cpp
View File

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

6
simdata/include/simulatorDatabase.hpp
View File

@ -12,8 +12,6 @@
#include "gate.h" #include "gate.h"
#include "runway.h" #include "runway.h"
#define CURRENT_VERSION 1
/* /*
* Header * Header
* *
@ -41,8 +39,8 @@ namespace germanairlinesva_simdata
std::uint8_t null = 0; std::uint8_t null = 0;
std::ofstream out(file, std::fstream::binary); 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); out.write(reinterpret_cast<const char *>(header), 6);
// Num Airports // Num Airports
std::uint16_t numAirports = airports.size(); 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()), static_cast<std::uint8_t>(this->designator.length()),
sizeof(std::uint8_t)); sizeof(std::uint8_t));
bufPtr++; 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; bufPtr += this->designator.length() + 1;
memcpy(bufPtr, &this->bounds, sizeof(this->bounds)); std::memcpy(bufPtr, &this->bounds, sizeof(this->bounds));
bufPtr += 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); bufPtr += sizeof(this->width);
memcpy(bufPtr, &this->length, sizeof(this->length)); std::memcpy(bufPtr, &this->length, sizeof(this->length));
bufPtr += 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, Runway::Runway(std::string designator,
@ -68,14 +68,14 @@ namespace germanairlinesva_simdata
static_cast<std::uint8_t>(this->designator.length()), static_cast<std::uint8_t>(this->designator.length()),
sizeof(std::uint8_t)); sizeof(std::uint8_t));
bufPtr++; 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; bufPtr += this->designator.length() + 1;
memcpy(bufPtr, &this->bounds, sizeof(this->bounds)); std::memcpy(bufPtr, &this->bounds, sizeof(this->bounds));
bufPtr += 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); bufPtr += sizeof(this->width);
memcpy(bufPtr, &this->length, sizeof(this->length)); std::memcpy(bufPtr, &this->length, sizeof(this->length));
bufPtr += 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 } // namespace germanairlinesva_simdata

1
websocket/include/websocket.h
View File

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

1
xplugin/include/main.h
View File

@ -22,6 +22,7 @@
#include <mutex> #include <mutex>
#include <queue> #include <queue>
#include <sstream> #include <sstream>
#include <string>
#include <thread> #include <thread>
float flightLoop(float elapsedMe, float elapsedSim, int counter, void *refcon); 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); 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); connector->sendData(copy);
@ -275,7 +275,7 @@ void recordingWorker()
{ {
const std::lock_guard<std::mutex> lock(mutex); 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( germanairlinesva_recording::PathSegment currentPath(