mirrors
/
raylib
mirror of https://github.com/raysan5/raylib
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[rnet] Review network examples formatting

This commit is contained in:
Ray 2020-02-20 12:42:37 +01:00
parent 19390eaf09
commit e176a476c0
8 changed files with 566 additions and 638 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

268
examples/network/network_ping_pong.c
View File

@ -1,6 +1,6 @@
/******************************************************************************************* /*******************************************************************************************
* *
* raylib [network] example - Client/Server ping-pong * raylib [network] example - Client/Server ping-pong
* *
* This example has been created using raylib 3.0 (www.raylib.com) * This example has been created using raylib 3.0 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) * raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
@ -14,57 +14,59 @@
#define RNET_IMPLEMENTATION #define RNET_IMPLEMENTATION
#include "rnet.h" #include "rnet.h"
#include <assert.h> float elapsed = 0.0f;
#include <stdio.h> float delay = 1.0f;
#include <string.h> bool ping = false;
bool pong = false;
float elapsed = 0.0f; bool connected = false;
float delay = 1.0f; bool clientConnected = false;
bool ping = false; const char *pingmsg = "Ping!";
bool pong = false; const char *pongmsg = "Pong!";
bool connected = false; int msglen = 0;
bool client_connected = false; SocketConfig serverConfig = { .host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .server = true, .nonblocking = true };
const char * pingmsg = "Ping!"; SocketConfig clientConfig = { .host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .nonblocking = true };
const char * pongmsg = "Pong!"; SocketConfig connectionConfig = { .nonblocking = true };
int msglen = 0; SocketResult *serverResult = NULL;
SocketConfig server_cfg = {.host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .server = true, .nonblocking = true}; SocketResult *clientResult = NULL;
SocketConfig client_cfg = {.host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .nonblocking = true}; SocketSet *socketSet = NULL;
SocketConfig connection_cfg = {.nonblocking = true}; Socket *connection = NULL;
SocketResult *server_res = NULL; char receiveBuffer[512] = { 0 };
SocketResult *client_res = NULL;
SocketSet * socket_set = NULL;
Socket * connection = NULL;
char recvBuffer[512];
// Attempt to connect to the network (Either TCP, or UDP) // Attempt to connect to the network (Either TCP, or UDP)
void NetworkConnect() static void NetworkConnect(void)
{ {
// If the server is configured as UDP, ignore connection requests // If the server is configured as UDP, ignore connection requests
if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) { if ((serverConfig.type == SOCKET_UDP) && (clientConfig.type == SOCKET_UDP))
ping = true; {
ping = true;
connected = true; connected = true;
} else { }
else
{
// If the client is connected, run the server code to check for a connection // If the client is connected, run the server code to check for a connection
if (client_connected) { if (clientConnected)
int active = CheckSockets(socket_set, 0); {
if (active != 0) { int active = CheckSockets(socketSet, 0);
TraceLog(LOG_DEBUG, if (active != 0) TraceLog(LOG_INFO, "There are currently %d socket(s) with data to be processed.", active);
"There are currently %d socket(s) with data to be processed.", active);
} if (active > 0)
if (active > 0) { {
if ((connection = SocketAccept(server_res->socket, &connection_cfg)) != NULL) { if ((connection = SocketAccept(serverResult->socket, &connectionConfig)) != NULL)
AddSocket(socket_set, connection); {
ping = true; AddSocket(socketSet, connection);
connected = true; connected = true;
ping = true;
} }
} }
} else { }
else
{
// Check if we're connected every _delay_ seconds // Check if we're connected every _delay_ seconds
elapsed += GetFrameTime(); elapsed += GetFrameTime();
if (elapsed > delay) { if (elapsed > delay)
if (IsSocketConnected(client_res->socket)) { {
client_connected = true; if (IsSocketConnected(clientResult->socket)) clientConnected = true;
}
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
@ -73,59 +75,46 @@ void NetworkConnect()
// Once connected to the network, check the sockets for pending information // Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong. // and when information is ready, send either a Ping or a Pong.
void UpdateNetwork() static void UpdateNetwork(void)
{ {
// CheckSockets // CheckSockets, if any of the sockets in the socketSet are pending (received data, or requests)
// // then mark the socket as being ready. You can check this with IsSocketReady(clientResult->socket)
// If any of the sockets in the socket_set are pending (received data, or requests) int active = CheckSockets(socketSet, 0);
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket) if (active != 0) TraceLog(LOG_DEBUG, "There are currently %d socket(s) with data to be processed.", active);
int active = CheckSockets(socket_set, 0);
if (active != 0) {
TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active);
}
// IsSocketReady // IsSocketReady, if the socket is ready, attempt to receive data from the socket
//
// If the socket is ready, attempt to receive data from the socket
int bytesRecv = 0; int bytesRecv = 0;
if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) { if ((serverConfig.type == SOCKET_UDP) && (clientConfig.type == SOCKET_UDP))
if (IsSocketReady(client_res->socket)) { {
bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen); if (IsSocketReady(clientResult->socket)) bytesRecv = SocketReceive(clientResult->socket, receiveBuffer, msglen);
} if (IsSocketReady(serverResult->socket)) bytesRecv = SocketReceive(serverResult->socket, receiveBuffer, msglen);
if (IsSocketReady(server_res->socket)) { }
bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen); else if (IsSocketReady(connection)) bytesRecv = SocketReceive(connection, receiveBuffer, msglen);
}
} else {
if (IsSocketReady(connection)) {
bytesRecv = SocketReceive(connection, recvBuffer, msglen);
}
}
// If we received data, was that data a "Ping!" or a "Pong!" // If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0) { if (bytesRecv > 0)
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; } {
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; } if (strcmp(receiveBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(receiveBuffer, pongmsg) == 0) { ping = true; }
} }
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa // After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime(); elapsed += GetFrameTime();
if (elapsed > delay) { if (elapsed > delay)
if (ping) { {
if (ping)
{
ping = false; ping = false;
if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) { if (serverConfig.type == SOCKET_UDP && clientConfig.type == SOCKET_UDP) SocketSend(clientResult->socket, pingmsg, msglen);
SocketSend(client_res->socket, pingmsg, msglen); else SocketSend(clientResult->socket, pingmsg, msglen);
} else { }
SocketSend(client_res->socket, pingmsg, msglen); else if (pong)
} {
} else if (pong) {
pong = false; pong = false;
if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) { if (serverConfig.type == SOCKET_UDP && clientConfig.type == SOCKET_UDP) SocketSend(clientResult->socket, pongmsg, msglen);
SocketSend(client_res->socket, pongmsg, msglen); else SocketSend(clientResult->socket, pongmsg, msglen);
} else {
SocketSend(client_res->socket, pongmsg, msglen);
}
} }
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
@ -137,80 +126,57 @@ int main(void)
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 450; const int screenHeight = 450;
InitWindow( InitWindow(screenWidth, screenHeight, "raylib [network] example - ping pong");
screenWidth, screenHeight, "raylib [network] example - ping pong");
SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG);
// Networking InitNetworkDevice(); // Init network communications
InitNetworkDevice();
// Create the server // Create the server: getaddrinfo + socket + setsockopt + bind + listen
// serverResult = AllocSocketResult();
// Performs if (!SocketCreate(&serverConfig, serverResult))
// getaddrinfo {
// socket TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", serverResult->status, serverResult->socket->status);
// setsockopt }
// bind else
// listen {
server_res = AllocSocketResult(); if (!SocketBind(&serverConfig, serverResult))
if (!SocketCreate(&server_cfg, server_res)) { {
TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", serverResult->status, serverResult->socket->status);
server_res->status, server_res->socket->status); }
} else { else
if (!SocketBind(&server_cfg, server_res)) { {
TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", if (!(serverConfig.type == SOCKET_UDP))
server_res->status, server_res->socket->status); {
} else { if (!SocketListen(&serverConfig, serverResult))
if (!(server_cfg.type == SOCKET_UDP)) { {
if (!SocketListen(&server_cfg, server_res)) { TraceLog(LOG_WARNING, "Failed to start listen server: status %d, errno %d", serverResult->status, serverResult->socket->status);
TraceLog(LOG_WARNING,
"Failed to start listen server: status %d, errno %d",
server_res->status, server_res->socket->status);
} }
} }
} }
} }
// Create the client // Create the client: getaddrinfo + socket + setsockopt + connect (TCP only)
// clientResult = AllocSocketResult();
// Performs if (!SocketCreate(&clientConfig, clientResult))
// getaddrinfo {
// socket TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d", clientResult->status, clientResult->socket->status);
// setsockopt }
// connect (TCP only) else
client_res = AllocSocketResult(); {
if (!SocketCreate(&client_cfg, client_res)) { if (!(clientConfig.type == SOCKET_UDP))
TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d", {
client_res->status, client_res->socket->status); if (!SocketConnect(&clientConfig, clientResult))
} else { {
if (!(client_cfg.type == SOCKET_UDP)) { TraceLog(LOG_WARNING, "Failed to connect to server: status %d, errno %d", clientResult->status, clientResult->socket->status);
if (!SocketConnect(&client_cfg, client_res)) {
TraceLog(LOG_WARNING,
"Failed to connect to server: status %d, errno %d",
client_res->status, client_res->socket->status);
} }
} }
} }
// Create & Add sockets to the socket set // Create and add sockets to the socket set
socket_set = AllocSocketSet(3); socketSet = AllocSocketSet(3);
msglen = strlen(pingmsg) + 1;
memset(recvBuffer, '\0', sizeof(recvBuffer)); AddSocket(socketSet, serverResult->socket);
AddSocket(socket_set, server_res->socket); AddSocket(socketSet, clientResult->socket);
AddSocket(socket_set, client_res->socket);
// Main game loop
while (!WindowShouldClose()) {
BeginDrawing();
ClearBackground(RAYWHITE);
if (connected) {
UpdateNetwork();
} else {
NetworkConnect();
}
EndDrawing();
}
SetTargetFPS(60); // Set our game to run at 60 frames-per-second SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -219,7 +185,8 @@ int main(void)
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// TODO: Update your variables here if (connected) UpdateNetwork();
//else NetworkConnect();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
@ -227,9 +194,8 @@ int main(void)
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
if (connected) UpdateNetwork(); // TODO: Draw relevant connection info
else NetworkConnect();
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -237,7 +203,9 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
return 0; return 0;

47
examples/network/network_resolve_host.c
View File

@ -1,6 +1,6 @@
/******************************************************************************************* /*******************************************************************************************
* *
* raylib [network] example - Resolve Host * raylib [network] example - Resolve Host
* *
* This example has been created using raylib 3.0 (www.raylib.com) * This example has been created using raylib 3.0 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) * raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
@ -21,35 +21,26 @@ int main(void)
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 450; const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [network] example - ping pong"); InitWindow(screenWidth, screenHeight, "raylib [network] example - resolve host");
InitNetworkDevice(); // Init network communications
char buffer[ADDRESS_IPV6_ADDRSTRLEN]; char buffer[ADDRESS_IPV6_ADDRSTRLEN];
uint16_t port = 0; unsigned short port = 0;
AddressInformation *address = AllocAddressList(1);
SetTraceLogLevel(LOG_DEBUG); // Address info flags
// ADDRESS_INFO_NUMERICHOST // or try them in conjunction to
// ADDRESS_INFO_NUMERICSERV // specify custom behaviour from
// Networking // ADDRESS_INFO_DNS_ONLY // the function getaddrinfo()
InitNetworkDevice(); // ADDRESS_INFO_ALL //
// ADDRESS_INFO_FQDN // e.g. ADDRESS_INFO_CANONNAME | ADDRESS_INFO_NUMERICSERV
AddressInformation* addr = AllocAddressList(1); int count = ResolveHost(NULL, "5210", ADDRESS_TYPE_IPV4, 0, address);
int count = ResolveHost(
NULL,
"5210",
ADDRESS_TYPE_IPV4,
0 // Uncomment any of these flags
// ADDRESS_INFO_NUMERICHOST // or try them in conjunction to
// ADDRESS_INFO_NUMERICSERV // specify custom behaviour from
// ADDRESS_INFO_DNS_ONLY // the function getaddrinfo()
// ADDRESS_INFO_ALL //
// ADDRESS_INFO_FQDN // e.g. ADDRESS_INFO_CANONNAME | ADDRESS_INFO_NUMERICSERV
,
addr
);
if (count > 0) if (count > 0)
{ {
GetAddressHostAndPort(addr[0], buffer, &port); GetAddressHostAndPort(address[0], buffer, &port);
TraceLog(LOG_INFO, "Resolved to ip %s::%d", buffer, port); TraceLog(LOG_INFO, "Resolved to ip %s::%d", buffer, port);
} }
@ -70,7 +61,7 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY); // TODO: Draw relevant connection info
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -78,7 +69,9 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
return 0; return 0;

251
examples/network/network_tcp_client.c
View File

@ -1,151 +1,142 @@
/******************************************************************************************* /*******************************************************************************************
* *
* raylib [network] example - TCP Client * raylib [network] example - TCP Client
* *
* Welcome to raylib! * This example has been created using raylib 3.0 (www.raylib.com)
* * raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
* To test examples, just press F6 and execute raylib_compile_execute script *
* Note that compiled executable is placed in the same folder as .c file * Copyright (c) 2019-2020 Jak Barnes (@syphonx) and Ramon Santamaria (@raysan5)
* *
* You can find all basic examples on C:\raylib\raylib\examples folder or ********************************************************************************************/
* raylib official webpage: www.raylib.com
*
* Enjoy using raylib. :)
*
* This example has been created using raylib 2.0 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h
*for details)
*
* Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h" #include "raylib.h"
#define RNET_IMPLEMENTATION
#include "rnet.h" #include "rnet.h"
#include <assert.h> int main(void)
#include <stdio.h>
#include <string.h>
float elapsed = 0.0f;
float delay = 1.0f;
bool ping = false;
bool pong = false;
bool connected = false;
const char * pingmsg = "Ping!";
const char * pongmsg = "Pong!";
int msglen = 0;
SocketConfig client_cfg = {.host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .nonblocking = true};
SocketResult *client_res = NULL;
SocketSet * socket_set = NULL;
char recvBuffer[512];
// Attempt to connect to the network (Either TCP, or UDP)
void NetworkConnect()
{ {
// Check if we're connected every _delay_ seconds // Initialization
elapsed += GetFrameTime(); //--------------------------------------------------------------------------------------
if (elapsed > delay) { const int screenWidth = 800;
if (IsSocketConnected(client_res->socket)) { connected = true; } const int screenHeight = 450;
elapsed = 0.0f;
}
}
// Once connected to the network, check the sockets for pending information InitWindow(screenWidth, screenHeight, "raylib [network] example - tcp client");
// and when information is ready, send either a Ping or a Pong.
void NetworkUpdate()
{
// CheckSockets
//
// If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0);
if (active != 0) {
TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active);
}
// IsSocketReady InitNetworkDevice(); // Init network communications
//
// If the socket is ready, attempt to receive data from the socket const char *pingmsg = "Ping!";
int bytesRecv = 0; const char *pongmsg = "Pong!";
if (IsSocketReady(client_res->socket)) {
bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen); bool ping = false;
} bool pong = false;
float elapsed = 0.0f;
float delay = 1.0f;
bool connected = false;
// If we received data, was that data a "Ping!" or a "Pong!" SocketConfig clientConfig = {
if (bytesRecv > 0) { .host = "127.0.0.1",
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; } .port = "4950",
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; } .type = SOCKET_TCP,
} .nonblocking = true
};
SocketSet *socketSet = NULL;
SocketResult *clientResult = NULL;
char receiveBuffer[512] = { 0 };
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa // Create the client: getaddrinfo + socket + setsockopt + connect (TCP only)
elapsed += GetFrameTime(); clientResult = AllocSocketResult();
if (elapsed > delay) { if (!SocketCreate(&clientConfig, clientResult)) TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d", clientResult->status, clientResult->socket->status);
if (ping) { else
ping = false; {
SocketSend(client_res->socket, pingmsg, msglen); if (!(clientConfig.type == SOCKET_UDP))
} else if (pong) { {
pong = false; if (!SocketConnect(&clientConfig, clientResult)) TraceLog(LOG_WARNING, "Failed to connect to server: status %d, errno %d", clientResult->status, clientResult->socket->status);
SocketSend(client_res->socket, pongmsg, msglen);
}
elapsed = 0.0f;
}
}
int main()
{
// Setup
int screenWidth = 800;
int screenHeight = 450;
InitWindow(
screenWidth, screenHeight, "raylib [network] example - tcp client");
SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG);
// Networking
InitNetwork();
// Create the client
//
// Performs
// getaddrinfo
// socket
// setsockopt
// connect (TCP only)
client_res = AllocSocketResult();
if (!SocketCreate(&client_cfg, client_res)) {
TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d",
client_res->status, client_res->socket->status);
} else {
if (!(client_cfg.type == SOCKET_UDP)) {
if (!SocketConnect(&client_cfg, client_res)) {
TraceLog(LOG_WARNING,
"Failed to connect to server: status %d, errno %d",
client_res->status, client_res->socket->status);
}
} }
} }
// Create & Add sockets to the socket set // Create and add sockets to the socket set
socket_set = AllocSocketSet(1); socketSet = AllocSocketSet(1);
msglen = strlen(pingmsg) + 1; AddSocket(socketSet, clientResult->socket);
memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, client_res->socket); SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop // Main game loop
while (!WindowShouldClose()) { while (!WindowShouldClose()) // Detect window close button or ESC key
BeginDrawing(); {
ClearBackground(RAYWHITE); // Update
if (connected) { //----------------------------------------------------------------------------------
NetworkUpdate(); if (connected)
} else { {
NetworkConnect(); // Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong.
// CheckSockets, if any of the sockets in the socketSet are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(clientResult->socket)
int active = CheckSockets(socketSet, 0);
if (active != 0) TraceLog(LOG_DEBUG, "There are currently %d socket(s) with data to be processed.", active);
// IsSocketReady, if the socket is ready, attempt to receive data from the socket
int bytesRecv = 0;
if (IsSocketReady(clientResult->socket)) bytesRecv = SocketReceive(clientResult->socket, receiveBuffer, strlen(pingmsg) + 1);
// If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0)
{
if (strcmp(receiveBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(receiveBuffer, pongmsg) == 0) { ping = true; }
}
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime();
if (elapsed > delay)
{
if (ping)
{
ping = false;
SocketSend(clientResult->socket, pingmsg, strlen(pingmsg) + 1);
}
else if (pong)
{
pong = false;
SocketSend(clientResult->socket, pongmsg, strlen(pingmsg) + 1);
}
elapsed = 0.0f;
}
} }
else
{
// Check if we're connected every delay seconds
elapsed += GetFrameTime();
if (elapsed > delay)
{
if (IsSocketConnected(clientResult->socket)) { connected = true; }
elapsed = 0.0f;
}
}
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
// TODO: Draw relevant connection info
EndDrawing(); EndDrawing();
//----------------------------------------------------------------------------------
} }
// Cleanup // De-Initialization
CloseWindow(); //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0; return 0;
} }

285
examples/network/network_tcp_server.c
View File

@ -1,165 +1,162 @@
/******************************************************************************************* /*******************************************************************************************
* *
* raylib [network] example - TCP Server * raylib [network] example - TCP Server
* *
* Welcome to raylib! * This example has been created using raylib 3.0 (www.raylib.com)
* * raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
* To test examples, just press F6 and execute raylib_compile_execute script *
* Note that compiled executable is placed in the same folder as .c file * Copyright (c) 2019-2020 Jak Barnes (@syphonx) and Ramon Santamaria (@raysan5)
* *
* You can find all basic examples on C:\raylib\raylib\examples folder or ********************************************************************************************/
* raylib official webpage: www.raylib.com
*
* Enjoy using raylib. :)
*
* This example has been created using raylib 2.0 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h
*for details)
*
* Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
*
********************************************************************************************/
#include "raylib.h" #include "raylib.h"
#define RNET_IMPLEMENTATION
#include "rnet.h" #include "rnet.h"
#include <assert.h> int main(void)
#include <stdio.h>
#include <string.h>
float elapsed = 0.0f;
float delay = 1.0f;
bool ping = false;
bool pong = false;
bool connected = false;
const char * pingmsg = "Ping!";
const char * pongmsg = "Pong!";
int msglen = 0;
SocketConfig server_cfg = {.host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .server = true, .nonblocking = true};
SocketConfig connection_cfg = {.nonblocking = true};
SocketResult *server_res = NULL;
SocketSet * socket_set = NULL;
Socket * connection = NULL;
char recvBuffer[512];
// Attempt to connect to the network (Either TCP, or UDP)
void NetworkConnect()
{ {
int active = CheckSockets(socket_set, 0); // Initialization
if (active != 0) { //--------------------------------------------------------------------------------------
TraceLog(LOG_DEBUG, const int screenWidth = 800;
"There are currently %d socket(s) with data to be processed.", active); const int screenHeight = 450;
}
if (active > 0) {
if ((connection = SocketAccept(server_res->socket, &connection_cfg)) != NULL) {
AddSocket(socket_set, connection);
ping = true;
connected = true;
}
}
}
// Once connected to the network, check the sockets for pending information InitWindow(screenWidth, screenHeight, "raylib [network] example - tcp server");
// and when information is ready, send either a Ping or a Pong.
void NetworkUpdate()
{
// CheckSockets
//
// If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0);
if (active != 0) {
TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active);
}
// IsSocketReady InitNetworkDevice(); // Init network communications
//
// If the socket is ready, attempt to receive data from the socket const char *pingmsg = "Ping!";
int bytesRecv = 0; const char *pongmsg = "Pong!";
if (IsSocketReady(connection)) {
bytesRecv = SocketReceive(connection, recvBuffer, msglen); bool ping = false;
} bool pong = false;
float elapsed = 0.0f;
float delay = 1.0f;
bool connected = false;
// If we received data, was that data a "Ping!" or a "Pong!" SocketConfig serverConfig = {
if (bytesRecv > 0) { .host = "127.0.0.1",
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; } .port = "4950",
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; } .type = SOCKET_TCP,
} .server = true,
.nonblocking = true
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa };
elapsed += GetFrameTime();
if (elapsed > delay) { SocketConfig connectionConfig = { .nonblocking = true };
if (ping) {
ping = false; Socket *connection = NULL;
SocketSend(connection, pingmsg, msglen); SocketSet *socketSet = NULL;
} else if (pong) { SocketResult *serverResult = NULL;
pong = false; char receiveBuffer[512] = { 0 };
SocketSend(connection, pongmsg, msglen);
} // Create the server: getaddrinfo + socket + setsockopt + bind + listen
elapsed = 0.0f; serverResult = AllocSocketResult();
} if (!SocketCreate(&serverConfig, serverResult))
} {
TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", serverResult->status, serverResult->socket->status);
int main() }
{ else
// Setup {
int screenWidth = 800; if (!SocketBind(&serverConfig, serverResult))
int screenHeight = 450; {
InitWindow( TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", serverResult->status, serverResult->socket->status);
screenWidth, screenHeight, "raylib [network] example - tcp server"); }
SetTargetFPS(60); else
SetTraceLogLevel(LOG_DEBUG); {
if (!(serverConfig.type == SOCKET_UDP))
// Networking {
InitNetwork(); if (!SocketListen(&serverConfig, serverResult)) TraceLog(LOG_WARNING, "Failed to start listen server: status %d, errno %d", serverResult->status, serverResult->socket->status);
// Create the server
//
// Performs
// getaddrinfo
// socket
// setsockopt
// bind
// listen
server_res = AllocSocketResult();
if (!SocketCreate(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d",
server_res->status, server_res->socket->status);
} else {
if (!SocketBind(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d",
server_res->status, server_res->socket->status);
} else {
if (!(server_cfg.type == SOCKET_UDP)) {
if (!SocketListen(&server_cfg, server_res)) {
TraceLog(LOG_WARNING,
"Failed to start listen server: status %d, errno %d",
server_res->status, server_res->socket->status);
}
} }
} }
} }
// Create & Add sockets to the socket set // Create and add sockets to the socket set
socket_set = AllocSocketSet(2); socketSet = AllocSocketSet(2);
msglen = strlen(pingmsg) + 1; AddSocket(socketSet, serverResult->socket);
memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, server_res->socket); SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop // Main game loop
while (!WindowShouldClose()) { while (!WindowShouldClose()) // Detect window close button or ESC key
BeginDrawing(); {
ClearBackground(RAYWHITE); // Update
if (connected) { //----------------------------------------------------------------------------------
NetworkUpdate(); if (connected)
} else { {
NetworkConnect(); // Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong.
// CheckSockets, if any of the sockets in the socketSet are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socketSet, 0);
if (active != 0) TraceLog(LOG_DEBUG, "There are currently %d socket(s) with data to be processed.", active);
// IsSocketReady, if the socket is ready, attempt to receive data from the socket
int bytesRecv = 0;
if (IsSocketReady(connection)) bytesRecv = SocketReceive(connection, receiveBuffer, strlen(pingmsg) + 1);
// If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0)
{
if (strcmp(receiveBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(receiveBuffer, pongmsg) == 0) { ping = true; }
}
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime();
if (elapsed > delay)
{
if (ping)
{
ping = false;
SocketSend(connection, pingmsg, strlen(pingmsg) + 1);
}
else if (pong)
{
pong = false;
SocketSend(connection, pongmsg, strlen(pingmsg) + 1);
}
elapsed = 0.0f;
}
} }
else
{
// Attempt to connect to the network (Either TCP, or UDP)
int active = CheckSockets(socketSet, 0);
if (active != 0) TraceLog(LOG_DEBUG, "There are currently %d socket(s) with data to be processed.", active);
if (active > 0)
{
if ((connection = SocketAccept(serverResult->socket, &connectionConfig)) != NULL)
{
AddSocket(socketSet, connection);
connected = true;
ping = true;
}
}
}
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
// TODO: Draw relevant connection info
EndDrawing(); EndDrawing();
//----------------------------------------------------------------------------------
} }
// Cleanup // De-Initialization
CloseWindow(); //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0; return 0;
} }

15
examples/network/network_test.c
View File

@ -123,11 +123,12 @@ int main(void)
InitWindow(screenWidth, screenHeight, "raylib [network] example - network test"); InitWindow(screenWidth, screenHeight, "raylib [network] example - network test");
// Run the tests InitNetworkDevice(); // Init network communications
test_network_initialise();
// Run some tests
test_resolve_host(); test_resolve_host();
//test_socket_create(); //test_socket_create();
test_resolve_ip(); //test_resolve_ip();
SetTargetFPS(60); // Set our game to run at 60 frames-per-second SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -145,8 +146,8 @@ int main(void)
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY); // TODO: Draw relevant connection info
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -154,7 +155,9 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
return 0; return 0;

152
examples/network/network_udp_client.c
View File

@ -1,6 +1,6 @@
/******************************************************************************************* /*******************************************************************************************
* *
* raylib [network] example - UDP Client * raylib [network] example - UDP Client
* *
* This example has been created using raylib 3.0 (www.raylib.com) * This example has been created using raylib 3.0 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) * raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
@ -14,65 +14,6 @@
#define RNET_IMPLEMENTATION #define RNET_IMPLEMENTATION
#include "rnet.h" #include "rnet.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>
float elapsed = 0.0f;
float delay = 1.0f;
bool ping = false;
bool pong = false;
const char * pingmsg = "Ping!";
const char * pongmsg = "Pong!";
int msglen = 0;
SocketConfig client_cfg = {.host = "127.0.0.1", .port = "4950", .type = SOCKET_UDP, .nonblocking = true};
SocketResult *client_res = NULL;
SocketSet * socket_set = NULL;
char recvBuffer[512];
// Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong.
void UpdateNetwork()
{
// CheckSockets
//
// If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0);
if (active != 0) {
TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active);
}
// IsSocketReady
//
// If the socket is ready, attempt to receive data from the socket
int bytesRecv = 0;
if (IsSocketReady(client_res->socket)) {
bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen);
}
// If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0) {
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; }
}
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime();
if (elapsed > delay) {
if (ping) {
ping = false;
SocketSend(client_res->socket, pingmsg, msglen);
} else if (pong) {
pong = false;
SocketSend(client_res->socket, pongmsg, msglen);
}
elapsed = 0.0f;
}
}
int main(void) int main(void)
{ {
// Initialization // Initialization
@ -82,27 +23,37 @@ int main(void)
InitWindow(screenWidth, screenHeight, "raylib [network] example - udp client"); InitWindow(screenWidth, screenHeight, "raylib [network] example - udp client");
InitNetworkDevice(); InitNetworkDevice(); // Init network communications
const char *pingmsg = "Ping!";
const char *pongmsg = "Pong!";
bool ping = true;
bool pong = false;
float elapsed = 0.0f;
float delay = 1.0f;
// Create the client SocketConfig clientConfig = {
// .host = "127.0.0.1",
// Performs .port = "4950",
// getaddrinfo .type = SOCKET_UDP,
// socket .nonblocking = true
// setsockopt };
// connect (TCP only)
client_res = AllocSocketResult(); SocketResult *clientResult = NULL;
if (!SocketCreate(&client_cfg, client_res)) { SocketSet *socketSet = NULL;
TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d", char receiveBuffer[512] = { 0 };
client_res->status, client_res->socket->status);
// Create the client: getaddrinfo + socket + setsockopt + connect (TCP only)
clientResult = AllocSocketResult();
if (!SocketCreate(&clientConfig, clientResult))
{
TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d", clientResult->status, clientResult->socket->status);
} }
// Create & Add sockets to the socket set // Create and add sockets to the socket set
socket_set = AllocSocketSet(1); socketSet = AllocSocketSet(1);
msglen = strlen(pingmsg) + 1; AddSocket(socketSet, clientResult->socket);
ping = true;
memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, client_res->socket);
SetTargetFPS(60); // Set our game to run at 60 frames-per-second SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -112,7 +63,42 @@ int main(void)
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
UpdateNetwork(); // Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong.
// CheckSockets, if any of the sockets in the socketSet are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(clientResult->socket)
int active = CheckSockets(socketSet, 0);
if (active != 0) TraceLog(LOG_INFO, "There are currently %d socket(s) with data to be processed.", active);
// IsSocketReady, if the socket is ready, attempt to receive data from the socket
int bytesRecv = 0;
if (IsSocketReady(clientResult->socket)) bytesRecv = SocketReceive(clientResult->socket, receiveBuffer, strlen(pingmsg) + 1);
// If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0)
{
if (strcmp(receiveBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(receiveBuffer, pongmsg) == 0) { ping = true; }
}
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice-versa
elapsed += GetFrameTime();
if (elapsed > delay)
{
if (ping)
{
ping = false;
SocketSend(clientResult->socket, pingmsg, strlen(pingmsg) + 1);
}
else if (pong)
{
pong = false;
SocketSend(clientResult->socket, pongmsg, strlen(pongmsg) + 1);
}
elapsed = 0.0f;
}
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
@ -120,6 +106,8 @@ int main(void)
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
// TODO: Draw relevant connection info
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -127,9 +115,9 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
return 0; return 0;

162
examples/network/network_udp_server.c
View File

@ -1,6 +1,6 @@
/******************************************************************************************* /*******************************************************************************************
* *
* raylib [network] example - UDP Server * raylib [network] example - UDP Server
* *
* This example has been created using raylib 3.0 (www.raylib.com) * This example has been created using raylib 3.0 (www.raylib.com)
* raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) * raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
@ -14,66 +14,6 @@
#define RNET_IMPLEMENTATION #define RNET_IMPLEMENTATION
#include "rnet.h" #include "rnet.h"
#include <assert.h>
#include <stdio.h>
#include <string.h>
float elapsed = 0.0f;
float delay = 1.0f;
bool ping = false;
bool pong = false;
const char * pingmsg = "Ping!";
const char * pongmsg = "Pong!";
int msglen = 0;
SocketConfig server_cfg = {.host = "127.0.0.1", .port = "4950", .server = true, .type = SOCKET_UDP, .nonblocking = true};
SocketResult *server_res = NULL;
SocketSet * socket_set = NULL;
char recvBuffer[512];
// Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong.
void UpdateNetwork()
{
// CheckSockets
//
// If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0);
if (active != 0) {
TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active);
}
// IsSocketReady
//
// If the socket is ready, attempt to receive data from the socket
// int bytesRecv = 0;
// if (IsSocketReady(server_res->socket)) {
// bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen);
// }
int bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen);
// If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0) {
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; }
}
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime();
if (elapsed > delay) {
if (ping) {
ping = false;
SocketSend(server_res->socket, pingmsg, msglen);
} else if (pong) {
pong = false;
SocketSend(server_res->socket, pongmsg, msglen);
}
elapsed = 0.0f;
}
}
int main(void) int main(void)
{ {
// Initialization // Initialization
@ -83,30 +23,37 @@ int main(void)
InitWindow(screenWidth, screenHeight, "raylib [network] example - udp server"); InitWindow(screenWidth, screenHeight, "raylib [network] example - udp server");
InitNetworkDevice(); InitNetworkDevice(); // Init network communications
const char *pingmsg = "Ping!";
const char *pongmsg = "Pong!";
bool ping = false;
bool pong = false;
float elapsed = 0.0f;
float delay = 1.0f;
// Create the server SocketConfig serverConfig = {
// .host = "127.0.0.1",
// Performs .port = "4950",
// getaddrinfo .server = true,
// socket .type = SOCKET_UDP,
// setsockopt .nonblocking = true
// bind };
// listen
server_res = AllocSocketResult(); SocketResult *serverResult = NULL;
if (!SocketCreate(&server_cfg, server_res)) SocketSet *socketSet = NULL;
{ char receiveBuffer[512] = { 0 };
TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", server_res->status, server_res->socket->status);
} else
{
if (!SocketBind(&server_cfg, server_res)) TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", server_res->status, server_res->socket->status);
}
// Create & Add sockets to the socket set // Create the server: getaddrinfo + socket + setsockopt + bind + listen
socket_set = AllocSocketSet(1); serverResult = AllocSocketResult();
msglen = strlen(pingmsg) + 1;
memset(recvBuffer, '\0', sizeof(recvBuffer)); if (!SocketCreate(&serverConfig, serverResult)) TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", serverResult->status, serverResult->socket->status);
AddSocket(socket_set, server_res->socket); else if (!SocketBind(&serverConfig, serverResult)) TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", serverResult->status, serverResult->socket->status);
// Create and add sockets to the socket set
socketSet = AllocSocketSet(1);
AddSocket(socketSet, serverResult->socket);
SetTargetFPS(60); // Set our game to run at 60 frames-per-second SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -116,7 +63,46 @@ int main(void)
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
UpdateNetwork(); // Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong.
// CheckSockets, if any of the sockets in the set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socketSet, 0);
if (active != 0) TraceLog(LOG_INFO, "There are currently %d socket(s) with data to be processed.", active);
// IsSocketReady, if the socket is ready, attempt to receive data from the socket
// int bytesRecv = 0;
// if (IsSocketReady(serverResult->socket)) {
// bytesRecv = SocketReceive(serverResult->socket, receiveBuffer, msglen);
// }
int bytesRecv = SocketReceive(serverResult->socket, receiveBuffer, strlen(pingmsg) + 1);
// If we received data, is that data a "Ping!" or a "Pong!"?
if (bytesRecv > 0)
{
if (strcmp(receiveBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(receiveBuffer, pongmsg) == 0) { ping = true; }
}
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice-versa
elapsed += GetFrameTime();
if (elapsed > delay)
{
if (ping)
{
ping = false;
SocketSend(serverResult->socket, pingmsg, strlen(pingmsg) + 1);
}
else if (pong)
{
pong = false;
SocketSend(serverResult->socket, pongmsg, strlen(pongmsg) + 1);
}
elapsed = 0.0f;
}
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
@ -125,7 +111,7 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
// TODO: Draw relevant connection info
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -133,7 +119,9 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
return 0; return 0;

24
src/rnet.h
View File

@ -252,7 +252,7 @@ typedef struct _SocketAddressStorage *SocketAddressStorage;
// IPAddress definition (in network byte order) // IPAddress definition (in network byte order)
typedef struct IPAddress { typedef struct IPAddress {
unsigned long host; // 32-bit IPv4 host address unsigned long host; // 32-bit IPv4 host address
unsigned short port; // 16-bit protocol port unsigned short port; // 16-bit protocol port
} IPAddress; } IPAddress;
@ -269,8 +269,8 @@ typedef struct UDPChannel {
} UDPChannel; } UDPChannel;
typedef struct Socket { typedef struct Socket {
int ready; // Is the socket ready? i.e. has information int ready; // Is the socket ready? i.e. has information
int status; // The last status code to have occured using this socket int status; // The last status code to have occured using this socket
bool isServer; // Is this socket a server socket (i.e. TCP/UDP Listen Server) bool isServer; // Is this socket a server socket (i.e. TCP/UDP Listen Server)
SocketChannel channel; // The socket handle id SocketChannel channel; // The socket handle id
SocketType type; // Is this socket a TCP or UDP socket? SocketType type; // Is this socket a TCP or UDP socket?
@ -345,8 +345,8 @@ int ResolveHost(const char *address, const char *service, int addressType, int f
int GetAddressFamily(AddressInformation address); int GetAddressFamily(AddressInformation address);
int GetAddressSocketType(AddressInformation address); int GetAddressSocketType(AddressInformation address);
int GetAddressProtocol(AddressInformation address); int GetAddressProtocol(AddressInformation address);
char* GetAddressCanonName(AddressInformation address); char *GetAddressCanonName(AddressInformation address);
char* GetAddressHostAndPort(AddressInformation address, char *outhost, int *outport); char *GetAddressHostAndPort(AddressInformation address, char *outhost, int *outport);
void PrintAddressInfo(AddressInformation address); void PrintAddressInfo(AddressInformation address);
// Address Memory API // Address Memory API
@ -632,7 +632,7 @@ static void SocketSetLastError(int err)
} }
// Returns the error status for the last Sockets operation that failed // Returns the error status for the last Sockets operation that failed
static int SocketGetLastError() static int SocketGetLastError(void)
{ {
#if defined(_WIN32) #if defined(_WIN32)
return WSAGetLastError(); return WSAGetLastError();
@ -642,7 +642,7 @@ static int SocketGetLastError()
} }
// Returns a human-readable string representing the last error message // Returns a human-readable string representing the last error message
static char *SocketGetLastErrorString() static char *SocketGetLastErrorString(void)
{ {
return SocketErrorCodeToString(SocketGetLastError()); return SocketErrorCodeToString(SocketGetLastError());
} }
@ -942,7 +942,7 @@ static void SocketSetHints(SocketConfig *config, struct addrinfo *hints)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Initialise the network (requires for windows platforms only) // Initialise the network (requires for windows platforms only)
bool InitNetworkDevice() bool InitNetworkDevice(void)
{ {
#if defined(_WIN32) #if defined(_WIN32)
WORD wVersionRequested; WORD wVersionRequested;
@ -972,7 +972,7 @@ bool InitNetworkDevice()
} }
// Cleanup, and close the network // Cleanup, and close the network
void CloseNetworkDevice() void CloseNetworkDevice(void)
{ {
#if defined(_WIN32) #if defined(_WIN32)
WSACleanup(); WSACleanup();
@ -1863,7 +1863,7 @@ bool IsSocketConnected(Socket *sock)
} }
// Allocate and return a SocketResult struct // Allocate and return a SocketResult struct
SocketResult *AllocSocketResult() SocketResult *AllocSocketResult(void)
{ {
struct SocketResult *res = (struct SocketResult *)RNET_MALLOC(sizeof(*res)); struct SocketResult *res = (struct SocketResult *)RNET_MALLOC(sizeof(*res));
@ -1893,7 +1893,7 @@ void FreeSocketResult(SocketResult **result)
} }
// Allocate a Socket // Allocate a Socket
Socket *AllocSocket() Socket *AllocSocket(void)
{ {
struct Socket *sock; struct Socket *sock;
sock = (Socket *)RNET_MALLOC(sizeof(*sock)); sock = (Socket *)RNET_MALLOC(sizeof(*sock));
@ -2053,7 +2053,7 @@ int CheckSockets(SocketSet *set, unsigned int timeout)
} }
// Allocate an AddressInformation // Allocate an AddressInformation
AddressInformation AllocAddress() AddressInformation AllocAddress(void)
{ {
AddressInformation addressInfo = NULL; AddressInformation addressInfo = NULL;
addressInfo = (AddressInformation) RNET_CALLOC(1, sizeof(*addressInfo)); addressInfo = (AddressInformation) RNET_CALLOC(1, sizeof(*addressInfo));