common/ttyconn.cc

Go to the documentation of this file.

//
// The TTYConnector class - connect to a tty...
//
// ***** 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 <fcntl.h>
}

#include <sstream>

#include "consmgr.h"
#include "ttyconn.h"
#include "guard.h"

TTYConnector::TTYConnector(const std::string &dev) : saved_state(NULL)
{
    // Initialize our mutex
    int ret = pthread_mutex_init(&mutex, NULL);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_init(mutex)");

    // Open the device
    open_device(dev);
    connect();
}

TTYConnector::TTYConnector(const int in, const int out) : saved_state(NULL)
{
    // Initialize our mutex
    int ret = pthread_mutex_init(&mutex, NULL);
    PTHREAD_CHECK_AND_THROW(ret, "mutex_init(mutex)");

    // Set up state, and check the input fd for being a TTY
    setup_fds(in, out);
    connect();
}

TTYConnector::~TTYConnector(void) throw()
{
    int         ret;

    disconnect();
#if SHOULD_NOT_BE_HERE
    // Is it safe to be calling shutdown here?  I think so, because
    // we don't implement our own, and the destructor for Connection
    // (and thus elimination of Connection::shutdown from our object)
    // is guaranteed to happen after TTYConnector::~TTYConnector...
    clog << "Calling shutdown() from TTYConnector(" << this << ")::~TTYConnector" << endl;
    try {
        shutdown();
    } CATCH_OR_DIE(17) {
        cerr << "Connection::shutdown from TTYConnector(" << this << ") failed!"
             << endl;
        exit(17);
    }
#endif

    ret = pthread_mutex_destroy(&mutex);
    if (ret != 0)
        cerr << "TTYConnector::~TTYConnector: Unable to destroy mutex ("
             << &mutex << "): " << strerror(ret) << endl;

    clog << "TTYConnector::~TTYConnector() returning" << endl;

    return;
}

#if 0
void
TTYConnector::notify_on_disconnect(const Messageable *owner)
{
    add_recipient(owner);
}
#endif

//
// Set/config functions...
//

void
TTYConnector::setup_fds(int r, int w)
{
    struct termios      tio;

    {
        /* Lock the mutex while setting the fd's, so noone can access */
        /* them while only one has been set. */
        Guard   locker(&mutex);

        read_fd = r;
        write_fd = w;
    }

    // If the input fd is a TTY, configure it to be in RAW mode, saving
    // the original state in private data for restoration in our destructor.
    if (isatty(r)) {
        clog << "RAW'ing fd#" << r << " (" << ttyname(r) << ")" << endl;
        saved_state = new struct termios;

        if (tcgetattr(r, saved_state) < 0) {
            throw(fireball(48,
                           "TTYConnector::setup_fds() - tcgetattr failed", true));
        }
        memcpy(&tio, saved_state, sizeof(struct termios));
        cfmakeraw(&tio);
        tio.c_cflag |= CLOCAL;
        tcsetattr(r, TCSAFLUSH, &tio);
        clog << "tcsetaddr completed" << endl;
    }

    clog << "TTYConnector::setup_fds(" << r << ", " << w << ")";

    return;
}

// Open a TTY device for reading and writing
void
TTYConnector::open_device(string dev_fn)
{
    int         fd;

    fd = ::open(dev_fn.c_str(), O_RDWR, 0);
    if (fd < 0) {
        throw "Error from ::open(): " + string(strerror(errno));
    }

    Guard       locker(&mutex);

    // XXX Could call setup_fds(), but we know it's not a TTY, right?
    read_fd = write_fd = fd;

    return;
}

// Establish a connection to a TTY.
//
// This assumes the read_fd and write_fd have been set already.  If not,
// it's a bit confused...
void
TTYConnector::connect(void)
{
    //MUTEX_LOG("TTYConnector::connect locking mutex " << &mutex);

    Guard       locker(&mutex);

    // This is fairly basic.  We'll assume the fd's are okay if they're
    // non-negative.  If so, we're connected!
    if ((read_fd < 0) || (write_fd < 0))
        throw(fireball(21, "Ack.  Unset read_fd or write_fd!"));

    //MUTEX_LOG("TTYConnector::connect unlocking mutex " << &mutex);

#if 0
    // Set connection active, which will broadcast state-change
    this->set_connected(true);
#endif

    return;
}

void
TTYConnector::disconnect(void)
{
    clog << "TTYConnector(" << this << ")::disconnect: ";
    // Restore the saved_state of the read tty...
    if (saved_state) {
        clog << "Restoring saved tty state..." << endl;
        tcsetattr(read_fd, TCSANOW, saved_state);
    } else
        clog << "no saved tty state to restore..." << endl;

    close(read_fd);
    if (write_fd != read_fd)
        close(write_fd);
}

//
// Generate a string to tell a human who we are...
//

string
TTYConnector::get_id(void) const
{
    std::ostringstream  id_str;

    id_str << "TTYConnector(read " << read_fd << "; write " << write_fd << ")";
    //id_str << "TTYConnector";

    return(id_str.str());
}

bool
TTYConnector::connected(void) const
{
    Guard       locker(&mutex);

    if ((read_fd >= 0) && (write_fd >= 0))
        return true;
    else
        return false;
}

// Both this code and that in FDConnector are very similar. The difference is
// that we have two separate fds to deal with. Hmm.
Data *
TTYConnector::read()
{
    char *buf = new char[Connector::BufSize];
    int len;
    while ((len = ::read(read_fd, buf, Connector::BufSize)) <= 0) {
        // XXX - Do anything? Is this dangerous to loop like this? Probably.
    }
    // XXX - Log this:
    //clog << "read " << len << " bytes (" << this->get_id() << ";fd " << sock_fd <<
    //  "): " << (string(buf)).substr(0,len) << endl;

    // Now return a Blob wrapping that data...
    return new Data((u_char *)buf, len);
}

ssize_t
TTYConnector::write(const Data &b)
{
    return ::write(write_fd, b.data(), b.len());
}

---