I don't understand cmake well enough to follow a single step apparently:

This driver requires the code to be compiled with emscripten.

emcmake cmake -DRAYLIB_LIBRARY_PATH=<path to raylib lib file> -DRAYLIB_INCLUDE_PATH=<path to raylib headers folder> .

So I do:
emcmake cmake -DRAYLIB_LIBRARY_PATH="../../../raylib-web/src/libraylib.a"
-DRAYLIB_INCLUDE_PATH="../../../raylib-web/src/" .

It can find the headers but gives me this even though it exists:
cannot find -l../../../raylib-web/src/libraylib.a: No such file or directory

Isn't it supposed to be -lraylib anyway? Regardless after hours of trying nothing works...

PS: I'm on windows with mingw makefiles

There is currently no way to cleanly disconnect from the server on the client side: you can just stop the client and the server will detect the disconnection after a few seconds as packets will no longer be received.

The idea is to add a function to the client API that attempts to clean disconnection by sending a specific (library reserved) message (reliably) from the client to the server. Upon reception, the server should probably just close the connection.

On the client side it might be needed to add a "disconnecting" to probably handle the amount of time between sending the disconnection message and actually being disconnected.

This is the result when testing rapid page reloads on the Raylib example project:
RuntimeError: abort(TypeError: Cannot read property 'error' of undefined) at Error
at jsStackTrace (E:\Git\C++\nbnetlatest\examples\raylib\server.js:1:41013)
at stackTrace (E:\Git\C++\nbnetlatest\examples\raylib\server.js:1:41189)
at process.abort (E:\Git\C++\nbnetlatest\examples\raylib\server.js:1:25525)
at process.emit (events.js:314:20)
at processPromiseRejections (internal/process/promises.js:209:33)
at processTicksAndRejections (internal/process/task_queues.js:98:32)
at process.abort (E:\Git\C++\nbnetlatest\examples\raylib\server.js:1:25556)
at process.emit (events.js:314:20)
at processPromiseRejections (internal/process/promises.js:209:33)
at processTicksAndRejections (internal/process/task_queues.js:98:32)

My guess is that an NBN_Connection is being referenced after being cleared to an undefined value.

When using NBNet's WebRTC driver compiled through emscripten and running inside nodejs, a connecting Firefox client will cause the game server to crash.
Unfortunately the server error logs don't provide any clues, nor does the firefox javascript console.

If I had to guess, it seems most likely to be a protocol issue in the WebRTC handshake.

On all tested platforms except for OSX, there is a segfault when calling NBN_GameClient_Deinit or NBN_GameServer_Deinit. For now, it was only reproduced with the soak test but I believe it's a library issue.

CodeFactor found multiple issues:

Complex Code

• nbnet.h

'reject' is defined but never used.

• net_drivers\webrtc\js\standalone\signaling_server.js:11

'_' is defined but never used.

• net_drivers\webrtc\js\api.js:110
• net_drivers\webrtc\js\api.js:44
• net_drivers\webrtc\js\standalone\signaling_client.js:75

'ev' is defined but never used.

• net_drivers\webrtc\js\standalone\signaling_client.js:21

Useless cat. Consider 'cmd < file | ..' or 'cmd file | ..' instead.

• bin\travis\run_soak.sh:29

'err' is defined but never used.

• net_drivers\webrtc\js\game_client.js:46

'options' is assigned a value but never used.

• net_drivers\webrtc\js\logger.js:28

Calling NBN_GameServer_Start or NBN_GameClient_Start after calling NBN_GameServer_Stop and NBN_GameClient_Stop, respectively, causes a segfault when allocating memory for pooling.

To reproduce the bug, put the calls in a RAII class/struct like so:

struct GameServer
{
    GameServer() { NBN_GameServer_Start(PROTOCOL_NAME, PORT, false); }
    ~GameServer() { NBN_GameServer_Stop(); }
};

Then in the main loop (using raylib):

// For simplicity's sake, I use GameServer here
// but should be an interface to switch between GameServer or GameClient
std::unique_ptr<GameServer> networkState; 

// Other code

while (!window.ShouldClose())
{
    // Other code

    // Toggle the network state using F1
    if ( IsKeyPressed(KEY_F1) )
    {
        if (networkState)
            networkState.reset();
        else
            networkState.reset(new GameServer());
    }
    // Rest of the code
}

Pressing F1 thrice should give a segfault.

__NBN_Connection is big enough (a little above 1 MB per connection) that it doesn't fit into the L2 cache of many systems.

A quick look into a frequently called function like Connection_ReadNextMessageFromStream shows that channels and endpoint are accessed often and immediately after each other, however, their positions in the struct are very far apart. On my Linux 64b system they look like this:

(gdb) p offsetof(NBN_Connection, channels)
$1 = (NBN_Channel *(*)[32]) 0x107318

(gdb) p offsetof(NBN_Connection, endpoint)
$2 = (struct __NBN_Endpoint **) 0x30

More than a MB apart. I believe this is introducing cache misses and impacting performance. The fix is very straightforward: move frequently used members of the struct closer together.

According to https://en.cppreference.com/w/c/language/identifier

The following identifiers are reserved and may not be declared in a program (doing so invokes undefined behavior): 
[...]
2. All external identifiers that begin with an underscore.
3. All identifiers that begin with an underscore followed by a capital letter or by another underscore (these reserved identifiers allow the library to use numerous behind-the-scenes non-external macros and functions).

Identifiers like those in extern NBN_MemoryManager __mem_manager (violates 2., 3.) or struct __NBN_Connection { ... }; (violates 3.) could cause the compiler to see adjacent code as UB and optimize it in a destructive way.

Hey nathhB,

I wanted to read the documentation since I need some extra information additionally to the examples.
The link in the github https://nbnet.docsforge.com/ is not working anymore unfortunately.
Would you be able to provide a new link?
Thanks!

Best,

Richard

Those two examples do not work on windows because of the Sleep function conflicting with winapi.

Also, the examples need to be compiled with -lwsock2 so this should be stated in the README.

I compiled and run the echo programs with MinGW and got this assertion:

Assertion failed!

Program: C:\<path>\nbnet\examples\echo\build\echo_server.exe
File: C:\<path>\nbnet\examples\echo\server.c, Line 135

Expression: NBN_GameServer_GetDisconnectedClient() == client

I think the error is inside NBN_GameServer_GetDisconnectedClient because for my other program the client returned by NBN_GameServer_GetDisconnectedClient is always not inside my clients.

Thank you for your time and for this amazing project,

Flayme

Hello, the second parameter of NBN_GameClient_Start can not be domain name:
int NBN_GameClient_Start(const char *protocol_name, const char *ip_address, uint16_t port, bool encryption, uint8_t *connection_data)

So if I try to use it like:
NBN_GameClient_Start(EXAMPLE_PROTOCOL_NAME, "localhost", SERVER_PORT, false, NULL)

It fails: ERROR: Failed to resolve IP address from localhost

It means only dotted IP address is supported. Could you make it support domain name? Thank you!

At the moment I use a static array on the game server to store client connections. I believe it's not great because:

• it limits the number of clients that can be connected at the same time
• in the UDP driver, I do a linear search to find the connection based on the IP address every time a packet is received
• in the WebRTC driver I use the NBN_GameServer_FindClientById method which also does a linear search by connection ID

Linear search if far from optimal and it's done every time a packet is received by a driver. I believe a better solution would be to use a hashmap (or another suitable data structure) instead of an array (in nbnet core) and let the drivers compute the hashes themselves as they might have different ways of storing/retrieving connections from this hashmap.

Here is are the relevant sources:

NBN_GameServer_FindClientById

FindClientConnectionByAddress

Summary

Sending too many messages too quickly appears to trigger an assert that should probably be a condition check + error return. The assert message from nbnet.h @ commit 4df322c running on MacOS is:

Assertion failed: (outgoing_message->ref_count == 0), function Endpoint_CreateOutgoingMessage, file nbnet.h, line 4839.
Abort trap: 6

Looking at nbnet.h, the offending assert can be found here within Endpoint_CreateOutgoingMessage:

    assert(outgoing_message->ref_count == 0); // problem with outgoing message pool

In this case, I think that the message pool has run out of space, and has not had the ability to recycle the message (although I could be wrong about that). In this case, I think Endpoint_CreateOutgoingMessage should return an error condition (return NULL?) instead of aborting, since running out of messages is a valid error case. This scenario was discovered during a refactor of a work-in-progress game where my server was sending messages at a much faster rate than the client was able to process them (the server had no sleep or equivalent function in its main-loop).

Example Code

shared.h

#ifndef SHARED_H
#define SHARED_H

#define NBN_LogInfo(...) /* nothing */
#define NBN_LogError(...) /* nothing */
#define NBN_LogDebug(...) /* nothing */
#define NBN_LogTrace(...) /* nothing */
#define NBN_LogWarning(...) /* nothing */

#include "nbnet.h"
#include "net_drivers/udp.h"

#define NAME "test"
#define ADDR "127.0.0.1"
#define PORT 31415
#define BUSY_CODE 42

#define MESSAGE_TYPE 0
#define MESSAGE_LENGTH 255
struct message {
    unsigned int length;
    char data[MESSAGE_LENGTH];
};

struct message* message_create(void);
void message_destroy(struct message* self);
int message_serialize(struct message* self, NBN_Stream* stream);

#endif /* SHARED_H */

shared.c

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "shared.h"

struct message*
message_create(void)
{
    return malloc(sizeof(struct message));
}

void
message_destroy(struct message* self)
{
    free(self);
}

int
message_serialize(struct message* self, NBN_Stream *stream)
{
    NBN_SerializeUInt(stream, self->length, 0, MESSAGE_LENGTH);
    NBN_SerializeBytes(stream, self->data, self->length);
    return 0;
}

client.c

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#define NBNET_IMPL
#include "shared.h"

int
main(int argc, char** argv)
{
    NBN_UDP_Register();
    if (NBN_GameClient_StartEx(NAME, ADDR, PORT, false, NULL, 0) < 0) {
        fprintf(stderr, "error: failed to start client\n");
        exit(EXIT_FAILURE);
    }

    NBN_GameClient_RegisterMessage(
        MESSAGE_TYPE,
        (NBN_MessageBuilder)message_create,
        (NBN_MessageDestructor)message_destroy,
        (NBN_MessageSerializer)message_serialize);

    bool connected = false;
    bool running = true;
    while (running) {
        int ev = -1;
        while ((ev = NBN_GameClient_Poll()) != NBN_NO_EVENT) {
            if (ev < 0) {
                fprintf(stderr, "error: failed to poll event\n");
                running = false;
                break;
            }

            if (ev == NBN_CONNECTED) {
                fprintf(stderr, "info: connected\n");
                connected = true;
            }

            if (ev == NBN_DISCONNECTED) {
                fprintf(stderr, "info: disconnected\n");
                connected = false;
                running = false;
                if (NBN_GameClient_GetServerCloseCode() == BUSY_CODE) {
                    fprintf(stderr, "error: another client is already connected\n");
                }
                break;
            }

            if (ev == NBN_MESSAGE_RECEIVED) {
                fprintf(stderr, "info: message received\n");
                NBN_MessageInfo info = NBN_GameClient_GetMessageInfo();
                assert(info.type == MESSAGE_TYPE);
                struct message *received = (struct message *)info.data;
                fprintf(stderr, "incoming message: %.*s (%u bytes)\n", (int)received->length, received->data, received->length);
                message_destroy(received);
            }
        }

        if (NBN_GameClient_SendPackets() < 0) {
            fprintf(stderr, "error: failed to send packets\n");
            running = false;
            break;
        }
    }

    NBN_GameClient_Stop();
    return 0;
}

server.c

#include <ctype.h>
#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

#define NBNET_IMPL
#include "shared.h"

int
main(void)
{
    NBN_UDP_Register();
    if (NBN_GameServer_StartEx(NAME, PORT, false) < 0) {
        fprintf(stderr, "error: failed to start the server\n");
        exit(EXIT_FAILURE);
    }
    NBN_GameServer_RegisterMessage(
        MESSAGE_TYPE,
        (NBN_MessageBuilder)message_create,
        (NBN_MessageDestructor)message_destroy,
        (NBN_MessageSerializer)message_serialize);

    NBN_ConnectionHandle client = 0;
    while (true) {
        int ev = -1;
        while ((ev = NBN_GameServer_Poll()) != NBN_NO_EVENT) {
            if (ev < 0) {
                fprintf(stderr, "error: failed to poll event\n");
                break;
            }

            if (ev == NBN_NEW_CONNECTION) {
                fprintf(stderr, "info: new connection\n");
                if (client != 0) {
                    NBN_GameServer_RejectIncomingConnectionWithCode(BUSY_CODE);
                }
                else {
                    client = NBN_GameServer_GetIncomingConnection();
                    NBN_GameServer_AcceptIncomingConnection();
                }
            }

            if (ev == NBN_CLIENT_DISCONNECTED) {
                fprintf(stderr, "info: disconnected\n");
                assert(NBN_GameServer_GetDisconnectedClient() == client);
                client = 0;
            }
        }

        // This message is sent every server-side game tick!!!
        if (client != 0) {
            char const* const str = "HELLO";
            size_t const len = strlen(str);
            struct message* outgoing = message_create();
            outgoing->length = len;
            memcpy(outgoing->data, str, len);
            NBN_GameServer_SendReliableMessageTo(client, MESSAGE_TYPE, outgoing);
        }

        if (NBN_GameServer_SendPackets() < 0) {
            fprintf(stderr, "error: failed to send packets\n");
            break;
        }
    }

    NBN_GameServer_Stop();
    return 0;
}

The server.c is running on 0.0.0.0 by default which is causing issues with internal/external ips

nbnet's native WebRTC driver uses two external libraries: facil.io for web sockets for WebRTC signaling and libdatachannel for WebRTC data channels. libdatachannel provides web socket support, so it should be possible to use only libdatachannel instead of relying on facil.io. This would reduce the dependencies and simplify things.

This issue is just a recommendation. I think nbnet deserves some catchy logo to get more identity and become more popular.

I can propose something if you want.