NetServerTelnet.cpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#include "NetServerTelnet.hpp"
#include <string.h>

NetServerTelnet::NetServerTelnet(int priority, size_t stackSize) :
        mTask(priority, "TELNET", stackSize, *this) {
    mEntries = 0;
}

NetServerTelnet::~NetServerTelnet() {
}

void NetServerTelnet::ansiCursorUp(int value) {
    mSocket.printf("\x1B[%uA", value);
}

void NetServerTelnet::ansiCursorDown(int value) {
    mSocket.printf("\x1B[%uB", value);
}

void NetServerTelnet::ansiCursorForward(int value) {
    mSocket.printf("\x1B[%uC", value);
}

void NetServerTelnet::ansiCursorBack(int value) {
    mSocket.printf("\x1B[%uD", value);
}

void NetServerTelnet::ansiCursorPosition(int x, int y) {
    mSocket.printf("\x1B[%u;%uH", y, x);
}

void NetServerTelnet::ansiEraseData(int value) {
    mSocket.printf("\x1B[%uJ", value);
}

void NetServerTelnet::ansiEraseInLine(int value) {
    mSocket.printf("\x1B[%uK", value);
}

void NetServerTelnet::ansiSaveCursorPosition() {
    mSocket.printf("\x1B[s");
}

void NetServerTelnet::ansiRestoreCursorPosition() {
    mSocket.printf("\x1B[u");
}

void NetServerTelnet::ansiHideCursor() {
    mSocket.printf("\x1B[?25l");
}

void NetServerTelnet::ansiShowCursor() {
    mSocket.printf("\x1B[?25h");
}

void NetServerTelnet::iacNegotiate() {
    const static char IAC_COMMANDS[] = {
            IAC, WILL, SUPPRESS_GO_AHEAD, //
            IAC, WILL, ECHO, //
            IAC, DO, SUPPRESS_GO_AHEAD, //
            IAC, DONT, ECHO, //
            IAC, DONT, LINEMODE, //
            0 };
    mSocket.printf(IAC_COMMANDS);
}

int NetServerTelnet::getLine(char** line) {
    char c;
    unsigned int index = 0;
    bool isLineTooLong = false;
    *line = 0;
    char* buffer = (char*) malloc(MAX_LINE_LEN);
    if (!buffer) {
        return RESULT_ERR_MEMORY;
    }

    while (mSocket.read(&c, 1)) {
        if ((c >= 0x20) && (c < 0x7F)) {
            if (index < (MAX_LINE_LEN - 1)) {
                mSocket.write(&c, 1);
                buffer[index++] = c;
            }
            else {
                isLineTooLong = true;
            }
        }
        else if (c == '\r' || c == '\n') {
            if (!mIsLineFeedSeq) {
                mSocket.printf("\r\n");
                mIsLineFeedSeq = true;
                if (isLineTooLong) {
                    free(buffer);
                    return RESULT_ERR_LINE_TOO_LONG;
                }
                if (index == 0) {
                    free(buffer);
                    return RESULT_EMPTY_LINE;
                }
                buffer[index] = 0;
                buffer = (char*) realloc(buffer, index + 1);
                *line = buffer;
                return index;
            }
        }
        //Escape sequence
        else if (c == 0x1B) {
            //Get the '[' char
            mSocket.read(&c, 1);
            if (c == '[') {
                mSocket.read(&c, 1);
                switch (c) {
                    case 'A':
                        //UP
                        break;
                    case 'B':
                        //DOWN
                        break;
                    case 'C':
                        //RIGHT
                        break;
                    case 'D':
                        //LEFT
                        break;
                }
            }
        }
        else if (c == IAC) {
            //Read and discard next two bytes, TODO manage the commands
            mSocket.read(&c, 1);
            mSocket.read(&c, 1);
        }
        else {
            switch (c) {
                case 0x03:
                    //ETX
                    mSocket.close();
                    free(buffer);
                    return 0;
                case 0x7F:
                case '\b':
                    //BACKSPACE
                    if (index > 0) {
                        index--;
                        mSocket.printf("\b \b");
                    }
                    break;
            }
        }
        mIsLineFeedSeq = false;
    }
    free(buffer);
    return RESULT_ERR_IO;
}

void NetServerTelnet::freeLine(char* line) {
    if (line != 0) {
        free(line);
    }
}

int NetServerTelnet::getArgc(char* line) {
    int argc = 0;
    bool isSpaceFound = false;
    char c;
    while (true) {
        c = *line++;
        if (c == 0) {
            break;
        }
        else if (c == ' ') {
            isSpaceFound = true;
        }
        else if (isSpaceFound) {
            argc++;
            isSpaceFound = false;
        }
    }

    return argc;
}

void NetServerTelnet::getArgV(char* line, char* argv[]) {
    bool isSpaceFound = false;
    char c;
    while (true) {
        c = *line;
        if (c == 0) {
            break;
        }
        else if (c == ' ') {
            *line = 0;
            isSpaceFound = true;
        }
        else if (isSpaceFound) {
            *argv = line;
            argv++;
            isSpaceFound = false;
        }
        line++;
    }
}

void NetServerTelnet::onConnection() {

}

void NetServerTelnet::onDisconnection() {

}

void NetServerTelnet::run() {
    while (true) {
        mIsLineFeedSeq = false;
        mSocket.listen(23);
        mSocket.accept(Rtos::TICK_INFINITE);
        iacNegotiate();
        onConnection();
        mSocket.printf(">");
        while (mSocket.isConnected()) {
            char* line;
            int len = getLine(&line);
            bool isEntryFound = false;
            if (len > 0) {
                int argc = getArgc(line);
                char** argv = 0;
                if (argc > 0) {
                    argv = (char**) malloc(sizeof(char*) * argc);
                    if (!argv) {
                        freeLine(line);
                        break; //Disconnect
                    }
                }
                getArgV(line, argv);
                if (mEntries) {
                    for (const ENTRY* entry = mEntries; entry->name; entry++) {
                        if (strcmp((const char*) line, entry->name) == 0) {
                            (this->*entry->handler)(argc, argv);
                            isEntryFound = true;
                            break;
                        }
                    }
                }
                if (argv) {
                    free(argv);
                }
                freeLine(line);
                if (!isEntryFound) {
                    mSocket.printf("Invalid command\r\n");
                }
            }
            mSocket.printf(">");
        }
        onDisconnection();
        mSocket.close();
    }
}