tec_socket_client.hpp

Go to the documentation of this file.

// Time-stamp: <Last changed 2026-02-07 14:13:52 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>
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L   // This line fixes the "storage size of ‘hints’ isn’t known" issue.
#endif
 
#include <cerrno>
#include <cstdlib>
#include <vector>
 
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
 
#include "tec/tec_def.hpp"  // IWYU pragma: keep
#include "tec/tec_trace.hpp"
#include "tec/tec_status.hpp"
#include "tec/tec_message.hpp"
#include "tec/tec_actor.hpp"
#include "tec/tec_memfile.hpp"
#include "tec/net/tec_socket.hpp"
 
 
namespace tec {
 
template <typename TParams>
class SocketClient: public Actor {
private:
    std::vector<char> buffer_;
 
public:
    using Params = TParams;
 
protected:
    Params params_;
 
    int sockfd_;
 
    constexpr char* get_buffer() { return buffer_.data(); }
 
    constexpr size_t get_buffer_size() { return params_.buffer_size; }
 
public:
    explicit SocketClient(const Params& params)
        : Actor()
        , params_{params}
        , sockfd_{EOF}
    {
        static_assert(
            std::is_base_of<SocketClientParams, Params>::value,
            "Not derived from tec::SocketClientParams class");
    }
 
    virtual ~SocketClient() {
        if (sockfd_ != EOF) {
            terminate();
        }
    }
 
    void start(Signal* sig_started, Status* status) override {
        TEC_ENTER("SocketClient::start");
        Signal::OnExit on_exit(sig_started);
 
        // Resolve the server address.
        TEC_TRACE("Resolving address {}:{}...", params_.addr, params_.port);
        addrinfo hints;
        ::memset(&hints, 0, sizeof(hints));
        hints.ai_family = params_.family;
        hints.ai_socktype = params_.socktype;
        hints.ai_protocol = params_.protocol;
 
        // getaddrinfo() returns a list of address structures.
        // Try each address until we successfully connect().
        addrinfo* servinfo{NULL};
        char port_str[16];
        ::snprintf(port_str, 15, "%d", params_.port);
        int ecode = ::getaddrinfo(params_.addr.c_str(), port_str,
                                  &hints, &servinfo);
        if( ecode != 0 ) {
            std::string emsg = ::gai_strerror(ecode);
            TEC_TRACE("Error resolving address: {}", emsg);
            *status = {ecode, emsg, Error::Kind::NetErr};
            return;
        }
        TEC_TRACE("Address resolved OK.");
 
        // If socket() (or connect()) fails, we close the socket
        // and try the next address.
        addrinfo* p{NULL};
        int fd{-1};
        TEC_TRACE("Connecting...");
        for( p = servinfo; p != NULL; p = p->ai_next ) {
            fd = ::socket(p->ai_family, p->ai_socktype, p->ai_protocol);
            if( fd == -1 ) {
                // Try next socket.
                continue;
            }
 
            if( ::connect(fd, p->ai_addr, p->ai_addrlen) != -1 ) {
                // Success.
                break;
            }
 
            // Try next socket.
            close(fd);
        }
 
        // No longer needed.
        ::freeaddrinfo(servinfo);
 
        if( p == NULL ) {
            auto emsg = format("Failed to connect to {}:{}", params_.addr, params_.port);
            *status = {ECONNREFUSED, emsg, Error::Kind::NetErr};
            TEC_TRACE(emsg);
            return;
        }
        //
        // Success. Allocate buffer for send/recv operations.
        //
        sockfd_ = fd;
        TEC_TRACE("Connected OK.");
        buffer_.resize(get_buffer_size());
        TEC_TRACE("Buffer size is {} bytes.", get_buffer_size());
    }
 
    void shutdown(Signal* sig_stopped) override {
        TEC_ENTER("SocketClient::shutdown");
        Signal::OnExit on_exit(sig_stopped);
        ::shutdown(sockfd_, SHUT_RDWR);
        close(sockfd_);
        sockfd_ = EOF;
    }
 
    Status process_request(Request request, Reply reply) override {
        TEC_ENTER("SocketClient::process_request");
        if( request.type() == typeid(const SocketCharStreamIn*) ) {
            // Process raw character stream.
            const SocketCharStreamIn* req = std::any_cast<const SocketCharStreamIn*>(request);
            SocketCharStreamOut* rep = nullptr;
            if( reply.has_value() ) {
                rep = std::any_cast<SocketCharStreamOut*>(reply);
            }
            return send_recv_string(req, rep);
        }
 
        // Process future NetData request. See `tec_socket_client_nd.hpp`
        // that implements NetData processing.
        return {Error::Kind::NotImplemented};
    }
 
    Status request_str(const std::string* str_in, std::string* str_out) {
        TEC_ENTER("SocketClient::request_str");
        SocketCharStreamIn request{str_in};
        SocketCharStreamOut reply{str_out};
        auto status = send_recv_string(&request, &reply);
        if (status && (str_out != nullptr)) {
            *str_out = *reply.str;
        }
        return status;
    }
 
protected:
 
    virtual Status set_socket_options(int sockfd) {
        return {};
    }
 
    virtual Status send_string(const SocketCharStreamIn* request) {
        TEC_ENTER("SocketClient::send_string");
        if (request && request->str) {
            // `request` must be valid.
            Bytes data(request->str->data(), request->str->size() + 1);
            Socket sock{sockfd_, params_.addr.c_str(), params_.port,
                        get_buffer(), get_buffer_size()};
            auto status = Socket::send(data, &sock);
            return status;
        }
        return {EFAULT, Error::Kind::Invalid};
    }
 
    virtual Status recv_string(SocketCharStreamOut* reply) {
        TEC_ENTER("SocketClient::recv_string");
        if (reply == nullptr) {
            // Notification message -- no reply required.
            return {};
        }
        if (reply->str == nullptr) {
            return {EFAULT, Error::Kind::Invalid};
        }
        Bytes data;
        Socket sock{sockfd_, params_.addr.c_str(), params_.port,
                    get_buffer(), get_buffer_size()};
        auto status = Socket::recv(data, &sock, 0);
        if (status) {
            *reply->str = static_cast<const char*>(data.data());
        }
        return status;
    }
 
    virtual Status send_recv_string(const SocketCharStreamIn* request, SocketCharStreamOut* reply) {
        TEC_ENTER("SocketClient::send_recv_string");
        auto status = send_string(request);
        if (status) {
            status = recv_string(reply);
        }
        else {
            terminate();
        }
        return status;
    }
 
}; // class SocketClient
 
} // namespace tec