UnrealXR/raylib
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[rnet] Review network examples formatting

Browse source
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
Download patch file Download diff file Expand all files Collapse all files

236
examples/network/network_ping_pong.c
View file

@ -14,57 +14,59 @@
#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 elapsed = 0.0f;
float delay = 1.0f; float delay = 1.0f;
bool ping = false; bool ping = false;
bool pong = false; bool pong = false;
bool connected = false; bool connected = false;
bool client_connected = false; bool clientConnected = false;
const char *pingmsg = "Ping!"; const char *pingmsg = "Ping!";
const char *pongmsg = "Pong!"; const char *pongmsg = "Pong!";
int msglen = 0; int msglen = 0;
SocketConfig server_cfg = {.host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .server = true, .nonblocking = true}; SocketConfig serverConfig = { .host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .server = true, .nonblocking = true };
SocketConfig client_cfg = {.host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .nonblocking = true}; SocketConfig clientConfig = { .host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .nonblocking = true };
SocketConfig connection_cfg = {.nonblocking = true}; SocketConfig connectionConfig = { .nonblocking = true };
SocketResult *server_res = NULL; SocketResult *serverResult = NULL;
SocketResult *client_res = NULL; SocketResult *clientResult = NULL;
SocketSet * socket_set = NULL; SocketSet *socketSet = NULL;
Socket *connection = NULL; Socket *connection = NULL;
char recvBuffer[512]; char receiveBuffer[512] = { 0 };
// 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, recvBuffer, msglen);
}
} }
else if (IsSocketReady(connection)) bytesRecv = SocketReceive(connection, receiveBuffer, 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
@ -228,8 +195,7 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
if (connected) UpdateNetwork(); // TODO: Draw relevant connection info
else NetworkConnect();
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -237,6 +203,8 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

29
examples/network/network_resolve_host.c
View file

@ -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;
SetTraceLogLevel(LOG_DEBUG); AddressInformation *address = AllocAddressList(1);
// Address info flags
// Networking
InitNetworkDevice();
AddressInformation* addr = AllocAddressList(1);
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_NUMERICHOST // or try them in conjunction to
// ADDRESS_INFO_NUMERICSERV // specify custom behaviour from // ADDRESS_INFO_NUMERICSERV // specify custom behaviour from
// ADDRESS_INFO_DNS_ONLY // the function getaddrinfo() // ADDRESS_INFO_DNS_ONLY // the function getaddrinfo()
// ADDRESS_INFO_ALL // // ADDRESS_INFO_ALL //
// ADDRESS_INFO_FQDN // e.g. ADDRESS_INFO_CANONNAME | ADDRESS_INFO_NUMERICSERV // ADDRESS_INFO_FQDN // e.g. ADDRESS_INFO_CANONNAME | ADDRESS_INFO_NUMERICSERV
, int count = ResolveHost(NULL, "5210", ADDRESS_TYPE_IPV4, 0, address);
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,6 +69,8 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

203
examples/network/network_tcp_client.c
View file

@ -2,150 +2,141 @@
* *
* 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 * Copyright (c) 2019-2020 Jak Barnes (@syphonx) and Ramon Santamaria (@raysan5)
* Note that compiled executable is placed in the same folder as .c file
*
* 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> // Initialization
//--------------------------------------------------------------------------------------
const int screenWidth = 800;
const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [network] example - tcp client");
InitNetworkDevice(); // Init network communications
float elapsed = 0.0f;
float delay = 1.0f;
bool ping = false;
bool pong = false;
bool connected = false;
const char *pingmsg = "Ping!"; const char *pingmsg = "Ping!";
const char *pongmsg = "Pong!"; 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) bool ping = false;
void NetworkConnect() bool pong = false;
float elapsed = 0.0f;
float delay = 1.0f;
bool connected = false;
SocketConfig clientConfig = {
.host = "127.0.0.1",
.port = "4950",
.type = SOCKET_TCP,
.nonblocking = true
};
SocketSet *socketSet = NULL;
SocketResult *clientResult = NULL;
char receiveBuffer[512] = { 0 };
// 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);
else
{ {
// Check if we're connected every _delay_ seconds if (!(clientConfig.type == SOCKET_UDP))
elapsed += GetFrameTime(); {
if (elapsed > delay) { if (!SocketConnect(&clientConfig, clientResult)) TraceLog(LOG_WARNING, "Failed to connect to server: status %d, errno %d", clientResult->status, clientResult->socket->status);
if (IsSocketConnected(client_res->socket)) { connected = true; }
elapsed = 0.0f;
} }
} }
// Create and add sockets to the socket set
socketSet = AllocSocketSet(1);
AddSocket(socketSet, clientResult->socket);
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
if (connected)
{
// 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 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 // 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 the socket is ready, attempt to receive data from the 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; int bytesRecv = 0;
if (IsSocketReady(client_res->socket)) { if (IsSocketReady(clientResult->socket)) bytesRecv = SocketReceive(clientResult->socket, receiveBuffer, strlen(pingmsg) + 1);
bytesRecv = SocketReceive(client_res->socket, 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;
SocketSend(client_res->socket, pingmsg, msglen); SocketSend(clientResult->socket, pingmsg, strlen(pingmsg) + 1);
} else if (pong) {
pong = false;
SocketSend(client_res->socket, pongmsg, msglen);
} }
else if (pong)
{
pong = false;
SocketSend(clientResult->socket, pongmsg, strlen(pingmsg) + 1);
}
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
else
int main()
{ {
// Setup // Check if we're connected every delay seconds
int screenWidth = 800; elapsed += GetFrameTime();
int screenHeight = 450; if (elapsed > delay)
InitWindow( {
screenWidth, screenHeight, "raylib [network] example - tcp client"); if (IsSocketConnected(clientResult->socket)) { connected = true; }
SetTargetFPS(60); elapsed = 0.0f;
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 // Draw
socket_set = AllocSocketSet(1); //----------------------------------------------------------------------------------
msglen = strlen(pingmsg) + 1;
memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, client_res->socket);
// Main game loop
while (!WindowShouldClose()) {
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
if (connected) {
NetworkUpdate(); // TODO: Draw relevant connection info
} else {
NetworkConnect();
}
EndDrawing(); EndDrawing();
//----------------------------------------------------------------------------------
} }
// Cleanup // De-Initialization
CloseWindow(); //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0; return 0;
} }

227
examples/network/network_tcp_server.c
View file

@ -2,164 +2,161 @@
* *
* 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 * Copyright (c) 2019-2020 Jak Barnes (@syphonx) and Ramon Santamaria (@raysan5)
* Note that compiled executable is placed in the same folder as .c file
*
* 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> // Initialization
//--------------------------------------------------------------------------------------
const int screenWidth = 800;
const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [network] example - tcp server");
InitNetworkDevice(); // Init network communications
float elapsed = 0.0f;
float delay = 1.0f;
bool ping = false;
bool pong = false;
bool connected = false;
const char *pingmsg = "Ping!"; const char *pingmsg = "Ping!";
const char *pongmsg = "Pong!"; const char *pongmsg = "Pong!";
int msglen = 0;
SocketConfig server_cfg = {.host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .server = true, .nonblocking = true}; bool ping = false;
SocketConfig connection_cfg = {.nonblocking = true}; bool pong = false;
SocketResult *server_res = NULL; float elapsed = 0.0f;
SocketSet * socket_set = NULL; float delay = 1.0f;
bool connected = false;
SocketConfig serverConfig = {
.host = "127.0.0.1",
.port = "4950",
.type = SOCKET_TCP,
.server = true,
.nonblocking = true
};
SocketConfig connectionConfig = { .nonblocking = true };
Socket *connection = NULL; Socket *connection = NULL;
char recvBuffer[512]; SocketSet *socketSet = NULL;
SocketResult *serverResult = NULL;
char receiveBuffer[512] = { 0 };
// Attempt to connect to the network (Either TCP, or UDP) // Create the server: getaddrinfo + socket + setsockopt + bind + listen
void NetworkConnect() serverResult = AllocSocketResult();
if (!SocketCreate(&serverConfig, serverResult))
{ {
int active = CheckSockets(socket_set, 0); TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", serverResult->status, serverResult->socket->status);
if (active != 0) {
TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active);
} }
if (active > 0) { else
if ((connection = SocketAccept(server_res->socket, &connection_cfg)) != NULL) { {
AddSocket(socket_set, connection); if (!SocketBind(&serverConfig, serverResult))
ping = true; {
connected = true; TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", serverResult->status, serverResult->socket->status);
}
else
{
if (!(serverConfig.type == SOCKET_UDP))
{
if (!SocketListen(&serverConfig, serverResult)) TraceLog(LOG_WARNING, "Failed to start listen server: status %d, errno %d", serverResult->status, serverResult->socket->status);
} }
} }
} }
// Create and add sockets to the socket set
socketSet = AllocSocketSet(2);
AddSocket(socketSet, serverResult->socket);
SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
if (connected)
{
// 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 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 // 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)
// If the socket is ready, attempt to receive data from the 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; int bytesRecv = 0;
if (IsSocketReady(connection)) { if (IsSocketReady(connection)) bytesRecv = SocketReceive(connection, receiveBuffer, strlen(pingmsg) + 1);
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;
SocketSend(connection, pingmsg, msglen); SocketSend(connection, pingmsg, strlen(pingmsg) + 1);
} else if (pong) {
pong = false;
SocketSend(connection, pongmsg, msglen);
} }
else if (pong)
{
pong = false;
SocketSend(connection, pongmsg, strlen(pingmsg) + 1);
}
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
else
int main()
{ {
// Setup // Attempt to connect to the network (Either TCP, or UDP)
int screenWidth = 800; int active = CheckSockets(socketSet, 0);
int screenHeight = 450; if (active != 0) TraceLog(LOG_DEBUG, "There are currently %d socket(s) with data to be processed.", active);
InitWindow(
screenWidth, screenHeight, "raylib [network] example - tcp server");
SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG);
// Networking if (active > 0)
InitNetwork(); {
if ((connection = SocketAccept(serverResult->socket, &connectionConfig)) != NULL)
// Create the server {
// AddSocket(socketSet, connection);
// Performs connected = true;
// getaddrinfo ping = true;
// 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 // Draw
socket_set = AllocSocketSet(2); //----------------------------------------------------------------------------------
msglen = strlen(pingmsg) + 1;
memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, server_res->socket);
// Main game loop
while (!WindowShouldClose()) {
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
if (connected) {
NetworkUpdate(); // TODO: Draw relevant connection info
} else {
NetworkConnect();
}
EndDrawing(); EndDrawing();
//----------------------------------------------------------------------------------
} }
// Cleanup // De-Initialization
CloseWindow(); //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0; return 0;
} }

11
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
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -146,7 +147,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();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -154,6 +155,8 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

146
examples/network/network_udp_client.c
View file

@ -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
// Create the client const char *pingmsg = "Ping!";
// const char *pongmsg = "Pong!";
// Performs
// getaddrinfo bool ping = true;
// socket bool pong = false;
// setsockopt float elapsed = 0.0f;
// connect (TCP only) float delay = 1.0f;
client_res = AllocSocketResult();
if (!SocketCreate(&client_cfg, client_res)) { SocketConfig clientConfig = {
TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d", .host = "127.0.0.1",
client_res->status, client_res->socket->status); .port = "4950",
.type = SOCKET_UDP,
.nonblocking = true
};
SocketResult *clientResult = NULL;
SocketSet *socketSet = NULL;
char receiveBuffer[512] = { 0 };
// 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
@ -121,13 +107,15 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
// TODO: Draw relevant connection info
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
} }
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

156
examples/network/network_udp_server.c
View file

@ -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
// Create the server const char *pingmsg = "Ping!";
// const char *pongmsg = "Pong!";
// 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);
}
// Create & Add sockets to the socket set bool ping = false;
socket_set = AllocSocketSet(1); bool pong = false;
msglen = strlen(pingmsg) + 1; float elapsed = 0.0f;
memset(recvBuffer, '\0', sizeof(recvBuffer)); float delay = 1.0f;
AddSocket(socket_set, server_res->socket);
SocketConfig serverConfig = {
.host = "127.0.0.1",
.port = "4950",
.server = true,
.type = SOCKET_UDP,
.nonblocking = true
};
SocketResult *serverResult = NULL;
SocketSet *socketSet = NULL;
char receiveBuffer[512] = { 0 };
// Create the server: getaddrinfo + socket + setsockopt + bind + listen
serverResult = AllocSocketResult();
if (!SocketCreate(&serverConfig, serverResult)) TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", serverResult->status, serverResult->socket->status);
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,6 +119,8 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseNetworkDevice(); // Close network communication
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

14
src/rnet.h
View file

@ -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));