term.cc

Go to the documentation of this file.

/*
 * Copyright (C) 2008 Kamil Dudka <xdudka00@stud.fit.vutbr.cz>
 *
 * This file is part of rob08
 *
 * rob08 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * rob08 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with rob08.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"
#include "term.h"

#include "core.h"
#include "robIO.h"
#include "scanner.h"

#ifndef BUILDING_DOX
#   include <assert.h>
#   include <errno.h>
#   include <fcntl.h>
#   include <fstream>
#   include <iomanip>
#   include <poll.h>
#   include <signal.h>
#   include <sstream>
#   include <string>
#   include <sys/types.h>
#   include <sys/stat.h>
#   include <unistd.h>
#endif

volatile sig_atomic_t bSignal = 0;

using namespace StreamDecorator;
using std::string;

class Term: public ITerm {
    public:
        Term(int fd, const string &fileName);
        ~Term();
        virtual bool hasError() const { return hasError_; }
        virtual bool writeAck();
        virtual bool writeByte(unsigned char data);
        virtual bool writeWord(unsigned int data);
        virtual bool writeText(const std::string &data);
        virtual bool getChar(char &c);
        virtual bool hasInput(int timeout);

    private:
        int             fd_;
        string          fileName_;
        bool            hasError_;

        bool            write(const std::string &data);
};

ITerm* TermFactory::createTerm(const std::string &fileName) {
    // check if given file is valid
    const char *const szFileName = fileName.c_str();
    struct stat statBuff;
    if (0 != stat(szFileName, &statBuff)) {
        std::cerr << Error(E_ERROR, fileName, "file does not exist") << std::endl;
        return 0;
    }
    if (! S_ISCHR(statBuff.st_mode)) {
        std::cerr << Error(E_ERROR, fileName, "file is not character device") << std::endl;
        return 0;
    }

    // check for permissions
    if (0!= euidaccess(szFileName, R_OK)) {
        std::cerr << Error(E_ERROR, fileName, "insufficient permissions to read from device") << std::endl;
        return 0;
    }
    if (0!= euidaccess(szFileName, W_OK)) {
        std::cerr << Error(E_ERROR, fileName, "insufficient permissions to write to device") << std::endl;
        return 0;
    }

    // open terminal
    // FIXME: use appropriate flags
    int fd = ::open(szFileName, O_RDWR|O_SYNC|O_NOCTTY);
    if (0 > fd) {
        std::cerr << Error(E_ERROR, fileName, "open = ") << fd << std::endl;
        std::cerr << Error(E_NOTE, fileName, "errno = ") << errno << std::endl;
        return 0;
    }

    return new Term(fd, fileName);
}

Term::Term(int fd, const string &fileName):
    fd_(fd),
    fileName_(fileName),
    hasError_(false)
{
    assert(0 <= fd);
}

Term::~Term() {
    ::close(fd_);
}

bool Term::writeAck() {
    return writeText("A");
}

bool Term::writeByte(unsigned char data) {
    data &= 0xFF;                                       // maybe not necessary for unsigned char

#if DEBUG_TERM_OUTPUT
    std::cerr << Color(C_LIGHT_GREEN) << "TERM" << Color(C_NO_COLOR) << " <-- "
        << Color(C_LIGHT_CYAN) << "0x" << PrintHex(data, 2) << Color(C_NO_COLOR) << std::endl;
#endif

    std::ostringstream out;
    out << PrintHex(data, 2) << std::flush;
    return write(out.str());
}

bool Term::writeWord(unsigned int data) {
    data &= 0xFFFF;

#if DEBUG_TERM_OUTPUT
    std::cerr << Color(C_LIGHT_GREEN) << "TERM" << Color(C_NO_COLOR) << " <-- "
        << Color(C_LIGHT_CYAN) << "0x" << PrintHex(data, 4) << Color(C_NO_COLOR) << std::endl;
#endif

    std::stringstream out;
    out << PrintHex(data, 4) << std::flush;
    return write(out.str());
}

bool Term::writeText(const std::string &data) {
#if DEBUG_TERM_OUTPUT
    std::cerr << Color(C_LIGHT_GREEN) << "TERM" << Color(C_NO_COLOR) << " <-- "
        << Color(C_LIGHT_PURPLE) << data << Color(C_NO_COLOR) << std::endl;
#endif

    return write(data);
}

bool Term::write(const std::string &data) {
    const char *buff = data.c_str();
    int toWrite = data.size();
    while (0 < toWrite) {
        int ret = ::write(fd_, buff, toWrite);
        if (ret <= 0) {
            if (errno == EINTR)
                // write interrupted by signal
                continue;

            hasError_ = false;
            std::cerr << Error(E_ERROR, fileName_, "write = ") << ret << std::endl;
            std::cerr << Error(E_NOTE, fileName_, "errno = ") << errno << std::endl;
            return false;
        }
        assert (ret <= toWrite);
        toWrite -= ret;
        buff += ret;
    }
    return true;
}

bool Term::getChar(char &c) {
    for(;;) {
        int ret = ::read(fd_, &c, 1);
        if (ret == 1)
            return true;

        switch (errno) {
            case EIO:
            case EINTR:
                break;
            default:
                std::cerr << Error(E_ERROR, fileName_, "read = ") << ret << std::endl;
                std::cerr << Error(E_NOTE, fileName_, "errno = ") << errno << std::endl;
                return false;
        }

#if DEBUG_TERM_POLL
        std::cerr << Error(E_WARNING, fileName_, "calling poll") << std::endl;
#endif
        struct pollfd fds;
        fds.fd = fd_;
        fds.events = POLLIN;
        do {
            if (bSignal) {
                std::cerr << Error(E_NOTE, fileName_, "signal caught") << std::endl;
                return false;
            }
            // FIXME: this should not be here
            // way to hell
            usleep(10);
        } while (1 == poll(&fds, 1, -1) && !(fds.revents & POLLIN));
    }
}

bool Term::hasInput(int timeout) {
        struct pollfd fds;
        fds.fd = fd_;
        fds.events = POLLIN;
        return (1 == poll(&fds, 1, timeout) && (fds.revents & POLLIN));
}

---