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

#define DEFAULT_HOST "irc.fixme.fi"

    13

#define DEFAULT_PORT "6667"

    14

#define DEFAULT_PORT_SSL "6697"

    15

    16

/**

    17

 * Command-line option codes

    18

 */

    19

enum option_code {

    20

    OPT_HELP            = 'h',

    21

    OPT_NETWORK         = 'n',

    22

    OPT_CHANNEL         = 'c',

    23

    OPT_MODULE          = 'm',

    24

    OPT_CONFIG          = 'C',

    25

    26

    /** Options without short names */

    27

    _OPT_EXT_BEGIN      = 0x00ff,

    28

    29

};

    30

    31

/**

    32

 * Command-line option definitions

    33

 */

    34

static struct option options[] = {

    35

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

    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

    {0,                 0,  0,      0               },

    41

};

    42

    43

/**

    44

 * Display --help output on stdout

    45

 */

    46

static void usage (const char *exe) 

    47

{

    48

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

    49

    printf("\n");

    50

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

    51

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

    52

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

    53

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

    54

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

    55

}

    56

    57

/**

    58

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

    59

 */

    60

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

    61

{

    62

    struct irc_net_info info = {

    63

        .network            = NULL,

    64

        .hostname           = NULL,

    65

        .service            = DEFAULT_PORT,

    66

        .use_ssl            = false,

    67

        .register_info      = {

    68

            .nickname       = "SpBotDev",

    69

            .username       = "spbot-dev",

    70

            .realname       = "SpBot (development version)"

    71

        }

    72

    };

    73

    74

    // parse the required fields

    75

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

    76

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

    77

    78

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

    79

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

    80

    81

    // parse the optional fields

    82

    if (opt)

    83

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

    84

    85

    // parse any remaining flags

    86

    while (opt) {

    87

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

    88

    89

        if (strcmp(flag, "ssl"))

    90

            info.use_ssl = true;

    91

    92

        else

    93

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

    94

    }

    95

    96

    // create the net

    97

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

    98

    99

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

   100

        return ERROR_CODE(err);

   101

   102

    // ok

   103

    return SET_ERROR(err, SUCCESS);

   104

}

   105

   106

/**

   107

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

   108

 */

   109

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

   110

{

   111

    const char *network = NULL;

   112

    struct irc_net *net;

   113

    struct irc_chan_info info = {

   114

        .channel            = NULL,

   115

    };

   116

   117

    // parse the required fields

   118

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

   119

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

   120

   121

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

   122

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

   123

   124

    // trailing garbage?

   125

    if (opt)

   126

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

   127

   128

    // look up the net

   129

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

   130

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

   131

   132

    // add the channel

   133

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

   134

   135

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

   136

        return ERROR_CODE(err);

   137

   138

    // ok

   139

    return SUCCESS;

   140

}

   141

   142

/**

   143

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

   144

 */

   145

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

   146

{

   147

    struct module_info info = {

   148

        .name       = NULL,

   149

        .path       = NULL,

   150

    };

   151

    struct module *module;

   152

   153

    // parse the required fields

   154

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

   155

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

   156

   157

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

   158

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

   159

   160

    // trailing garbage?

   161

    if (opt)

   162

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

   163

   164

    // load it

   165

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

   166

   167

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

   168

        return ERROR_CODE(err);

   169

   170

    // ok

   171

    return SUCCESS;

   172

}

   173

   174

/**

   175

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

   176

 */

   177

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

   178

{

   179

    struct module *module;

   180

    const char *module_name, *conf_name;

   181

    char *conf_value;

   182

   183

    // parse the required fields

   184

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

   185

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

   186

   187

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

   188

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

   189

   190

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

   191

    conf_value = opt;

   192

   193

    // lookup the module

   194

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

   195

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

   196

   197

    // do the config

   198

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

   199

   200

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

   201

        return ERROR_CODE(err);

   202

   203

    // ok

   204

    return SUCCESS;

   205

}

   206

   207

/**

   208

 * Parse arguments and apply them to the given nexus

   209

 */

   210

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

   211

{

   212

    int opt, option_index;

   213

   214

    // parse options

   215

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

   216

        switch (opt) {

   217

            case OPT_HELP:

   218

                usage(argv[0]);

   219

   220

                // XXX: return instead

   221

                exit(EXIT_SUCCESS);

   222

   223

            case OPT_NETWORK:

   224

                if (apply_network(nexus, optarg, err))

   225

                    return ERROR_CODE(err);

   226

   227

                break;

   228

   229

            case OPT_CHANNEL:

   230

                if (apply_channel(nexus, optarg, err))

   231

                    return ERROR_CODE(err);

   232

   233

                break;

   234

   235

            case OPT_MODULE:

   236

                if (apply_module(nexus, optarg, err))

   237

                    return ERROR_CODE(err);

   238

   239

                break;

   240

   241

            case OPT_CONFIG:

   242

                if (apply_config(nexus, optarg, err))

   243

                    return ERROR_CODE(err);

   244

   245

                break;

   246

   247

            case '?':

   248

                usage(argv[0]);

   249

                return SET_ERROR(err, ERR_CMD_OPT);

   250

        }

   251

    }

   252

   253

    // ok

   254

    return SUCCESS;

   255

}

   256

   257

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

   258

{

   259

    struct nexus *ctx = arg;

   260

   261

    (void) sig;

   262

    (void) what;

   263

   265

   268

   274

}

   275

   276

int main (int argc, char **argv) 

   277

{

   279

    struct error_info err;

   280

   281

    // zero nexus

   282

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

   283

   284

    // initialize libevent

   285

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

   286

        FATAL("event_base_new");

   287

   288

    // initialize signal handlers

   290

        FATAL("signals_create");

   291

   292

    // add our signal handlers

   293

    if (

   296

    )

   297

        FATAL_ERROR(&err, "signals_add");

   298

   299

    // initialize sock module

   300

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

   301

        FATAL_ERROR(&err, "sock_init");

   302

   303

    // modules 

   304

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

   305

        FATAL_ERROR(&err, "modules_create");

   306

   307

    // the IRC client

   308

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

   309

        FATAL_ERROR(&err, "irc_client_create");

   310

   311

    // parse args

   312

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

   313

        FATAL_ERROR(&err, "parse_args");

   314

   315

    // run event loop

   316

    if (event_base_dispatch(nexus->ev_base))

   317

        FATAL("event_base_dispatch");

   318

   319

    // ok, no cleanup

   320

    return 0;

   321

}

   322