/*      $OpenBSD: client.cpp,v 1.1 2020/09/15 01:45:16 bluhm Exp $      */
/*
 * Copyright (c) 2019-2020 Alexander Bluhm <bluhm@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/socket.h>

#include <err.h>
#include <netdb.h>
#include <unistd.h>

#include <botan/tls_client.h>
#include <botan/tls_callbacks.h>
#include <botan/tls_session_manager.h>
#include <botan/tls_policy.h>
#include <botan/auto_rng.h>
#include <botan/certstor.h>

#include <iostream>
#include <string>
using namespace std;

class Callbacks : public Botan::TLS::Callbacks {
public:
        Callbacks(int socket) :
                m_socket(socket)
        {}

        void print_sockname()
        {
                struct sockaddr_storage ss;
                char host[NI_MAXHOST], port[NI_MAXSERV];
                socklen_t slen;

                slen = sizeof(ss);
                if (getsockname(m_socket, (struct sockaddr *)&ss, &slen) == -1)
                        err(1, "getsockname");
                if (getnameinfo((struct sockaddr *)&ss, ss.ss_len, host,
                    sizeof(host), port, sizeof(port),
                    NI_NUMERICHOST | NI_NUMERICSERV))
                        errx(1, "getnameinfo");
                cout <<"sock: " <<host <<" " <<port <<endl <<flush;
        }

        void print_peername()
        {
                struct sockaddr_storage ss;
                char host[NI_MAXHOST], port[NI_MAXSERV];
                socklen_t slen;

                slen = sizeof(ss);
                if (getpeername(m_socket, (struct sockaddr *)&ss, &slen) == -1)
                        err(1, "getpeername");
                if (getnameinfo((struct sockaddr *)&ss, ss.ss_len, host,
                    sizeof(host), port, sizeof(port),
                    NI_NUMERICHOST | NI_NUMERICSERV))
                        errx(1, "getnameinfo");
                cout <<"peer: " <<host <<" " <<port <<endl <<flush;
        }

        void tls_emit_data(const uint8_t data[], size_t size) override
        {
                size_t off = 0, len = size;

                while (len > 0) {
                        ssize_t n;

                        n = send(m_socket, data + off, len, 0);
                        if (n < 0)
                                err(1, "send");
                        off += n;
                        len -= n;
                }
        }

        void tls_record_received(uint64_t seq_no, const uint8_t data[],
            size_t size) override
        {
                cout <<"<<< " <<string((const char *)data, size) <<flush;

                string str("hello\n");
                cout <<">>> " <<str <<flush;
                m_channel->send(str);
                m_channel->close();
        }

        void tls_alert(Botan::TLS::Alert alert) override
        {
                errx(1, "alert: %s", alert.type_string().c_str());
        }

        bool tls_session_established(const Botan::TLS::Session& session)
            override
        {
                cout <<"established" <<endl <<flush;
                return false;
        }

        void set_channel(Botan::TLS::Channel &channel) {
                m_channel = &channel;
        }

protected:
        int m_socket = -1;
        Botan::TLS::Channel *m_channel = nullptr;
};

class Credentials : public Botan::Credentials_Manager {
public:
        std::vector<Botan::Certificate_Store*> trusted_certificate_authorities(
            const std::string  &type, const std::string  &context)
            override
        {
                std::vector<Botan::Certificate_Store*> cs { &m_ca };
                return cs;
        }

        void add_certificate_file(const std::string &file) {
                Botan::X509_Certificate cert(file);
                m_ca.add_certificate(cert);
        }
private:
        Botan::Certificate_Store_In_Memory m_ca;
};

class Policy : public Botan::TLS::Strict_Policy {
public:
        bool require_cert_revocation_info() const override {
                return false;
        }
};

void __dead
usage(void)
{
        fprintf(stderr, "usage: client [-C CA] host port\n");
        exit(2);
}

int
main(int argc, char *argv[])
{
        struct addrinfo hints, *res;
        int ch, s, error;
        char buf[256];
        char *cafile = NULL;
        char *host, *port;

        while ((ch = getopt(argc, argv, "C:")) != -1) {
                switch (ch) {
                case 'C':
                        cafile = optarg;
                        break;
                default:
                        usage();
                }
        }
        argc -= optind;
        argv += optind;
        if (argc == 2) {
                host = argv[0];
                port = argv[1];
        } else {
                usage();
        }

        memset(&hints, 0, sizeof(hints));
        hints.ai_family = AF_INET;
        hints.ai_socktype = SOCK_STREAM;
        error = getaddrinfo(host, port, &hints, &res);
        if (error)
                errx(1, "getaddrinfo: %s", gai_strerror(error));
        if (res == NULL)
                errx(1, "getaddrinfo empty");
        s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if (s == -1)
                err(1, "socket");
        if (connect(s, res->ai_addr, res->ai_addrlen) == -1)
                err(1, "connect");
        freeaddrinfo(res);

        {
                Callbacks callbacks(s);
                Botan::AutoSeeded_RNG rng;
                Botan::TLS::Session_Manager_In_Memory session_mgr(rng);
                Credentials creds;
                if (cafile != NULL)
                        creds.add_certificate_file(cafile);
                Policy policy;

                callbacks.print_sockname();
                callbacks.print_peername();
                Botan::TLS::Client client(callbacks, session_mgr, creds,
                    policy, rng);
                callbacks.set_channel(client);

                while (!client.is_closed()) {
                        ssize_t n;

                        n = recv(s, buf, sizeof(buf), 0);
                        if (n < 0)
                                err(1, "recv");
                        if (n == 0)
                                errx(1, "eof");
                        client.received_data((uint8_t *)&buf, n);
                }
        }

        if (close(s) == -1)
                err(1, "close");

        cout <<"success" <<endl;

        return 0;
}