AfonsoCMSousa/ACPlayer_tracker
1
1
Fork 0
generated from AfonsoCMSousa/CPP-Template
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

merge: merge conflict

Browse Source
This commit is contained in:
Afonso Clerigo Mendes de Sousa 2026-03-13 20:56:26 +00:00
commit fe193cd648
19 changed files with 942 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,3 +1,4 @@
*.a
*.log
*.so

1
compile_commands.json
View File

@ -1 +0,0 @@
/mnt/combined/servers/acserver_GT4/utils/ACPlayer_tracker/build/compile_commands.json

193
include/handle.hpp Normal file
View File

@ -0,0 +1,193 @@
#ifndef HANDLE_HPP
#define HANDLE_HPP
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
#include "file.hpp" // for parce_args
#include "net.hpp" // for socket operations
#include "server_structs.h"
using namespace std;
class PacketReader {
private:
const u_char *buffer_;
size_t buffer_size_;
size_t offset_ = 0;
bool error_ = false;
public:
PacketReader(); // TODO:
~PacketReader(); // TODO:
bool read_uint8(uint8_t &value) {
size_t __bytes = sizeof(value);
if (offset_ + __bytes > buffer_size_) {
error_ = true;
return false;
}
memcpy(&value, buffer_ + offset_, sizeof(value));
offset_++;
return true;
}
bool read_uint16(uint16_t &value) {
size_t __bytes = sizeof(value);
if (offset_ + __bytes > buffer_size_) {
error_ = true;
return false;
}
memcpy(&value, buffer_ + offset_, sizeof(value));
value = ntohs(value);
offset_ += 2;
return true;
}
bool read_uint32(uint32_t &value) {
size_t __bytes = sizeof(value);
if (offset_ + __bytes > buffer_size_) {
error_ = true;
return false;
}
memcpy(&value, buffer_ + offset_, sizeof(value));
value = ntohl(value);
offset_ += 4;
return true;
}
bool read_float(float &value) {
size_t __bytes = sizeof(value);
if (offset_ + __bytes > buffer_size_) {
error_ = true;
return false;
}
uint32_t v_int;
memcpy(&v_int, buffer_ + offset_, sizeof(v_int));
v_int = ntohl(v_int);
memcpy(&value, &v_int, sizeof(value));
offset_ += 4;
return true;
}
bool read_string_utf32l(string &value) {
uint8_t __length;
if (!read_uint8(__length))
return false;
if (offset_ + (__length * sizeof(uint32_t)) > buffer_size_) {
error_ = true;
return false;
}
value.clear();
for (size_t i = 0; i < __length; i++) {
uint32_t codeunit;
if (!read_uint32(codeunit))
return false;
if (codeunit == 0) {
break; // null terminator
}
value.push_back(static_cast<char>(codeunit));
}
return true;
}
bool has_error() const {
return error_;
}
};
class ProtocolHandler {
private:
trackAtributes track_info_;
carAtributes player_info_[64];
public:
ProtocolHandler();
~ProtocolHandler();
bool handle_new_session(PacketReader &reader) {
if (!reader.read_uint8(track_info_.protocol_version))
return false;
if (!reader.read_uint8(track_info_.session_index))
return false;
if (!reader.read_uint8(track_info_.current_session_index))
return false;
if (!reader.read_uint8(track_info_.session_count))
return false;
/*
* str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
read_utf32le_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.server_name, str_len_8, &ok);
str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.track, str_len_8, &ok);
str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.track_config, str_len_8, &ok);
str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.session_name, str_len_8, &ok);
trackInfo.typ = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
trackInfo.time = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
trackInfo.laps = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
trackInfo.wait_time = read_uint16((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
trackInfo.ambient_temp = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
trackInfo.road_temp = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
str_len_8 = read_uint8((const u_int8_t *)buffer, recv_bytes, &offset, &ok);
read_string((const u_int8_t *)buffer, recv_bytes, &offset, trackInfo.weather_graphics, str_len_8, &ok);
*/
if (!reader.read_string_utf32l(track_info_.server_name))
return false;
if (!reader.read_string_utf32l(track_info_.track))
return false;
if (!reader.read_string_utf32l(track_info_.track_config))
return false;
if (!reader.read_string_utf32l(track_info_.session_name))
return false;
if (!reader.read_uint8(track_info_.typ))
return false;
if (!reader.read_uint16(track_info_.time))
return false;
if (!reader.read_uint16(track_info_.laps))
return false;
if (!reader.read_uint16(track_info_.wait_time))
return false;
if (!reader.read_uint8(track_info_.ambient_temp))
return false;
if (!reader.read_uint8(track_info_.road_temp))
return false;
if (!reader.read_string_utf32l(track_info_.weather_graphics))
return false;
return true;
}
};
#endif // HANDLE_HPP

23
include/log.h Normal file
View File

@ -0,0 +1,23 @@
#ifndef LOG_H
#define LOG_H
#include <stdio.h>
#include <stdarg.h>
#include <time.h>
typedef enum {
LOG_INFO,
LOG_DEBUG,
LOG_WARN,
LOG_ERROR
} LogLevel;
void log_print(LogLevel level, const char* format, ...);
#define log_info(...) log_print(LOG_INFO, __VA_ARGS__)
#define log_debug(...) log_print(LOG_DEBUG, __VA_ARGS__)
#define log_warn(...) log_print(LOG_WARN, __VA_ARGS__)
#define log_error(...) log_print(LOG_ERROR, __VA_ARGS__)
#endif // LOG_H

45
include/mapper.hpp Normal file
View File

@ -0,0 +1,45 @@
#ifndef MAPPER_HPP
#define MAPPER_HPP
#include <cstdint>
#include <cstddef>
#include "parcer.h"
#include "server_structs.h"
// INFO: This is basically a identity mapper between raw byte buffer and structs defined in server_structs.h
class Mapper {
private:
const uint_least8_t *buffer;
size_t buffer_size;
size_t offset;
bool ok;
public:
Mapper(const uint_least8_t *buf, size_t buf_size);
uint8_t get_message_type();
bool is_ok() const { return ok; }
void parse_new_session(trackAtributes &track);
void parse_new_connection(carAtributes &car);
void parse_connection_closed(carAtributes &car);
void parse_car_update(carAtributes &car);
void parse_car_info(carAtributes &car);
void parse_lap_completed(uint8_t &car_id, uint32_t &lap_time, uint32_t &cuts);
void parse_collision_event(uint8_t &car1, uint8_t &car2, uint8_t &event_type);
void parse_chat(uint8_t &car_id, char *message, size_t max_len);
void parse_client_loaded(uint8_t &car_id);
void set_size(size_t size) { this->buffer_size = size; }
void update_buffer(const uint8_t *buf, size_t size) {
this->buffer = buf;
this->buffer_size = size;
reset();
}
private:
// INFO: Reset the offset to 1 because the first byte is message type
void reset() { offset = 1; ok = true; }
};
#endif // MAPPER_HPP

1
include/net.hpp
View File

@ -9,6 +9,7 @@
#include <sys/un.h>
#include <unistd.h>
#include "log.h"
#include "server_structs.h"
using namespace std;

141
include/parcer.c.old Normal file
View File

@ -0,0 +1,141 @@
#include "parcer.h"
#include "server_structs.h"
#include <sys/types.h>
int ensure(size_t recv_len, size_t offset, size_t need) {
return (offset + need <= recv_len);
}
u_int8_t read_uint8(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
if (!ensure(recv_len, *offset, sizeof(uint8_t))) {
*ok = 0;
return 0;
}
u_int8_t v;
memcpy(&v, buf + *offset, sizeof(v));
*offset += sizeof(v);
return v;
}
u_int16_t read_uint16(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
if (!ensure(recv_len, *offset, sizeof(uint16_t))) {
*ok = 0;
return 0;
}
u_int16_t v;
memcpy(&v, buf + *offset, sizeof(v));
*offset += sizeof(v);
return (u_int16_t)ntohs(v);
}
u_int32_t read_uint32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
if (!ensure(recv_len, *offset, sizeof(uint32_t))) {
*ok = 0;
return 0;
}
u_int32_t v;
memcpy(&v, buf + *offset, sizeof(v));
*offset += sizeof(v);
return (u_int32_t)ntohl(v);
}
int32_t read_int32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
if (!ensure(recv_len, *offset, sizeof(int32_t))) {
*ok = 0;
return 0;
}
int32_t v;
memcpy(&v, buf + *offset, sizeof(v));
*offset += sizeof(v);
return (int32_t)ntohl(v);
}
float read_float(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
if (!ensure(recv_len, *offset, sizeof(float))) {
*ok = 0;
return 0.0f;
}
u_int32_t v_int;
memcpy(&v_int, buf + *offset, sizeof(v_int));
*offset += sizeof(v_int);
v_int = ntohl(v_int);
float v_float;
memcpy(&v_float, &v_int, sizeof(v_float));
return v_float;
}
void read_bytes(const u_int8_t *buf, size_t recv_len, size_t *offset, u_int8_t *out, size_t len, int *ok) {
if (!ensure(recv_len, *offset, len)) {
*ok = 0;
return;
}
memcpy(out, buf + *offset, len);
*offset += len;
}
void read_utf32le_string(const uint8_t *buffer, size_t buf_size, size_t *offset, char *dest, size_t max_len, int *ok) {
size_t i = *offset;
size_t j = 0;
while (i + 3 < buf_size && j < max_len) {
uint32_t codeunit = buffer[i] | (buffer[i + 1] << 8) | (buffer[i + 2] << 16) | (buffer[i + 3] << 24);
if (codeunit == 0) {
i += 4; // termina a string
break;
}
if (codeunit < 0x80) {
dest[j++] = (char)codeunit;
} else {
dest[j++] = '?'; // substitui caracteres fora de ASCII
}
i += 4;
}
dest[j] = '\0';
*offset = i;
*ok = 1;
}
void read_utf16le_string(const uint8_t *buffer, size_t buf_size, size_t *offset, char *dest, size_t max_len, int *ok) {
size_t i = *offset;
size_t j = 0;
while (i + 1 < buf_size && j < max_len - 1) {
uint16_t codeunit = buffer[i] | (buffer[i + 1] << 8);
if (codeunit == 0) {
i += 2; // termina a string
break;
}
if (codeunit < 0x80) {
dest[j++] = (char)codeunit;
} else {
dest[j++] = '?'; // substitui caracteres fora de ASCII
}
i += 2;
}
dest[j] = '\0';
*offset = i;
*ok = 1;
}
void read_string(const u_int8_t *buf, size_t recv_len, size_t *offset, char *out, size_t len, int *ok) {
if (!ensure(recv_len, *offset, len)) {
*ok = 0;
return;
}
for (size_t i = 0; i <= len; i++) {
out[i] = (char)buf[*offset + i];
}
out[len] = '\0'; // Ensure null termination
*offset += len;
*ok = 1;
}

4
include/parcer.h
View File

@ -27,6 +27,10 @@ u_int8_t read_uint8(const u_int8_t *buf, size_t recv_len, size_t *offset, int *o
// Advances the offset by 2 bytes.
u_int16_t read_uint16(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
// Reads a 16-bit unsigned integer from the buffer in little-endian byte order.
// Advances the offset by 2 bytes.
u_int16_t read_uint16_le(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
// Reads a 32-bit unsigned integer from the buffer in network byte order.
// Advances the offset by 4 bytes.
u_int32_t read_uint32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);

62
include/parcer.h.old Normal file
View File

@ -0,0 +1,62 @@
#ifndef PARCER_H
#define PARCER_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include "server_structs.hpp"
// Ensures that there are at least 'need' bytes available in the buffer
// starting from 'offset'. Returns 1 if enough bytes are available, 0 otherwise.
int ensure(size_t recv_len, size_t offset, size_t need);
// Reads an 8-bit unsigned integer from the buffer.
// Advances the offset by 1 byte.
u_int8_t read_uint8(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
// Reads a 16-bit unsigned integer from the buffer in network byte order.
// Advances the offset by 2 bytes.
u_int16_t read_uint16(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
// Reads a 32-bit unsigned integer from the buffer in network byte order.
// Advances the offset by 4 bytes.
u_int32_t read_uint32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
// Reads a 32-bit signed integer from the buffer in network byte order.
// Advances the offset by 4 bytes.
int32_t read_int32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
// Reads a 32-bit float from the buffer in network byte order.
// Advances the offset by 4 bytes.
float read_float(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok);
// Reads a fixed number of bytes into the output buffer.
// The output buffer must be at least 'len' bytes long.
void read_bytes(const u_int8_t *buf, size_t recv_len, size_t *offset, u_int8_t *out, size_t len, int *ok);
// Reads a length-prefixed string. The length is a single byte.
// The string is not null-terminated in the buffer, but the function
void read_utf32le_string(const uint8_t *buffer, size_t buf_size, size_t *offset, char *dest, size_t max_len, int *ok);
// reads up to max_len - 1 characters and null-terminates the destination buffer.
// The string is encoded in UTF-32LE.
void read_utf16le_string(const uint8_t *buffer, size_t buf_size, size_t *offset, char *dest, size_t max_len, int *ok);
// Reads a null-terminated string from the buffer.
// The string is read into the output buffer, which must be at least max_len bytes long
void read_string(const u_int8_t *buf, size_t recv_len, size_t *offset, char *out, size_t max_len, int *ok);
#ifdef __cplusplus
}
#endif
#endif // PARCER_H

1
include/server_structs.h
View File

@ -199,6 +199,7 @@ enum ACSP_MessageType {
// ============================
// PROTOCOL VERSION
// ============================
// DONE: Update this when protocol changes
PROTOCOL_VERSION = 4,
// ============================

158
include/server_structs.hpp Normal file
View File

@ -0,0 +1,158 @@
#ifndef SERVER_STRUCTS_H
#define SERVER_STRUCTS_H
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <string>
#include <sys/cdefs.h>
#include <sys/types.h>
using namespace std;
typedef struct app_info {
// From args
u_int16_t app_id;
u_int16_t app_port_in;
u_int16_t app_port_out;
// From .env
const char *app_api_socket_path;
u_int16_t max_players;
const char *app_server_out_ip;
} __attribute__((packed)) app_info;
typedef struct postion {
float x;
float y;
float z;
} __attribute__((packed)) postion;
typedef enum flag {
NO_FLAG = 0,
YELLOW_FLAG = 1,
BLUE_FLAG = 2,
BLACK_FLAG = 3,
CHECKERED_FLAG = 4,
} __attribute__((packed)) flag;
typedef struct carAtributes {
// Related to ACSP_CAR_INFO
u_char isConnected; // 1 = connected, 0 = disconnected
u_char isLoading; // 1 = loading, 0 = not isLoading
string car_model[64];
string car_skin[64];
string driver_name[64];
string driver_team[64];
string driver_GUID[64];
// Related to ACSP_CAR_UPDATE
u_int8_t carID;
postion position;
postion velocity;
u_int8_t carGear;
u_int16_t carRPM;
u_int32_t lap_time;
u_int32_t cuts;
u_int32_t total_cuts;
u_int32_t total_cuts_alltime;
u_int16_t total_laps_completed;
u_int16_t contacts;
u_int16_t total_contacts;
flag current_flag; // TODO: implement flag status updates
// TAG:3
float normalizedSplinePos;
} __attribute__((packed)) carAtributes;
typedef enum SessionType {
PRACTICE = 0,
RACE = 1,
QUALIFYING = 2,
} __attribute__((packed)) SessionType;
typedef struct trackAtributes{
u_int8_t protocol_version;
u_int8_t session_index;
u_int8_t current_session_index;
u_int8_t session_count;
SessionType session_type;
string server_name;
string track[64];
string track_config[64];
string session_name[64];
u_int8_t typ;
u_int16_t time;
u_int16_t laps;
u_int16_t wait_time;
u_int8_t ambient_temp;
u_int8_t road_temp;
string weather_graphics[64];
u_int32_t elapsed_ms;
} __attribute__((packed)) trackAtributes;
typedef struct api_packet {
u_char message_type; // ACSP_MessageType
u_int8_t tracker_id;
u_int8_t connected_players;
carAtributes cars[64];
trackAtributes track_info;
} __attribute__((packed)) api_packet;
enum ACSP_MessageType {
// ============================
// PROTOCOL VERSION
// ============================
PROTOCOL_VERSION = 4,
// ============================
// SERVER → CLIENT MESSAGES
// ============================
ACSP_NEW_SESSION = 50,
ACSP_NEW_CONNECTION = 51,
ACSP_CONNECTION_CLOSED = 52,
ACSP_CAR_UPDATE = 53,
ACSP_CAR_INFO = 54, // Response to ACSP_GET_CAR_INFO
ACSP_END_SESSION = 55,
ACSP_VERSION = 56,
ACSP_CHAT = 57,
ACSP_CLIENT_LOADED = 58,
ACSP_SESSION_INFO = 59,
ACSP_ERROR = 60,
ACSP_LAP_COMPLETED = 73,
// ============================
// EVENTS
// ============================
ACSP_CLIENT_EVENT = 130,
// ============================
// EVENT TYPES
// ============================
ACSP_CE_COLLISION_WITH_CAR = 10,
ACSP_CE_COLLISION_WITH_ENV = 11,
// ============================
// CLIENT → SERVER COMMANDS
// ============================
ACSP_REALTIMEPOS_INTERVAL = 200,
ACSP_GET_CAR_INFO = 201,
ACSP_SEND_CHAT = 202, // Sends chat to one car
ACSP_BROADCAST_CHAT = 203, // Sends chat to everybody
ACSP_GET_SESSION_INFO = 204,
ACSP_SET_SESSION_INFO = 205,
ACSP_KICK_USER = 206,
ACSP_NEXT_SESSION = 207,
ACSP_RESTART_SESSION = 208,
ACSP_ADMIN_COMMAND = 209 // Send message plus a string
};
#endif // SERVER_STRUCTS_H

1
include/session.hpp
View File

@ -14,7 +14,6 @@ private:
public:
SessionManager(u_int8_t sid);
~SessionManager();
void on_new_session(const trackAtributes &track);
void on_player_connected(const carAtributes &car);

90
include/socket.c.old Normal file
View File

@ -0,0 +1,90 @@
#include "socket.h"
// =========================
// UDP SOCKET FUCNTIONS
// =========================
// Create a UDP socket
// @return: Socket file descriptor, or -1 on error
int create_udp_socket(void) {
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("[!] socket() failed");
return -1;
}
return sockfd;
}
// Create a UDP socket and connect it to a specific IP and port
// Used for sending data (no bind needed)
// @param ip: Destination IP address as a string
// @return: Socket file descriptor, or -1 on error
int connect_udp_socket(const char *ip, uint16_t port) {
int sockfd = create_udp_socket();
if (sockfd < 0)
return -1;
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
servaddr.sin_addr.s_addr = inet_addr(ip);
if (connect(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("[!] connect() failed");
close(sockfd);
return -1;
}
printf("[+] Connected UDP socket to %s:%d\n", ip, port);
return sockfd;
}
// Create and bind a UDP socket to a local IP and port
// Used for listening for incoming data
// @param ip: Local IP address to bind to
// @param port: Local port to bind to
// @return: Socket file descriptor, or -1 on error
int create_bound_udp_socket(const char *ip, uint16_t port) {
int sockfd = create_udp_socket();
if (sockfd < 0)
return -1;
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(ip);
if (bind(sockfd, (const struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("[!] bind() failed");
close(sockfd);
return -1;
}
printf("[+] Bound UDP socket on %s:%d\n", ip, port);
return sockfd;
}
// Send a UDP message to the specified IP and port
// @param sockfd: Socket file descriptor
// @param message: Message to send
// @param dest_ip: Destination IP address as a string
// @param dest_port: Destination port
// @return: Number of bytes sent, or -1 on error
ssize_t send_udp_message(int sockfd, const char *message, const char *dest_ip, uint16_t dest_port) {
struct sockaddr_in destaddr;
memset(&destaddr, 0, sizeof(destaddr));
destaddr.sin_family = AF_INET;
destaddr.sin_port = htons(dest_port);
destaddr.sin_addr.s_addr = inet_addr(dest_ip);
ssize_t n = sendto(sockfd, message, strlen(message), 0, (const struct sockaddr *)&destaddr, sizeof(destaddr));
if (n < 0) {
perror("[!] sendto() failed");
return -1;
}
printf("[+] Sent %zd bytes to %s:%d\n", n, dest_ip, dest_port);
return n;
}

42
include/socket.h.old Normal file
View File

@ -0,0 +1,42 @@
#ifndef SOCKET_H
#define SOCKET_H
#ifdef __cplusplus
extern "C" {
#endif
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib") // link Winsock
#else
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#endif
// =========================
// UDP SOCKET FUCNTIONS
// =========================
// Server hosts a UDP socket at 127.0.0.1:12000
// Client sends a message to the server at 11000
// UDP socket creation & management
int create_udp_socket(void);
int connect_udp_socket(const char *ip, uint16_t port);
int create_bound_udp_socket(const char *ip, uint16_t port);
// UDP messaging
ssize_t send_udp_message(int sockfd, const char *message, const char *dest_ip, uint16_t dest_port);
#ifdef __cplusplus
}
#endif
#endif // SOCKET_H

24
source/log.c Normal file
View File

@ -0,0 +1,24 @@
#include "log.h"
void log_print(LogLevel level, const char* format, ...) {
time_t now = time(NULL);
struct tm *t = localtime(&now);
const char* level_tag;
switch(level) {
case LOG_INFO: level_tag = "INF"; break;
case LOG_DEBUG: level_tag = "DBG"; break;
case LOG_ERROR: level_tag = "ERR"; break;
case LOG_WARN: level_tag = "WRN"; break;
default: level_tag = "UNK"; break;
}
// %02d ensures it prints "05" instead of just "5"
printf("[%02d:%02d:%02d %s] ",
t->tm_hour, t->tm_min, t->tm_sec, level_tag);
va_list args;
va_start(args, format);
vprintf(format, args); // vprintf takes a va_list instead of ...
va_end(args);
}

121
source/main.cpp
View File

@ -1,27 +1,31 @@
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <signal.h>
#include <stdexcept>
#include <string>
#include <sys/types.h>
#include <vector>
#include <unistd.h>
#include <signal.h>
#include <vector>
#include "app.hpp" // for app_info struct
#include "file.hpp" // for parce_args
#include "log.h" // for logging
#include "net.hpp" // for socket operations
#include "server_structs.h" // for api_packet and ACSP_MessageType
#include "session.hpp" // for SessionManager
#include "mapper.hpp" // for Mapper
const u_int8_t UPDATE_INTERVAL = 120; // in milliseconds
using namespace std;
volatile bool STOP_PROGRAM = false;
void signal_handler(int signum) {
if (signum == SIGINT || signum == SIGTERM) {
STOP_PROGRAM = true;
}
if (signum == SIGINT || signum == SIGTERM) {
STOP_PROGRAM = true;
}
}
int main(int argc, char *argv[]) {
@ -30,36 +34,47 @@ int main(int argc, char *argv[]) {
Socket sock;
SessionManager session_manager(app.app_id); // Server ID 1 for now
SessionManager session_manager(app.app_id);
char buffer[2048];
uint8_t buffer[1028];
Mapper map(buffer, 1028);
trackAtributes track;
track.server_name = new char[256];
track.track = new char[64];
track.track_config = new char[64];
track.session_name = new char[64];
track.weather_graphics = new char[64];
try {
// Connect socket to API
sock.connect_unix(app.app_api_socket_path.c_str(), app.app_port_out);
// sock.connect_unix(app.app_api_socket_path.c_str(), app.app_port_out);
// Connect socket to Server
sock.connect_server(app.app_server_out_ip.c_str(), app.app_port_out);
sock.bind_server("127.0.0.1", app.app_port_in);
// Await server for initial data
sock.receive_server(buffer, sizeof(buffer));
cout << "[+] Received info from server!" << endl;
log_info("Connected to server, awaiting version confirmation...\n");
if (buffer[0] == ACSP_VERSION) {
cout << "[+] Server API Version: " << (int)buffer[1] << endl;
log_info("Server version confirmed. Sending update rate request @ %ums\n", UPDATE_INTERVAL);
} else {
throw runtime_error("Did not receive version confirmation from server.");
}
// Right after confirmation, send update rate request
char request[516] = {0};
request[0] = ACSP_REALTIMEPOS_INTERVAL;
request[1] = 120;
request[1] = UPDATE_INTERVAL;
sock.send_server(request, sizeof(request));
cout << "[!] Info: " << endl;
cout << " > API Socket Path: " << app.app_api_socket_path << endl;
cout << " > Server Out IP: " << app.app_server_out_ip << endl;
cout << " > App Port In: " << app.app_port_in << endl;
cout << " > App Port Out: " << app.app_port_out << endl;
log_debug("Info:\n");
log_debug("\t\tApp ID: %d\n", app.app_id);
log_debug("\t\tAPI Socket Path: %s\n", app.app_api_socket_path.c_str());
log_debug("\t\tServer Out IP: %s\n", app.app_server_out_ip.c_str());
log_debug("\t\tApp Port In: %d\n", app.app_port_in);
log_debug("\t\tApp Port Out: %d\n", app.app_port_out);
} catch (const runtime_error &e) {
cerr << "Error: " << e.what() << endl;
@ -73,37 +88,67 @@ int main(int argc, char *argv[]) {
while (STOP_PROGRAM == false) {
// Receive data from server
ssize_t received = sock.receive_server(buffer, sizeof(buffer));
if (received > 0) {
switch (buffer[0]) {
case ACSP_VERSION: {
cout << "[?] Received Version Packet?\nResending Update Rate Request..." << endl;
char request[516] = {0};
request[0] = ACSP_REALTIMEPOS_INTERVAL;
request[1] = 120;
sock.send_server(request, sizeof(request));
if (received > 0) {
map.update_buffer(buffer, static_cast<size_t>(received));
switch (map.get_message_type()) {
// DONE:
case ACSP_VERSION: {
log_warn("Received Version Again? (Probably server restart) Resending Update Request @ %ums\n", UPDATE_INTERVAL);
char request[516] = {0};
request[0] = ACSP_REALTIMEPOS_INTERVAL;
request[1] = UPDATE_INTERVAL;
sock.send_server(request, sizeof(request));
break;
}
// TODO:
case ACSP_CAR_UPDATE: {
log_info("Received car update.\n");
break;
}
// TODO:
case ACSP_NEW_SESSION: {
log_info("New session started.\n");
map.parse_new_session(track);
if (map.is_ok()) {
session_manager.on_new_session(track);
} else {
log_error("Failed to parse new session data.\n");
}
// TESTING: Print track info
log_info("Track Info:\n");
log_info("\t\tServer Name: %s\n", track.server_name);
log_info("\t\tTrack: %s\n", track.track);
log_info("\t\tTrack Config: %s\n", track.track_config);
log_info("\t\tSession Name: %s\n", track.session_name);
log_info("\t\tWeather Graphics: %s\n", track.weather_graphics);
log_info("\t\tSession Type: %d\n", track.session_type);
log_info("\t\tLaps: %d\n", track.laps);
log_info("\t\tTime: %d\n", track.time);
log_info("\t\tAmbient Temp: %d\n", track.ambient_temp);
log_info("\t\tRoad Temp: %d\n", track.road_temp);
log_info("\t\tElapsed MS: %u\n", track.elapsed_ms);
break;
}
case ACSP_CAR_UPDATE: {
cout << "[+] Received Car Update Packet with " << (int)packet.connected_players << " connected players." << endl;
break;
}
case ACSP_NEW_SESSION: {
cout << "[+] New Session Started: " << packet.track_info.session_name << endl;
break;
}
default: {
cout << "[!] Unknown packet type received: " << (int)buffer[0] << endl;
break;
}
}
}
}
delete[] track.server_name;
delete[] track.track;
delete[] track.track_config;
delete[] track.session_name;
delete[] track.weather_graphics;
return 0;
}

56
source/mapper.cpp Normal file
View File

@ -0,0 +1,56 @@
#include "mapper.hpp"
#include "parcer.h"
Mapper::Mapper(const uint8_t *buf, size_t size) : buffer(buf), buffer_size(size), offset(0), ok(1) {}
uint8_t Mapper::get_message_type() {
if (buffer_size < 1) {
this->ok = false;
return 0;
}
return buffer[0];
}
void Mapper::parse_new_session(trackAtributes &track) {
reset();
int __ok;
track.protocol_version = read_uint8(buffer, buffer_size, &offset, &__ok);
track.session_index = read_uint8(buffer, buffer_size, &offset, &__ok);
track.current_session_index = read_uint8(buffer, buffer_size, &offset, &__ok);
track.session_count = read_uint8(buffer, buffer_size, &offset, &__ok);
track.session_type = (SessionType)track.session_index;
uint8_t str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
read_utf32le_string(buffer, buffer_size, &offset, track.server_name, str_len, &__ok);
str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
read_string(buffer, buffer_size, &offset, track.track, str_len, &__ok);
str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
read_string(buffer, buffer_size, &offset, track.track_config, str_len, &__ok);
str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
read_string(buffer, buffer_size, &offset, track.session_name, str_len, &__ok);
track.typ = read_uint8(buffer, buffer_size, &offset, &__ok);
track.time = read_uint16_le(buffer, buffer_size, &offset, &__ok);
track.laps = read_uint16_le(buffer, buffer_size, &offset, &__ok);
track.wait_time = read_uint16_le(buffer, buffer_size, &offset, &__ok);
track.ambient_temp = read_uint8(buffer, buffer_size, &offset, &__ok);
track.road_temp = read_uint8(buffer, buffer_size, &offset, &__ok);
str_len = read_uint8(buffer, buffer_size, &offset, &__ok);
read_string(buffer, buffer_size, &offset, track.weather_graphics, str_len, &__ok);
track.elapsed_ms = read_uint32(buffer, buffer_size, &offset, &__ok);
if (__ok == 0) {
this->ok = false;
} else {
this->ok = true;
}
}

7
source/net.cpp
View File

@ -1,4 +1,5 @@
#include "net.hpp"
#include "log.c"
#include <sys/types.h>
Socket::Socket() {
@ -32,11 +33,11 @@ void Socket::bind_server(const char *ip, uint16_t port) {
bind_addr.sin_addr.s_addr = inet_addr(ip);
if (bind(sock_server, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)) < 0) {
perror("[!] bind() failed");
log_error("Failed to bind UDP socket on %s:%d\n", ip, port);
throw runtime_error("Failed to bind UDP socket");
}
printf("[+] Bound UDP socket on %s:%d\n", ip, port);
log_info("Successfully bound UDP socket on %s:%d\n", ip, port);
}
void Socket::connect_unix(const char *ip, uint16_t port) {
@ -63,7 +64,7 @@ void Socket::send_server() {
ssize_t Socket::receive_server(void *buffer, size_t len) {
ssize_t recv_bytes = recv(sock_server, buffer, len, 0);
if (recv_bytes < 0) {
perror("[!] recv() failed");
log_error("Failed to receive data from server socket\n");
return -1;
}
return recv_bytes;

16
source/parcer.c
View File

@ -1,8 +1,8 @@
#include "parcer.h"
#include "server_structs.h"
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <arpa/inet.h>
int ensure(size_t recv_len, size_t offset, size_t need) {
return (offset + need <= recv_len);
@ -27,9 +27,22 @@ u_int16_t read_uint16(const u_int8_t *buf, size_t recv_len, size_t *offset, int
u_int16_t v;
memcpy(&v, buf + *offset, sizeof(v));
*offset += sizeof(v);
return (u_int16_t)ntohs(v);
}
u_int16_t read_uint16_le(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
if (!ensure(recv_len, *offset, sizeof(uint16_t))) {
*ok = 0;
return 0;
}
u_int16_t v;
memcpy(&v, buf + *offset, sizeof(v));
*offset += sizeof(v);
return v;
}
u_int32_t read_uint32(const u_int8_t *buf, size_t recv_len, size_t *offset, int *ok) {
if (!ensure(recv_len, *offset, sizeof(uint32_t))) {
*ok = 0;
@ -140,4 +153,3 @@ void read_string(const u_int8_t *buf, size_t recv_len, size_t *offset, char *out
*offset += len;
*ok = 1;
}