OpenFusion/src/CNProtocol.cpp

447 lines
14 KiB
C++
Raw Normal View History

2020-08-18 20:42:30 +00:00
#include "CNProtocol.hpp"
2020-08-19 01:34:39 +00:00
#include "CNStructs.hpp"
2020-08-18 20:42:30 +00:00
#include <assert.h>
2020-08-18 20:42:30 +00:00
// ========================================================[[ CNSocketEncryption ]]========================================================
// literally C/P from the client and converted to C++ (does some byte swapping /shrug)
int CNSocketEncryption::Encrypt_byte_change_A(int ERSize, uint8_t* data, int size) {
int num = 0;
int num2 = 0;
int num3 = 0;
while (num + ERSize <= size) {
2020-08-18 20:42:30 +00:00
int num4 = num + num3;
int num5 = num + (ERSize - 1 - num3);
uint8_t b = data[num4];
data[num4] = data[num5];
data[num5] = b;
num += ERSize;
num3++;
if (num3 > ERSize / 2) {
2020-08-18 20:42:30 +00:00
num3 = 0;
}
}
num2 = ERSize - (num + ERSize - size);
return num + num2;
}
int CNSocketEncryption::xorData(uint8_t* buffer, uint8_t* key, int size) {
// xor every 8 bytes with 8 byte key
for (int i = 0; i < size; i++) {
buffer[i] ^= key[i % keyLength];
}
return size;
}
uint64_t CNSocketEncryption::createNewKey(uint64_t uTime, int32_t iv1, int32_t iv2) {
uint64_t num = (uint64_t)(iv1 + 1);
uint64_t num2 = (uint64_t)(iv2 + 1);
uint64_t dEKey = (uint64_t)(*(uint64_t*)&defaultKey[0]);
return dEKey * (uTime * num * num2);
}
int CNSocketEncryption::encryptData(uint8_t* buffer, uint8_t* key, int size) {
int eRSize = size % (keyLength / 2 + 1) * 2 + keyLength; // C/P from client
int size2 = xorData(buffer, key, size);
return Encrypt_byte_change_A(eRSize, buffer, size2);
}
int CNSocketEncryption::decryptData(uint8_t* buffer, uint8_t* key, int size) {
int eRSize = size % (keyLength / 2 + 1) * 2 + keyLength; // size % of 18????
int size2 = Encrypt_byte_change_A(eRSize, buffer, size);
return xorData(buffer, key, size2);
}
// ========================================================[[ CNPacketData ]]========================================================
2020-08-23 17:19:12 +00:00
CNPacketData::CNPacketData(void* b, uint32_t t, int l): buf(b), size(l), type(t) {}
2020-08-18 20:42:30 +00:00
// ========================================================[[ CNSocket ]]========================================================
CNSocket::CNSocket(SOCKET s, PacketHandler ph): sock(s), pHandler(ph) {
EKey = (uint64_t)(*(uint64_t*)&CNSocketEncryption::defaultKey[0]);
}
bool CNSocket::sendData(uint8_t* data, int size) {
int sentBytes = 0;
2020-08-22 02:32:22 +00:00
int maxTries = 10;
2020-08-18 20:42:30 +00:00
while (sentBytes < size) {
int sent = send(sock, (buffer_t*)(data + sentBytes), size - sentBytes, 0);
2020-08-22 00:33:42 +00:00
if (SOCKETERROR(sent)) {
2020-08-24 18:23:28 +00:00
if (OF_ERRNO == OF_EWOULD && maxTries > 0) {
2020-08-22 02:32:22 +00:00
maxTries--;
2020-08-22 00:33:42 +00:00
continue; // try again
2020-08-22 02:32:22 +00:00
}
2020-08-24 18:23:28 +00:00
std::cout << "[FATAL] SOCKET ERROR: " << OF_ERRNO << std::endl;
2020-08-18 20:42:30 +00:00
return false; // error occured while sending bytes
2020-08-22 00:33:42 +00:00
}
2020-08-18 20:42:30 +00:00
sentBytes += sent;
}
2020-08-18 20:42:30 +00:00
return true; // it worked!
}
void CNSocket::setEKey(uint64_t k) {
EKey = k;
}
void CNSocket::setFEKey(uint64_t k) {
FEKey = k;
}
uint64_t CNSocket::getEKey() {
return EKey;
}
uint64_t CNSocket::getFEKey() {
return FEKey;
}
bool CNSocket::isAlive() {
return alive;
}
void CNSocket::kill() {
alive = false;
#ifdef _WIN32
shutdown(sock, SD_BOTH);
closesocket(sock);
#else
shutdown(sock, SHUT_RDWR);
close(sock);
#endif
}
2020-08-24 18:23:28 +00:00
// we don't own buf, TODO: queue packets up to send in step()
2020-08-22 23:31:09 +00:00
void CNSocket::sendPacket(void* buf, uint32_t type, size_t size) {
if (!alive)
2020-08-22 00:33:42 +00:00
return;
size_t bodysize = size + sizeof(uint32_t);
uint8_t* fullpkt = (uint8_t*)xmalloc(bodysize+4);
uint8_t* body = fullpkt+4;
memcpy(fullpkt, (void*)&bodysize, 4);
2020-08-18 20:42:30 +00:00
// copy packet type to the front of the buffer & then the actual buffer
memcpy(body, (void*)&type, sizeof(uint32_t));
memcpy(body+sizeof(uint32_t), buf, size);
2020-08-18 20:42:30 +00:00
// encrypt the packet
2020-08-22 23:31:09 +00:00
switch (activeKey) {
case SOCKETKEY_E:
CNSocketEncryption::encryptData((uint8_t*)body, (uint8_t*)(&EKey), bodysize);
2020-08-22 23:31:09 +00:00
break;
case SOCKETKEY_FE:
CNSocketEncryption::encryptData((uint8_t*)body, (uint8_t*)(&FEKey), bodysize);
2020-08-22 23:31:09 +00:00
break;
default: {
free(fullpkt);
2020-08-22 23:31:09 +00:00
DEBUGLOG(
std::cout << "[WARN]: UNSET KEYTYPE FOR SOCKET!! ABORTING SEND" << std::endl;
)
return;
}
}
2020-08-18 20:42:30 +00:00
// send packet data!
if (alive && !sendData(fullpkt, bodysize+4))
2020-08-22 00:33:42 +00:00
kill();
2020-08-18 20:42:30 +00:00
free(fullpkt);
2020-08-18 20:42:30 +00:00
}
2020-08-22 23:31:09 +00:00
void CNSocket::setActiveKey(ACTIVEKEY key) {
activeKey = key;
}
2020-08-18 20:42:30 +00:00
void CNSocket::step() {
2020-08-24 18:23:28 +00:00
// read step
// XXX NOTE: we must not recv() twice without a poll() inbetween
2020-08-18 20:42:30 +00:00
if (readSize <= 0) {
// we aren't reading a packet yet, try to start looking for one
int recved = recv(sock, (buffer_t*)readBuffer, sizeof(int32_t), 0);
if (!SOCKETERROR(recved)) {
// we got our packet size!!!!
2020-08-18 20:42:30 +00:00
readSize = *((int32_t*)readBuffer);
// sanity check
if (readSize > CN_PACKET_BUFFER_SIZE) {
2020-08-18 20:42:30 +00:00
kill();
return;
}
// we'll just leave bufferIndex at 0 since we already have the packet size, it's safe to overwrite those bytes
activelyReading = true;
2020-08-24 18:23:28 +00:00
} else if (OF_ERRNO != OF_EWOULD) {
// serious socket issue, disconnect connection
kill();
return;
2020-08-18 20:42:30 +00:00
}
}
if (readSize > 0 && readBufferIndex < readSize) {
2020-08-18 20:42:30 +00:00
// read until the end of the packet! (or at least try too)
int recved = recv(sock, (buffer_t*)(readBuffer + readBufferIndex), readSize - readBufferIndex, 0);
if (!SOCKETERROR(recved))
readBufferIndex += recved;
2020-08-24 18:23:28 +00:00
else if (OF_ERRNO != OF_EWOULD) {
// serious socket issue, disconnect connection
kill();
return;
}
2020-08-18 20:42:30 +00:00
}
if (activelyReading && readBufferIndex >= readSize) {
2020-08-18 20:42:30 +00:00
// decrypt readBuffer and copy to CNPacketData
CNSocketEncryption::decryptData((uint8_t*)&readBuffer, (uint8_t*)(&EKey), readSize);
2020-08-18 20:42:30 +00:00
2020-08-26 19:23:40 +00:00
void* tmpBuf = readBuffer+sizeof(uint32_t);
2020-08-22 23:31:09 +00:00
CNPacketData tmp(tmpBuf, *((uint32_t*)readBuffer), readSize-sizeof(int32_t));
// call packet handler!!
pHandler(this, &tmp);
2020-08-18 20:42:30 +00:00
// reset vars :)
readSize = 0;
readBufferIndex = 0;
activelyReading = false;
}
}
// ========================================================[[ CNServer ]]========================================================
void CNServer::init() {
// create socket file descriptor
2020-08-18 20:42:30 +00:00
sock = socket(AF_INET, SOCK_STREAM, 0);
if (SOCKETINVALID(sock)) {
std::cerr << "[FATAL] OpenFusion: socket failed" << std::endl;
exit(EXIT_FAILURE);
2020-08-18 20:42:30 +00:00
}
// attach socket to the port
int opt = 1;
#ifdef _WIN32
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(opt)) != 0) {
2020-08-18 20:42:30 +00:00
#else
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) != 0) {
2020-08-18 20:42:30 +00:00
#endif
std::cerr << "[FATAL] OpenFusion: setsockopt failed" << std::endl;
exit(EXIT_FAILURE);
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(port);
2020-08-18 20:42:30 +00:00
addressSize = sizeof(address);
// Bind to the port
if (SOCKETERROR(bind(sock, (struct sockaddr *)&address, addressSize))) {
std::cerr << "[FATAL] OpenFusion: bind failed" << std::endl;
exit(EXIT_FAILURE);
2020-08-18 20:42:30 +00:00
}
if (SOCKETERROR(listen(sock, SOMAXCONN))) {
std::cerr << "[FATAL] OpenFusion: listen failed" << std::endl;
exit(EXIT_FAILURE);
2020-08-18 20:42:30 +00:00
}
// set server listener to non-blocking
#ifdef _WIN32
unsigned long mode = 1;
if (ioctlsocket(sock, FIONBIO, &mode) != 0) {
#else
if (fcntl(sock, F_SETFL, (fcntl(sock, F_GETFL, 0) | O_NONBLOCK)) != 0) {
#endif
std::cerr << "[FATAL] OpenFusion: fcntl failed" << std::endl;
exit(EXIT_FAILURE);
}
2020-08-18 20:42:30 +00:00
}
CNServer::CNServer() {};
CNServer::CNServer(uint16_t p): port(p) {}
2020-08-18 20:42:30 +00:00
void CNServer::start() {
int nfds = 1, oldnfds;
PollFD fds[30]; // TODO: dynamically grow
memset(&fds, 0, sizeof(fds));
// listener socket
fds[0].fd = sock;
fds[0].events = POLLIN;
2020-08-18 20:42:30 +00:00
std::cout << "Starting server at *:" << port << std::endl;
// listen to new connections, add to connection list
2020-08-19 00:52:02 +00:00
while (active) {
// the timeout is to ensure shard timers are ticking
//std::cout << "pre-poll\n";
int n = poll((PollFD*)&fds, nfds, 200);
//if (n > 0)
// std::cout << "poll returned " << n << std::endl;
if (SOCKETERROR(n)) {
std::cout << "[FATAL] poll() returned error" << std::endl;
terminate(0);
}
2020-08-19 00:52:02 +00:00
oldnfds = nfds;
activeCrit.lock();
for (int i = 0; i < oldnfds && n > 0; i++) {
if (fds[i].revents == 0)
continue; // nothing in this one; don't decrement n
// is it the listener?
if (fds[i].fd == sock) {
// any sort of error on the listener
if (fds[i].revents & ~POLLIN) {
std::cout << "[FATAL] Error on listener socket" << std::endl;
activeCrit.unlock(); // must unlock before calling terminate()
terminate(0);
}
SOCKET newConnectionSocket = accept(sock, (struct sockaddr *)&address, (socklen_t*)&addressSize);
if (SOCKETINVALID(newConnectionSocket)) {
n--;
continue;
}
// set it to non-blocking mode
#ifdef _WIN32
unsigned long mode = 1;
if (ioctlsocket(newConnectionSocket, FIONBIO, &mode) != 0) {
#else
if (fcntl(newConnectionSocket, F_SETFL, (fcntl(sock, F_GETFL, 0) | O_NONBLOCK)) != 0) {
#endif
std::cerr << "[WARN] OpenFusion: fcntl failed on new connection" << std::endl;
#ifdef _WIN32
shutdown(newConnectionSocket, SD_BOTH);
closesocket(newConnectionSocket);
#else
shutdown(newConnectionSocket, SHUT_RDWR);
close(newConnectionSocket);
#endif
n--;
continue;
}
std::cout << "New connection! " << inet_ntoa(address.sin_addr) << std::endl;
// add to pollfds
assert(nfds < 30); // XXX
fds[nfds].fd = newConnectionSocket;
fds[nfds].events = POLLIN;
nfds++;
std::cout << "in thread " << (void*) this << " nfds is now " << nfds << std::endl;
// add connection to list!
CNSocket* tmp = new CNSocket(newConnectionSocket, pHandler);
connections.push_back(tmp);
newConnection(tmp);
} else {
// player sockets
std::list<CNSocket*>::iterator it = connections.begin();
while (it != connections.end()) {
CNSocket* cSock = *it;
if (fds[i].fd != cSock->sock) {
// not the socket we're looking for; check the next one
it++;
continue;
}
// kill the socket on error
if (fds[i].revents & ~POLLIN) {
std::cout << "Killing socket at fds[" << i << "]\n";
cSock->kill();
}
if (cSock->isAlive()) {
cSock->step();
++it; // go to the next element
} else {
killConnection(cSock);
connections.erase(it++);
delete cSock;
nfds--;
assert(nfds > 0);
std::cout << "in thread " << (void*) this << " nfds is now " << nfds << std::endl;
if (i != nfds) {
// move the last entry to the new empty spot
fds[i].fd = fds[nfds].fd;
fds[i].events = fds[nfds].events; // redundant; events are always the same
}
// delete the entry
fds[nfds].fd = 0;
fds[nfds].events = 0;
break;
}
}
}
n--;
}
2020-08-18 20:42:30 +00:00
onStep();
activeCrit.unlock();
2020-08-18 20:42:30 +00:00
}
}
2020-08-19 00:52:02 +00:00
void CNServer::kill() {
std::lock_guard<std::mutex> lock(activeCrit); // the lock will be removed when the function ends
active = false;
// kill all connections
std::list<CNSocket*>::iterator i = connections.begin();
while (i != connections.end()) {
CNSocket* cSock = *i;
if (cSock->isAlive()) {
cSock->kill();
}
++i; // go to the next element
delete cSock;
}
connections.clear();
}
2020-08-23 21:09:31 +00:00
void CNServer::printPacket(CNPacketData *data, int type) {
if (settings::VERBOSITY < 2)
return;
if (settings::VERBOSITY < 3) switch (data->type) {
case P_CL2LS_REP_LIVE_CHECK:
case P_CL2FE_REP_LIVE_CHECK:
case P_CL2FE_REQ_PC_MOVE:
case P_CL2FE_REQ_PC_JUMP:
case P_CL2FE_REQ_PC_SLOPE:
case P_CL2FE_REQ_PC_MOVEPLATFORM:
case P_CL2FE_REQ_PC_MOVETRANSPORTATION:
case P_CL2FE_REQ_PC_ZIPLINE:
case P_CL2FE_REQ_PC_JUMPPAD:
case P_CL2FE_REQ_PC_LAUNCHER:
case P_CL2FE_REQ_PC_STOP:
return;
}
std::cout << "OpenFusion: received " << Defines::p2str(type, data->type) << " (" << data->type << ")" << std::endl;
}
2020-08-22 23:31:09 +00:00
void CNServer::newConnection(CNSocket* cns) {} // stubbed
void CNServer::killConnection(CNSocket* cns) {} // stubbed
void CNServer::onStep() {} // stubbed