quote-bot/main.c

/*
 * Dictionary bot.
 *
 * Code adapted from:
 *
 * <https://gist.github.com/enile8/2424514>
 * <https://www.rosettacode.org/wiki/Write_entire_file#C>
 * <https://rosettacode.org/wiki/Read_entire_file#C>
 * libircclient-1.10/examples/spammer.c
 *
 * And surely others.
 *
 * Copyright (C) 2004-2009 Georgy Yunaev gyunaev@ulduzsoft.com
 * Copyright (C) 2021      Bubblegumdrop <Bubblegumdrop@lain.church>
 *
 * This example is free, and not covered by LGPL license. There is no 
 * restriction applied to their modification, redistribution, using and so on.
 * You can study them, modify them, use them in your own program - either 
 * completely or partially. By using it you may give me some credits in your
 * program, but you don't have to.
 *
 *            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
 *                    Version 2, December 2004
 *  
 * Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
 * Copyright (C) 2021 Bubblegumdrop <Bubblegumdrop@lain.church>
 * 
 * Everyone is permitted to copy and distribute verbatim or modified
 * copies of this license document, and changing it is allowed as long
 * as the name is changed.
 *  
 *            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
 *   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 * 
 *  0. You just DO WHAT THE FUCK YOU WANT TO.
 */
#define _POSIX_C_SOURCE 200809L /* strtok_r, strndup */
#include <string.h>
#include <assert.h>             /* assert */
#include <errno.h>
#include <getopt.h>             /* getopt */
#include <stdio.h>              /* size_t */
#include <unistd.h>             /* getopt */
#include "libircclient.h"

#include "data.h"
#include "db.h"
#include "events.h"
#include "levenshtein.h"
#include "strings.h"
#include "threads.h"
#include "unused.h"

extern void install_signal_handler(void);

char F_IRC_THREAD = STOPPED;
char F_MAIN_THREAD = STOPPED;
char IsIPv6Enabled = 0;
irc_session_t *irc_session = NULL;

THREAD_FUNCTION(IrcSessionThread) {
    int rc;
    const char *server;
    struct irc_ctx_t *ctx;
    irc_callbacks_t callbacks;
    ctx = (struct irc_ctx_t *)arg;
    assert(NULL != ctx);
    server = ctx->server;
    assert(NULL != server);
    assert(NULL != ctx->nick);
    assert(NULL != ctx->channel);
    while (RUNNING == F_IRC_THREAD) {
        /* Initialize the callbacks */
        memset(&callbacks, 0, sizeof(callbacks));
        /* Set up the callbacks we will use */
        callbacks.event_channel = irc_event_channel;
        callbacks.event_connect = irc_event_connect;
        callbacks.event_dcc_chat_req = irc_event_dcc_chat;
        callbacks.event_dcc_send_req = irc_event_dcc_send;
        callbacks.event_join = irc_event_join;
        callbacks.event_nick = irc_event_nick;
        callbacks.event_numeric = irc_event_numeric;
        callbacks.event_privmsg = irc_event_privmsg;

        callbacks.event_ctcp_action = dump_event;
        callbacks.event_ctcp_rep = dump_event;
        callbacks.event_invite = dump_event;
        callbacks.event_kick = dump_event;
        callbacks.event_mode = dump_event;
        callbacks.event_nick = dump_event;
        callbacks.event_notice = dump_event;
        callbacks.event_part = dump_event;
        callbacks.event_quit = dump_event;
        callbacks.event_topic = dump_event;
        callbacks.event_umode = dump_event;
        callbacks.event_unknown = dump_event;

        /* And create the IRC session; 0 means error */
        irc_session = irc_create_session(&callbacks);
        if (!irc_session) {
            fprintf(stderr, string_connect_failure, irc_strerror(irc_errno(irc_session)));
            F_IRC_THREAD = STOPPED;
        }
        irc_set_ctx(irc_session, ctx);
        irc_option_set(irc_session, LIBIRC_OPTION_STRIPNICKS);
        /* If the port number is specified in the server string, use the port 0 so it gets parsed */
        if (strchr(server, ':') != 0)
            ctx->port = 0;
        /*
         * To handle the "SSL certificate verify failed" from command line we allow passing ## in front 
         * of the server name, and in this case tell libircclient not to verify the cert
         */
        if (server[0] == '#' && server[0] == '#') {
            /* Skip the first character as libircclient needs only one # for SSL support, i.e. #irc.freenode.net */
            server++;
            irc_option_set(irc_session, LIBIRC_OPTION_SSL_NO_VERIFY);
        }
        /* Initiate the IRC server connection */
        rc = 1;
        if (IsIPv6Enabled) {
            rc = irc_connect6(irc_session, server, ctx->port, 0, ctx->nick, 0, 0);
        } else {
            rc = irc_connect(irc_session, server, ctx->port, 0, ctx->nick, 0, 0);
        }
        if (rc) {
            fprintf(stderr, string_connect_failure, irc_strerror(irc_errno(irc_session)));
            F_IRC_THREAD = STOPPED;
        }
        /* and run into forever loop, generating events */
        if (irc_run(irc_session)) {
            fprintf(stderr, string_connect_failure, irc_strerror(irc_errno(irc_session)));
            F_IRC_THREAD = STOPPED;
        }
        irc_destroy_session(irc_session);
        irc_session = NULL;
    }
    F_MAIN_THREAD = STOPPED;
#ifdef _WIN32
    return 0;
#else
    return NULL;
#endif
}
int main(int argc, char *argv[]) {
    int c;
    int rc;
    int opt;
    const char *db_name;
    const char *query_str;
    const char *filename;
    sqlite3 *db;
    struct irc_ctx_t ctx;
    thread_id_t tid;
#if 0
    const char *s1 = "rosettacode";
    const char *s2 = "raisethysword";
    printf("distance between `%s' and `%s': %d\n", s1, s2, levenshtein(s1, s2));
#endif
    install_signal_handler();
    db_name = "familyGuy.sqlite3";
    query_str = NULL;
    filename = NULL;
    rc = -1;
    db = NULL;
    memset(&ctx, 0, sizeof(struct irc_ctx_t));
    ctx.port = 6667;
    while ((opt = getopt(argc, argv, "c:d:f:hn:p:q:s:46")) != -1) {
        switch (opt) {
            case '4':
                IsIPv6Enabled = 0;
                break;
            case '6':
                IsIPv6Enabled = 1;
                break;
        case 'c':
            ctx.channel = optarg;
            break;
        case 'd':
            db_name = optarg;
            break;
        case 'f':
            filename = optarg;
            break;
        case 'n':
            ctx.nick = optarg;
            break;
        case 'p':
            ctx.port = atoi(optarg);
            break;
        case 'q':
            query_str = optarg;
            break;
        case 's':
            ctx.server = optarg;
            break;
        case 'h':
        default:
            fprintf(stderr, string_usage_fmt, argv[0]);
            return -1;
            break;
        }
    }
    if (NULL != db_name) {
        if (SQLITE_OK == (rc = sqlite3_open(db_name, &db))) {
            printf("%s", string_opendb_success);
            sqlite_version(db);
        }
    } else {
        fprintf(stderr, string_opendb_failure, sqlite3_errmsg(db));
        return -1;
    }

    /*run_one(db, create_db_query);*/

    if (NULL != query_str) {
        rc = run_one(db, query_str);
    } else if (NULL != filename) {
        rc = run_script(db, filename);
    } else if (argc == 4) {
        if (argc > 1)
            ctx.server = argv[1];
        if (argc > 2)
            ctx.nick = argv[2];
        if (argc > 3)
            ctx.channel = argv[3];
        if (!ctx.server || !ctx.nick || !ctx.channel) {
            fprintf(stderr, string_usage_fmt, argv[0]);
            return -1;
        }
        F_IRC_THREAD = RUNNING;
        F_MAIN_THREAD = RUNNING;
        if (CREATE_THREAD(&tid, IrcSessionThread, &ctx)) {
            printf(string_thread_failure, strerror(errno));
        } else {
            printf("%s", string_ircthread_success);
        }
        while (RUNNING == F_MAIN_THREAD) {
            sleep(1);
            c = getchar();
            if ('q' == c) {
                if (irc_session)
                    irc_cmd_quit(irc_session, "Bye!");
                F_MAIN_THREAD = STOPPED;
            }
        }
        F_IRC_THREAD = STOPPED;
        F_SPAM_THREADS = STOPPED;
        rc = 0;
    } else {
        fprintf(stderr, string_usage_fmt, argv[0]);
        return -1;
    }

    sqlite3_close(db);
    return rc;
}