1

#include "console.h"

     2

#include "log.h"

     3

     4

#include <stdlib.h>

     5

#include <unistd.h>

     6

#include <stdio.h>

     7

#include <readline/readline.h>

     8

#include <readline/history.h>

     9

    10

#include <assert.h>

    11

    12

/** The global console state */

    13

static struct console _console;

    14

    15

/**

    16

 * Our stdin input handler

    17

 */

    18

static void console_input (int fd, short what, void *arg)

    19

{

    20

    struct console *console = arg;

    21

    22

    (void) fd;

    23

    (void) what;

    24

    25

    // update state

    26

    console->have_input = true;

    27

    28

    // tell readline to process it

    29

    rl_callback_read_char();

    30

}

    31

    32

/**

    33

 * Our readline line handler

    34

 */

    35

static void console_line (char *line)

    36

{

    37

    struct console *console = &_console;

    38

    39

    // XXX: line == NULL -> EOF?

    40

    41

    // update state

    42

    console->have_input = false;

    43

    44

    // invoke the console callback

    45

    if (console->callbacks && console->callbacks->on_line)

    46

        console->callbacks->on_line(line, console->cb_arg);

    47

    48

    // add to history mechanism

    49

    add_history(line);

    50

    51

    // release the line

    52

    free(line);

    53

    54

    // update state, as the prompt will be displayed again

    55

    console->have_input = true;

    56

}

    57

    58

err_t console_init (struct console **console_ptr, struct event_base *ev_base, const struct console_config *config,

    59

        const struct console_callbacks *callbacks, void *cb_arg, struct error_info *err)

    60

{

    61

    struct console *console = &_console;

    62

    63

    // check it's not already initialized

    64

    assert(!console->initialized);

    65

    66

    // store callbacks?

    67

    if (callbacks)

    68

        console_set_callbacks(console, callbacks, cb_arg);

    69

    70

    // setup the input event

    71

    if ((console->ev = event_new(ev_base, STDIN_FILENO, EV_READ | EV_PERSIST, &console_input, console)) == NULL)

    72

        JUMP_SET_ERROR(err, ERR_EVENT_NEW);

    73

    74

    // setup readline

    75

    rl_callback_handler_install(config->prompt, &console_line);

    76

    77

    // mark it as initialized

    78

    console->initialized = true;

    79

    80

    // enable input

    81

    if (event_add(console->ev, NULL))

    82

        JUMP_SET_ERROR(err, ERR_EVENT_ADD);

    83

    84

    // ok

    85

    *console_ptr = console;

    86

    87

    return SUCCESS;

    88

    89

error:

    90

    console_destroy(console);

    91

    92

    return ERROR_CODE(err);

    93

}

    94

    95

void console_set_callbacks (struct console *console, const struct console_callbacks *callbacks, void *cb_arg)

    96

{

    97

    console->callbacks = callbacks;

    98

    console->cb_arg = cb_arg;

    99

}

   100

   101

err_t console_print (struct console *console, const char *line)

   102

{

   103

    if (console->have_input)

   104

        // don't interrupt current input line

   105

        rl_crlf();

   106

   107

    // output the line

   108

    if (printf("%s\n", line) < 0)

   109

        return _ERR_GENERAL;

   110

   111

    if (console->have_input) {

   112

        // restore input

   113

        rl_on_new_line();

   114

        rl_redisplay();

   115

    }

   116

   117

    // ok

   118

    return SUCCESS;

   119

}

   120

   121

/**

   122

 * Our log_output_func implementation

   123

 */

   124

static void console_log_output_func (const char *line, void *_console)

   125

{

   126

    struct console *console = _console;

   127

   128

    console_print(console, line);

   129

}

   130

   131

void console_set_log_output (struct console *console)

   132

{

   133

    // replace old one

   134

    log_set_func(console_log_output_func, console);

   135

   136

    // mark

   137

    console->log_output = true;

   138

}

   139

   140

void console_destroy (struct console *console)

   141

{

   142

    if (console->log_output)

   143

        // unset ourselves as the log handler

   144

        log_set_func(NULL, NULL);

   145

   146

    // remove the input event

   147

    if (console->ev)

   148

        event_free(console->ev); 

   149

   150

    console->ev = NULL;

   151

   152

    // de-init rl?

   153

    if (console->initialized)

   154

        rl_callback_handler_remove();

   155

   156

    console->initialized = false;

   157

   158

    // remove stored stuff

   159

    console->callbacks = console->cb_arg = NULL;

   160

}

   161