server.cpp

/*
** libutil++
** $Id: server.cpp 1653 2016-02-28 19:54:59Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: server.cpp 1653 2016-02-28 19:54:59Z sella $";

#include "test.h"

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

#include <mutex>
#include <condition_variable>

#include "alias.h"
#include "version.h"
#include "sella/util/Log.h"
#include "sella/util/String.h"
#include "sella/util/CommandLine.h"
#include "sella/net/IPAddressPort.h"
#include "sella/net/SocketMux.h"
#include "sella/net/SecureTCPSocket.h"

namespace sella {
        namespace server {
                bool running = true;
                int debug = 0;
        }
}

using namespace sella::server;
using namespace sella::util;
using namespace sella::net;

bool init_config(int argc, char **argv);
bool init_signals(void);
void sighandler(int sig);

int main(int argc, char **argv) {
        SET_FORMAT(SimpleLogFormat());
        SET_IDENTIFIER("server");
        SET_OPTION(Log::WithStderrOption);

        init_config(argc, argv);
        init_signals();

        INFO("Using %s v%s", libutilxx__package(), libutilxx__version());

        try {
                INFO("Setting up server...");

                SecureTCPSocket::shared server = SecureTCPSocket::shared_ptr(AF_INET);

                server->setCertificateFile("../contrib/cert.pem");
                server->setPrivateKeyFile("../contrib/key.pem");
                //server->setPasswordFile("../contrib/key.secret");
                server->setProtocol(SecureTCPSocket::SSLv3, false);
                server->setCiphers(SecureTCPSocket::PerformanceCiphers); /* Higher performance, but less secure. */
                server->setPreferServerCiphers(); /* Will prefer client ciphers and ordering without this. */

                server->setSoReuseAddr();
                server->setBlock(false);
                server->bind("127.0.0.1", 9876);
                server->setSoReuseAddr();
                server->listen();

                SocketMux mux;

                mux.insertRead(server);

                INFO("Using %s", server->getSSLLibraryVersion());
                INFO("Waiting for a connection on %s", server->getLocalIPAddressPort().c_str());

                int c, n;
                while (running) {
                        if ((c = mux.rselect()) > 0) {
                                auto &pending = mux.getReadList();

                                for (auto p = pending.begin(); p != pending.end(); ++p) {
                                        if (*p == server) {
                                                SecureTCPSocket::shared client = std::static_pointer_cast<SecureTCPSocket>(server->accept());

                                                INFO("Established connection %s using protocol %s with cipher %s", client->getRemoteIPAddressPort().c_str(), client->getActiveProtocol(), client->getActiveCipher());

                                                mux.insertRead(client);
                                        } else { /* Handle client */
                                                if ((*p)->isUsable()) {
                                                        std::string buf;
                                                        if ((n = (*p)->recv(buf)) > 0) { /* May trigger disconnect */
                                                                INFO("Recv: %s", buf.c_str());

                                                                if (rand() % 5 == 0) {
                                                                        int r = rand() % 5;

                                                                        if (r == 0) {
                                                                                (*p)->send("Hail to the king, baby.");
                                                                        } else if (r == 1) {
                                                                                (*p)->send("I got it, I got it! I know your damn words, alright?.");
                                                                        } else if (r == 2) {
                                                                                (*p)->send("Good. Bad. I'm the guy with the gun.");
                                                                        } else if (r == 3) {
                                                                                (*p)->send("Alright you primitive screwheads, listen up!");
                                                                        } else {
                                                                                (*p)->send("It's a trick, get an axe.");
                                                                        }
                                                                }
                                                        }
                                                }

                                                if (!(*p)->isUsable()) {
                                                        INFO("Client disconnected");

                                                        mux.removeRead(*p);
                                                }
                                        }
                                }
                        }
                }
        } catch (SocketException &e) {
                INFO("Exception: %s", e.what());

                return EXIT_FAILURE;
        }

        INFO("Clean shutdwn");

        return EXIT_SUCCESS;
}

bool init_config(int argc, char **argv) {
        std::string m;
        sella::util::CommandLine cmdln(argc, argv);

        cmdln.add('d', "debug", "set debug level to INT", "INT", debug, 0, 9);
        cmdln.add();
        cmdln.add('h', "help", "display this help screen");
        cmdln.add('v', "version", "display version information");

        std::map<std::string, std::string>      conf = cmdln.parse(stdin);

        if (conf.find("help") != conf.end()) {
                printf("%s v%s\n", libutilxx__package(), libutilxx__version());
                cmdln.usage(stdout, EXIT_SUCCESS);
        } else if (conf.find("version") != conf.end()) {
                printf("%s v%s\n", libutilxx__package(), libutilxx__version());

                exit(EXIT_SUCCESS);
        }

        if (conf.find("debug") != conf.end()) {
                debug = atoi(conf["debug"].c_str());

                switch (debug) {
                        case 9:
                                SET_TRACE("all");
                                SET_LOGMASK(LOG_UPTO(LOG_DEBUG));

                        case 3:
                                SET_TRACE(PACKAGE "-detail");

                        case 2:
                                SET_TRACE(PACKAGE);

                        case 1:
                                SET_TRACE("print");
                }
        }

        return true;
}

bool init_signals(void) {
        struct sigaction act, old;

        act.sa_handler = sighandler;
        sigemptyset(&act.sa_mask);
        act.sa_flags = SA_RESTART;

        if (sigaction(SIGINT, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGINT.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGINT, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGINT.\n");
                }
        }

        if (sigaction(SIGTERM, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGTERM.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGTERM, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGTERM.\n");
                }
        }

        if (sigaction(SIGHUP, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGHUP.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGHUP, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGHUP.\n");
                }
        }

        if (sigaction(SIGUSR1, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGUSR1.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGUSR1, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGUSR1.\n");
                }
        }

        if (sigaction(SIGUSR2, NULL, &old) < 0) {
                fprintf(stderr, "Failed to retrieve signal handler for SIGUSR2.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGUSR2, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGUSR2.\n");
                }
        }

        if (sigaction(SIGPIPE, NULL, &old) < 0) { /* Prevents send() and write() on broken socket from terminating. */
                fprintf(stderr, "Failed to retrieve signal handler for SIGPIPE.\n");
        } else if (old.sa_handler == SIG_DFL) {
                if (sigaction(SIGPIPE, &act, NULL) < 0) {
                        fprintf(stderr, "Failed to install signal handler for SIGPIPE.\n");
                }
        }

        return true;
}

void sighandler(int sig) { /* Do not call syslog within handler. Will cause hangs/crash. */
        switch (sig) {
                case SIGINT:
                case SIGTERM:
                        running = false;

                        break;

                case SIGHUP:
                        running = false;

                        break;

                case SIGUSR1:
                        break;

                case SIGUSR2:
                        break;

                case SIGPIPE:
                        break;

                default:
                        break;
        }
}

/*
** vim: noet ts=3 sw=3
*/