net.cc

//------------------------------------------------------------//
//                                                            //
//      Copyright (c) Texas A&M University                    //
//                                                            //
//      CAN-to-Ethernet gateway service for Raspberry PI      //
//                                                            //
//      Authored by Justus Languell <justus@tamu.edu>         //
//                                                            //
//------------------------------------------------------------//

#include "net.h"

#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdexcept>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <unistd.h>
#include <cerrno>

#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0
#endif

static bool SockAddrGetHostInfo(const sockaddr* sa, std::string& ip, uint16_t& port)
{
    char buf[INET6_ADDRSTRLEN] = {0};
    if (sa->sa_family == AF_INET)
    {
        const sockaddr_in* s = reinterpret_cast<const sockaddr_in*>(sa);
        if (!::inet_ntop(AF_INET, &s->sin_addr, buf, sizeof(buf))) return false;
        ip.assign(buf);
        port = ntohs(s->sin_port);
        return true;
    }
    else if (sa->sa_family == AF_INET6)
    {
        const sockaddr_in6* s6 = reinterpret_cast<const sockaddr_in6*>(sa);
        if (!::inet_ntop(AF_INET6, &s6->sin6_addr, buf, sizeof(buf))) return false;
        ip.assign(buf);
        port = ntohs(s6->sin6_port);
        return true;
    }
    return false;
}


NetConn::NetConn(int _fd) : fd(_fd)
{
    if (fd < 0) return;


    int one = 1;
    ::setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
}

NetConn::~NetConn() { if (fd >= 0) ::close(fd); }

ssize_t NetConn::Recv(void* buf, size_t len)
{
    for (;;)
    {
        ssize_t r = ::recv(fd, buf, len, 0);
        if (r < 0 && errno == EINTR) continue;
        return r;
    }
}

ssize_t NetConn::Send(const void* buf, size_t len)
{
    for (;;)
    {
        ssize_t w = ::send(fd, buf, len, MSG_NOSIGNAL);
        if (w < 0 && errno == EINTR) continue;
        return w;
    }
}

void NetConn::ShutdownRD() { ::shutdown(fd, SHUT_RD); }
void NetConn::ShutdownWR() { ::shutdown(fd, SHUT_WR); }
void NetConn::ShutdownRW() { ::shutdown(fd, SHUT_RDWR); }

bool NetConn::PeerAddress(std::string& ip, uint16_t& port) const
{
    sockaddr_storage ss; socklen_t slen = sizeof(ss);
    if (::getpeername(fd, reinterpret_cast<sockaddr*>(&ss), &slen) < 0) return false;
    return SockAddrGetHostInfo(reinterpret_cast<sockaddr*>(&ss), ip, port);
}

bool NetConn::LocalAddress(std::string& ip, uint16_t& port) const
{
    sockaddr_storage ss; socklen_t slen = sizeof(ss);
    if (::getsockname(fd, reinterpret_cast<sockaddr*>(&ss), &slen) < 0) return false;
    return SockAddrGetHostInfo(reinterpret_cast<sockaddr*>(&ss), ip, port);
}

std::string NetConn::PeerAddress() const
{
    std::string ip; uint16_t port{};
    if (!PeerAddress(ip, port)) return {};
    return ip + ":" + std::to_string(port);
}

std::string NetConn::LocalAddress() const
{
    std::string ip; uint16_t port{};
    if (!LocalAddress(ip, port)) return {};
    return ip + ":" + std::to_string(port);
}

NetSocket::NetSocket(std::uint16_t port)
{
    fd = ::socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0) {
        fprintf(stderr, "Error creating network socket socket\n");
    }

    int one = 1;
    ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
#ifdef SO_REUSEPORT
    ::setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one));
#endif
    ::setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));

    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(port);

    if (::bind(fd, (sockaddr*)&addr, sizeof(addr)) < 0) {
        fprintf(stderr, "Error binding to network socket\n");
        ::close(fd);
    }

    if (::listen(fd, 8) < 0) {
        fprintf(stderr, "Error listening to network socket\n");
        ::close(fd);
    }
}

NetSocket::~NetSocket()
{
    if (fd >= 0) ::close(fd);
}

std::shared_ptr<NetConn> NetSocket::Accept()
{
    sockaddr_in cli{};
    socklen_t len = sizeof(cli);
    int cfd = ::accept(fd, (sockaddr*)&cli, &len);
    if (cfd < 0) {
        // fprintf(stderr, "Error accepting to client connection\n");
        return nullptr;
    }
    return std::make_shared<NetConn>(cfd);
}