ttysrv/ttysrv.cc

Go to the documentation of this file.

//
// ttysrv.cc - This is the main component of the ttysrv program, which will
// accept client connections through a UNIX domain socket, and maintains
// a consistent connection to a host/port on a directly-connected serial port.
//
// ***** BEGIN LICENSE BLOCK *****
// Version: MPL 1.1/GPL 2.0/LGPL 2.1
// 
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (the "License"); you may not use this file except in
// compliance with the License. You may obtain a copy of the License at
// http://www.mozilla.org/MPL/
// 
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
// the License for the specific language governing rights and limitations
// under the License.
// 
// The Original Code is the consmgr network/serial-line monitoring package.
// 
// The Initial Developer of the Original Code is Chris P. Ross.
// Portions created by the Initial Developer are Copyright (C) 2000-2008
// the Initial Developer.  All Rights Reserved.
// 
// Contributor(s):
// 
// Alternatively, the contents of this file may be used under the terms of
// either the GNU General Public License Version 2 or later (the "GPL"), or
// the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
// in which case the provisions of the GPL or the LGPL are applicable instead
// of those above. If you wish to allow use of your version of this file only
// under the terms of either the GPL or the LGPL, and not to allow others to
// use your version of this file under the terms of the MPL, indicate your
// decision by deleting the provisions above and replace them with the notice
// and other provisions required by the GPL or the LGPL. If you do not delete
// the provisions above, a recipient may use your version of this file under
// the terms of any one of the MPL, the GPL or the LGPL.
// 
// ***** END LICENSE BLOCK *****

extern "C" {
#include <unistd.h>
#include <netinet/in.h>
}

#include <fstream>

#include "consmgr.h"
#include "cmconfig.h"
#include "incoming.h"
#include "logfile.h"
#include "history.h"
#include "ttyconn.h"
#include "udslistener.h"

/* Internal function prototypes */
static void usage(void);

int
main(int argc, char *argv[])
{
    int                 ret, ch;

    // Shut off clog until we parse options...
    std::ofstream               *null = new std::ofstream("/dev/null");
    clog.rdbuf(null->rdbuf());

    bool                        debug = false;
    bool                        foreground = false; 
    pthread_t                   server_pt, client_pt;
    std::vector<pthread_t>      threads;
    Config                      *cnf = NULL;
    BiDirConn                   *serv = NULL;

    // ConfigFactory::config_object() may throw exceptions
    try {
        while ((ch = getopt(argc, argv, "c:fDv")) != -1) {
            switch (ch) {
              case 'c':
                if (cnf)
                    err(5,"Only one configuration file [currently] allowed");
                else
                    cnf = ConfigFactory::config_object(optarg);
                break;
              case 'D':
                debug = true;
                break;
              case 'f':
                foreground = true;
                break;
              case 'v':
                std::cout << "ttysrv, part of consmgr, built " << __DATE__
                          << " " << __TIME__ << endl;
                break;
              case '?':
                usage();
                exit(1);
            }
        }

        if (cnf == NULL)
            cnf = ConfigFactory::config_object("/etc/consmgr.conf");
        
        argc -= optind;
        argv += optind;

        if (argc != 1) {
            usage();
            exit(1);
        }
    } catch (const string &error) {
        cerr << error << endl;
        exit(7);
    } catch (...) {
        cerr << "Other random exception thrown while parsing arguments"
             << endl;
        exit(7);
    }

    // Hold on to the entry we're to configure ourselves to use...
    string      entry(argv[0]);

    // Set up the debugging stream to go to stderr, and nuke the
    // temporary null out we made for it...
    if (debug) {
        clog.rdbuf(cerr.rdbuf());
        delete null;
    }

    // Look up the configuration for the specified connection
    try {
        cnf->load_entry(argv[0]);
    } CATCH_STR_OR_DIE(2) {
        cerr << "** Uncaught exception in cnf.load_entry(" << entry
             << ")!!" << endl;
        exit(2);
    }

    // Set the address of this server
    try {
        if (cnf->find("device") == cnf->end())
            throw "No 'device' parameter in configuration for '" + entry + "'";
        ConnectorP      dev(new TTYConnector((*cnf)["device"]));
        serv = new BiDirConn(dev);
    } CATCH_STR_OR_DIE(3) {
        cerr << "** Uncaught exception in open_dev(cnf.str(\"device\"))!!"
             << endl;
        exit(3);
    }

#if 0
    ret = pthread_create(&server_pt, NULL, BiDirConn::establish_wrapper,
                         serv);
    PTHREAD_CHECK_AND_THROW(ret, "pthread_create(server_pt)");
    threads.push_back(server_pt);
#endif

    // If we're to log, establish the LogFile outlet, and connect it to
    // the server Connection...
    if (cnf->find("logfile") != cnf->end()) {
        //string                lfstr;
        try {
            // ** Must be dynamically allocated, so it won't get destroyed
            //    at end of scope **
            ConnectorP  lf(new LogFile((*cnf)["logfile"]));
#if 0
            pthread_t   log_pt;

            // Lame.  Connection has establish_wrapper(), Outlet has establish()
            ret = pthread_create(&log_pt, NULL, Outlet::establish, lf);
            PTHREAD_CHECK_AND_THROW(ret, "pthread_create(log_pt)");

            threads.push_back(log_pt);
#endif
            serv->add_recipient(new Outlet(lf));
        } CATCH_STR_OR_DIE(4) {
            cerr << "Unable to open and attach logfile '" << (*cnf)["logfile"]
                 << "'." << endl;
        }
    }
#if defined(HISTORY) && (HISTORY > 0)
    // Keep a history in-memory to be returned on request.
    try {
        ConnectorP      hist(new History(HISTORY));
#if 0
        pthread_t       hist_pt;

        ret = pthread_create(&hist_pt, NULL, Outlet::establish, hist);
        PTHREAD_CHECK_AND_THROW(ret, "pthread_create(hist_pt)");

        threads.push_back(hist_pt);
#endif
        serv->add_recipient(new Outlet(hist));
    } CATCH_STR_OR_DIE(5) {
        cerr << "Unable to set up History module (size " << HISTORY
             << ")." << endl;
    }
#endif  /* HISTORY */

    // See if a socket path is set.  If it's not, we're screwed.  Bail...
    std::string         socket_path;

    if (cnf->find("local_socket") != cnf->end())
        try {
            socket_path = (*cnf)["local_socket"];
        } CATCH_STR_OR_DIE(5) {
            cerr << "Unable to get/set UDSConn address from configuration."  << endl;
            exit(5);
        }
    else {
        cerr << "No 'local_socket' parameter is specified for " << argv[0]
             << "; cannot proceed." << endl;
        exit(5);
    }
    // Then, start up the listener for the client connections...  See if a
    SocketAddressP      client_socket(new UDSSocketAddress(socket_path));
    ListenerP           base(new UDSListener(client_socket));

    Incoming            client(base, CONNECT_TO_ONE(serv));
#if 0
    ret = pthread_create(&client_pt, NULL, Listener::listen_for_connections,
                         &client);
    PTHREAD_CHECK_AND_THROW(ret, "pthread_create(client_pt)");
    threads.push_back(client_pt);
#endif

    // Now, we should switch into just waiting for input (signals,
    // I think, are the only input we'll get here...); and pass on
    // messages to our thread children when we get them...
    // XXX - to be implemented

    /* XXX - hacka hacka - we don't really want to join the thread */
    ret = pthread_join(server_pt, NULL);
    PTHREAD_CHECK_AND_THROW(ret, "pthread_join");

    cerr << "Exiting..." << endl;

    // Close down the Listener and unlink the socket file
    base->disconnect();

    exit(0);
}

static void
usage(void)
{
    cerr << "Usage: " << __progname << " [-D] [-t] [-c <config-file>]"
         << " <connection-name>" << endl;
    return;
}

---