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

/**

    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

    98

    // create the net

    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

/**

   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");

   133

   134

    // add the channel

   135

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

   136

        return ERROR_CODE(err);

   137

   138

    // ok

   139

    return SUCCESS;

   140

}

   141

   142

/**

   175

 * Parse arguments and apply them to the given nexus

   176

 */

   177

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

   178

{

   179

    int opt, option_index;

   180

   181

    // parse options

   182

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

   183

        switch (opt) {

   184

            case OPT_HELP:

   185

                usage(argv[0]);

   186

   187

                // XXX: return instead

   188

                exit(EXIT_SUCCESS);

   189

   190

            case OPT_NETWORK:

   191

                if (apply_network(nexus, optarg, err))

   192

                    return ERROR_CODE(err);

   193

   194

                break;

   195

   196

            case OPT_CHANNEL:

   197

                if (apply_channel(nexus, optarg, err))

   198

                    return ERROR_CODE(err);

   199

   200

                break;

   201

   202

            case OPT_MODULE:

   208

            case OPT_CONFIG:

   209

                RETURN_SET_ERROR_STR(err, ERR_CMD_OPT, "option unimplemented");

   210

   211

            case '?':

   212

                usage(argv[0]);

   213

                return SET_ERROR(err, ERR_CMD_OPT);

   214

        }

   215

    }

   216

   217

    // ok

   218

    return SUCCESS;

   219

}

   220

   221

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

   222

{

   223

    struct nexus *ctx = arg;

   224

   225

    (void) sig;

   226

    (void) what;

   227

   228

    if (ctx->client && !ctx->client->quitting) {

   229

        log_info("Quitting...");

   230

   231

        // quit it

   232

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

   233

   234

    } else {

   235

        log_error("Aborting");

   236

   237

        // die

   238

        if (ctx->client) {

   239

            irc_client_destroy(ctx->client);

   240

            ctx->client = NULL;

   241

        }

   242

   243

        // exit

   244

        event_base_loopexit(ctx->ev_base, NULL);

   245

    }

   246

}

   247

   248

int main (int argc, char **argv) 

   249

{

   250

    struct signals *signals;

   251

    struct error_info err;

   252

   253

    struct nexus _nexus, *nexus = &_nexus;

   254

   255

    // zero nexus

   256

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

   257

   258

    // initialize libevent

   259

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

   260

        FATAL("event_base_new");

   261

   262

    // initialize signal handlers

   263

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

   264

        FATAL("signals_create");

   265

   266

    // add our signal handlers

   267

    if (

   268

            (ERROR_CODE(&err) = signals_add(signals, SIGPIPE, &signals_ignore, signals))

   269

        ||  (ERROR_CODE(&err) = signals_add(signals, SIGINT, &on_sigint, nexus))

   270

    )

   271

        FATAL_ERROR(&err, "signals_add");

   272

   273

    // initialize sock module

   274

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

   275

        FATAL_ERROR(&err, "sock_init");

   276

   277

    // modules 

   278

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

   279

        FATAL_ERROR(&err, "modules_create");

   280

   281

    // the IRC client

   282

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

   283

        FATAL_ERROR(&err, "irc_client_create");

   284

   285

    // parse args

   286

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

   287

        FATAL_ERROR(&err, "parse_args");

   288

   289

    // run event loop

   290

    if (event_base_dispatch(nexus->ev_base))

   291

        FATAL("event_base_dispatch");

   292

   293

    // ok, no cleanup

   294

    return 0;

   295

}

   296