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

struct console {

    14

    /** Configuration */

    15

    struct console_config config;

    16

    17

    /** Input event */

    18

    struct event *ev;

    19

    20

    /** Callback functions */

    21

    const struct console_callbacks *callbacks;

    22

    23

    /** Callback context argument */

    24

    void *cb_arg;

    25

    26

    /** Old SIGINT handler */

    27

    struct sigaction old_sigint;

    28

    29

    /** Already initialized? */

    30

    bool initialized;

    31

    32

    /** Set as log output function? */

    33

    bool log_output;

    34

    35

    /** In the middle of input? */

    36

    bool have_input;

    37

};

    38

    39

/** The global console state */

    40

static struct console _console;

    41

    42

/**

    43

 * Our stdin input handler

    44

 */

    45

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

    46

{

    47

    struct console *console = arg;

    48

    49

    (void) fd;

    50

    (void) what;

    51

    52

    // update state

    53

    console->have_input = true;

    54

    55

    // tell readline to process it

    56

    rl_callback_read_char();

    57

}

    58

    59

/**

    60

 * Our readline line handler

    61

 */

    62

static void console_line (char *line)

    63

{

    64

    struct console *console = &_console;

    65

    66

    // special-case EOF

    67

    if (!line) {

    68

        // prettify

    69

        rl_crlf();

    70

        rl_on_new_line();

    71

    72

        if (console->callbacks->on_eof)

    73

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

    74

    75

        return;

    76

    }

    77

    78

    // update state

    79

    console->have_input = false;

    80

    81

    // invoke the console callback

    82

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

    83

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

    84

    85

    // add to history mechanism

    86

    add_history(line);

    87

    88

    // release the line

    89

    free(line);

    90

    91

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

    92

    console->have_input = true;

    93

}

    94

    95

static void on_sigint (int sig)

    96

{

    97

    struct console *console = &_console;

    98

    99

    (void) sig;

   100

   101

    // interrupt the input line

   102

    // XXX: is this the right function to call?

   103

    rl_free_line_state();

   104

   105

    // redisplay on new line

   106

    rl_crlf();

   107

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

   108

}

   109

   110

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

   111

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

   112

{

   113

    struct console *console = &_console;

   114

   115

    // check it's not already initialized

   116

    assert(!console->initialized);

   117

   118

    // store

   119

    console->config = *config;

   120

   121

    // store callbacks?

   122

    if (callbacks)

   123

        console_set_callbacks(console, callbacks, cb_arg);

   124

   125

    // setup the input event

   126

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

   127

        JUMP_SET_ERROR(err, ERR_EVENT_NEW);

   128

   129

    // set our SIGINT handler

   130

    struct sigaction sigact;

   131

   132

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

   133

    sigact.sa_handler = on_sigint;

   134

    sigaction(SIGINT, &sigact, &console->old_sigint);

   135

   136

    // setup readline

   137

    rl_callback_handler_install(config->prompt, console_line);

   138

   139

    // mark it as initialized

   140

    console->initialized = true;

   141

   142

    // enable input

   143

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

   144

        JUMP_SET_ERROR(err, ERR_EVENT_ADD);

   145

   146

    // ok

   147

    *console_ptr = console;

   148

   149

    return SUCCESS;

   150

   151

error:

   152

    console_destroy(console);

   153

   154

    return ERROR_CODE(err);

   155

}

   156

   157

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

   158

{

   159

    console->callbacks = callbacks;

   160

    console->cb_arg = cb_arg;

   161

}

   162

   163

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

   164

{

   165

    if (console->have_input)

   166

        // don't interrupt current input line

   167

        rl_crlf();

   168

   169

    // output the line

   170

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

   171

        return _ERR_GENERAL;

   172

   173

    if (console->have_input) {

   174

        // restore input

   175

        rl_on_new_line();

   176

        rl_redisplay();

   177

    }

   178

   179

    // ok

   180

    return SUCCESS;

   181

}

   182

   183

/**

   184

 * Our log_output_func implementation

   185

 */

   186

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

   187

{

   188

    struct console *console = _console;

   189

   190

    console_print(console, line);

   191

}

   192

   193

void console_set_log_output (struct console *console)

   194

{

   195

    // replace old one

   196

    log_set_func(console_log_output_func, console);

   197

   198

    // mark

   199

    console->log_output = true;

   200

}

   201

   202

void console_destroy (struct console *console)

   203

{

   204

    if (console->log_output)

   205

        // unset ourselves as the log handler

   206

        log_set_func(NULL, NULL);

   207

   208

    // remove the input event

   209

    if (console->ev)

   210

        event_free(console->ev); 

   211

   212

    console->ev = NULL;

   213

   214

    // de-init rl?

   215

    if (console->initialized)

   216

        rl_callback_handler_remove();

   217

   218

    console->initialized = false;

   219

   220

    // restore signal handler

   221

    sigaction(SIGINT, &console->old_sigint, NULL);

   222

   223

    // remove stored stuff

   224

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

   225

}

   226