libunixsocket.c

Go to the documentation of this file.

#ifndef _GNU_SOURCE
#define _GNU_SOURCE  // accept4()
#endif

#include <conf.h>

#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>  // UNIX domain sockets
#include <unistd.h>  // read()/write()

/*
 * Structure of the functions defined here:
 *
 * <Declarations>
 * <Checks on passed arguments>
 * <actual code>
 *
 */

//# define VERBOSE

// Macro definitions

#define LIBSOCKET_BACKLOG 128

#define LIBSOCKET_STREAM 1
#define LIBSOCKET_DGRAM 2

#define LIBSOCKET_READ 1
#define LIBSOCKET_WRITE 2

#define debug_write(str)                \
    {                                   \
        int verbose_errno_save = errno; \
        write(2, str, strlen(str));     \
        errno = verbose_errno_save;     \
    }

static inline signed int check_error(int return_value) {
#ifdef VERBOSE
    const char* errbuf;
#endif
    if (return_value < 0) {
#ifdef VERBOSE
        errbuf = strerror(errno);
        debug_write(errbuf);
#endif
        return -1;
    }

    return 0;
}

static int set_unix_socket_path(struct sockaddr_un* saddr, const char* path_or_name) {
    memset(&saddr->sun_path, 0, sizeof(saddr->sun_path));
    if (path_or_name[0] != 0) {
        strncpy(saddr->sun_path, path_or_name, sizeof(saddr->sun_path) - 1);
    } else {
        // Abstract socket address.
        // Make sure this is not a nulled memory region.
        if (path_or_name[1] == 0) {
            errno = EINVAL;
#ifdef VERBOSE
            debug_write("set_unix_socket_path: Socket address is too many 0s\n");
#endif
            return -1;
        }
        size_t max_len = 1 + strlen(path_or_name+1);
        if (max_len > sizeof(saddr->sun_path) - 1) {
#ifdef VERBOSE
            debug_write("set_unix_socket_path: Abstract socket address is too long\n");
#endif
            errno = ENAMETOOLONG;
            return -1;
        }
        memcpy(saddr->sun_path, path_or_name, max_len);
    }
    return 0;
}

int create_unix_stream_socket(const char* path, int flags) {
    struct sockaddr_un saddr;
    int sfd;

    if (path == NULL) return -1;

    if (-1 == check_error(sfd = socket(AF_UNIX, SOCK_STREAM | flags, 0)))
        return -1;

    memset(&saddr, 0, sizeof(struct sockaddr_un));

    if (strlen(path) > (sizeof(saddr.sun_path) - 1)) {
#ifdef VERBOSE
        debug_write(
            "create_unix_stream_socket: UNIX socket destination path too "
            "long\n");
#endif
        return -1;
    }

    saddr.sun_family = AF_UNIX;
    if (-1 == check_error(set_unix_socket_path(&saddr, path)))
        return -1;
    size_t pathlen = strlen(saddr.sun_path);
    if (pathlen == 0) // likely abstract socket address
        pathlen = sizeof(saddr.sun_path);


    if (-1 == check_error(
                  connect(sfd, (struct sockaddr*)&saddr,
                          sizeof(saddr.sun_family) + pathlen))) {
        close(sfd);
        return -1;
    }

    return sfd;
}

int create_unix_dgram_socket(const char* bind_path, int flags) {
    int sfd, retval;
    struct sockaddr_un saddr;

    if (-1 == check_error(sfd = socket(AF_UNIX, SOCK_DGRAM | flags, 0)))
        return -1;

    memset(&saddr, 0, sizeof(struct sockaddr_un));

    if (bind_path != NULL) {
        if ((retval = unlink(bind_path)) == -1 &&
            errno != ENOENT)  // If there's another error than "doesn't exist"
        {
            check_error(retval);
            return -1;
        }

        if (strlen(bind_path) > (sizeof(saddr.sun_path) - 1)) {
#ifdef VERBOSE
            debug_write(
                "create_unix_dgram_socket: UNIX socket path too long\n");
#endif
            return -1;
        }

        saddr.sun_family = AF_UNIX;
        if (-1 == check_error(set_unix_socket_path(&saddr, bind_path)))
            return -1;

        size_t pathlen = strlen(saddr.sun_path);
        if (pathlen == 0) // likely abstract socket address
            pathlen = sizeof(saddr.sun_path);

        bind(sfd, (struct sockaddr*)&saddr,
             sizeof(saddr.sun_family) + pathlen);
    }

    return sfd;
}

int connect_unix_dgram_socket(int sfd, const char* path) {
    struct sockaddr_un new_addr;
    struct sockaddr deconnect;

    if (sfd < 0) return -1;

    if (path == NULL) {
        memset(&deconnect, 0, sizeof(struct sockaddr));

        deconnect.sa_family = AF_UNSPEC;

        if (check_error(connect(sfd, &deconnect, sizeof(struct sockaddr))))
            return -1;

        return 0;
    }

    memset(&new_addr, 0, sizeof(struct sockaddr_un));

    new_addr.sun_family = AF_UNIX;

    if (strlen(path) > sizeof(new_addr.sun_path) - 1) {
#ifdef VERBOSE
        debug_write("connect_unix_dgram_socket: Path too long\n");
#endif
        return -1;
    }

    if (-1 == check_error(set_unix_socket_path(&new_addr, path))) {
        return -1;
    }

    size_t pathlen = strlen(new_addr.sun_path);
    if (pathlen == 0) // likely abstract socket address
        pathlen = sizeof(new_addr.sun_path);

    if (-1 == check_error(connect(
                  sfd, (struct sockaddr*)&new_addr,
                  sizeof(new_addr.sun_family) + pathlen)))
        return -1;

    return 0;
}

int destroy_unix_socket(int sfd) {
    if (sfd < 0) return -1;

    if (-1 == check_error(close(sfd))) return -1;

    return 0;
}

int shutdown_unix_stream_socket(int sfd, int method) {
    if (sfd < 0) return -1;

    if ((method != LIBSOCKET_READ) && (method != LIBSOCKET_WRITE) &&
        (method != (LIBSOCKET_READ | LIBSOCKET_WRITE)))
        return -1;

    if (method & LIBSOCKET_READ)  // READ is set (0001 && 0001 => 0001)
    {
        if (-1 == check_error(shutdown(sfd, SHUT_RD))) return -1;
    }

    if (method & LIBSOCKET_WRITE)  // WRITE is set (0010 && 0010 => 0010)
    {
        if (-1 == check_error(shutdown(sfd, SHUT_WR))) return -1;
    }

    return 0;
}

int create_unix_server_socket(const char* path, int socktype, int flags) {
    struct sockaddr_un saddr;
    int sfd, type, retval;

    if (path == NULL) return -1;

    if (strlen(path) > (sizeof(saddr.sun_path) - 1)) {
#ifdef VERBOSE
        debug_write("create_unix_server_socket: Path too long\n");
#endif
        return -1;
    }

    switch (socktype) {
        case LIBSOCKET_STREAM:
            type = SOCK_STREAM;
            break;
        case LIBSOCKET_DGRAM:
            type = SOCK_DGRAM;
            break;
        default:
            return -1;
    }

    if (-1 == check_error(sfd = socket(AF_UNIX, type | flags, 0))) return -1;

    if ((retval = unlink(path)) == -1 &&
        errno != ENOENT)  // If there's another error than "doesn't exist"
    {
        check_error(retval);
        return -1;
    }

    memset(&saddr, 0, sizeof(struct sockaddr_un));

    saddr.sun_family = AF_UNIX;

    if (-1 == check_error(set_unix_socket_path(&saddr, path)))
        return -1;

    size_t pathlen = strlen(saddr.sun_path);
    if (pathlen == 0) // likely abstract socket address
        pathlen = sizeof(saddr.sun_path);

    if (-1 ==
        check_error(bind(sfd, (struct sockaddr*)&saddr,
                         sizeof(saddr.sun_family) + pathlen)))
        return -1;

    if (type == SOCK_STREAM) {
        if (-1 == check_error(listen(sfd, LIBSOCKET_BACKLOG))) return -1;
    }

    return sfd;
}

int accept_unix_stream_socket(int sfd, int flags) {
    int cfd;

    if (sfd < 0) return -1;
#if LIBSOCKET_LINUX
    if (-1 == check_error(cfd = accept4(sfd, 0, 0, flags))) return -1;
#else
    if (-1 == check_error(cfd = accept(sfd, 0, 0))) return -1;
#endif
    return cfd;
}

ssize_t recvfrom_unix_dgram_socket(int sfd, void* buf, size_t size, char* from,
                                   size_t from_size, int recvfrom_flags) {
    int bytes;
    socklen_t socksize = sizeof(struct sockaddr_un);
    struct sockaddr_un saddr;

    memset(buf, 0, size);
    memset(from, 0, from_size);

    if (-1 ==
        check_error(bytes = recvfrom(sfd, buf, size, recvfrom_flags,
                                     (struct sockaddr*)&saddr, &socksize)))
        return -1;

    if (from != NULL && from_size > 0) {
        memcpy(from, saddr.sun_path,
               from_size < sizeof(saddr.sun_path) ? from_size
                                                  : sizeof(saddr.sun_path));
    }

    return bytes;
}

ssize_t sendto_unix_dgram_socket(int sfd, const void* buf, size_t size,
                                 const char* path, int sendto_flags) {
    int bytes;
    struct sockaddr_un saddr;

    if (strlen(path) > sizeof(saddr.sun_path) - 1) {
#ifdef VERBOSE
        debug_write(
            "sendto_unix_dgram_socket: UNIX destination socket path too "
            "long\n");
#endif
        return -1;
    }

    memset(&saddr, 0, sizeof(struct sockaddr_un));

    saddr.sun_family = AF_UNIX;
    if (-1 == check_error(set_unix_socket_path(&saddr, path)))
        return -1;

    if (-1 == check_error(bytes = sendto(sfd, buf, size, sendto_flags,
                                         (struct sockaddr*)&saddr,
                                         sizeof(struct sockaddr_un))))
        return -1;

    return bytes;
}

#undef debug_write