tec_socket_nd.hpp

Go to the documentation of this file.

// Time-stamp: <Last changed 2026-02-20 16:24:51 by magnolia>
/*----------------------------------------------------------------------
------------------------------------------------------------------------
Copyright (c) 2020-2026 The Emacs Cat (https://github.com/olddeuteronomy/tec).
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
------------------------------------------------------------------------
----------------------------------------------------------------------*/
#pragma once
 
#ifndef _POSIX_C_SOURCE
// This line fixes the "storage size of 'hints' isn't known" issue.
#define _POSIX_C_SOURCE 200809L
#endif
 
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netdb.h>
 
#include <cerrno>
 
#include "tec/tec_def.hpp"  // IWYU pragma: keep
#include "tec/tec_trace.hpp"
#include "tec/tec_status.hpp"
#include "tec/net/tec_net_data.hpp"
#include "tec/net/tec_socket.hpp"
 
 
namespace tec {
 
struct SocketNd : public Socket
{
    explicit SocketNd(const Socket& sock)
        : Socket(sock.fd, sock.addr, sock.port, sock.buffer, sock.buffer_size)
    {}
 
    SocketNd(int _fd, const char* _addr, int _port, char* _buffer, size_t _buffer_size)
        : Socket(_fd, _addr, _port, _buffer, _buffer_size)
    {}
 
    static Status send_nd(const NetData* nd, const SocketNd* sock)
    {
        TEC_ENTER("SocketNd::send_nd");
        //
        // Write the NetData header to the stream.
        //
        ssize_t sent = write(sock->fd, &nd->header, sizeof(NetData::Header));
        if (sent == 0) {
            auto errmsg = format("{}:{} Peer closed the connection.",
                                 sock->addr, sock->port);
            TEC_TRACE(errmsg);
            return {EIO, errmsg, Error::Kind::NetErr};
        }
        else if (sent != sizeof(NetData::Header)) {
            auto errmsg = format("{}:{} NetData::Header write error.",
                                 sock->addr, sock->port);
            TEC_TRACE(errmsg);
            return {EIO, errmsg, Error::Kind::NetErr};
        }
        //
        // Write data to the stream.
        //
        if (nd->size() > 0) {
            return Socket::send(nd->bytes(), sock);
        }
        return {};
    }
 
    static Status recv_nd(NetData* nd, const SocketNd* sock)
    {
        TEC_ENTER("SocketNd::recv_nd");
        Status status;
        NetData::Header hdr;
        //
        // Read the header.
        //
        // The MSG_PEEK flag causes the receive operation to return data
        // from the beginning of the receive queue without removing that data from the queue.
        // Thus, a subsequent receive call will return the same data.
        //
        ssize_t rd = ::recv(sock->fd, &hdr, sizeof(NetData::Header),
                            MSG_PEEK);
        if (rd == 0) {
            auto errmsg = format("{}:{} Peer closed the connection.",
                                 sock->addr, sock->port);
            TEC_TRACE(errmsg);
            return {EIO, errmsg, Error::Kind::NetErr};
        }
        else if (rd < 0) {
            auto errmsg = format("{}:{} Socket read error.",
                                 sock->addr, sock->port);
            TEC_TRACE(errmsg);
            return {errno, errmsg, Error::Kind::NetErr};
        }
        else if (rd != sizeof(NetData::Header)) {
            auto errmsg = format("{}:{} NetData::Header read error.",
                                 sock->addr, sock->port);
            TEC_TRACE(errmsg);
            return {EBADMSG, errmsg, Error::Kind::Invalid};
        }
        // Validate the header.
        else if (!hdr.is_valid()) {
            auto errmsg = format("{}:{} NetData::Header is invalid.",
                                 sock->addr, sock->port);
            TEC_TRACE(errmsg);
            return {EBADMSG, errmsg, Error::Kind::Invalid};
        }
        // Re-read the header from the message queue (destructive this time).
        auto rd2 = read(sock->fd, &hdr, sizeof(NetData::Header));
        if (rd2 != sizeof(NetData::Header)) {
            return {EIO, Error::Kind::System};
        }
        //
        // Read data.
        //
        nd->header = hdr;
        if (nd->size() > 0) {
            status = Socket::recv(nd->bytes(), sock, nd->size());
        }
        nd->rewind();
        return status;
    }
};
 
} // namespace tec