    // ------------------------------- //
    // -------- Start of File -------- //
    // ------------------------------- //
    // ----------------------------------------------------------- //
    // C++ Source Code File Name: server.cpp
    // Compiler Used: MSVC, GCC
    // Produced By: DataReel Software Development Team
    // File Creation Date: 10/17/2001
    // Date Last Modified: 06/17/2016
    // Copyright (c) 2001-2024 DataReel Software Development
    // ----------------------------------------------------------- //
    // ------------- Program Description and Details ------------- //
    // ----------------------------------------------------------- //
    /*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
    USA

    This is a test program used demonstrate the use of the gxSSL
    class in a multi-threaded HTTPS server application.
    */
    // ----------------------------------------------------------- //
    #include "gxdlcode.h"

    #if defined (__USE_ANSI_CPP__) // Use the ANSI Standard C++ library
    #include <iostream>
    using namespace std; // Use unqualified names for Standard C++ library
    #else // Use the old iostream library by default
    #include <iostream.h>
    #endif // __USE_ANSI_CPP__

    #include <string.h>
    #include <stdlib.h>
    #include "m_thread.h"

    class ConsoleThread : public gxThread
    {
    public:
      ConsoleThread() { }
      ~ConsoleThread() { }

    private:
      void *ThreadEntryRoutine(gxThread_t *thread);
    };

    void *ConsoleThread::ThreadEntryRoutine(gxThread_t *thread)
    {
      const int cmd_len = 255;
      char sbuf[cmd_len];

      while(1) {
        for(int i = 0; i < cmd_len; i++) sbuf[i] = 0;
        cin >> sbuf;
        if(strcmp(sbuf, "quit") == 0) break;
        if(strcmp(sbuf, "exit") == 0) break;
        cout << "Invalid command" << "\n" << flush;
        cout << "Enter quit to exit" << "\n" << flush;
      }
      return (void *)0;
    }

    void KeyGenCallback(int p, int n, void *arg)
    {
      char c = 'B';
      if (p == 0) c = '.';
      if (p == 1) c = '+';
      if (p == 2) c = '*';
      if (p == 3) c = '\n';
      cout << c << flush;
    }

    void nt_SSL_error_print(gxSSL *ssl)
    // Non-thread safe error message print
    {
      if(!ssl) return;
      gxString err;
      cout << ssl->SSLExceptionMessage() << "\n" << flush;
      gxSSL::GlobalSSLError(err);
      cout << err.c_str() << "\n" << flush;
    }

    void InputData(const char *prompt, gxString &data)
    // Function used to read a string from the input stream.
    {
      data.Clear();
      if(!prompt) return;
      char buf[1024];
      memset(buf, 0, 1024);
      cout << prompt << ": " << flush;
      cin.getline(buf, sizeof(buf));
      data << buf;
    }

    int main(int argc, char **argv)
    {
      // Check arguments. Should be only one: the port number to bind to.
      if(argc != 2) {
        cerr << "Usage: " << argv[0] << " port" << "\n" << flush;
        return 1;
      }

      ServerThread server;
      gxSSL *ssl = &server.openssl;
      gxRandom rand_num;

      servercfg->port = (gxsPort_t) atoi(argv[1]);
      const char *private_key_fname = "server_private_key.pem";
      const char *cert_req_fname = "server_cert.pem";
      const char *dh_fname = "dhparms.pem";

      if(!futils_exists(dh_fname)) {
        cout << "Generating Diffie-Hellman parameters file" << "\n" << flush;
        if(ssl->InitPRNG() != gxSSL_NO_ERROR) {
          nt_SSL_error_print(ssl);
          return 1;
        }
        if(ssl->MakeDHParms(dh_fname) != gxSSL_NO_ERROR) {
          nt_SSL_error_print(ssl);
          return 1;
        }
      }

      if(!futils_exists(private_key_fname)) {
        cout << "Generating private RSA key" << "\n" << flush;

        if(ssl->InitPRNG() != gxSSL_NO_ERROR) {
          nt_SSL_error_print(ssl);
          return 1;
        }
        if(ssl->MakeRSAPrivateKey(private_key_fname, 2048,
    			      KeyGenCallback, 0) != gxSSL_NO_ERROR) {
          nt_SSL_error_print(ssl);
          return 1;
        }

        cout << "\n" << flush;
        cout << "Generating and self-signing certificate request" << "\n" << flush;
        gxCertIssuerInfo ci;
        ci.sn = rand_num.RandomNumber();
        ci.days = 365;
        InputData("Country Name XX", ci.C);
        if(ci.C.is_null()) ci.C = "US";
        InputData("State or Province", ci.ST);
        if(ci.ST.is_null()) ci.ST = "MyState";
        InputData("City or Locality", ci.L);
        if(ci.L.is_null()) ci.L = "MyCity";
        InputData("Organization Name", ci.O);
        if(ci.O.is_null()) ci.O = "My Org. Name";
        InputData("Organizational Unit", ci.OU);
        if(ci.OU.is_null()) ci.OU = "My Org. Unit";
        InputData("Common Name (or site name)", ci.CN);
        if(ci.CN.is_null()) ci.CN = "my.server.com";

        // Add standard extensions if needed by application
        // ci.basic_constraints = "critical,CA:TRUE";
        // ci.key_usage = "critical,keyCertSign,cRLSign";
        // ci.subject_key_identifier = "hash";

        // Add Netscape specific extensions if needed by application
        // ci.netscape_cert_type = "sslCA";
        // ci.netscape_comment = "my comment extension";

        if(ssl->MakeCertReq(private_key_fname, ci, cert_req_fname)!=
           gxSSL_NO_ERROR) {
          nt_SSL_error_print(ssl);
          return 1;
        }
      }

      cout << "Initializing HTTPS server..." << "\n" << flush;
      int rv = server.InitServer(servercfg->port);
      if(rv != 0) {
        cout << server.SocketExceptionMessage() << "\n" << flush;
        return 1;
      }

      if(!gxSSL::InitSSLibrary()) {
        cout << "Error initializing SSL library" << "\n" << flush;
        nt_SSL_error_print(ssl);
        return 1;
      }
      cout << "Initializing SSL context object..." << "\n" << flush;
      if(!ssl->InitCTX(cert_req_fname, private_key_fname)) {
        nt_SSL_error_print(ssl);
        return 1;
      }

      cout << "Loading Diffie-Hellman parameters..." << "\n" << flush;
      if(ssl->LoadDHParms(dh_fname) != gxSSL_NO_ERROR) {
        nt_SSL_error_print(ssl);
        return 1;
      }

      // Get the host name assigned to this machine
      char hostname[gxsMAX_NAME_LEN];
      rv = server.GetHostName(hostname);
      if(rv != 0) {
        cout << server.SocketExceptionMessage() << "\n" << flush;
        return 1;
      }

      cout << "Opening HTTPS server on host " << hostname << "\n" << flush;
      cout << "Enter quit to exit" << "\n" << flush;
      cout << "\n" << flush;

      cout << "Listening on port " << servercfg->port << "\n" << flush;
      cout.flush();

     gxThread_t *server_thread = server.CreateThread();
      if(server_thread->GetThreadError() != gxTHREAD_NO_ERROR) {
        cout << server_thread->ThreadExceptionMessage() << "\n" << flush;
        return 1;
      }

      ConsoleThread console;
      gxThread_t *console_thread = console.CreateThread();
      if(console_thread->GetThreadError() != gxTHREAD_NO_ERROR) {
        cout << console_thread->ThreadExceptionMessage() << "\n" << flush;
        return 1;
      }

      if(console.JoinThread(console_thread) != 0) {
        cout << "Could not join the console thread" << "\n" << flush;
      }

      // Destroy the serial port receiver thread
      cout << "Stopping the server thread..." << "\n" << flush;
      servercfg->accept_clients = 0;

      // Cannot the server thread due to the blocking accept() function, so
      // cancel the thread before it is destroyed
      server.CancelThread(server_thread);
      if(server_thread->GetThreadState() == gxTHREAD_STATE_CANCELED) {
        cout << "The server thread was stopped" << "\n" << flush;
      }
      else {
        cout << "Could not cancel the server thread" << "\n" << flush;
      }

      if(server.JoinThread(server_thread) != 0) {
        cout << "Could not join the server thread" << "\n" << flush;
      }

      delete server_thread;
      delete console_thread;

      cout << "Exiting..." << "\n" << flush;
      return 0;
    }
    // ----------------------------------------------------------- //
    // ------------------------------- //
    // --------- End of File --------- //
    // ------------------------------- //