2 crash fixes + data compressor

CMakeLists.txt

@@ -9,6 +9,6 @@ project(BeamMP-Launcher)
 
 set(CMAKE_CXX_STANDARD 14)
 
-add_executable(BeamMP-Launcher main.cpp proxy.cpp Security.cpp http.cpp Discord.cpp UpdateCheck.cpp CoreNetwork.cpp Resources.cpp)
+add_executable(BeamMP-Launcher main.cpp VehicleNetwork.cpp proxy.cpp Security.cpp http.cpp Discord.cpp UpdateCheck.cpp CoreNetwork.cpp Resources.cpp Compressor.cpp VehicleNetwork.cpp)
 
-target_link_libraries(BeamMP-Launcher discord-rpc libcurl_a)
+target_link_libraries(BeamMP-Launcher discord-rpc libcurl_a zlibstatic)

Compressor.cpp

@@ -0,0 +1,60 @@
+///
+/// Created by Anonymous275 on 4/23/2020
+///
+
+#include <string>
+#include <iostream>
+#include "include/zlib.h"
+
+
+void Print(const std::string&MSG){
+    //std::cout << MSG << std::endl;
+}
+
+
+std::string Compress(const std::string&Data){
+    std::string b;
+    b.resize(Data.size());
+    z_stream defstream;
+    defstream.zalloc = Z_NULL;
+    defstream.zfree = Z_NULL;
+    defstream.opaque = Z_NULL;
+    defstream.avail_in = (uInt)Data.length()+1;
+    defstream.next_in = (Bytef *)&Data[0];
+    defstream.avail_out = (uInt)b.size();
+    defstream.next_out = (Bytef *)&b[0];
+    deflateInit(&defstream, Z_BEST_COMPRESSION);
+    deflate(&defstream, Z_FINISH);
+    deflateEnd(&defstream);
+    for(int i = int(b.length())-1;i >= 0;i--){
+        if(b.at(i) != '\0'){
+            b.resize(i);
+            break;
+        }
+    }
+    return b;
+}
+
+std::string Decompress(const std::string&Data)
+{
+    std::string c;
+    c.resize(Data.size()*5);
+    z_stream infstream,defstream;
+    infstream.zalloc = Z_NULL;
+    infstream.zfree = Z_NULL;
+    infstream.opaque = Z_NULL;
+    infstream.avail_in = (uInt)((char*)defstream.next_out - Data.c_str());
+    infstream.next_in = (Bytef *)&Data[0];
+    infstream.avail_out = (uInt)c.size();
+    infstream.next_out = (Bytef *)&c[0];
+    inflateInit(&infstream);
+    inflate(&infstream, Z_NO_FLUSH);
+    inflateEnd(&infstream);
+    for(int i = int(c.length())-1;i >= 0;i--){
+        if(c.at(i) != '\0'){
+            c.resize(i+2);
+            break;
+        }
+    }
+    return c;
+}

CoreNetwork.cpp

@@ -21,6 +21,7 @@ extern bool Terminate;
 extern bool TCPTerminate;
 void StartSync(const std::string &Data){
     std::thread t1(SyncResources,Data.substr(1,Data.find(':')-1),std::stoi(Data.substr(Data.find(':')+1)));
+    //std::thread t1(SyncResources,"127.0.0.1",30814);
     t1.detach();
 }
 

Resources.cpp

@@ -140,16 +140,16 @@ void SyncResources(const std::string&IP,int Port){
         }
     }while (iResult > 0);
     if(BytesSent == SOCKET_ERROR)
-        printf("Client: send() error %ld.\n", WSAGetLastError());
+        printf("Client: send() error %d.\n", WSAGetLastError());
 
 
 
     if( shutdown(SendingSocket, SD_SEND) != 0)
-        printf("Client: Well, there is something wrong with the shutdown() The error code: %ld\n", WSAGetLastError());
+        printf("Client: Well, there is something wrong with the shutdown() The error code: %d\n", WSAGetLastError());
 
 
     if(closesocket(SendingSocket) != 0)
-        printf("Client: Cannot close \"SendingSocket\" socket. Error code: %ld\n", WSAGetLastError());
+        printf("Client: Cannot close \"SendingSocket\" socket. Error code: %d\n", WSAGetLastError());
 
 
     if(WSACleanup() != 0)

VehicleNetwork.cpp

@@ -0,0 +1,154 @@
+///
+/// Created by Anonymous275 on 4/23/2020
+///
+
+#include <WinSock2.h>
+#include <WS2tcpip.h>
+#include <iostream>
+#include <string>
+#include <thread>
+#include <queue>
+
+extern bool TCPTerminate;
+void Print(const std::string&MSG);
+std::queue<std::string> VNTCPQueue;
+extern std::queue<std::string> RUDPToSend;
+#define DEFAULT_PORT "4446"
+
+void Responder(const SOCKET *CS){
+    SOCKET ClientSocket = *CS;
+    int iSendResult;
+    while(!TCPTerminate){
+        while (!VNTCPQueue.empty()) {
+            VNTCPQueue.front() += "\n";
+            iSendResult = send(ClientSocket, VNTCPQueue.front().c_str(), VNTCPQueue.front().length(), 0);
+            if (iSendResult == SOCKET_ERROR) {
+                std::cout << "(VN) send failed with error: " << WSAGetLastError() << std::endl;
+                break;
+            } else {
+                if(iSendResult > 1000){
+                    std::cout << "(Launcher->Game VN) Bytes sent: " << iSendResult <<  " : " <<  VNTCPQueue.front().substr(0,10)
+                              << VNTCPQueue.front().substr(VNTCPQueue.front().length()-10) << std::endl;
+                }
+                VNTCPQueue.pop();
+            }
+        }
+        std::this_thread::sleep_for(std::chrono::nanoseconds(1));
+    }
+}
+
+void VehicleNetworkStart(){
+    do {
+        std::cout << "VN on Start" << std::endl;
+        WSADATA wsaData;
+        int iResult;
+        SOCKET ListenSocket = INVALID_SOCKET;
+        SOCKET ClientSocket = INVALID_SOCKET;
+
+        struct addrinfo *result = nullptr;
+        struct addrinfo hints{};
+
+        int iSendResult;
+        char recvbuf[7507];
+        int recvbuflen = 6507;
+
+        // Initialize Winsock
+        iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
+        if (iResult != 0) {
+            std::cout << "(VN) WSAStartup failed with error: " << iResult << std::endl;
+            std::cin.get();
+            exit(-1);
+        }
+
+        ZeroMemory(&hints, sizeof(hints));
+        hints.ai_family = AF_INET;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_protocol = IPPROTO_TCP;
+        hints.ai_flags = AI_PASSIVE;
+
+        // Resolve the server address and port
+        iResult = getaddrinfo(nullptr, DEFAULT_PORT, &hints, &result);
+        if (iResult != 0) {
+            std::cout << "(VN) getaddrinfo failed with error: " << iResult << std::endl;
+            WSACleanup();
+            break;
+        }
+
+        // Create a socket for connecting to server
+        ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
+        if (ListenSocket == INVALID_SOCKET) {
+            std::cout << "(VN) socket failed with error: " << WSAGetLastError() << std::endl;
+            freeaddrinfo(result);
+            WSACleanup();
+            break;
+        }
+
+        // Setup the TCP listening socket
+        iResult = bind(ListenSocket, result->ai_addr, (int) result->ai_addrlen);
+        if (iResult == SOCKET_ERROR) {
+            std::cout << "(VN) bind failed with error: " << WSAGetLastError() << std::endl;
+            freeaddrinfo(result);
+            closesocket(ListenSocket);
+            WSACleanup();
+            break;
+        }
+
+        freeaddrinfo(result);
+
+        iResult = listen(ListenSocket, SOMAXCONN);
+        if (iResult == SOCKET_ERROR) {
+            std::cout << "(VN) listen failed with error: " << WSAGetLastError() << std::endl;
+            closesocket(ListenSocket);
+            WSACleanup();
+            continue;
+        }
+        ClientSocket = accept(ListenSocket, NULL, NULL);
+        if (ClientSocket == INVALID_SOCKET) {
+            std::cout << "(VN) accept failed with error: " << WSAGetLastError() << std::endl;
+            closesocket(ListenSocket);
+            WSACleanup();
+            continue;
+        }
+        closesocket(ListenSocket);
+        std::cout << "(VN) Game Connected!" << std::endl;
+
+        std::thread TCPSend(Responder,&ClientSocket);
+        TCPSend.detach();
+        do {
+            //std::cout << "(Proxy) Waiting for Game Data..." << std::endl;
+            iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
+            if (iResult > 0) {
+                std::string buff;
+                buff.resize(iResult*2);
+                memcpy(&buff[0],recvbuf,iResult);
+                buff.resize(iResult);
+                //Print(buff);
+                if(buff.length() > 3)RUDPToSend.push(buff);
+
+
+                std::cout << "(Game->Launcher VN) Data : " << buff.length() << std::endl;
+            } else if (iResult == 0) {
+                std::cout << "(VN) Connection closing...\n";
+                closesocket(ClientSocket);
+                WSACleanup();
+
+                continue;
+            } else {
+                std::cout << "(VN) recv failed with error: " << WSAGetLastError() << std::endl;
+                closesocket(ClientSocket);
+                WSACleanup();
+                continue;
+            }
+        } while (iResult > 0);
+
+        iResult = shutdown(ClientSocket, SD_SEND);
+        if (iResult == SOCKET_ERROR) {
+            std::cout << "(VN) shutdown failed with error: " << WSAGetLastError() << std::endl;
+            closesocket(ClientSocket);
+            WSACleanup();
+            continue;
+        }
+        closesocket(ClientSocket);
+        WSACleanup();
+    }while (!TCPTerminate);
+}

include/enet.h

@@ -39,7 +39,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <time.h>
-
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
 #define ENET_VERSION_MAJOR 2
 #define ENET_VERSION_MINOR 2
 #define ENET_VERSION_PATCH 0
@@ -48,7 +48,6 @@
 #define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF)
 #define ENET_VERSION_GET_PATCH(version) ((version)&0xFF)
 #define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH)
-
 #define ENET_TIME_OVERFLOW 86400000
 #define ENET_TIME_LESS(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW)
 #define ENET_TIME_GREATER(a, b) ((b) - (a) >= ENET_TIME_OVERFLOW)
@@ -1071,7 +1070,7 @@ __inline int64_t enet_at_atomic_cas(char *ptr, int64_t new_val, int64_t old_val,
             return InterlockedCompareExchange64((volatile LONGLONG *)ptr, (LONGLONG)new_val,
                                                 (LONGLONG)old_val);
 #else
-        return _InterlockedCompareExchange64((volatile LONGLONG *)ptr, (LONGLONG)new_val,
+            return _InterlockedCompareExchange64((volatile LONGLONG *)ptr, (LONGLONG)new_val,
                                                      (LONGLONG)old_val);
 #endif
         default:
@@ -5588,7 +5587,6 @@ int enet_address_set_host_ip(ENetAddress *address, const char *name) {
 int enet_address_set_host(ENetAddress *address, const char *name) {
     struct hostent *hostEntry = NULL;
     hostEntry = gethostbyname(name);
-
     if (hostEntry == NULL || hostEntry->h_addrtype != AF_INET) {
         if (!inet_pton(AF_INET6, name, &address->host)) {
             return -1;

include/zconf.h

@@ -0,0 +1,527 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+#  define Z_PREFIX_SET
+
+/* all linked symbols and init macros */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_bits        z__tr_flush_bits
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define adler32_z             z_adler32_z
+#  ifndef Z_SOLO
+#    define compress              z_compress
+#    define compress2             z_compress2
+#    define compressBound         z_compressBound
+#  endif
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define crc32_z               z_crc32_z
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateGetDictionary  z_deflateGetDictionary
+#  define deflateInit           z_deflateInit
+#  define deflateInit2          z_deflateInit2
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePending        z_deflatePending
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateResetKeep      z_deflateResetKeep
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  ifndef Z_SOLO
+#    define gz_error              z_gz_error
+#    define gz_intmax             z_gz_intmax
+#    define gz_strwinerror        z_gz_strwinerror
+#    define gzbuffer              z_gzbuffer
+#    define gzclearerr            z_gzclearerr
+#    define gzclose               z_gzclose
+#    define gzclose_r             z_gzclose_r
+#    define gzclose_w             z_gzclose_w
+#    define gzdirect              z_gzdirect
+#    define gzdopen               z_gzdopen
+#    define gzeof                 z_gzeof
+#    define gzerror               z_gzerror
+#    define gzflush               z_gzflush
+#    define gzfread               z_gzfread
+#    define gzfwrite              z_gzfwrite
+#    define gzgetc                z_gzgetc
+#    define gzgetc_               z_gzgetc_
+#    define gzgets                z_gzgets
+#    define gzoffset              z_gzoffset
+#    define gzoffset64            z_gzoffset64
+#    define gzopen                z_gzopen
+#    define gzopen64              z_gzopen64
+#    ifdef _WIN32
+#      define gzopen_w              z_gzopen_w
+#    endif
+#    define gzprintf              z_gzprintf
+#    define gzputc                z_gzputc
+#    define gzputs                z_gzputs
+#    define gzread                z_gzread
+#    define gzrewind              z_gzrewind
+#    define gzseek                z_gzseek
+#    define gzseek64              z_gzseek64
+#    define gzsetparams           z_gzsetparams
+#    define gztell                z_gztell
+#    define gztell64              z_gztell64
+#    define gzungetc              z_gzungetc
+#    define gzvprintf             z_gzvprintf
+#    define gzwrite               z_gzwrite
+#  endif
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit       z_inflateBackInit
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCodesUsed      z_inflateCodesUsed
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetDictionary  z_inflateGetDictionary
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit           z_inflateInit
+#  define inflateInit2          z_inflateInit2
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateResetKeep      z_inflateResetKeep
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflateValidate       z_inflateValidate
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  ifndef Z_SOLO
+#    define uncompress            z_uncompress
+#    define uncompress2           z_uncompress2
+#  endif
+#  define zError                z_zError
+#  ifndef Z_SOLO
+#    define zcalloc               z_zcalloc
+#    define zcfree                z_zcfree
+#  endif
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  ifndef Z_SOLO
+#    define gzFile                z_gzFile
+#  endif
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#  define z_const const
+#else
+#  define z_const
+#endif
+
+#ifdef Z_SOLO
+   typedef unsigned long z_size_t;
+#else
+#  define z_longlong long long
+#  if defined(NO_SIZE_T)
+     typedef unsigned NO_SIZE_T z_size_t;
+#  elif defined(STDC)
+#    include <stddef.h>
+     typedef size_t z_size_t;
+#  else
+     typedef unsigned long z_size_t;
+#  endif
+#  undef z_longlong
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#    define Z_ARG(args)  args
+#  else
+#    define Z_ARG(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (UINT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned
+#  elif (ULONG_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned long
+#  elif (USHRT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned short
+#  endif
+#endif
+
+#ifdef Z_U4
+   typedef Z_U4 z_crc_t;
+#else
+   typedef unsigned long z_crc_t;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_STDARG_H
+#endif
+
+#ifdef STDC
+#  ifndef Z_SOLO
+#    include <sys/types.h>      /* for off_t */
+#  endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+#    include <stdarg.h>         /* for va_list */
+#  endif
+#endif
+
+#ifdef _WIN32
+#  ifndef Z_SOLO
+#    include <stddef.h>         /* for wchar_t */
+#  endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#  define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#    ifdef VMS
+#      include <unixio.h>       /* for off_t */
+#    endif
+#    ifndef z_off_t
+#      define z_off_t off_t
+#    endif
+#  endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
+#  define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#  define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
+#  define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#  define z_off64_t off64_t
+#else
+#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#    define z_off64_t __int64
+#  else
+#    define z_off64_t z_off_t
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */

main.cpp

@@ -78,7 +78,7 @@ std::string CheckVer(const std::string &path){
 void SyncResources(const std::string&IP,int Port);
 int main(int argc, char* argv[])
 {
-    std::string ver = "0.56", Path = CheckDir(argv[0],ver),HTTP_Result;
+    std::string ver = "0.735", Path = CheckDir(argv[0],ver),HTTP_Result;
     CheckForUpdates(ver); //Update Check
 
     //Security
@@ -96,7 +96,7 @@ int main(int argc, char* argv[])
 
     HTTP_Result = HTTP_REQUEST("https://beamng-mp.com/entitlement?did="+Discord_Main().at(2),443);
     std::cout << "you have : " << HTTP_Result << std::endl;
-    if(HTTP_Result.find("[\"MDEV\"]") == std::string::npos)exit(-1); ///Remove later
+    if(HTTP_Result.find("[\"MDEV\"]") == std::string::npos && HTTP_Result.find("[\"MOD\"]") == std::string::npos)exit(-1); ///Remove later
 
 
     std::string ExeDir = GamePath.substr(0,GamePath.find_last_of('\\')) + "\\Bin64\\BeamNG.drive.x64.exe";

proxy.cpp

@@ -11,14 +11,13 @@
 #include <string>
 #include <thread>
 #include <queue>
-#include <mutex>
 
-#define DEFAULT_BUFLEN 64000
 #define DEFAULT_PORT "4445"
 typedef struct {
     ENetHost *host;
     ENetPeer *peer;
 } Client;
+std::vector<std::string> Split(const std::string& String,const std::string& delimiter);
 std::chrono::time_point<std::chrono::steady_clock> PingStart,PingEnd;
 extern std::vector<std::string> GlobalInfo;
 std::queue<std::string> RUDPToSend;
@@ -38,7 +37,7 @@ void AutoPing(ENetPeer*peer){
     }
 }
 void NameRespond(ENetPeer*peer){
-    std::string Packet = "NR" + GlobalInfo.at(0);
+    std::string Packet = "NR" + GlobalInfo.at(0)+":"+GlobalInfo.at(2);
     enet_peer_send(peer, 0, enet_packet_create(Packet.c_str(), Packet.length()+1, ENET_PACKET_FLAG_RELIABLE));
 }
 
@@ -63,7 +62,7 @@ void HandleEvent(ENetEvent event,Client client){
         case ENET_EVENT_TYPE_CONNECT:
             std::cout << "(Launcher->Server) Client Connected!" << std::endl;
             //printf("Client Connected port : %u.\n",event.peer->address.port);
-            event.peer->data = (void *)"Connected Server";
+            event.peer->data = (void*)"Connected Server";
             break;
         case ENET_EVENT_TYPE_RECEIVE:
             RUDPParser((char*)event.packet->data,event.peer);
@@ -93,7 +92,6 @@ void RUDPClientThread(const std::string& IP, int Port){
 
     address.host = ENET_HOST_ANY;
     address.port = Port;
-    std::mutex m;
     std::cout << "(Launcher->Server) Connecting...\n";
 
     enet_address_set_host(&address, IP.c_str());
@@ -109,17 +107,21 @@ void RUDPClientThread(const std::string& IP, int Port){
         enet_host_service(client.host, &event, 0);
         HandleEvent(event,client);
         while (!RUDPToSend.empty()){
-            int Rel = 8;
+                int Rel = 8;
-            char C = RUDPToSend.front().at(0);
+                char C = RUDPToSend.front().at(0);
-            if(C=='s'||C=='d'||C=='m'||C=='r')Rel = 1;
+                if (C == 's' || C == 'd' || C == 'm' || C == 'r')Rel = 1;
-            ENetPacket* packet = enet_packet_create(RUDPToSend.front().c_str(),
+                ENetPacket *packet = enet_packet_create(RUDPToSend.front().c_str(),
-                                                     RUDPToSend.front().length()+1,
+                                                        RUDPToSend.front().length() + 1,
-                                                    Rel);
+                                                        Rel);
-            enet_peer_send(client.peer, 0, packet);
+                enet_peer_send(client.peer, 0, packet);
-            std::cout << "(Launcher->Server) sending " << RUDPToSend.front().length() << " Bytes" << std::endl;
+                if (RUDPToSend.front().length() > 1000) {
+                    std::cout << "(Launcher->Server) Bytes sent: " << RUDPToSend.front().length() << " : "
+                              << RUDPToSend.front().substr(0, 10)
+                              << RUDPToSend.front().substr(RUDPToSend.front().length() - 10) << std::endl;
+                }
             RUDPToSend.pop();
         }
-        std::this_thread::sleep_for(std::chrono::microseconds(10));
+        std::this_thread::sleep_for(std::chrono::nanoseconds(1));
     } while (!Terminate);
     enet_peer_disconnect(client.peer,0);
     enet_host_service(client.host, &event, 0);
@@ -134,17 +136,20 @@ void TCPRespond(const SOCKET *CS){
     std::mutex m;
     while(!TCPTerminate){
         while (!RUDPData.empty()) {
-            RUDPData.front() += "\n";
+            std::string Data =  RUDPData.front() + "\n";
-            iSendResult = send(ClientSocket, RUDPData.front().c_str(), RUDPData.front().length(), 0);
+            iSendResult = send(ClientSocket, Data.c_str(), Data.length(), 0);
             if (iSendResult == SOCKET_ERROR) {
                 std::cout << "(Proxy) send failed with error: " << WSAGetLastError() << std::endl;
                 break;
             } else {
+                if(iSendResult > 1000){
+                    std::cout << "(Launcher->Game) Bytes sent: " << iSendResult <<  " : " <<  RUDPData.front().substr(0,10)
+                    << RUDPData.front().substr(RUDPData.front().length()-10) << std::endl;
+                }
                 RUDPData.pop();
-                std::cout << "(Proxy->Game) Bytes sent: " << iSendResult << std::endl;
             }
         }
-        std::this_thread::sleep_for(std::chrono::microseconds(10));
+        std::this_thread::sleep_for(std::chrono::nanoseconds(1));
     }
 }
 
@@ -161,8 +166,8 @@ void TCPServerThread(const std::string& IP, int Port){
         struct addrinfo hints{};
 
         int iSendResult;
-        char recvbuf[DEFAULT_BUFLEN];
+        char recvbuf[10000];
-        int recvbuflen = DEFAULT_BUFLEN;
+        int recvbuflen = 10000;
 
         // Initialize Winsock
         iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
@@ -231,13 +236,17 @@ void TCPServerThread(const std::string& IP, int Port){
         std::thread TCPSend(TCPRespond,&ClientSocket);
         TCPSend.detach();
         do {
-            std::cout << "(Proxy) Waiting for Game Data..." << std::endl;
+            //std::cout << "(Proxy) Waiting for Game Data..." << std::endl;
             iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
             if (iResult > 0) {
-                std::string buff = recvbuf;
+                std::string buff;
+                buff.resize(iResult*2);
+                memcpy(&buff[0],recvbuf,iResult);
                 buff.resize(iResult);
-                RUDPToSend.push(buff);
+
-                std::cout << "(Game->Launcher) Data : " << buff.length() << std::endl;
+                if(buff.length() > 3)RUDPToSend.push(buff);
+
+                //std::cout << "(Game->Launcher) Data : " << buff.length() << std::endl;
             } else if (iResult == 0) {
                 std::cout << "(Proxy) Connection closing...\n";
                 closesocket(ClientSocket);
@@ -271,10 +280,12 @@ void ProxyStart(){
     std::cout << "Core Network Started!\n";
     t1.join();
 }
-
+void VehicleNetworkStart();
 void ProxyThread(const std::string& IP, int Port){
     Terminate = false;
     TCPTerminate = false;
     std::thread t1(TCPServerThread,IP,Port);
     t1.detach();
+    std::thread t2(VehicleNetworkStart);
+    t2.detach();
 }