257 lines
8.1 KiB
C
257 lines
8.1 KiB
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;
|
|
}
|