1

#include "nexus.h"

     2

#include "signals.h"

     3

#include "log.h"

     4

     5

#include <stdlib.h>

     6

#include <stdbool.h>

     7

#include <stdio.h>

     8

#include <getopt.h>

     9

#include <signal.h>

    10

#include <string.h>

    11

    12

/**

    13

 * Command-line option codes

    14

 */

    15

enum option_code {

    16

    OPT_HELP            = 'h',

    17

    OPT_DEFAULTS        = 'D',

    18

    OPT_NETWORK         = 'n',

    19

    OPT_CHANNEL         = 'c',

    20

    OPT_MODULE          = 'm',

    21

    OPT_CONFIG          = 'C',

    22

    OPT_DEBUG           = 'd',

    23

    24

    /** Options without short names */

    25

    _OPT_EXT_BEGIN      = 0x00ff,

    26

    27

    OPT_CONSOLE,

    28

};

    29

    30

/**

    31

 * Command-line option definitions

    32

 */

    33

static struct option options[] = {

    34

    {"help",            0,  NULL,   OPT_HELP        },

    35

    {"defaults",        1,  NULL,   OPT_DEFAULTS    },

    36

    {"network",         1,  NULL,   OPT_NETWORK     },

    37

    {"channel",         1,  NULL,   OPT_CHANNEL     },

    38

    {"module",          1,  NULL,   OPT_MODULE      },

    39

    {"config",          1,  NULL,   OPT_CONFIG      },

    40

    {"debug",           0,  NULL,   OPT_DEBUG       },

    41

    {"console",         0,  NULL,   OPT_CONSOLE     },

    42

    {0,                 0,  0,      0               },

    43

};

    44

    45

/**

    46

 * Display --help output on stdout.

    47

 *

    48

 * If nexus is given, --config options for loaded modules are also listed

    49

 */

    50

static void usage (struct nexus *nexus, const char *exe)

    51

{

    52

    printf("Usage: %s [OPTIONS]\n", exe);

    53

    printf("\n");

    54

    printf(" --help / -h            display this message\n");

    55

    printf(" --defaults / -D        set the IRC client default info using '<nickname>:<username>:<realname>'\n");

    56

    printf(" --network / -n         add an IRC network using '<name>:<hostname>[:<port>[:ssl]]' format\n");

    57

    printf(" --channel / -c         add an IRC channel using '<network>:<channel>' format\n");

    58

    printf(" --module / -m          add a module using '<name>:<path>' format\n");

    59

    printf(" --config / -C          add a module configuration option using '<mod_name>:<name>[:<value>]' format\n");

    60

    printf(" --debug / -d           set logging level to DEBUG\n");

    61

    printf(" --console              use the interactive console\n");

    62

    63

    // dump loaded module configs

    64

    if (nexus && !TAILQ_EMPTY(&nexus->modules->list)) {

    65

        struct module *module;

    66

    67

        printf("\n");

    68

        printf("Module configuration options\n");

    69

    70

        TAILQ_FOREACH(module, &nexus->modules->list, modules_list) {

    71

            printf("\n");

    72

            printf("%s:\n", module->info.name);

    73

    74

            // XXX: shouldn't be accessing directly

    75

            if (module->desc->config_options) {

    76

                const struct config_option *opt;

    77

    78

                for (opt = module->desc->config_options; opt->name && opt->type; opt++) {

    79

                    printf(" --config %s:%s:%s\t\t%s\n", module->info.name, opt->name, opt->description, opt->help);

    80

                }

    81

    82

            } else {

    83

                printf("\t???\n");

    84

            }

    85

        }

    86

    }

    87

}

    88

    89

/**

    90

 * Parse and apply a --defaults option, setting the resulting defaults to our irc_client

    91

 */

    92

static err_t apply_defaults (struct nexus *nexus, char *opt, struct error_info *err)

    93

{

    94

    struct irc_client_defaults defaults = {

    95

        .register_info      = { NULL, NULL, NULL },

    96

        .service            = IRC_PORT,

    97

        .service_ssl        = IRC_SSL_PORT,

    98

    };

    99

   100

    // parse the required fields

   101

    if ((defaults.register_info.nickname = strsep(&opt, ":")) == NULL)

   102

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <nickname> field for --defaults");

   103

   104

    if ((defaults.register_info.username = strsep(&opt, ":")) == NULL)

   105

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <username> field for --defaults");

   106

   107

    if ((defaults.register_info.realname = strsep(&opt, ":")) == NULL)

   108

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <realname> field for --defaults");

   109

   110

    // trailing garbage?

   111

    if (opt)

   112

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "trailing values for --channel");

   113

   114

    // apply them

   115

    log_info("using default nick/user/real-name: %s/%s/%s", 

   116

            defaults.register_info.nickname, defaults.register_info.username, defaults.register_info.realname);

   117

   118

    irc_client_set_defaults(nexus->client, &defaults);

   119

   120

    // ok

   121

    return SET_ERROR(err, SUCCESS);

   122

}

   123

   124

/**

   125

 * Parse and apply a --network option, adding the given network to our irc_client.

   126

 */

   127

static err_t apply_network (struct nexus *nexus, char *opt, struct error_info *err)

   128

{

   129

    struct irc_net_info info;

   130

   131

    // init to zero

   132

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

   133

   134

    // parse the required fields

   135

    if ((info.network = strsep(&opt, ":")) == NULL)

   136

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <name> field for --network");

   137

   138

    if ((info.hostname = strsep(&opt, ":")) == NULL)

   139

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <hostname> field for --network");

   140

   141

    // parse the optional fields

   142

    if (opt)

   143

        info.service = strsep(&opt, ":");

   144

   145

    // parse any remaining flags

   146

    while (opt) {

   147

        char *flag = strsep(&opt, ":");

   148

   149

        if (strcmp(flag, "ssl"))

   150

            info.use_ssl = true;

   151

   152

        else

   153

            RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "unrecognized flag for --network");

   154

    }

   155

   156

    // create the net

   157

    log_info("add network '%s' at '%s:%s'", info.network, info.hostname, info.service);

   158

   159

    if (irc_client_add_net(nexus->client, NULL, &info, err))

   160

        return ERROR_CODE(err);

   161

   162

    // ok

   163

    return SET_ERROR(err, SUCCESS);

   164

}

   165

   166

/**

   167

 * Parse and apply a --channel option, adding the given channel to the given irc_net.

   168

 */

   169

static err_t apply_channel (struct nexus *nexus, char *opt, struct error_info *err)

   170

{

   171

    const char *network = NULL;

   172

    struct irc_net *net;

   173

    struct irc_chan_info info = {

   174

        .channel            = NULL,

   175

    };

   176

   177

    // parse the required fields

   178

    if ((network = strsep(&opt, ":")) == NULL)

   179

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <network> field for --channel");

   180

   181

    if ((info.channel = strsep(&opt, ":")) == NULL)

   182

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <channel> field for --channel");

   183

   184

    // trailing garbage?

   185

    if (opt)

   186

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "trailing values for --channel");

   187

   188

    // look up the net

   189

    if ((net = irc_client_get_net(nexus->client, network)) == NULL)

   190

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "unknown network for --channel");

   191

   192

    // add the channel

   193

    log_info("add channel '%s' on network '%s'", info.channel, net->info.network);

   194

   195

    if (irc_net_add_chan(net, NULL, &info, err))

   196

        return ERROR_CODE(err);

   197

   198

    // ok

   199

    return SUCCESS;

   200

}

   201

   202

/**

   203

 * Parse and apply a --module option, loading the given module.

   204

 */

   205

static err_t apply_module (struct nexus *nexus, char *opt, struct error_info *err)

   206

{

   207

    struct module_info info = {

   208

        .name       = NULL,

   209

        .path       = NULL,

   210

    };

   211

    struct module *module;

   212

   213

    // parse the required fields

   214

    if ((info.name = strsep(&opt, ":")) == NULL)

   215

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <name> field for --module");

   216

   217

    if ((info.path = strsep(&opt, ":")) == NULL)

   218

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <path> field for --module");

   219

   220

    // trailing garbage?

   221

    if (opt)

   222

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "trailing values for --channel");

   223

   224

    // load it

   225

    log_info("loading module '%s' from path '%s'", info.name, info.path);

   226

   227

    if (module_load(nexus->modules, &module, &info, err))

   228

        return ERROR_CODE(err);

   229

   230

    // ok

   231

    return SUCCESS;

   232

}

   233

   234

/**

   235

 * Parse and apply a --config option, calling the module's conf func.

   236

 */

   237

static err_t apply_config (struct nexus *nexus, char *opt, struct error_info *err)

   238

{

   239

    struct module *module;

   240

    const char *module_name, *conf_name;

   241

    char *conf_value;

   242

   243

    // parse the required fields

   244

    if ((module_name = strsep(&opt, ":")) == NULL)

   245

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <module> field for --config");

   246

   247

    if ((conf_name = strsep(&opt, ":")) == NULL)

   248

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "missing <name> field for --config");

   249

   250

    // value is the rest of the data, might be NULL

   251

    conf_value = opt;

   252

   253

    // lookup the module

   254

    if ((module = module_get(nexus->modules, module_name)) == NULL)

   255

        RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "unknown module for --config");

   256

   257

    // do the config

   258

    log_info("applying module '%s' config name '%s' with value: %s", module->info.name, conf_name, conf_value);

   259

   260

    if (module_conf_raw(module, conf_name, conf_value, err))

   261

        return ERROR_CODE(err);

   262

   263

    // ok

   264

    return SUCCESS;

   265

}

   266

   267

/**

   268

 * Open the console

   269

 */

   270

static err_t apply_console (struct nexus *nexus, struct error_info *err)

   271

{

   272

    struct console_config config = {

   273

        .prompt     = "> ",

   274

    };

   276

   277

    log_info("initializing the console");

   278

   279

    // init the console

   281

        return ERROR_CODE(err);

   282

   283

    // create the lua console on top of that

   286

   287

    // ok

   288

    return SUCCESS;

   294

}

   295

   296

/**

   297

 * Parse arguments and apply them to the given nexus

   298

 */

   299

static err_t parse_args (struct nexus *nexus, int argc, char **argv, struct error_info *err)

   300

{

   301

    int opt, option_index;

   302

   303

    // parse options

   304

    while ((opt = getopt_long(argc, argv, "hn:c:m:C:", options, &option_index)) != -1) {

   305

        switch (opt) {

   306

            case OPT_HELP:

   307

                usage(nexus, argv[0]);

   308

   309

                // XXX: return instead

   310

                exit(EXIT_SUCCESS);

   311

   312

            case OPT_NETWORK:

   313

                if (apply_network(nexus, optarg, err))

   314

                    return ERROR_CODE(err);

   315

   316

                break;

   317

   318

            case OPT_DEFAULTS:

   319

                if (apply_defaults(nexus, optarg, err))

   320

                    return ERROR_CODE(err);

   321

   322

                break;

   323

   324

            case OPT_CHANNEL:

   325

                if (apply_channel(nexus, optarg, err))

   326

                    return ERROR_CODE(err);

   327

   328

                break;

   329

   330

            case OPT_MODULE:

   331

                if (apply_module(nexus, optarg, err))

   332

                    return ERROR_CODE(err);

   333

   334

                break;

   335

   336

            case OPT_CONFIG:

   337

                if (apply_config(nexus, optarg, err))

   338

                    return ERROR_CODE(err);

   339

   340

                break;

   341

   342

            case OPT_DEBUG:

   343

                set_log_level(LOG_DEBUG);

   344

                break;

   345

   346

            case OPT_CONSOLE:

   347

                if (apply_console(nexus, err))

   348

                    return ERROR_CODE(err);

   349

   350

                break;

   351

   352

            case '?':

   353

                usage(nexus, argv[0]);

   354

                return SET_ERROR(err, ERR_CMD_OPT);

   355

        }

   356

    }

   357

   358

    // ok

   359

    return SUCCESS;

   360

}

   361

   362

void nexus_shutdown (struct nexus *nexus)

   363

{

   364

    // destroy the console

   365

    if (nexus->lua_console)

   366

        lua_console_destroy(nexus->lua_console);

   367

   368

    nexus->lua_console = NULL;

   369

   370

    // unload the modules

   371

    if (nexus->modules)

   372

       modules_unload(nexus->modules);

   373

   374

    // quit the irc client

   375

    if (nexus->client)

   376

       irc_client_quit(nexus->client, "Goodbye, cruel world ;(");

   377

   378

    // remove the signal handlers

   379

    if (nexus->signals)

   380

        signals_free(nexus->signals);

   381

   382

    nexus->signals = NULL;

   383

   384

    // now event_base_dispatch should return once everythings' shut down...

   385

    nexus->shutdown = true;

   386

}

   387

   388

void nexus_destroy (struct nexus *nexus)

   389

{

   394

    // destroy the modules

   395

    if (nexus->modules)

   396

        modules_destroy(nexus->modules);

   397

   398

    nexus->modules = NULL;

   399

   400

    // destroy the irc client

   401

    if (nexus->client)

   402

        irc_client_destroy(nexus->client);

   403

   404

    nexus->client = NULL;

   405

   406

    // then force-quit the event loop

   407

    event_base_loopbreak(nexus->ev_base);

   408

}

   409

   410

static void on_sigint (evutil_socket_t sig, short what, void *arg)

   411

{

   412

    struct nexus *nexus = arg;

   413

   414

    (void) sig;

   415

    (void) what;

   416

   417

    log_info("Quitting...");

   418

   419

    // shutdown

   420

    nexus_shutdown(nexus);

   421

}

   422

   423

int main (int argc, char **argv) 

   424

{

   425

    struct nexus _nexus, *nexus = &_nexus;

   426

    struct error_info err;

   427

   428

    // zero nexus

   429

    memset(nexus, 0, sizeof(*nexus));

   430

   431

    // initialize libevent

   432

    if ((nexus->ev_base = event_base_new()) == NULL)

   433

        FATAL("event_base_new");

   434

   435

   436

    // initialize signal handlers

   437

    if ((ERROR_CODE(&err) = signals_create(&nexus->signals, nexus->ev_base)))

   438

        FATAL("signals_create");

   439

   440

    // add our signal handlers

   441

    if (signal_ignore(SIGPIPE, &err))

   442

        FATAL_ERROR(&err, "signals_ignore(SIGPIPE)");

   443

   444

    // XXX: add our SIGINT handler after console_init()?

   445

    if ((ERROR_CODE(&err) = signals_add(nexus->signals, SIGINT, &on_sigint, nexus)))

   446

        FATAL_ERROR(&err, "signals_add(SIGINT)");

   447

   448

   449

    // initialize sock module

   450

    if (sock_init(nexus->ev_base, &err))

   451

        FATAL_ERROR(&err, "sock_init");

   452

   453

    // modules 

   454

    if ((ERROR_CODE(&err) = modules_create(&nexus->modules, nexus)))

   455

        FATAL_ERROR(&err, "modules_create");

   456

   457

    // the IRC client

   458

    if (irc_client_create(&nexus->client, &err))

   459

        FATAL_ERROR(&err, "irc_client_create");

   464

   466

    // parse args

   467

    if (parse_args(nexus, argc, argv, &err))

   468

        FATAL_ERROR(&err, "parse_args");

   469

   470

   471

    // run event loop

   472

    log_info("entering event loop");

   473

   474

    if (event_base_dispatch(nexus->ev_base)) {

   475

        if (nexus->shutdown) {

   476

            log_info("clean shutdown completed");

   477

   478

        } else {

   479

            FATAL("event_base_dispatch returned without shutdown");

   480

   481

        }

   482

    }

   483

   484

    // ok, no cleanup

   485

    return 0;

   486

}

   487