server.c

Example of sending and receiving GWY objects over a network stream. This is the server part which listens to requests and answers them.

/*
 * $Id: clientserver.h 351 2021-08-30 13:55:14Z yeti-dn $
 *
 * This file provides some common functions for client.c and server.c.
 *
 * I, the copyright holder of this work, release this work into the public
 * domain.  This applies worldwide.  In some countries this may not be legally
 * possible; if so: I grant anyone the right to use this work for any purpose,
 * without any conditions, unless such conditions are required by law.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <unistd.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/types.h>
#include "gwyfile.h"
 
static void
ensure_buffer_size(char **buffer, size_t *bufsize, size_t len)
{
    if (len <= *bufsize)
        return;
 
    if (2*(*bufsize) >= len)
        *bufsize *= 2;
    else
        *bufsize = len;
 
    *buffer = realloc(*buffer, *bufsize);
}
 
#ifdef __GNUC__
__attribute__((unused))
#endif
static GwyfileObject*
recv_gwyfile_message(int sock, char **buffer, size_t *bufsize, int *err)
{
    GwyfileError *error = NULL;
    GwyfileObject *message;
    size_t objsize, len = 0;
    ssize_t read_size;
 
    /* Purposedly make the buffer small at the beginning. */
    if (!*bufsize || !*buffer)
        ensure_buffer_size(buffer, bufsize, 16);
 
    *err = -1;
    printf("Trying to read %u bytes.\n", (unsigned)(*bufsize - len));
    while ((read_size = read(sock, *buffer + len, *bufsize - len)) > 0) {
        printf("Read %ld bytes from socket %d\n", (long int)read_size, sock);
        len += read_size;
        /* Process the message we have in the buffer. */
        if (!(message = gwyfile_object_read_memory(*buffer, len, &objsize, &error))) {
            assert(error);
            if (error->domain == GWYFILE_ERROR_DOMAIN_DATA && error->code == GWYFILE_ERROR_TRUNCATED) {
                /* There is an incomplete message. */
                gwyfile_error_clear(&error);
                if (len == *bufsize) {
                    ensure_buffer_size(buffer, bufsize, 2*(*bufsize));
                    fprintf(stderr, "Enlarging buffer to %lu.\n", (unsigned long)(*bufsize));
                }
                continue;
            }
            else {
                fprintf(stderr, "Failed to read message. %s\n", error->message);
                fprintf(stderr, "Giving up.\n");
                gwyfile_error_clear(&error);
                return NULL;
            }
        }
        printf("Obtained message of %lu bytes\n", (unsigned long int)objsize);
        *err = 0;
        return message;
    }
    /* If either read_size < 0 or we have still something in buffer then an error occurred. */
    if (read_size < 0) {
        fprintf(stderr, "recv() failed: %s.\n", strerror(errno));
        return NULL;
    }
    else if (len > 0) {
        fprintf(stderr, "Incomplete message.\n");
        return NULL;
    }
 
    /* Returning NULL with zero error means there is simply nothing more to read. */
    *err = 0;
    return NULL;
}
 
#ifdef __GNUC__
__attribute__((unused))
#endif
static GwyfileObject*
recv_gwyfile_message2(int sock, char **buffer, size_t *bufsize, size_t *have_bytes, int *err)
{
    GwyfileError *error = NULL;
    GwyfileObject *message;
    size_t objsize;
    ssize_t read_size;
    int first_try = 1;
 
    /* Purposedly make the buffer small at the beginning. */
    if (!*bufsize || !*buffer)
        ensure_buffer_size(buffer, bufsize, 16);
 
    while (1) {
        if (!first_try || !*have_bytes) {
            printf("Trying to read %u bytes.\n", (unsigned)(*bufsize - *have_bytes));
            if ((read_size = read(sock, *buffer + *have_bytes, *bufsize - *have_bytes)) <= 0)
                break;
            printf("Read %ld bytes from socket %d\n", (long int)read_size, sock);
            *have_bytes += read_size;
        }
        else {
            printf("Trying to use the %lu bytes left in buffer.\n", (unsigned long int)(*have_bytes));
        }
        /* Process the message we have in the buffer. */
        if ((message = gwyfile_object_read_memory(*buffer, *have_bytes, &objsize, &error))) {
            printf("Obtained message of %lu bytes (%lu bytes remaining)\n",
                   (unsigned long int)objsize, (unsigned long int)(*have_bytes - objsize));
            /* Handled piece-wise objects by keeping whatever extra data we received in the buffer. */
            memmove(*buffer, *buffer + objsize, *have_bytes - objsize);
            *have_bytes -= objsize;
            *err = 0;
            return message;
        }
        assert(error);
        if (!(error->domain == GWYFILE_ERROR_DOMAIN_DATA && error->code == GWYFILE_ERROR_TRUNCATED))
            goto bad_message;
        /* There is an incomplete message.  If it is incomplete because we would block, just pass it up.
         * Otherwise enlarge the buffer. */
        gwyfile_error_clear(&error);
        if (*have_bytes == *bufsize) {
            ensure_buffer_size(buffer, bufsize, 2*(*bufsize));
            fprintf(stderr, "Enlarging buffer to %lu.\n", (unsigned long)(*bufsize));
        }
        first_try = 0;
    }
    /* If either read_size < 0 or we have still something in buffer then an error occurred. */
    *err = errno;
    if (read_size < 0) {
        fprintf(stderr, "recv() failed: %s.\n", strerror(errno));
        return NULL;
    }
    if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR) {
        *err = EAGAIN;
        fprintf(stderr, "Incomplete message so far.\n");
        return NULL;
    }
 
    /* Returning NULL with zero error means there is simply nothing more to read. */
    if (errno)
        fprintf(stderr, "We got zero from recv() with unexpected error %s.\n", strerror(errno));
    return NULL;
 
bad_message:
    fprintf(stderr, "Failed to read message. %s\n", error->message);
    fprintf(stderr, "Giving up.\n");
    gwyfile_error_clear(&error);
    *err = EINVAL;
    return NULL;
}
 
#ifdef __GNUC__
__attribute__((unused))
#endif
static int
send_gwyfile_message(GwyfileObject *message, int sock, char **buffer, size_t *bufsize)
{
    ssize_t pos, write_size;
    size_t len;
 
    len = gwyfile_object_size(message);
    ensure_buffer_size(buffer, bufsize, len);
    len = gwyfile_object_write_memory(message, *buffer, *bufsize, NULL);
    assert(len);
    pos = 0;
    while (len > 0) {
        write_size = write(sock, *buffer + pos, len);
        if (write_size < 0) {
            int saved_errno = errno;
            fprintf(stderr, "send() failed: %s.\n", strerror(errno));
            errno = saved_errno;
            return -1;
        }
        len -= write_size;
        pos += write_size;
    }
 
    return 0;
}
 
/* vim: set cin et ts=4 sw=4 columns=120 tw=119 cino=>1s,e0,n0,f0,{0,}0,^0,\:1s,=0,g1s,h0,t0,+1s,c3,(0,u0 : */

/*
 * $Id: server.c 396 2023-02-08 14:03:53Z yeti-dn $
 *
 * This example is the server for client.c.  It shows how to answer queries using libgwyfile as a serialisation
 * framework.
 *
 * I, the copyright holder of this work, release this work into the public domain.  This applies worldwide.  In some
 * countries this may not be legally possible; if so: I grant anyone the right to use this work for any purpose,
 * without any conditions, unless such conditions are required by law.
 */
#include "clientserver.h"
 
static void           connection_handler(int sock);
static GwyfileObject* answer_to_message (GwyfileObject *message);
 
int
main(int argc, char *argv[])
{
    int portno, socket_desc, client_sock, c = sizeof(struct sockaddr_in);
    struct sockaddr_in server, client;
 
    if (argc < 2) {
        printf("Usage: server PORTNUMBER\n");
        exit(EXIT_SUCCESS);
    }
 
    /* Standard network setup. */
    socket_desc = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_desc == -1) {
        perror("Cannot create socket");
        exit(EXIT_FAILURE);
    }
 
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    portno = atoi(argv[1]);
    server.sin_port = htons(portno);
 
    if (bind(socket_desc, (struct sockaddr *)&server, sizeof(server)) < 0) {
        perror("bind() failed");
        exit(EXIT_FAILURE);
    }
 
    listen(socket_desc, 3);
 
    /* Main loop handling client requests.  It runs indefinitely, i.e. until the process is terminated externally. */
    while ((client_sock = accept(socket_desc, (struct sockaddr*)&client, (socklen_t*)&c)) > 0) {
        printf("Connection accepted.\n");
        /* Normally we would do this in a subprocess or thread.  Do not bother in the example. */
        connection_handler(client_sock);
        close(client_sock);
    }
 
    if (client_sock < 0) {
        perror("accept() failed");
        exit(EXIT_FAILURE);
    }
 
    return 0;
}
 
/* Handle a client connection. */
static void
connection_handler(int sock)
{
    GwyfileObject *message, *answer;
    char *recvbuffer = NULL, *sendbuffer = NULL;
    size_t recvbufsize = 0, sendbufsize = 0, recvlen = 0;
    int err;
 
    /* Receive data from the client.  Use a simple busy wait to block on recv_gwyfile_message2().  */
    while ((message = recv_gwyfile_message2(sock, &recvbuffer, &recvbufsize, &recvlen, &err)) || err == EAGAIN) {
        if (err == EAGAIN)
            continue;
        answer = answer_to_message(message);
        gwyfile_object_free(message);
        /* Random sleep for the spectators.  Otherwise everything happens in an instant. */
        usleep(rand() % 1000000);
        if ((err = send_gwyfile_message(answer, sock, &sendbuffer, &sendbufsize)) < 0) {
            gwyfile_object_free(answer);
            break;
        }
    }
 
    if (err == 0)
        printf("Communication finished successfully.\n\n");
    else
        fprintf(stderr, "Communication failed.\n\n");
 
    free(sendbuffer);
    free(recvbuffer);
}
 
static GwyfileObject*
answer_to_message(GwyfileObject *message)
{
    const char *dont = "I thought I had told you a thousand times that I really do not like ";
    GwyfileObject *answer;
    GwyfileItem *item, *newitem;
    unsigned int nitems, i, len, ll = strlen(dont);
    GwyfileItemType type;
    const char *name, *s;
    char *t;
 
    /* Send something back depending on what we got.  Mostly various modification of the items in the query. */
    answer = gwyfile_object_new("MSG", NULL);
    nitems = gwyfile_object_nitems(message);
    for (i = 0; i < nitems; i++) {
        item = gwyfile_object_get_nth(message, i);
        type = gwyfile_item_type(item);
        name = gwyfile_item_name(item);
        newitem = NULL;
        if (type == GWYFILE_ITEM_INT32)
            newitem = gwyfile_item_new_int32(name, 2*gwyfile_item_get_int32(item));
        else if (type == GWYFILE_ITEM_DOUBLE)
            newitem = gwyfile_item_new_double(name, -gwyfile_item_get_double(item));
        else if (type == GWYFILE_ITEM_BOOL)
            newitem = gwyfile_item_new_bool(name, !gwyfile_item_get_bool(item));
        else if (type == GWYFILE_ITEM_INT64) {
            char hexbuf[8*2+3];
            snprintf(hexbuf, sizeof(hexbuf), "0x%016lx", (unsigned long)gwyfile_item_get_int64(item));
            newitem = gwyfile_item_new_string_copy(name, hexbuf);
        }
        else if (type == GWYFILE_ITEM_STRING) {
            s = gwyfile_item_get_string(item);
            len = strlen(s);
            t = malloc(len + ll + 1);
            memcpy(t, dont, ll);
            memcpy(t + ll, s, len+1);
            newitem = gwyfile_item_new_string(name, t);
        }
        else if (type == GWYFILE_ITEM_DOUBLE_ARRAY) {
            /* Since @message can be freed before we send back the response, take the ownership of the data array. */
            if (gwyfile_item_owns_data(item)) {
                double *data = gwyfile_item_take_double_array(item);
                unsigned int j, n = gwyfile_item_array_length(item);
                for (j = 0; j < n; j++)
                    data[i] *= 2.0;
                /* This is slightly reckless as we completely transfer ownership and data[] is allowed to be freed
                 * immediately in gwyfile_item_new_double_array(). Nothing in Gwyfile is going to actually accesss (or
                 * free) the data in @item, but the possibly dangling pointer will be lying around. */
                newitem = gwyfile_item_new_double_array(name, data, n);
            }
            else {
                fprintf(stderr, "Cannot take ownership of double array item %s.\n", name);
            }
        }
 
        if (newitem)
            gwyfile_object_add(answer, newitem);
    }
 
    return answer;
}
 
/* vim: set cin et ts=4 sw=4 columns=120 tw=119 cino=>1s,e0,n0,f0,{0,}0,^0,\:1s,=0,g1s,h0,t0,+1s,c3,(0,u0 : */