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 *ctx = arg;

    48

    49

    (void) sig;

    50

    (void) what;

    51

    53

        log_info("Quitting...");

    54

    55

        // quit it

    57

    58

    } else {

    59

        log_error("Aborting");

    60

    61

        // die

    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;

    76

    struct nexus_ctx ctx;

    78

    struct error_info err;

    79

    80

    struct irc_net_info net_info = {

    81

        .network                    = NULL,

    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

    struct irc_chan_info log_chan_info = {

    93

        .channel                    = NULL, 

    94

    };

    95

    96

    struct irc_log_info log_info = {

    97

        .db_info                    = NULL,

    98

        .channel                    = NULL,

    99

    };

   100

   101

    bool port_default = true;

   102

   103

    // parse options

   104

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

   105

        switch (opt) {

   106

            case 'h':

   107

                usage(argv[0]);

   108

                return EXIT_SUCCESS;

   109

   110

            case 'H':

   111

                net_info.hostname = optarg;

   112

                break;

   113

   114

            case 'P':

   115

                net_info.service = optarg;

   116

                port_default = false;

   117

                break;

   118

   119

            case 'S':

   120

                net_info.use_ssl = true;

   121

   122

                if (port_default)

   123

                    net_info.service = DEFAULT_PORT_SSL;

   124

   125

                break;

   126

   127

            case OPT_LOG_DATABASE:

   128

                log_info.db_info = optarg;

   129

                break;

   130

   131

            case OPT_LOG_CHANNEL:

   132

                log_chan_info.channel = optarg;

   133

                break;

   134

   135

            case '?':

   136

                usage(argv[0]);

   137

                return EXIT_FAILURE;

   138

        }

   139

    }

   140

   141

    // initialize libevent

   142

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

   143

        FATAL("event_base_new");

   144

   145

    // initialize signal handlers

   146

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

   147

        FATAL("signals_create");

   148

   149

    // initialize sock module

   150

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

   151

        FATAL_ERROR(&err, "sock_init");

   152

   157

    // the IRC network

   160

   161

    // add our signal handlers

   162

    if (

   163

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

   164

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

   165

    )

   166

        FATAL_ERROR(&err, "signals_add");

   167

   168

    // logging?

   169

    if (log_info.db_info || log_chan_info.channel) {

   170

        // get the channel

   172

            FATAL("irc_net_add_chan");

   173

   174

        // init the irc_log module

   175

        if ((ERROR_CODE(&err) = irc_log_init(ctx.ev_base, &log_info)))

   176

            FATAL_ERROR(&err, "irc_log_init");

   177

    }

   178

   179

    // run event loop

   180

    if (event_base_dispatch(ctx.ev_base))

   181

        FATAL("event_base_dispatch");

   182

   183

    // ok, no cleanup

   184

    return 0;

   185

}

   186