socket.cc

Go to the documentation of this file.

#include "socket.hh"
 
#include "util.hh"
 
#include <cstddef>
#include <stdexcept>
#include <unistd.h>
 
using namespace std;
 
// default constructor for socket of (subclassed) domain and type
Socket::Socket(const int domain, const int type) : FileDescriptor(SystemCall("socket", socket(domain, type, 0))) {}
 
// construct from file descriptor
Socket::Socket(FileDescriptor &&fd, const int domain, const int type) : FileDescriptor(move(fd)) {
    int actual_value;
    socklen_t len;
 
    // verify domain
    len = sizeof(actual_value);
    SystemCall("getsockopt", getsockopt(fd_num(), SOL_SOCKET, SO_DOMAIN, &actual_value, &len));
    if ((len != sizeof(actual_value)) or (actual_value != domain)) {
        throw runtime_error("socket domain mismatch");
    }
 
    // verify type
    len = sizeof(actual_value);
    SystemCall("getsockopt", getsockopt(fd_num(), SOL_SOCKET, SO_TYPE, &actual_value, &len));
    if ((len != sizeof(actual_value)) or (actual_value != type)) {
        throw runtime_error("socket type mismatch");
    }
}
 
// get the local or peer address the socket is connected to
Address Socket::get_address(const string &name_of_function,
                            const function<int(int, sockaddr *, socklen_t *)> &function) const {
    Address::Raw address;
    socklen_t size = sizeof(address);
 
    SystemCall(name_of_function, function(fd_num(), address, &size));
 
    return {address, size};
}
 
Address Socket::local_address() const { return get_address("getsockname", getsockname); }
 
Address Socket::peer_address() const { return get_address("getpeername", getpeername); }
 
// bind socket to a specified local address (usually to listen/accept)
void Socket::bind(const Address &address) { SystemCall("bind", ::bind(fd_num(), address, address.size())); }
 
// connect socket to a specified peer address
void Socket::connect(const Address &address) { SystemCall("connect", ::connect(fd_num(), address, address.size())); }
 
// shut down a socket in the specified way
void Socket::shutdown(const int how) {
    SystemCall("shutdown", ::shutdown(fd_num(), how));
    switch (how) {
        case SHUT_RD:
            register_read();
            break;
        case SHUT_WR:
            register_write();
            break;
        case SHUT_RDWR:
            register_read();
            register_write();
            break;
        default:
            throw runtime_error("Socket::shutdown() called with invalid `how`");
    }
}
 
void UDPSocket::recv(received_datagram &datagram, const size_t mtu) {
    // receive source address and payload
    Address::Raw datagram_source_address;
    datagram.payload.resize(mtu);
 
    socklen_t fromlen = sizeof(datagram_source_address);
 
    const ssize_t recv_len = SystemCall(
        "recvfrom",
        ::recvfrom(
            fd_num(), datagram.payload.data(), datagram.payload.size(), MSG_TRUNC, datagram_source_address, &fromlen));
 
    if (recv_len > ssize_t(mtu)) {
        throw runtime_error("recvfrom (oversized datagram)");
    }
 
    register_read();
    datagram.source_address = {datagram_source_address, fromlen};
    datagram.payload.resize(recv_len);
}
 
UDPSocket::received_datagram UDPSocket::recv(const size_t mtu) {
    received_datagram ret{{nullptr, 0}, ""};
    recv(ret, mtu);
    return ret;
}
 
void sendmsg_helper(const int fd_num,
                    const sockaddr *destination_address,
                    const socklen_t destination_address_len,
                    const BufferViewList &payload) {
    auto iovecs = payload.as_iovecs();
 
    msghdr message{};
    message.msg_name = const_cast<sockaddr *>(destination_address);
    message.msg_namelen = destination_address_len;
    message.msg_iov = iovecs.data();
    message.msg_iovlen = iovecs.size();
 
    const ssize_t bytes_sent = SystemCall("sendmsg", ::sendmsg(fd_num, &message, 0));
 
    if (size_t(bytes_sent) != payload.size()) {
        throw runtime_error("datagram payload too big for sendmsg()");
    }
}
 
void UDPSocket::sendto(const Address &destination, const BufferViewList &payload) {
    sendmsg_helper(fd_num(), destination, destination.size(), payload);
    register_write();
}
 
void UDPSocket::send(const BufferViewList &payload) {
    sendmsg_helper(fd_num(), nullptr, 0, payload);
    register_write();
}
 
// mark the socket as listening for incoming connections
void TCPSocket::listen(const int backlog) { SystemCall("listen", ::listen(fd_num(), backlog)); }
 
// accept a new incoming connection
TCPSocket TCPSocket::accept() {
    register_read();
    return TCPSocket(FileDescriptor(SystemCall("accept", ::accept(fd_num(), nullptr, nullptr))));
}
 
// set socket option
template <typename option_type>
void Socket::setsockopt(const int level, const int option, const option_type &option_value) {
    SystemCall("setsockopt", ::setsockopt(fd_num(), level, option, &option_value, sizeof(option_value)));
}
 
// allow local address to be reused sooner, at the cost of some robustness
void Socket::set_reuseaddr() { setsockopt(SOL_SOCKET, SO_REUSEADDR, int(true)); }