[rnet] Review network examples formatting

examples/network/network_ping_pong.c

@@ -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)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
@@ -14,57 +14,59 @@
 #define RNET_IMPLEMENTATION
 #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;
-bool          connected        = false;
-bool          client_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  client_cfg       = {.host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .nonblocking = true};
-SocketConfig  connection_cfg   = {.nonblocking = true};
-SocketResult *server_res       = NULL;
-SocketResult *client_res       = NULL;
-SocketSet *   socket_set       = NULL;
-Socket *      connection       = NULL;
-char          recvBuffer[512];
+float elapsed = 0.0f;
+float delay = 1.0f;
+bool ping = false;
+bool pong = false;
+bool connected = false;
+bool clientConnected = false;
+const char *pingmsg = "Ping!";
+const char *pongmsg = "Pong!";
+int msglen = 0;
+SocketConfig serverConfig = { .host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .server = true, .nonblocking = true };
+SocketConfig clientConfig = { .host = "127.0.0.1", .port = "4950", .type = SOCKET_TCP, .nonblocking = true };
+SocketConfig connectionConfig = { .nonblocking = true };
+SocketResult *serverResult = NULL;
+SocketResult *clientResult = NULL;
+SocketSet *socketSet = NULL;
+Socket *connection = NULL;
+char receiveBuffer[512] = { 0 };
 
 // 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 (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) {
-        ping      = true;
+    if ((serverConfig.type == SOCKET_UDP) && (clientConfig.type == SOCKET_UDP))
+    {
+        ping = true;
         connected = true;
-    } else {
+    } 
+    else 
+    {
         // If the client is connected, run the server code to check for a connection
-        if (client_connected) {
-            int active = CheckSockets(socket_set, 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(server_res->socket, &connection_cfg)) != NULL) {
-                    AddSocket(socket_set, connection);
-                    ping      = true;
+        if (clientConnected) 
+        {
+            int active = CheckSockets(socketSet, 0);
+            if (active != 0) TraceLog(LOG_INFO, "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;
                 }
             }
-        } else {
+        } 
+        else
+        {
             // Check if we're connected every _delay_ seconds
             elapsed += GetFrameTime();
-            if (elapsed > delay) {
-                if (IsSocketConnected(client_res->socket)) {
-                    client_connected = true;
-                }
+            if (elapsed > delay)
+            {
+                if (IsSocketConnected(clientResult->socket)) clientConnected = true;
+                
                 elapsed = 0.0f;
             }
         }
@@ -73,59 +75,46 @@ void NetworkConnect()
 
 // 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()
+static void UpdateNetwork(void)
 {
-    // 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);
-    }
+    // 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
+    // IsSocketReady, if the socket is ready, attempt to receive data from the socket
     int bytesRecv = 0;
-    if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) {
-        if (IsSocketReady(client_res->socket)) {
-            bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen);
-        }
-        if (IsSocketReady(server_res->socket)) {
-            bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen);
-        }
-    } else {
-        if (IsSocketReady(connection)) {
-            bytesRecv = SocketReceive(connection, recvBuffer, msglen);
-        }
-    }
+    if ((serverConfig.type == SOCKET_UDP) && (clientConfig.type == SOCKET_UDP))
+    {
+        if (IsSocketReady(clientResult->socket)) bytesRecv = SocketReceive(clientResult->socket, receiveBuffer, msglen);
+        if (IsSocketReady(serverResult->socket)) bytesRecv = SocketReceive(serverResult->socket, receiveBuffer, msglen);
+    } 
+    else if (IsSocketReady(connection)) bytesRecv = SocketReceive(connection, receiveBuffer, 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; }
+    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) {
+    if (elapsed > delay)
+    {
+        if (ping)
+        {
             ping = false;
-            if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) {
-                SocketSend(client_res->socket, pingmsg, msglen);
-            } else {
-                SocketSend(client_res->socket, pingmsg, msglen);
-            }
-        } else if (pong) {
+            if (serverConfig.type == SOCKET_UDP && clientConfig.type == SOCKET_UDP) SocketSend(clientResult->socket, pingmsg, msglen);
+            else SocketSend(clientResult->socket, pingmsg, msglen);
+        } 
+        else if (pong)
+        {
             pong = false;
-            if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) {
-                SocketSend(client_res->socket, pongmsg, msglen);
-            } else {
-                SocketSend(client_res->socket, pongmsg, msglen);
-            }
+            if (serverConfig.type == SOCKET_UDP && clientConfig.type == SOCKET_UDP) SocketSend(clientResult->socket, pongmsg, msglen);
+            else SocketSend(clientResult->socket, pongmsg, msglen);
         }
+        
         elapsed = 0.0f;
     }
 }
@@ -137,80 +126,57 @@ int main(void)
     const int screenWidth = 800;
     const int screenHeight = 450;
 
-    InitWindow(
-        screenWidth, screenHeight, "raylib [network] example - ping pong");
-    SetTargetFPS(60);
-    SetTraceLogLevel(LOG_DEBUG);
-
-    // Networking
-    InitNetworkDevice();
-
-    // 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);
+    InitWindow(screenWidth, screenHeight, "raylib [network] example - ping pong");
+
+    InitNetworkDevice();    // Init network communications
+
+    //  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);
+        } 
+        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 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 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
+    {
+        if (!(clientConfig.type == SOCKET_UDP))
+        {
+            if (!SocketConnect(&clientConfig, clientResult))
+            {
+                TraceLog(LOG_WARNING, "Failed to connect to server: status %d, errno %d", clientResult->status, clientResult->socket->status);
             }
         }
     }
 
-    // Create & Add sockets to the socket set
-    socket_set = AllocSocketSet(3);
-    msglen     = strlen(pingmsg) + 1;
-    memset(recvBuffer, '\0', sizeof(recvBuffer));
-    AddSocket(socket_set, server_res->socket);
-    AddSocket(socket_set, client_res->socket);
+    // Create and add sockets to the socket set
+    socketSet = AllocSocketSet(3);
+
+    AddSocket(socketSet, serverResult->socket);
+    AddSocket(socketSet, clientResult->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
     //--------------------------------------------------------------------------------------
 
@@ -219,7 +185,8 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
-        // TODO: Update your variables here
+        if (connected) UpdateNetwork();
+        //else NetworkConnect();
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -227,9 +194,8 @@ int main(void)
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
-
-            if (connected) UpdateNetwork();
-            else NetworkConnect();
+            
+            // TODO: Draw relevant connection info
 
         EndDrawing();
         //----------------------------------------------------------------------------------
@@ -237,7 +203,9 @@ int main(void)
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    CloseWindow();        // Close window and OpenGL context
+    CloseNetworkDevice();   // Close network communication
+    
+    CloseWindow();          // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;

examples/network/network_resolve_host.c

@@ -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)
 *   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 screenHeight = 450;
 
-    InitWindow(screenWidth, screenHeight, "raylib [network] example - ping pong");
+    InitWindow(screenWidth, screenHeight, "raylib [network] example - resolve host");
     
-    char buffer[ADDRESS_IPV6_ADDRSTRLEN];
-    uint16_t port = 0;
+    InitNetworkDevice();    // Init network communications
     
-    SetTraceLogLevel(LOG_DEBUG);
-
+    char buffer[ADDRESS_IPV6_ADDRSTRLEN];
+    unsigned short port = 0;
 
-    // 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_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
-    );
+    AddressInformation *address = AllocAddressList(1);
+    
+    // Address info 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
+    int count = ResolveHost(NULL, "5210", ADDRESS_TYPE_IPV4, 0, address);
 
     if (count > 0)
     {
-        GetAddressHostAndPort(addr[0], buffer, &port);
+        GetAddressHostAndPort(address[0], buffer, &port);
         TraceLog(LOG_INFO, "Resolved to ip %s::%d", buffer, port);
     }
 
@@ -70,7 +61,7 @@ int main(void)
 
             ClearBackground(RAYWHITE);
 
-            DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
+            // TODO: Draw relevant connection info
 
         EndDrawing();
         //----------------------------------------------------------------------------------
@@ -78,7 +69,9 @@ int main(void)
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    CloseWindow();        // Close window and OpenGL context
+    CloseNetworkDevice();   // Close network communication
+    
+    CloseWindow();          // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;

examples/network/network_tcp_client.c

@@ -1,151 +1,142 @@
 /*******************************************************************************************
- *
- *   raylib [network] example - TCP Client
- *
- *   Welcome to raylib!
- *
- *   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
- *
- *   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)
- *
- ********************************************************************************************/
+*
+*   raylib [network] example - TCP Client
+*
+*   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)
+*
+*   Copyright (c) 2019-2020 Jak Barnes (@syphonx) and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
 
 #include "raylib.h"
+
+#define RNET_IMPLEMENTATION
 #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;
-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()
+int main(void)
 {
-    // Check if we're connected every _delay_ seconds
-    elapsed += GetFrameTime();
-    if (elapsed > delay) {
-        if (IsSocketConnected(client_res->socket)) { connected = true; }
-        elapsed = 0.0f;
-    }
-}
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
-// Once connected to the network, check the sockets for pending information
-// 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);
-    }
+    InitWindow(screenWidth, screenHeight, "raylib [network] example - tcp client");
 
-    // 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);
-    }
+    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;
+    bool connected = false;
 
-    // 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; }
-    }
+    SocketConfig clientConfig = {
+        .host = "127.0.0.1", 
+        .port = "4950", 
+        .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
-    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);
+    // 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 
+    {
+        if (!(clientConfig.type == SOCKET_UDP)) 
+        {
+            if (!SocketConnect(&clientConfig, clientResult)) TraceLog(LOG_WARNING, "Failed to connect to server: status %d, errno %d", clientResult->status, clientResult->socket->status);
         }
-        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 and add sockets to the socket set
+    socketSet = AllocSocketSet(1);
+    AddSocket(socketSet, clientResult->socket);
 
-    //  Create & Add sockets to the socket set
-    socket_set = AllocSocketSet(1);
-    msglen     = strlen(pingmsg) + 1;
-    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
-    while (!WindowShouldClose()) {
-        BeginDrawing();
-        ClearBackground(RAYWHITE);
-        if (connected) {
-            NetworkUpdate();
-        } else {
-            NetworkConnect();
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (connected)
+        {
+            // 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();
+        //----------------------------------------------------------------------------------
     }
 
-    // Cleanup
-    CloseWindow();
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseNetworkDevice();   // Close network communication
+    
+    CloseWindow();          // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
     return 0;
 }

examples/network/network_tcp_server.c

@@ -1,165 +1,162 @@
 /*******************************************************************************************
- *
- *   raylib [network] example - TCP Server
- *
- *   Welcome to raylib!
- *
- *   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
- *
- *   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)
- *
- ********************************************************************************************/
+*
+*   raylib [network] example - TCP Server
+*
+*   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)
+*
+*   Copyright (c) 2019-2020 Jak Barnes (@syphonx) and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
 
 #include "raylib.h"
+
+#define RNET_IMPLEMENTATION
 #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;
-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 main(void)
 {
-    int active = CheckSockets(socket_set, 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(server_res->socket, &connection_cfg)) != NULL) {
-            AddSocket(socket_set, connection);
-            ping      = true;
-            connected = true;
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [network] example - tcp server");
+
+    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;
+    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;
+    SocketSet *socketSet = NULL;
+    SocketResult *serverResult = 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);
+        } 
+        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);
+            }
         }
     }
-}
 
-// Once connected to the network, check the sockets for pending information
-// 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);
-    }
+    // Create and add sockets to the socket set
+    socketSet = AllocSocketSet(2);
+    AddSocket(socketSet, serverResult->socket);
 
-    // IsSocketReady
-    //
-    // If the socket is ready, attempt to receive data from the socket
-    int bytesRecv = 0;
-    if (IsSocketReady(connection)) {
-        bytesRecv = SocketReceive(connection, recvBuffer, msglen);
-    }
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
 
-    // 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; }
-    }
+    // 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
+            // and when information is ready, send either a Ping or a Pong.
 
-    // 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, msglen);
-        } else if (pong) {
-            pong = false;
-            SocketSend(connection, pongmsg, msglen);
-        }
-        elapsed = 0.0f;
-    }
-}
+            // 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);
 
-int main()
-{
-    // Setup
-    int screenWidth  = 800;
-    int screenHeight = 450;
-    InitWindow(
-        screenWidth, screenHeight, "raylib [network] example - tcp server");
-    SetTargetFPS(60);
-    SetTraceLogLevel(LOG_DEBUG);
-
-    // Networking
-    InitNetwork();
-
-    //  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);
+            // 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);
 
-    //  Create & Add sockets to the socket set
-    socket_set = AllocSocketSet(2);
-    msglen     = strlen(pingmsg) + 1;
-    memset(recvBuffer, '\0', sizeof(recvBuffer));
-    AddSocket(socket_set, server_res->socket);
+            if (active > 0) 
+            {
+                if ((connection = SocketAccept(serverResult->socket, &connectionConfig)) != NULL) 
+                {
+                    AddSocket(socketSet, connection);
+                    connected = true;
+                    ping = true;
+                }
+            }
+        }
+        //----------------------------------------------------------------------------------
 
-    // Main game loop
-    while (!WindowShouldClose()) {
+        // Draw
+        //----------------------------------------------------------------------------------
         BeginDrawing();
-        ClearBackground(RAYWHITE);
-        if (connected) {
-            NetworkUpdate();
-        } else {
-            NetworkConnect();
-        }
+
+            ClearBackground(RAYWHITE);
+            
+            // TODO: Draw relevant connection info
+
         EndDrawing();
+        //----------------------------------------------------------------------------------
     }
 
-    // Cleanup
-    CloseWindow();
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseNetworkDevice();   // Close network communication
+    
+    CloseWindow();          // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
     return 0;
 }

examples/network/network_test.c

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

examples/network/network_udp_client.c

@@ -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)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
@@ -14,65 +14,6 @@
 #define RNET_IMPLEMENTATION
 #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)
 {
     // Initialization
@@ -82,27 +23,37 @@ int main(void)
 
     InitWindow(screenWidth, screenHeight, "raylib [network] example - udp client");
 
-    InitNetworkDevice();
-
-    // 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);
+    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;
+
+    SocketConfig clientConfig = {
+        .host = "127.0.0.1", 
+        .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
-    socket_set = AllocSocketSet(1);
-    msglen     = strlen(pingmsg) + 1;
-    ping       = true;
-    memset(recvBuffer, '\0', sizeof(recvBuffer));
-    AddSocket(socket_set, client_res->socket);
+    //  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
     //--------------------------------------------------------------------------------------
@@ -112,7 +63,42 @@ int main(void)
     {
         // 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
@@ -120,6 +106,8 @@ int main(void)
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
+            
+            // TODO: Draw relevant connection info
 
         EndDrawing();
         //----------------------------------------------------------------------------------
@@ -127,9 +115,9 @@ int main(void)
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    CloseNetworkDevice(); // Close network
+    CloseNetworkDevice();   // Close network communication
     
-    CloseWindow();        // Close window and OpenGL context
+    CloseWindow();          // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;

examples/network/network_udp_server.c

@@ -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)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
@@ -14,66 +14,6 @@
 #define RNET_IMPLEMENTATION
 #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)
 {
     // Initialization
@@ -83,30 +23,37 @@ int main(void)
 
     InitWindow(screenWidth, screenHeight, "raylib [network] example - udp server");
 
-    InitNetworkDevice();
-
-    //  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);
-    }
-
-    //  Create & Add sockets to the socket set
-    socket_set = AllocSocketSet(1);
-    msglen = strlen(pingmsg) + 1;
-    memset(recvBuffer, '\0', sizeof(recvBuffer));
-    AddSocket(socket_set, server_res->socket);
+    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;
+
+    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
     //--------------------------------------------------------------------------------------
@@ -116,7 +63,46 @@ int main(void)
     {
         // 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
@@ -125,7 +111,7 @@ int main(void)
 
             ClearBackground(RAYWHITE);
 
-            
+            // TODO: Draw relevant connection info
 
         EndDrawing();
         //----------------------------------------------------------------------------------
@@ -133,7 +119,9 @@ int main(void)
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    CloseWindow();        // Close window and OpenGL context
+    CloseNetworkDevice();   // Close network communication
+    
+    CloseWindow();          // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;

src/rnet.h

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