lserver

This library includes a linux server implementation, and a client one.

It uses my other libraries (socket, buffer and lvector) to run.

Each lclient_t is usable in each index of server.clients.arr[i].

Each struct poll_event::data.ptr member is a client_t *

You can use the lvector_foreach API to loop in it

Everything is readable in it. The buffer is writeable using the cbuffer_t API on client->buffer.

Lserver example:

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

#include <lserver.h>

static void say_hi(lserver_t *server, lclient_t *client, uint16_t port, void *userdata)
{
	printf("Say hi to '%s' who joined the server on port %u\n", inet_ntoa(client->socket.saddr.sin_addr), port);
}

static void say_goodbye(lserver_t *server, lclient_t *client, void *userdata)
{
	printf("'%s' left the server, goodbye !\n", inet_ntoa(client->socket.saddr.sin_addr));
}

int main(void)
{
  lserver_t server = {0};
  uint16_t ports[] = {
      2121,
      5555,
  };
  struct lserver_config config = {
	  .ports = ports,
	  .ports_count = 2,
	  .client_buffer_size = 65536,
	  .cbs.on_connect_callback = &say_hi,
	  .cbs.on_connect_userdata = NULL,
	  .cbs.on_disconnect_callback = &say_goodbye,
	  .cbs.on_disconnect_userdata = NULL,
	  .backlog = 5
  };
  lclient_t *ptr;
  char *line;

  /* Start the server on port 2121 and 5555, each client will have a circular buffer of 65536 bytes */
  if (lserver_create(&server, &config) == -1) {
    fprintf(stderr, "Failed to start server\n");
    return (-1);
  }

  while (1) {
    /* Gives 100 miliseconds to the server to update */
    lserver_update(&server, 100);

		/* For each event in the server read events */
    lvector_foreach(evt, server.revents) {
      /* implicit cast of the union in 'struct poll_event' into a 'lclient_t *' */
      ptr = evt->data.ptr;

      /* Read from the client buffer and store each byte into <line> until a "\n" is encountered */
      ssize_t rd = lbuffer_getbytes(&ptr->buffer, &line, "\n");

      /* on 'lbuffer_getbytes()' success */
      if (rd > 0) {
        /* removes the \n */
        rd -= 1;
        line[rd] = '\0';

        /* print the length of the line and the line itself */
        printf("Client: [%zd] \"%s\"\n", rd, line);

        /* answer to the client */
        dprintf(ptr->socket.fd, "Hello !");
      }

      /* Since 'lbuffer_getbytes()' uses MALLOC(3) to set 'line' value, it needs to be freed */
      free(line);
    }
  }

  /* Destroy the server, eject all clients, close all listeners, clean all buffers, free all memory */
  lserver_destroy(&server);
  return (0);
}

The other part of the library, which is partially used in the server part, includes a client implementation.

int main(void)
{
  lclient_t client;
  char *output;

  /* Connect the client on the address specified as 3rd parameter on port `2121`, with a circular buffer of `4096` bytes
  ** an other function: `lclient_connect32()`, takes a `uint32_t` as ip address
  */
  lclient_create(&client, 4096, "localhost", 2121);

  /* Reads from the server and store the read bytes into the client's circular buffer and returns the amount of bytes read */
  lclient_update(&client, 100); /* We give 100 milliseconds as timeout to the function */

  /* Retrieve each bytes of the buffer, allocate enough space and copy them into the given pointer */
  lbuffer_retrieve(&client.buffer, &output);

  /* simply printf the output, we expect a human readable null-terminated string */
  printf("%s\n", output);

  /* `lbuffer_retrieve()` uses MALLOC(3), we need to `free()` it */
  free(output);

  /* destroy the client, close the connection and free allocated memory */
  lclient_destroy(&client);
  return (0);
}