SocketBase.hpp

// -*- C++ -*-
/*
 *    Copyright (C) 2021 Joshua Boudreau <jboudreau@45drives.com>
 *
 *    This file is part of lib45d.
 *
 *    lib45d is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    lib45d is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with lib45d.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <45d/socket/Exceptions.hpp>
#include <sstream>
#include <vector>
 
extern "C" {
#include <string.h> // for strerror
#include <sys/socket.h>
#include <unistd.h> // for close
}
 
namespace ffd {
    namespace Socket {
        const int _backlog_default = 50; 
 
        const int _buff_sz =
#ifndef FFD_SOCKET_BUFF_SZ
            1024;
#else
            FFD_SOCKET_BUFF_SZ;
#endif
        const char _rec_delim = 0x1E; 
    }                                 // namespace Socket
    class SocketBase {
    public:
        SocketBase(int domain, int type, int protocol = 0) : ACK('\6') {
            int res = socket(domain, type, protocol);
            if (res == -1) {
                int error = errno;
                throw SocketCreateException(strerror(error), error);
            }
            fd_ = res;
        }
        ~SocketBase() {
            close(fd_);
        }
        void close_connection(int fd = 0) {
            if (fd == 0) {
                fd = io_fd_;
            }
            int res = close(fd);
            if (res == -1) {
                int error = errno;
                throw SocketCloseException(strerror(error), error);
            }
        }
        void send_data_async(const std::string &str, int flags = 0, int fd = 0) {
            if (fd == 0)
                fd = io_fd_;
            int res = send(fd, (void *)str.c_str(), str.length(), flags);
            if (res == -1) {
                int error = errno;
                throw SocketWriteException(strerror(error), error);
            }
        }
        void send_data_sync(const std::string &str, int flags = 0, int fd = 0) {
            if (fd == 0)
                fd = io_fd_;
            send_data_async(str, flags, fd);
            get_ack(fd);
        }
        void send_data(const std::string &str, int flags = 0, int fd = 0) {
            send_data_sync(str, flags, fd);
        }
        void send_data_async(const std::vector<std::string> &vec, int flags = 0, int fd = 0) {
            std::string payload;
            std::vector<std::string>::const_iterator itr = vec.begin();
            payload = *itr;
            ++itr;
            for (; itr != vec.end(); ++itr) {
                payload += Socket::_rec_delim + *itr;
            }
            send_data_async(payload, flags, fd);
        }
        void send_data_sync(const std::vector<std::string> &vec, int flags = 0, int fd = 0) {
            send_data_async(vec, flags, fd);
            get_ack(fd);
        }
        void send_data(const std::vector<std::string> &vec, int flags = 0, int fd = 0) {
            send_data_sync(vec, fd, flags);
        }
        void receive_data_async(std::string &payload, int flags = 0, int fd = 0) {
            payload = "";
            if (fd == 0)
                fd = io_fd_;
            char buff[Socket::_buff_sz];
            memset(&buff, 0, sizeof(buff));
            int bytes_read = 0;
            do {
                bytes_read = recv(fd, &buff, sizeof(buff) - 1, flags);
                if (bytes_read == -1) {
                    int error = errno;
                    throw SocketReadException(strerror(error), error);
                }
                buff[bytes_read] = '\0';
                payload += buff;
            } while (bytes_read > 0
                     && recv(fd, &buff, sizeof(buff) - 1, MSG_PEEK | MSG_DONTWAIT) > 0);
        }
        void receive_data_sync(std::string &payload, int flags = 0, int fd = 0) {
            receive_data_async(payload, flags, fd);
            send_ack(fd);
        }
        void receive_data(std::string &payload, int flags = 0, int fd = 0) {
            receive_data_sync(payload, flags, fd);
        }
        void receive_data_async(std::vector<std::string> &vec, int flags = 0, int fd = 0) {
            vec.clear();
            std::string payload, record;
            receive_data_async(payload, flags, fd);
            std::stringstream ss(payload);
            while (std::getline(ss, record, Socket::_rec_delim)) {
                vec.push_back(record);
            }
        }
        void receive_data_sync(std::vector<std::string> &vec, int flags = 0, int fd = 0) {
            receive_data_async(vec, flags, fd);
            send_ack(fd);
        }
        void receive_data(std::vector<std::string> &vec, int flags = 0, int fd = 0) {
            receive_data_sync(vec, flags, fd);
        }
        void shutdown(int how = SHUT_RDWR) {
            int res = ::shutdown(fd_, how);
            if (res == -1) {
                int error = errno;
                throw SocketShutdownException(strerror(error), error);
            }
        }
    protected:
        int fd_;    
        int io_fd_; 
        char ACK;   
    private:
        void get_ack(int fd) {
            if (fd == 0)
                fd = io_fd_;
            char ack_check;
            recv(fd, &ack_check, 1, 0);
            if (ack_check != ACK) {
                throw SocketWriteException("ACK failed");
            }
        }
        void send_ack(int fd) {
            if (fd == 0)
                fd = io_fd_;
            send(fd, &ACK, 1, 0);
        }
    };
} // namespace ffd