port.cpp

Go to the documentation of this file.

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>
#include <termios.h>

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

#include "port.h"
#include "serial.h"

PortException::PortException(const char* con, const char* msg) :
    conn_str(con), message(msg)
{
    fprintf(stderr,"PortException: %s: %s\n", conn_str, message);
    fflush(stderr);
}


Port::Port(const char* conn_string, struct pollfd* pollfd_ptr)
    : m_conn_string(conn_string), m_pollfd_ptr(pollfd_ptr)
{
    if (m_pollfd_ptr == 0) {
        throw new PortException(m_conn_string, "pollfd object not specified.");
    } else {
        m_pollfd_ptr->fd = -1;
        m_pollfd_ptr->events = POLLIN;
    }
}

Port::~Port() {
    /* Trivial destructor.  But if you inline this in the class definition,
     * you'll find that gcc spits a bunch of undefined vtable references
     * in your face. */
}

Port* Port::create(const char *conn_string, struct pollfd* pollfd_ptr) {
    if( ! strncmp(conn_string, "serial:", 7) ) {
        return new SerialPort(conn_string, pollfd_ptr);
    } else if( !strncmp(conn_string, "pty:", 4) ) {
        return new PtyPort(conn_string + 4, pollfd_ptr);
    } else {
        return new PtyPort(conn_string, pollfd_ptr);
    }
}
    
short Port::poll_revents() {
    return m_pollfd_ptr->revents;
}

PtyPort::PtyPort(const char* path, struct pollfd* pollfd_ptr) : Port(0, pollfd_ptr), m_path(path), m_slavefd(-1)
{
    /* Make sure no file already exists at path */
    if( ! access(m_path, F_OK) ) {
        throw new PortException(m_path, "File already exists");
    }

    _create_pty();
}

PtyPort::~PtyPort()
{
    unlink(m_path);
    if(m_pollfd_ptr->fd >= -1) close(m_pollfd_ptr->fd);
    if(m_slavefd >= -1) close(m_slavefd);
}

void PtyPort::_create_pty()
{
    /* Create the PTY */
    m_pollfd_ptr->fd = posix_openpt( O_RDWR | O_NOCTTY | O_NDELAY);
    if( m_pollfd_ptr->fd == -1 ) {
        throw new PortException(m_path, strerror(errno));
    }

    if( grantpt(m_pollfd_ptr->fd) ) {
        throw new PortException(m_path, strerror(errno));
        }
        if( unlockpt(m_pollfd_ptr->fd) ) {
        throw new PortException(m_path, strerror(errno));
        }

    /* Disable echoing */
    struct termios pty_attr;
    if( tcgetattr(m_pollfd_ptr->fd, &pty_attr) ) {
        throw new PortException(m_path, strerror(errno));
    }
    cfmakeraw(&pty_attr);
    if( tcsetattr(m_pollfd_ptr->fd, TCSANOW, &pty_attr) ) {
        throw new PortException(m_path, strerror(errno));
    }

    /* Obtain the name of the slave device file */
        const char *slave_name = (const char*)ptsname(m_pollfd_ptr->fd);
    if( !slave_name ) {
        throw new PortException(m_path, strerror(errno));
        }

    /* Open the slave device 
     * We never ever actually do anything with this.  This is a hack; it 
     * ensures that there is always an open file descriptor to the pty, so
     * it doesn't get closed when a client process closes the slave */
    m_slavefd = open(slave_name, O_RDWR | O_NOCTTY);

    /* Create a symlink to the slave device file */
    // Remove any old symlink
    int retval = unlink( m_path );
    if( (retval) && (errno!=ENOENT) ) {
        throw new PortException(m_path, strerror(errno));
    }
    retval = symlink(slave_name, m_path);
    if(retval) {
        throw new PortException(m_path, strerror(errno));
    }

    printf("\nCreated pty: %s --> %s\n", m_path, slave_name);
}

void PtyPort::_respawn_pty()
{
    if( m_pollfd_ptr->fd >= 0 ) close(m_pollfd_ptr->fd);
    _create_pty();
}

ssize_t PtyPort::read(void *buf, size_t count)
{
    if(m_pollfd_ptr->fd == -1 ) throw new PortException(m_path, "Attempted read from invalid pty");

    int retval = ::read(m_pollfd_ptr->fd, buf, count);
    if( (retval < 0) && (errno!=EAGAIN) ) {
        /* I/O error, attempt to respawn pty */ 
        _respawn_pty();
        return 0;
    } 
    if( retval <= 0 ) {
        // No data
        return 0;
    }
    return 1;
}

ssize_t PtyPort::write(void *buf, size_t count)
{
    if(m_pollfd_ptr->fd == -1) throw new PortException(m_path, "Attempted write to invalid pty");

    int retval = ::write(m_pollfd_ptr->fd, buf, count);
    if( (retval < 0) && (errno!=EAGAIN) ) {
        /* I/O error, attempt to respawn pty */
        _respawn_pty();
    }
}

SerialPort::SerialPort(const char* conn_str, struct pollfd* pollfd_ptr)
    : Port(conn_str, pollfd_ptr)
{
    if( strncmp(conn_str, "serial:", 7) ) 
        throw new PortException(conn_str, "Bad serial connection string");

    /* Parse out the device name */
    const int devname_ofst = 7;
    char portname[128];
    // Dev name ends with the comma, or end of string
    int i;
    for(i=devname_ofst; conn_str[i]!='\0' && conn_str[i]!=','; ++i) {
        if( i>= 128 )
            throw new PortException(conn_str, "Buffer overrun reading device name");

        portname[i-devname_ofst] = conn_str[i];
    }
    portname[i-devname_ofst] = '\0';

    /* Parse out the baud rate */
    int baudrate = 115200;
    // If nothing followed the dev name, we just use default baud
    if( (conn_str[i] != '\0') || (conn_str[i+1]=='\0') ) {
        i++;  // at beginning of baud rate
        baudrate = atoi(conn_str+i);
    }

    printf("Opening serial port: %s, b%d\n", portname, baudrate);
    if( OpenSerial(&m_pollfd_ptr->fd, portname) < 0) {
        perror("OpenSerial");
        throw new PortException(conn_str, "Failed to open device.");
    }

    if( SetupSerial(m_pollfd_ptr->fd, baudrate) < 0) {
        perror("SetupSerial");
        throw new PortException(conn_str, "Failed to configure serial port.");
    }
}

SerialPort::~SerialPort()
{
    if(m_pollfd_ptr->fd != -1) close(m_pollfd_ptr->fd);
}

ssize_t SerialPort::read(void *buf, size_t count)
{
    return ::read(m_pollfd_ptr->fd, buf, count);
}

ssize_t SerialPort::write(void *buf, size_t count)
{
    int n = 0;
    do {
        errno = 0;
            n = ::write(m_pollfd_ptr->fd, buf, count);
    } while( errno == EAGAIN);
    return n;
}