josh/Sockets
2
1
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 4 Wiki Activity

Fix Small Error

Browse Source
This commit is contained in:
josh
2025-01-18 14:21:14 -05:00
parent a055f02b4b
commit c7dc7c7f0e
2 changed files with 33 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/Sockets/UdpSocket.hpp
View File

@@ -142,10 +142,10 @@ private:
{ {
tempBuffer[messageLength] = '\0'; tempBuffer[messageLength] = '\0';
if (udpSocket->onMessageReceived) if (udpSocket->onMessageReceived)
udpSocket->onMessageReceived(std::string(tempBuffer, messageLength), ipToString(udpSocket->address), ntohs(udpSocket->address.sin_port)); udpSocket->onMessageReceived(std::string(tempBuffer, messageLength), IPToString(udpSocket->address), ntohs(udpSocket->address.sin_port));
if (udpSocket->onRawMessageReceived) if (udpSocket->onRawMessageReceived)
udpSocket->onRawMessageReceived(tempBuffer, messageLength, ipToString(udpSocket->address), ntohs(udpSocket->address.sin_port)); udpSocket->onRawMessageReceived(tempBuffer, messageLength, IPToString(udpSocket->address), ntohs(udpSocket->address.sin_port));
} }
} }

274
main.cpp
View File

@@ -1,257 +1,45 @@
#include <Sockets/TcpSocket.hpp> #include "Sockets/UdpServer.hpp"
#include <iostream> #include <iostream>
#include <exception>
#include <cstring>
#include <memory>
#include "Sockets/UdpSocket.hpp"
#include <Sockets/Endianness.hpp>
#include <jlog/Logger.hpp>
#include <Event.h>
#include <EventConnection.h>
class ServerLogger { using namespace std;
private:
class TransmissionLogger : protected jlog::ConsoleLogger {
public:
TransmissionLogger(std::string ctx, Color4 transcolor) : ConsoleLogger("Server::" + ctx) {
this->timestampColor = Colors::Gray;
this->contextColor = transcolor;
this->locationColor = Colors::Gray;
this->pointerColor = transcolor;
this->messageColor = Colors::White;
//Colors::Green, Colors::Gray, Colors::Gray, Colors::Green, Colors::White
}
void operator()(const std::string &message, const std::source_location &location = std::source_location::current(), const jlog::Timestamp &ts = jlog::Timestamp())
{
std::string msg = message;
if (!msg.empty() && msg[msg.length()-1] == '\n') {
msg.erase(msg.length()-1);
}
ConsoleLogger::Log(msg, location, ts);
};
};
public:
ServerLogger() : RX("RX", Colors::Oranges::Coral), TX("TX", Colors::Green) {};
public:
TransmissionLogger RX;
TransmissionLogger TX;
};
using namespace Socket; int main()
{
// Initialize server socket..
UDPServer<> udpServer;
class TCPServer { // onMessageReceived will run when a message received with information of ip & port of sender:
public: /*udpServer.onMessageReceived = [&](string message, string ipv4, uint16_t port) {
ServerLogger logger; //cout << ipv4 << ":" << port << " => " << message << endl;
using Socket_p = std::shared_ptr<TcpSocket>;
//Event<Socket_p> OnServe;
Event<Socket_p> OnAccept;
Event<Socket_p> OnRX;
Event<Socket_p> OnTX;
Socket_p sock {new TcpSocket};
Socket_p client;
public:
TCPServer() {};
public:
virtual void Serve() {
try {
sock->Bind(42069);
sock->Listen(5);
client = sock->Accept();
Accept();
} catch(std::exception &e) {
std::cout << e.what() << std::endl;
return;
}
// Welcoming the new users // Echo to client:
//std::string payload = "Welcome!\n\f"; udpServer.SendTo("A!", ipv4, port);
};*/
//client->Send(reinterpret_cast<const u8 *>(payload.data()), payload.size(), 0); // If you want to use raw byte arrays:
// Closing the listening socket, we want nobody else. udpServer.onRawMessageReceived = [&](const char* message, int length, string ipv4, uint16_t port) {
//sock->Close(); cout << ipv4 << ":" << port << " => " << message << "(" << length << ")" << endl;
/* // Echo to client:
u8 data[512]; udpServer.SendTo(message, length, ipv4, port);
memset(&data, 0, 512);
while (client->Receive(data, sizeof data, 0))
{
logger.RX(reinterpret_cast<char*>(data));
client->Send(data, sizeof data, 0);
logger.TX(reinterpret_cast<char*>(data));
memset(&data, 0, 512);
}
*/
//OnRX(client);
//OnTX(client);
//client->Close();
};
virtual void Accept() { OnAccept(client); }
virtual void RX() { OnRX(client); };
virtual void TX() { OnTX(client); };
};
class MProtoServer : public TCPServer {
public:
enum MsgID : uint8_t {
THandShake = 100,
RHandShake = 101,
}; };
MProtoServer() : TCPServer() {};
void Accept() { // Bind the server to a port.
sock->Close(); udpServer.Bind(8888, [](int errorCode, string errorMessage) {
u8 data[7]; // BINDING FAILED:
memset(&data, 0, 1); cout << errorCode << " : " << errorMessage << endl;
while (client->Receive(data, sizeof data, 0)) { });
//logger.RX(reinterpret_cast<char *>(data));
//client->Send(data, sizeof data, 0);
//logger.TX(reinterpret_cast<char *>(data));
std::cout << std::to_string(data[7]) << std::endl;
if (uint8_t(data[1]) == THandShake) {
logger.RX("THandShake");
}
memset(&data, 0, 1);
} // You should do an input loop, so the program won't terminate immediately
string input;
getline(cin, input);
client->Close(); while (input != "exit")
//uint16_t wd = (data[2] << 8) | data[1];
};
/// Spins up a TCP server, listens for connections, and echoes input directly back to the client.
/// While running this function, use the terminal program netcat to connect and send messages:
/// nc localhost 40269
void TCP_ReceiveTest() {
ServerLogger TCPLogger;
using Socket_p = std::shared_ptr<TcpSocket>;
Socket_p sock(new TcpSocket);
Socket_p client;
try {
sock->Bind(42069);
sock->Listen(5);
client = sock->Accept();
} catch (std::exception &e) {
std::cout << e.what() << std::endl;
return;
}
// Welcoming the new users
std::string payload = "Welcome!\n\f";
client->Send(reinterpret_cast<const u8 *>(payload.data()), payload.size(), 0);
// Closing the listening socket, we want nobody else.
sock->Close();
u8 data[512];
memset(&data, 0, 512);
while (client->Receive(data, sizeof data, 0)) {
//std::cout << "[Recv] " << data << std::endl;
//std::string datastr = reinterpret_cast<char*>(data);
TCPLogger.RX(reinterpret_cast<char *>(data));
client->Send(data, sizeof data, 0);
TCPLogger.TX(reinterpret_cast<char *>(data));
memset(&data, 0, 512);
}
client->Close();
}
void UDP_ReceiveTest() {
using UdpSocket_p = std::shared_ptr<UdpSocket>;
UdpSocket_p sock(new UdpSocket);
try {
sock->Open();
sock->Bind(42575);
} catch (const std::exception &e) {
std::cout << e.what() << std::endl;
return;
}
UdpSocket_p client(new UdpSocket);
try {
client->Open();
client->Connect(42575);
std::string payload = "bruh";
client->Send(reinterpret_cast<const u8 *>(payload.data()), payload.size());
//client->SendTo(IPAddress::Loopback(42575), reinterpret_cast<const u8 *>(payload.data()), payload.size(), 0);
//client->BindAny();
//client->Open();
//client->Connect(sock->GetSelfIP());
} catch (const std::exception &e) {
std::cout << e.what() << std::endl;
return;
}
client->Close();
sock->Close();
}
};
int main(int argc, char *argv[])
{ {
getline(cin, input);
}
if (Socket::Endianness::IsBigEndian()) udpServer.Close();
std::cout << "Big Endian" << std::endl;
return 0;
if (Socket::Endianness::IsLittleEndian()) }
std::cout << "Little Endian" << std::endl;
float val = 420.5f;
float a = Socket::Endianness::HostToNetworkOrder(val);
a = Socket::Endianness::NetworkToHostOrder(a);
std::cout << a << std::endl;
//TCP_ReceiveTest();
//UDP_ReceiveTest();
TCPServer server;
server.OnAccept += [&] (TCPServer::Socket_p s) {
server.logger.RX("Accepted client");
server.RX();
};
server.OnRX += [&] (TCPServer::Socket_p s) {
u8 data[512];
memset(&data, 0, 512);
while (s->Receive(data, sizeof data, 0))
{
server.logger.RX(reinterpret_cast<char*>(data));
//s->Send(data, sizeof data, 0);
//server.logger.TX(reinterpret_cast<char*>(data));
server.TX();
memset(&data, 0, 512);
}
};
server.OnTX += [&] (TCPServer::Socket_p s) {
std::string pong = "Message recieved";
u8 data[512];
memset(&data, 0, 512);
std::copy(pong.begin(), pong.end(), std::begin(data));
s->Send(data, sizeof(data), 0);
server.logger.TX(pong);
memset(&data, 0, 512);
};
server.Serve();
//MProtoServer ms;
//ms.Serve();
return 0;
}