tec_socket.hpp

Go to the documentation of this file.

// Time-stamp: <Last changed 2026-02-05 01:48:09 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
 
#include <cstddef>
#include <cstdio>
#include <sys/types.h>
#ifndef _POSIX_C_SOURCE
// This line fixes the "storage size of 'hints' isn't known" issue.
#define _POSIX_C_SOURCE 200809L
#endif
 
#include <sys/socket.h>
#include <unistd.h>
#include <netdb.h>
 
#include <cstring>
#include <thread>
 
#include "tec/tec_def.hpp"  // IWYU pragma: keep
#include "tec/tec_trace.hpp"
#include "tec/tec_status.hpp"
#include "tec/tec_memfile.hpp"
#include "tec/net/tec_compression.hpp"
 
 
namespace tec {
 
struct SocketParams {
    static constexpr char kAnyAddr[]{"0.0.0.0"};
 
    static constexpr char kLocalAddr[]{"127.0.0.1"};
 
    static constexpr char kLocalURI[]{"localhost"};
 
    static constexpr char kAnyAddrIP6[]{"::"};
 
    static constexpr char kLocalAddrIP6[]{"::1"};
 
    static constexpr int kDefaultPort{4321};
 
    static constexpr int kDefaultFamily{AF_UNSPEC};
 
    static constexpr int kDefaultSockType{SOCK_STREAM};
 
    static constexpr int kDefaultProtocol{0};
 
    static constexpr int kDefaultServerFlags{AI_PASSIVE};
 
    static constexpr int kDefaultClientFlags{0};
 
    static constexpr char kNullChar{0};
 
    static constexpr size_t kDefaultBufSize{BUFSIZ};
 
    std::string addr;
 
    int port; 
    int family; 
    int socktype; 
    int protocol; 
    int flags; 
    int compression; 
    int compression_level; 
    size_t compression_min_size; 
    size_t buffer_size; 
 
    SocketParams()
        : addr{kLocalURI}
        , port{kDefaultPort}
        , family{kDefaultFamily}
        , socktype{kDefaultSockType}
        , protocol{kDefaultProtocol}
        , flags{0}
        , compression{CompressionParams::kDefaultCompression}
        , compression_level{CompressionParams::kDefaultCompressionLevel}
        , compression_min_size{CompressionParams::kMinSize}
        , buffer_size{kDefaultBufSize}
    {}
};
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*                     Client parameters
*
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
struct SocketClientParams : public SocketParams {
 
    SocketClientParams() {
        flags = kDefaultClientFlags;
    }
};
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*                         Server parameters
*
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
struct SocketServerParams : public SocketParams  {
 
    static constexpr int kOptReuseAddress{0};
 
    static constexpr int kOptReusePort{1};
 
    static constexpr int kModeCharStream{0};
 
    static constexpr int kModeNetData{1};
 
    static constexpr int kDefaultMode{kModeCharStream};
 
    static constexpr int kDefaultMaxThreads{16};
 
    static constexpr int kDefaultConnQueueSize{SOMAXCONN};
 
    static constexpr bool kUseThreadPool{false};
 
    int mode; 
    int queue_size; 
    int opt_reuse_addr; 
    int opt_reuse_port; 
    bool use_thread_pool; 
    size_t thread_pool_size; 
 
    SocketServerParams()
        : mode{kDefaultMode}
        , queue_size{kDefaultConnQueueSize}
        , opt_reuse_addr{kOptReuseAddress}
        , opt_reuse_port{kOptReusePort}
        , use_thread_pool{kUseThreadPool}
    {
        addr = kAnyAddr; // IPv4, use kAnyAddrIP6 to accept from both IPv4 and IPv6.
        flags = kDefaultServerFlags;
        thread_pool_size = std::thread::hardware_concurrency();
    }
};
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*                       Character stream request
*
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
struct SocketCharStreamIn {
    const std::string* str;
};
 
struct SocketCharStreamOut {
    std::string* str;
};
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
*                           Socket helpers
*
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
struct Socket {
    int fd; 
    char addr[INET6_ADDRSTRLEN]; 
    int port; 
    char* buffer; 
    size_t buffer_size; 
 
    Socket(int _fd, const char* _addr, int _port)
        : fd{_fd}
        , port{_port}
        , buffer{nullptr}
        , buffer_size{SocketParams::kDefaultBufSize}
    {
        std::strncpy(addr, _addr, INET6_ADDRSTRLEN);
        addr[INET6_ADDRSTRLEN-1] = '\0';
    }
 
 
    Socket(int _fd, const char* _addr, int _port, char* _buffer, size_t _buffer_size)
        : fd{_fd}
        , port{_port}
        , buffer{_buffer}
        , buffer_size{_buffer_size}
    {
        std::strncpy(addr, _addr, INET6_ADDRSTRLEN);
        addr[INET6_ADDRSTRLEN-1] = '\0';
    }
 
    static Status recv(Bytes& data, const Socket* sock, size_t length) {
        TEC_ENTER("Socket::recv");
        size_t total_received{0};
        ssize_t received{0};
        bool eot{false}; // End of transfer.
        //
        // Read data from the socket.
        //
        while ((received = read(sock->fd, sock->buffer, sock->buffer_size)) > 0) {
            if (length == 0 && received > 0) {
                // Length is unknown -- check for null-terminated char stream.
                if (sock->buffer[received-1] == '\0') {
                    TEC_TRACE("{}:{} EOT received.", sock->addr, sock->port);
                    eot = true;
                 }
            }
            if (received > 0) {
                data.write(sock->buffer, received);
                TEC_TRACE("{}:{} --> RECV {} bytes.", sock->addr, sock->port, received);
                total_received += received;
                if (length > 0 && length == total_received) {
                    break;
                }
            }
            if (eot || received < static_cast<ssize_t>(sock->buffer_size)) {
                break;
            }
        }
        //
        // Check for errors.
        //
        if (length > 0  &&  total_received == length) {
            // OK
            return {};
        }
        else if (received == 0) {
            auto errmsg = format("{}:{} Peer closed the connection.", sock->addr, sock->port);
            TEC_TRACE(errmsg);
            return {EIO, errmsg, Error::Kind::NetErr};
        }
        else if (received < 0) {
            auto errmsg = format("{}:{} socket read error {}.", sock->addr, sock->port, errno);
            TEC_TRACE(errmsg);
            return {errno, errmsg, Error::Kind::NetErr};
        }
        else if (length > 0  &&  total_received != length) {
            auto errmsg = format("{}:{} socket partial read: {} bytes of {}.",
                                 sock->addr, sock->port, total_received, length);
            TEC_TRACE(errmsg);
            return {EIO, errmsg, Error::Kind::NetErr};
        }
 
        // OK
        return {};
    }
 
    static Status send(const Bytes& data, const Socket* sock) {
        TEC_ENTER("Socket::send");
        ssize_t sent{0};
        //
        // Write data to the socket.
        //
        if (data.size() > 0) {
            sent = write(sock->fd, data.ptr(0), data.size());
            //
            // Check for errors.
            //
            if (sent < 0) {
                auto errmsg = format("{}:{} socket write error {}.", sock->addr, sock->port, errno);
                TEC_TRACE(errmsg.c_str());
                return {errno, errmsg, Error::Kind::NetErr};
            }
            else if (data.size() != static_cast<size_t>(sent)) {
                auto errmsg = format("{}:{} socket partial write: {} bytes of {}.",
                                     sock->addr, sock->port, sent, data.size());
                return {EIO, errmsg, Error::Kind::NetErr};
            }
 
        }
        TEC_TRACE("{}:{} <-- SEND {} bytes.", sock->addr, sock->port, sent);
        return {};
    }
 
}; // struct Socket
 
} // namespace tec