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 <signal.h>

    11

#include <assert.h>

    12

    13

/** The global console state */

    14

static struct console _console;

    15

    16

/**

    17

 * Our stdin input handler

    18

 */

    19

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

    20

{

    21

    struct console *console = arg;

    22

    23

    (void) fd;

    24

    (void) what;

    25

    26

    // update state

    27

    console->have_input = true;

    28

    29

    // tell readline to process it

    30

    rl_callback_read_char();

    31

}

    32

    33

/**

    34

 * Our readline line handler

    35

 */

    36

static void console_line (char *line)

    37

{

    38

    struct console *console = &_console;

    39

    40

    // special-case EOF

    41

    if (!line) {

    42

        // prettify

    43

        rl_crlf();

    44

        rl_on_new_line();

    45

    46

        if (console->callbacks->on_eof)

    47

            console->callbacks->on_eof(console->cb_arg);

    48

    49

        return;

    50

    }

    51

    52

    // update state

    53

    console->have_input = false;

    54

    55

    // invoke the console callback

    56

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

    57

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

    58

    59

    // add to history mechanism

    60

    add_history(line);

    61

    62

    // release the line

    63

    free(line);

    64

    65

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

    66

    console->have_input = true;

    67

}

    68

    69

static void on_sigint (int sig)

    70

{

    71

    struct console *console = &_console;

    72

    73

    (void) sig;

    74

    75

    // interrupt the input line

    76

    rl_free_line_state();

    77

    78

    // redisplay on new line

    79

    rl_crlf();

    80

    rl_callback_handler_install(console->config.prompt, console_line);

    81

}

    82

    83

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

    84

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

    85

{

    86

    struct console *console = &_console;

    87

    88

    // check it's not already initialized

    89

    assert(!console->initialized);

    90

    91

    // store

    92

    console->config = *config;

    93

    94

    // store callbacks?

    95

    if (callbacks)

    96

        console_set_callbacks(console, callbacks, cb_arg);

    97

    98

    // setup the input event

    99

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

   100

        JUMP_SET_ERROR(err, ERR_EVENT_NEW);

   101

   102

    // set our SIGINT handler

   103

    struct sigaction sigact;

   104

   105

    memset(&sigact, 0, sizeof(sigact));

   106

    sigact.sa_handler = on_sigint;

   107

    sigaction(SIGINT, &sigact, NULL);

   108

   109

    // setup readline

   110

    rl_callback_handler_install(config->prompt, console_line);

   111

   112

    // mark it as initialized

   113

    console->initialized = true;

   114

   115

    // enable input

   116

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

   117

        JUMP_SET_ERROR(err, ERR_EVENT_ADD);

   118

   119

    // ok

   120

    *console_ptr = console;

   121

   122

    return SUCCESS;

   123

   124

error:

   125

    console_destroy(console);

   126

   127

    return ERROR_CODE(err);

   128

}

   129

   130

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

   131

{

   132

    console->callbacks = callbacks;

   133

    console->cb_arg = cb_arg;

   134

}

   135

   136

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

   137

{

   138

    if (console->have_input)

   139

        // don't interrupt current input line

   140

        rl_crlf();

   141

   142

    // output the line

   143

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

   144

        return _ERR_GENERAL;

   145

   146

    if (console->have_input) {

   147

        // restore input

   148

        rl_on_new_line();

   149

        rl_redisplay();

   150

    }

   151

   152

    // ok

   153

    return SUCCESS;

   154

}

   155

   156

/**

   157

 * Our log_output_func implementation

   158

 */

   159

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

   160

{

   161

    struct console *console = _console;

   162

   163

    console_print(console, line);

   164

}

   165

   166

void console_set_log_output (struct console *console)

   167

{

   168

    // replace old one

   169

    log_set_func(console_log_output_func, console);

   170

   171

    // mark

   172

    console->log_output = true;

   173

}

   174

   175

void console_destroy (struct console *console)

   176

{

   177

    if (console->log_output)

   178

        // unset ourselves as the log handler

   179

        log_set_func(NULL, NULL);

   180

   181

    // remove the input event

   182

    if (console->ev)

   183

        event_free(console->ev); 

   184

   185

    console->ev = NULL;

   186

   187

    // de-init rl?

   188

    if (console->initialized)

   189

        rl_callback_handler_remove();

   190

   191

    console->initialized = false;

   192

   193

    // remove stored stuff

   194

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

   195

}

   196