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

    37

    38

    /** Waiting for line to be processed */

    39

    bool waiting;

    40

};

    41

    42

/** The global console state */

    43

static struct console _console;

    44

    45

/**

    46

 * Our stdin input handler

    47

 */

    48

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

    49

{

    50

    struct console *console = arg;

    51

    52

    (void) fd;

    53

    (void) what;

    54

    58

    62

}

    63

    64

/**

    65

 * Our readline line handler

    66

 */

    67

static void console_line (char *line)

    68

{

    69

    struct console *console = &_console;

    70

    enum console_line_status status = CONSOLE_CONTINUE;

    71

    72

    // special-case EOF

    73

    if (!line) {

    74

        // prettify

    75

        rl_crlf();

    76

        rl_on_new_line();

    77

    78

        if (console->callbacks->on_eof)

    79

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

    80

    81

        return;

    82

    }

    83

    84

    // update state for console_print during processing

    86

    87

    // invoke the console callback

    88

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

    89

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

    90

    91

    // add to history mechanism

    92

    add_history(line);

    93

    94

    // release the line

    95

    free(line);

    96

    97

    switch (status) {

    98

        case CONSOLE_CONTINUE:

   101

   102

            break;

   103

   104

        case CONSOLE_WAIT:

   109

            // remove the readline stuff to stop it from displaying the prompt

   110

            rl_callback_handler_remove();

   111

   113

            console->waiting = true;

   114

   115

            break;

   116

    }

   117

}

   118

   119

static void on_sigint (int sig)

   120

{

   121

    struct console *console = &_console;

   122

   123

    (void) sig;

   124

   125

    // interrupt the input line

   126

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

   127

    rl_free_line_state();

   128

   129

    // redisplay on new line

   130

    rl_crlf();

   131

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

   132

}

   133

   134

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

   135

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

   136

{

   137

    struct console *console = &_console;

   138

   139

    // check it's not already initialized

   140

    assert(!console->initialized);

   141

   142

    // store

   143

    console->config = *config;

   144

   145

    // store callbacks?

   146

    if (callbacks)

   147

        console_set_callbacks(console, callbacks, cb_arg);

   148

   149

    // setup the input event

   150

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

   151

        JUMP_SET_ERROR(err, ERR_EVENT_NEW);

   152

   153

    // set our SIGINT handler

   154

    struct sigaction sigact;

   155

   156

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

   157

    sigact.sa_handler = on_sigint;

   158

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

   159

   163

    // setup readline

   164

    rl_callback_handler_install(config->prompt, console_line);

   165

   166

    // mark it as initialized

   167

    console->initialized = true;

   168

   169

    // enable input

   170

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

   171

        JUMP_SET_ERROR(err, ERR_EVENT_ADD);

   172

   173

    // ok

   174

    *console_ptr = console;

   175

   176

    return SUCCESS;

   177

   178

error:

   179

    console_destroy(console);

   180

   181

    return ERROR_CODE(err);

   182

}

   183

   184

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

   185

{

   186

    console->callbacks = callbacks;

   187

    console->cb_arg = cb_arg;

   188

}

   189

   190

void console_continue (struct console *console)

   191

{

   194

   195

    // re-enable input

   196

    console->waiting = false;

   197

   201

    // the prompt will be displayed again

   203

   204

    // re-setup readline with prompt

   205

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

   206

}

   207

   208

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

   209

{

   211

        // don't interrupt current input line

   212

        rl_crlf();

   213

   214

    // output the line

   215

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

   216

        return _ERR_GENERAL;

   217

   219

        // restore input

   220

        rl_on_new_line();

   221

        rl_redisplay();

   222

    }

   223

   224

    // ok

   225

    return SUCCESS;

   226

}

   227

   228

/**

   229

 * Our log_output_func implementation

   230

 */

   231

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

   232

{

   233

    struct console *console = _console;

   234

   235

    console_print(console, line);

   236

}

   237

   238

void console_set_log_output (struct console *console)

   239

{

   240

    // replace old one

   241

    log_set_func(console_log_output_func, console);

   242

   243

    // mark

   244

    console->log_output = true;

   245

}

   246

   247

void console_destroy (struct console *console)

   248

{

   249

    if (console->log_output)

   250

        // unset ourselves as the log handler

   251

        log_set_func(NULL, NULL);

   252

   253

    // remove the input event

   254

    if (console->ev)

   255

        event_free(console->ev); 

   256

   257

    console->ev = NULL;

   258

   259

    // de-init rl?

   260

    if (console->initialized)

   261

        rl_callback_handler_remove();

   262

   263

    console->initialized = false;

   264

   265

    // restore signal handler

   266

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

   267

   268

    // remove stored stuff

   269

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

   270

}

   271