bsd-user/bsd-socket.h

/*
 * socket related system call shims
 *
 * Copyright (c) 2013 Stacey D. Son
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */
#ifndef BSD_SOCKET_H
#define BSD_SOCKET_H

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>

#include "qemu-bsd.h"

ssize_t safe_recvfrom(int s, void *buf, size_t len, int flags,
    struct sockaddr *restrict from, socklen_t *restrict fromlen);
ssize_t safe_sendto(int s, const void *buf, size_t len, int flags,
    const struct sockaddr *to, socklen_t tolen);
int safe_select(int nfds, fd_set *readfs, fd_set *writefds, fd_set *exceptfds,
    struct timeval *timeout);
int safe_pselect(int nfds, fd_set *restrict readfds,
    fd_set *restrict writefds, fd_set *restrict exceptfds,
    const struct timespec *restrict timeout,
    const sigset_t *restrict newsigmask);

/* bind(2) */
static inline abi_long do_bsd_bind(int sockfd, abi_ulong target_addr,
                                   socklen_t addrlen)
{
    abi_long ret;
    void *addr;

    if ((int)addrlen < 0) {
        return -TARGET_EINVAL;
    }

    addr = alloca(addrlen + 1);
    ret = target_to_host_sockaddr(addr, target_addr, addrlen);
    if (is_error(ret)) {
        return ret;
    }

    return get_errno(bind(sockfd, addr, addrlen));
}

/* connect(2) */
static inline abi_long do_bsd_connect(int sockfd, abi_ulong target_addr,
                                      socklen_t addrlen)
{
    abi_long ret;
    void *addr;

    if ((int)addrlen < 0) {
        return -TARGET_EINVAL;
    }
    addr = alloca(addrlen + 1);

    ret = target_to_host_sockaddr(addr, target_addr, addrlen);

    if (is_error(ret)) {
        return ret;
    }

    return get_errno(connect(sockfd, addr, addrlen));
}

/* accept(2) */
static inline abi_long do_bsd_accept(int fd, abi_ulong target_addr,
                                     abi_ulong target_addrlen_addr)
{
    socklen_t addrlen;
    void *addr;
    abi_long ret;

    if (target_addr == 0) {
        return get_errno(accept(fd, NULL, NULL));
    }
    /* return EINVAL if addrlen pointer is invalid */
    if (get_user_u32(addrlen, target_addrlen_addr)) {
        return -TARGET_EINVAL;
    }
    if ((int)addrlen < 0) {
        return -TARGET_EINVAL;
    }
    if (!access_ok(VERIFY_WRITE, target_addr, addrlen)) {
        return -TARGET_EINVAL;
    }
    addr = alloca(addrlen);

    ret = get_errno(accept(fd, addr, &addrlen));
    if (!is_error(ret)) {
        if (is_error(host_to_target_sockaddr(target_addr, addr, addrlen))) {
            close(ret);
            ret = -TARGET_EFAULT;
        } else if (put_user_u32(addrlen, target_addrlen_addr)) {
            close(ret);
            ret = -TARGET_EFAULT;
        }
    }
    return ret;
}

/* getpeername(2) */
static inline abi_long do_bsd_getpeername(int fd, abi_ulong target_addr,
                                          abi_ulong target_addrlen_addr)
{
    socklen_t addrlen;
    void *addr;
    abi_long ret;

    if (get_user_u32(addrlen, target_addrlen_addr)) {
        return -TARGET_EFAULT;
    }
    if ((int)addrlen < 0) {
        return -TARGET_EINVAL;
    }
    if (!access_ok(VERIFY_WRITE, target_addr, addrlen)) {
        return -TARGET_EFAULT;
    }
    addr = alloca(addrlen);
    ret = get_errno(getpeername(fd, addr, &addrlen));
    if (!is_error(ret)) {
        ret = host_to_target_sockaddr(target_addr, addr, addrlen);
        if (is_error(ret)) {
            ret = -TARGET_EFAULT;
        } else if (put_user_u32(addrlen, target_addrlen_addr)) {
            ret = -TARGET_EFAULT;
        }
    }
    return ret;
}

/* getsockname(2) */
static inline abi_long do_bsd_getsockname(int fd, abi_ulong target_addr,
                                          abi_ulong target_addrlen_addr)
{
    socklen_t addrlen;
    void *addr;
    abi_long ret;

    if (get_user_u32(addrlen, target_addrlen_addr)) {
        return -TARGET_EFAULT;
    }
    if ((int)addrlen < 0) {
        return -TARGET_EINVAL;
    }
    if (!access_ok(VERIFY_WRITE, target_addr, addrlen)) {
        return -TARGET_EFAULT;
    }
    addr = alloca(addrlen);

    ret = get_errno(getsockname(fd, addr, &addrlen));
    if (!is_error(ret)) {
        ret = host_to_target_sockaddr(target_addr, addr, addrlen);
        if (is_error(ret)) {
            ret = -TARGET_EFAULT;
        } else if (put_user_u32(addrlen, target_addrlen_addr)) {
            ret = -TARGET_EFAULT;
        }
    }
    return ret;
}

/* socketpair(2) */
static inline abi_long do_bsd_socketpair(int domain, int type, int protocol,
                                         abi_ulong target_tab_addr)
{
    int tab[2];
    abi_long ret;

    if (!access_ok(VERIFY_WRITE, target_tab_addr, sizeof(tab[0]) * 2)) {
        return -TARGET_EFAULT;
    }
    ret = get_errno(socketpair(domain, type, protocol, tab));
    if (!is_error(ret)) {
        if (put_user_s32(tab[0], target_tab_addr) ||
                put_user_s32(tab[1], target_tab_addr + sizeof(tab[0]))) {
            ret = -TARGET_EFAULT;
        }
    }
    return ret;
}

/* sendto(2) */
static inline abi_long do_bsd_sendto(int fd, abi_ulong msg, size_t len,
                                     int flags, abi_ulong target_addr,
                                     socklen_t addrlen)
{
    struct sockaddr *saddr;
    void *host_msg;
    abi_long ret;

    if ((int)addrlen < 0) {
        return -TARGET_EINVAL;
    }
    if (len != 0) {
        host_msg = lock_user(VERIFY_READ, msg, len, 1);
        if (!host_msg) {
            return -TARGET_EFAULT;
        }
    } else {
        host_msg = NULL;
    }
    if (target_addr) {
        saddr = alloca(addrlen + 1);
        ret = target_to_host_sockaddr(saddr, target_addr, addrlen);
        if (is_error(ret)) {
            unlock_user(host_msg, msg, 0);
            return ret;
        }
        ret = get_errno(safe_sendto(fd, host_msg, len, flags, saddr, addrlen));
    } else {
        ret = get_errno(send(fd, host_msg, len, flags));
    }
    unlock_user(host_msg, msg, 0);
    return ret;
}

/* recvfrom(2) */
static inline abi_long do_bsd_recvfrom(int fd, abi_ulong msg, size_t len,
                                       int flags, abi_ulong target_addr,
                                       abi_ulong target_addrlen)
{
    socklen_t addrlen;
    struct sockaddr *saddr;
    void *host_msg;
    abi_long ret;

    host_msg = lock_user(VERIFY_WRITE, msg, len, 0);
    if (!host_msg) {
        return -TARGET_EFAULT;
    }
    if (target_addr) {
        if (get_user_u32(addrlen, target_addrlen)) {
            ret = -TARGET_EFAULT;
            goto fail;
        }
        if ((int)addrlen < 0) {
            ret = -TARGET_EINVAL;
            goto fail;
        }
        saddr = alloca(addrlen + 1);
        ret = get_errno(safe_recvfrom(fd, host_msg, len, flags, saddr,
                    &addrlen));
    } else {
        saddr = NULL; /* To keep compiler quiet.  */
        ret = get_errno(recv(fd, host_msg, len, flags));
    }
    if (!is_error(ret)) {
        if (target_addr) {
            if (is_error(host_to_target_sockaddr(target_addr, saddr, addrlen))) {
                ret = -TARGET_EFAULT;
                goto fail;
            } else if (put_user_u32(addrlen, target_addrlen)) {
                ret = -TARGET_EFAULT;
                goto fail;
            }
        }
        unlock_user(host_msg, msg, ret);
    } else {
fail:
        unlock_user(host_msg, msg, 0);
    }
    return ret;
}

/* socket(2) */
static inline abi_long do_bsd_socket(abi_long domain, abi_long type,
                                     abi_long protocol)
{
    return get_errno(socket(domain, type, protocol));
}

/* shutdown(2) */
static inline abi_long do_bsd_shutdown(abi_long s, abi_long how)
{
    return get_errno(shutdown(s, how));
}

#endif /* BSD_SOCKET_H */