Console.hxx

Go to the documentation of this file.

 
#ifndef _CONSOLE_CONSOLE_HXX_
#define _CONSOLE_CONSOLE_HXX_
 
#include "openmrn_features.h"
#include "utils/macros.h"
#include "executor/Service.hxx"
#include "executor/StateFlow.hxx"
 
#if OPENMRN_FEATURE_BSD_SOCKETS
#define CONSOLE_NETWORKING
#endif
 
class Console : public Service
{
private:
    struct Command;
 
    class Session;
 
public:
    enum CommandStatus
    {
        COMMAND_OK,        
        COMMAND_NEXT,      
        COMMAND_ERROR,     
        COMMAND_CLOSE,     
        COMMAND_NOT_FOUND, 
    };
 
    typedef CommandStatus (*Callback)(FILE *, int, const char *argv[], void *);
 
    Console(ExecutorBase *executor, uint16_t port);
 
    Console(ExecutorBase *executor, int fd_in, int fd_out, int port = -1);
 
    ~Console()
    {
    }
 
    void add_session(int fd_in, int fd_out)
    {
        open_session(fd_in, fd_out);
    }
 
    void add_command(const char *name, Callback callback, void *context = NULL);
 
    static const int FD_STDIN = 0;
 
    static const int FD_STDOUT = 1;
 
    class CommandFlow : public StateFlowBase
    {
    protected:
        CommandFlow(Console *console, const char *name);
 
        ~CommandFlow();
 
        virtual StateFlowBase::Action entry() = 0;
 
        StateFlowBase::Action read_line();
 
        int argc;
 
        const char **argv;
 
        FILE *fp;
 
        StateFlowBase::Action wait_for_line_and_call(StateFlowBase::Callback c)
        {
            fflush(fp);
            this->status = COMMAND_NEXT;
            session->notify();
            return wait_and_call(c);
        }
 
        StateFlowBase::Action record_status_and_exit(CommandStatus status)
        {
            this->status = status;
            session->notify();
            return STATE(exit);
        }
 
    private:
        CommandStatus callback(Session *session, int fd, FILE *fp, int argc, const char *argv[])
        {
            this->session = session;
            this->fd = fd;
            this->fp = fp;
            this->argc = argc;
            this->argv = argv;
            start_flow(STATE(entry));
 
            return COMMAND_NEXT;
        }
 
        Command *command;
 
        int fd;
 
        Session *session;
 
        CommandStatus status;
 
        friend class Console;
 
        friend class Session;
 
        DISALLOW_COPY_AND_ASSIGN(CommandFlow);
    };
 
private:
    static const size_t MAX_ARGS = 10;
 
    struct Command
    {
        Command(const char *name, Callback callback, void *context = NULL, Command *next = NULL)
            : name(name)
            , callback(callback)
            , context(context)
            , interactive(false)
            , next(next)
        {
        }
 
        Command(const char *name, CommandFlow *flow, Command *next = NULL)
            : name(name)
            , flow(flow)
            , interactive(true)
            , next(next)
        {
        }
 
        const char *name;  
        union 
        {
            struct
            {
                Callback callback; 
                void *context;     
            };
            CommandFlow *flow; 
        };
        bool interactive; 
        Command *next;    
    };
 
#if defined (CONSOLE_NETWORKING)
    class Listen : public StateFlowBase
    {
    public:
        Listen(Service *service, int port);
 
    private:
        StateFlowBase::Action entry()
        {
            return listen_and_call(&selectHelper, fdListen, STATE(accept));
        }
 
        StateFlowBase::Action accept();
 
        int fdListen;
 
        StateFlowBase::StateFlowSelectHelper selectHelper;
 
        DISALLOW_COPY_AND_ASSIGN(Listen);
    };
#endif
 
    class Session : public StateFlowBase
    {
    public:
        Session(Service *service, int fd_in, int fd_out);
 
        ~Session()
        {
            /* should only delete sockets, which should have the same read
             * and write fds
             */
            HASSERT(fdIn == fdOut);
            fclose(fp);
            /* There is no need for a "close(fdIn)" because the "fclose(fp)"
             * will already have completed that operation.
             */
            free(line);
        }
 
    private:
        StateFlowBase::Action entry()
        {
            return read_single(&selectHelper, fdIn, line + pos,
                               line_size - pos, STATE(process_read));
        }
 
        StateFlowBase::Action process_read();
 
        StateFlowBase::Action exit_interactive();
 
        CommandStatus callback(int argc, const char *argv[]);
 
        void prompt(FILE *fp)
        {
            fputs("> ", fp);
            fflush(fp);
        }
 
        bool callback_result_process(CommandStatus status, const char *name);
 
        int fdIn;         
        int fdOut;        
        FILE *fp;         
        char *line;       
        size_t line_size; 
        size_t pos;       
        const char *args[MAX_ARGS]; 
        StateFlowBase::StateFlowSelectHelper selectHelper;
 
        Command *command;
 
        DISALLOW_COPY_AND_ASSIGN(Session);
    };
 
    static CommandStatus help_command(FILE *fp, int argc, const char *argv[], void *context)
    {
        return static_cast<Console*>(context)->help_command(fp, argc, argv);
    }
 
    CommandStatus help_command(FILE *fp, int argc, const char *argv[]);
 
    static CommandStatus quit_command(FILE *fp, int argc, const char *argv[], void *context)
    {
        return static_cast<Console*>(context)->quit_command(fp, argc, argv);
    }
 
    CommandStatus quit_command(FILE *fp, int argc, const char *argv[]);
 
    void open_session(int fd_in, int fd_out);
 
    Command help;     
    Command helpMark; 
#if defined (CONSOLE_NETWORKING)
    Listen listen; 
#endif
    friend class CommandFlow;
 
    friend class Listen;
 
    friend class Session;
 
    DISALLOW_COPY_AND_ASSIGN(Console);
};
 
#endif // _CONSOLE_CONSOLE_HXX_