server_socket.cpp

//--------------------------
// Server module
//--------------------------
// Description:
// Provides basic TCP/IP socket server functions
//--------------------------
// Author: Layne Bernardo
// Email: lmbernar@uark.edu
//
// Created July 20th, 2018
// Modified: November 7th, 2018
// Version 0.5
//--------------------------

//-----------------------------

#include "server_socket.h"

//-----------------------------
// Class: server_socket
//-----------------------------
// Simplifies use of socket functions
// Provides storage of parameters (e.g., TCP or UDP)
// Also handles creation and configuration of sockaddr_in struct
// Default settings can be found in server_socket.h
//-----------------------------

server_socket::server_socket(){
        // Port to listen on
        s_port = DEFAULT_PORT;
        // Use IPV4 addressing
        s_domain = DEFAULT_ADDRESSING;
        // Use TCP
        s_type = DEFAULT_CONN_TYPE;
        // Use Internet Protocol (IP)
        s_protocol = DEFAULT_PROTOCOL;
        // Bind to localhost
        s_bind_address = DEFAULT_BIND_ADDRESS;
        // How many clients can be waiting for a connection before new clients get rejected
        backlog = DEFAULT_BACKLOG;

        // "Read" buffer
        socket_read_buffer = new char[DEFAULT_SOCKET_BUFFER_SIZE];
        socket_read_buffer_size = DEFAULT_SOCKET_BUFFER_SIZE;

        // Initialize read buffer
        for (int i = 0; i < socket_read_buffer_size; i++) {
                socket_read_buffer[i] = 0;
        }
}

server_socket::server_socket(uint16_t s_p, sa_family_t s_d, int s_ty, int s_pr, int s_b_a, int bl, int s_b_s){
        s_port = s_p;
        s_domain = s_d;
        s_type = s_ty;
        s_protocol = s_pr;
        s_bind_address = s_b_a;
        backlog = bl;
        socket_read_buffer = new char[s_b_s];
        socket_read_buffer_size = s_b_s;

        // Initialize read buffer
        for (int i = 0; i < socket_read_buffer_size; i++) {
                socket_read_buffer[i] = 0;
        }
}

server_socket::~server_socket(){
        // Clean up read buffer
        delete[] socket_read_buffer;
        // Close socket (destructor, can't output to console)
        close(s_sockfd);
}

int server_socket::client_count(){
        return (int) client_list.size();
}

// Initialize socket and listen
// 0 = success, -1 = invalid port, anything else is an errno
int server_socket::s_init(){

        // Check port range
        if ( (s_port < 0) || (s_port > 65534) ) {
                std::cout << "\nPort out of range! (0 to 65534)\n\n";
                return -1;
        }

        // Create and configure socket
        if ( s_create() < 0 ) {
                int errsv = errno;
                std::cout << "Failed to create socket!" << std::endl;
                return errsv;
        }

        // Bind socket to port (or something)
        if ( s_bind() < 0 ) {
                int errsv = errno;
                std::cout << "Failed to bind socket on port " << s_port << std::endl;
                return errsv;
        }

        // Listen for client connections
        if ( s_listen() < 0 ) {
                int errsv = errno;
                std::cout << "Failed to listen on port " << s_port << ", sockfd " << s_sockfd << std::endl;
                return errsv;
        }

        std::cout << "Socket configured. Listening on port " << s_port << std::endl;
        return 0;
}

// Returns file descriptor or -1
int server_socket::s_create(){
        s_sockfd = socket(s_domain, s_type, s_protocol);
        return s_sockfd;
}

// Return < 0 if failed
int server_socket::s_set_nonblocking(){
        // setsockopt(int sockfd, int level, int optname, const void* optval, socklen_t optlen)
        // SOL_SOCKET is at the socket API level
        // Set socket descriptor to be reusable

        int on = 1;
        int err = setsockopt(s_sockfd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));
        if (err < 0) {
                err = errno;
                std::cout << "setsockopt() failed" << std::endl;
                return err;
        }
        // Set socket to be non-blocking. Affects all client sockets as well
        err = ioctl(s_sockfd, FIONBIO, (char *)&on);
        if (err < 0)
        {
                err = errno;
                std::cout << "setsockopt() failed" << std::endl;
                return err;
        }
        return 0;
}

// Returns 0 or -1
int server_socket::s_bind(){
        // IPV4
        s_address.sin_family = s_domain;
        // Bind to localhost
        s_address.sin_addr.s_addr = (in_addr_t) s_bind_address;
        // Convert port to network byte order (?)
        s_address.sin_port = htons( s_port );
        return bind(s_sockfd, (struct sockaddr *) &s_address, s_address_len);
}

// Listen on port
int server_socket::s_listen(){
        return listen(s_sockfd, backlog);
}

int server_socket::s_accept(){
        // Open a socket for the client
        int new_client = accept(s_sockfd, (struct sockaddr*) &s_address, &s_address_len);
        if ( new_client  < 0) {
                return -1;
        } else {
                std::cout << "New client: " << new_client << std::endl;
                // new_client is a file descriptor for the new socket
                client_list.push_back(new_client);
                return new_client;
        }
}

int server_socket::remove_client(int client_num){
        client_list.erase(client_list.begin()+client_num);
        return 0;
}

// Get value of largest client fd for select()
int server_socket::max_client_fd(){
        return *( std::max_element(client_list.begin(), client_list.end()) );
}

// Read from the socket buffer of the specified client
long server_socket::s_read(int s_client){
        return (long) read(client_list[s_client], socket_read_buffer, (size_t) socket_read_buffer_size);
}

int server_socket::s_write(char* data){
        std::cout << data << std::endl;
        return -1;
}

long server_socket::socket_read(int client_number){
        long num_bytes = s_read(client_number);
        if ( num_bytes < 0 ) {
                int errsv = errno;
                std::cout << "Error reading from socket!" << std::endl;
                std::cout << "Errno: " << errsv << std::endl;
                return -1;
        } else if ( num_bytes > 0 ) {
                std::cout << num_bytes << " bytes read from socket: " << std::endl;
                for (int i=0; i < num_bytes; i++) {
                        std::cout << socket_read_buffer[i];
                }
                std::cout << std::endl;
                return num_bytes;
        } else {
                return 0;
        }
}

// Splits comma delimited data from the socket buffer into a vector of strings
// Seperates messages via message delimiter '!'
std::vector<std::string> server_socket::splitBuffer(int& start){

        std::string temp_string;
        std::vector<std::string> data_strings;

        // Debug
        std::cout << "Message:";

        char next_char = '0';
        // Put data into vector, stop on '!' or null terminator
        while (next_char != '!' && next_char != '\0') {
                next_char = socket_read_buffer[start];
                if (next_char == ',' || next_char == '!') {
                        data_strings.push_back(temp_string);
                        // Debug
                        std::cout << " " << temp_string;
                        temp_string = "";
                } else {
                        temp_string += next_char;
                }
                start++;
        }

        // Debug
        std::cout << " " << temp_string << std::endl;

        return data_strings;
}

int server_socket::accept_pending_clients(){
        // Create fd_set of clients for select()
        fd_set socket_set;
        int select_result;
        int err;

        // Wait for 100ms on select() calls
        struct timeval delay = {0};
        delay.tv_sec = 0;
        delay.tv_usec = 100;

        // Initialize set
        FD_ZERO(&socket_set);
        // Add server socket to socket settings
        FD_SET(s_sockfd, &socket_set);

        select_result = select(s_sockfd + 1, &socket_set, nullptr, nullptr, &delay);
        err = errno;

    if ( FD_ISSET(s_sockfd, &socket_set ) ){
                // Attempt to accept client connection
                if ( s_accept() < 0 ) {
                        int errsv = errno;
                        std::cout << "Failed to accept client connection" << std::endl;
                        std::cout << "Errno: " << errsv << std::endl;
                } else {
                        std::cout << "Accepted new client connection" << std::endl;
                        std::cout << std::endl;
                }
        }

        if (err == EWOULDBLOCK) {
                return select_result;
        } else {
                return err;
        }
}

std::vector<int> server_socket::check_client_buffers(){
        // Create fd_set of clients for select()
        fd_set socket_set;
        int select_result;
        int err;

        // Wait for 100ms on select() calls
        struct timeval delay = {0};
        delay.tv_sec = 0;
        delay.tv_usec = 100;

        // Result vector. Returns -1,err on error, 0 on timeout, and 1,fd,fd,... for ready fds
        std::vector<int> results;

        // Check for data on each client socket
                // Initialize set
                FD_ZERO(&socket_set);
                // Add clients to socket_set;
                for (auto i : client_list) {
                        FD_SET(i, &socket_set);
                }

                int max_fd = max_client_fd();

                // select(max fd + 1, read socket_set, write socket_set, except socket_set, timeout)
                select_result = select(max_fd + 1, &socket_set, nullptr, nullptr, &delay);
                err = errno;

        // Something went wrong
        if (select_result < 0){
                results.push_back(-1);
                results.push_back(err);
                return results;
        } else if (select_result > 0) {
                results.push_back(1);
                // Check which client sockets are readable
                int desc_ready = select_result;
                for (int i = 0; i < (int) client_list.size() && desc_ready > 0; i++) {
                        if (FD_ISSET(client_list[i], &socket_set)) {
                                // Client socket has data to read
                                desc_ready--;
                                results.push_back(i);
                        }
                }
                return results;
        }
        // No socket has pending data
        results.push_back(0);
        return results;
}