1

#include "nexus.h"

     2

#include "irc_log.h"

     3

#include "signals.h"

     4

#include "log.h"

     5

     6

#include <stdlib.h>

     7

#include <stdbool.h>

     8

#include <stdio.h>

     9

#include <getopt.h>

    10

#include <signal.h>

    11

    12

#define DEFAULT_HOST "irc.fixme.fi"

    13

#define DEFAULT_PORT "6667"

    14

#define DEFAULT_PORT_SSL "6697"

    15

    16

enum option_code {

    17

    _OPT_LOG_BEGIN      = 0x00ff,

    18

    19

    OPT_LOG_DATABASE,

    20

    OPT_LOG_CHANNEL,

    21

};

    22

    23

static struct option options[] = {

    24

    {"help",            0,  NULL,   'h'                 },

    25

    {"hostname",        1,  NULL,   'H'                 },

    26

    {"port",            1,  NULL,   'P'                 },

    27

    {"ssl",             0,  NULL,   'S'                 },

    28

    {"log-database",    1,  NULL,   OPT_LOG_DATABASE    },

    29

    {"log-channel",     1,  NULL,   OPT_LOG_CHANNEL     },

    30

    {0,                 0,  0,      0                   },

    31

};

    32

    33

void usage (const char *exe) 

    34

{

    35

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

    36

    printf("\n");

    37

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

    38

    printf(" --hostname / -H HOST   set hostname to connect to\n");

    39

    printf(" --port / -P PORT       set service port to connect to\n");

    40

    printf(" --ssl / -S             use SSL\n");

    41

    printf(" --log-database         database connection string for logging\n");

    42

    printf(" --log-channel          channel to log\n");

    43

}

    44

    45

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

    46

{

    47

    struct nexus *ctx = arg;

    48

    49

    (void) sig;

    50

    (void) what;

    51

    52

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

    53

        log_info("Quitting...");

    54

    55

        // quit it

    56

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

    57

    58

    } else {

    59

        log_error("Aborting");

    60

    61

        // die

    62

        if (ctx->client) {

    63

            irc_client_destroy(ctx->client);

    64

            ctx->client = NULL;

    65

        }

    66

    67

        // exit

    68

        event_base_loopexit(ctx->ev_base, NULL);

    69

    }

    70

}

    71

    72

int main (int argc, char **argv) 

    73

{

    74

    int opt, option_index;

    75

    struct signals *signals;

    76

    struct nexus ctx;

    77

    struct irc_net *net;

    78

    struct error_info err;

    79

    80

    struct irc_net_info net_info = {

    81

        .network                    = "default",

    82

        .hostname                   = DEFAULT_HOST,

    83

        .service                    = DEFAULT_PORT,

    84

        .use_ssl                    = false,

    85

        .register_info              = {

    86

            .nickname               = "SpBotDev",

    87

            .username               = "spbot-dev",

    88

            .realname               = "SpBot (development version)",

    89

        }

    90

    };

    91

    92

    // XXX: hardcode irc_log config

    93

    char *log_db_info = NULL;

    94

    struct irc_chan_info log_chan_info = {

    95

        .channel                    = NULL, 

    96

    };

    97

    98

    bool port_default = true;

    99

   100

    // parse options

   101

    while ((opt = getopt_long(argc, argv, "hH:P:S", options, &option_index)) != -1) {

   102

        switch (opt) {

   103

            case 'h':

   104

                usage(argv[0]);

   105

                return EXIT_SUCCESS;

   106

   107

            case 'H':

   108

                net_info.hostname = optarg;

   109

                break;

   110

   111

            case 'P':

   112

                net_info.service = optarg;

   113

                port_default = false;

   114

                break;

   115

   116

            case 'S':

   117

                net_info.use_ssl = true;

   118

   119

                if (port_default)

   120

                    net_info.service = DEFAULT_PORT_SSL;

   121

   122

                break;

   123

   124

            case OPT_LOG_DATABASE:

   125

                log_db_info = optarg;

   126

                break;

   127

   128

            case OPT_LOG_CHANNEL:

   129

                log_chan_info.channel = optarg;

   130

                break;

   131

   132

            case '?':

   133

                usage(argv[0]);

   134

                return EXIT_FAILURE;

   135

        }

   136

    }

   137

   138

    // initialize libevent

   139

    if ((ctx.ev_base = event_base_new()) == NULL)

   140

        FATAL("event_base_new");

   141

   142

    // initialize signal handlers

   143

    if ((ERROR_CODE(&err) = signals_create(&signals, ctx.ev_base)))

   144

        FATAL("signals_create");

   145

   146

    // initialize sock module

   147

    if (sock_init(ctx.ev_base, &err))

   148

        FATAL_ERROR(&err, "sock_init");

   149

   150

    // modules 

   151

    if ((ERROR_CODE(&err) = modules_create(&ctx.modules, &ctx)))

   152

        FATAL_ERROR(&err, "modules_create");

   153

   154

    // the IRC client

   155

    if (irc_client_create(&ctx.client, &err))

   156

        FATAL_ERROR(&err, "irc_client_create");

   157

   158

    // the IRC network

   159

    if (irc_client_add_net(ctx.client, &net, &net_info))

   160

        FATAL_ERR(ERROR_CODE(&err), "irc_client_add_net");

   161

   162

    // add our signal handlers

   163

    if (

   164

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

   165

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

   166

    )

   167

        FATAL_ERROR(&err, "signals_add");

   168

   169

    // logging?

   170

    if (log_db_info || log_chan_info.channel) {

   171

        struct module *mod_irc_log;

   172

   173

        struct module_info mod_irc_log_info = {

   174

            .name = "irc_log",

   176

        };

   177

   178

        // load the module

   179

        if (module_load(ctx.modules, &mod_irc_log, &mod_irc_log_info, &err))

   180

            FATAL_ERROR(&err, "module_load");

   181

   182

        // get the channel

   183

        if (log_chan_info.channel) {

   184

            char conf_channel[] = "default/#test";

   185

   186

            // create the channel

   187

            if ((irc_net_add_chan(net, &log_chan_info)) == NULL)

   188

                FATAL("irc_net_add_chan");

   189

   190

            // configure it

   191

            // XXX: hardcoded

   192

            if (module_conf(mod_irc_log, "channel", conf_channel, &err))

   193

                FATAL_ERROR(&err, "module_conf(irc_log, '%s', '%s)", "channel", conf_channel);

   194

        }

   195

   196

        // configure the databse info

   197

        if (log_db_info && module_conf(mod_irc_log, "db_info", log_db_info, &err))

   198

            FATAL_ERROR(&err, "module_conf(irc_log, 'db_info', '%s')", log_db_info);

   199

    }

   200

   201

    // run event loop

   202

    if (event_base_dispatch(ctx.ev_base))

   203

        FATAL("event_base_dispatch");

   204

   205

    // ok, no cleanup

   206

    return 0;

   207

}

   208