client.cpp

/*
** libutil++
** $Id: client.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: client.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 secure {
                bool running = true;
                int debug = 0;
        }
}

using namespace sella::secure;
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("secure");
        SET_OPTION(Log::WithStderrOption);

        init_config(argc, argv);
        init_signals();

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

        try {
                INFO("Connecting to server...");

                SecureTCPSocket::shared client = SecureTCPSocket::shared_ptr(AF_INET, "127.0.0.1", 9876);
                client->setBlock(false);

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

                SocketMux mux;

                mux.insertRead(client);

                while (running && client->isUsable()) {
                        std::string buf = su::String::random(64);

                        INFO("Send: %s", buf.c_str());
                        client->send(buf);

                        if (mux.rselect(750000) > 0) { /* Client must read from socket to be able to receive a shutdown notification. */
                                std::string buf;
                                size_t n;

                                if ((n = client->recv(buf)) > 0) {
                                        INFO("Recv: %s", buf.c_str());
                                }
                        }
                }
        } catch (SocketException &e) {
                INFO("Exception: %s", e.what());

                return EXIT_FAILURE;
        }

        INFO("Clean shutdown");

        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
*/