vomak.c

   1 /*
   2  *      vomak.c - this file is part of vomak - a very simple IRC bot
   3  *
   4  *      Copyright 2008 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
   5  *
   6  *      This program is free software; you can redistribute it and/or modify
   7  *      it under the terms of the GNU General Public License as published by
   8  *      the Free Software Foundation; version 2 of the License.
   9  *
  10  *      This program is distributed in the hope that it will be useful,
  11  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *      GNU General Public License for more details.
  14  *
  15  *      You should have received a copy of the GNU General Public License
  16  *      along with this program; if not, write to the Free Software
  17  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  */
  19
  20
  21
  22 #define _GNU_SOURCE
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <errno.h>
  27 #include <netdb.h>
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #include <netinet/in.h>
  31 #include <sys/socket.h>
  32 #include <unistd.h>
  33 #include <string.h>
  34 #include <signal.h>
  35 #ifndef DEBUG
  36 # include <syslog.h>
  37 #endif
  38
  39 #include <glib.h>
  40 #include <glib/gstdio.h>
  41
  42 #include "vomak.h"
  43 #include "socket.h"
  44 #include "irc.h"
  45
  46 #define CONFIG_SECTION_GENERAL "general"
  47 #define CONFIG_SECTION_DATABASE "general"
  48
  49
  50 static irc_conn_t irc_conn;
  51 static socket_info_t socket_info;
  52 static GMainLoop *main_loop = NULL;
  53 static gchar *userlist = NULL;
  54 static GList *words = NULL;
  55 config_t *config;
  56
  57
  58
  59 static void load_database_real(GKeyFile *keyfile)
  60 {
  61         gsize j, len_keys = 0;
  62         gchar **keys;
  63
  64         TRACE
  65
  66         // unload previously loaded data, aka reload
  67         if (config->data != NULL)
  68         {
  69                 g_hash_table_destroy(config->data);
  70         }
  71
  72         config->data = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
  73
  74         keys = g_key_file_get_keys(keyfile, CONFIG_SECTION_DATABASE, &len_keys, NULL);
  75         for (j = 0; j < len_keys; j++)
  76         {
  77                 g_hash_table_insert(config->data, g_strdup(keys[j]),
  78                                         g_key_file_get_string(keyfile, CONFIG_SECTION_DATABASE, keys[j], NULL));
  79         }
  80         g_strfreev(keys);
  81 }
  82
  83
  84 static void load_database()
  85 {
  86         gchar *config_name = g_build_filename(getenv("HOME"), ".vomak", "database", NULL);
  87         GKeyFile *keyfile = g_key_file_new();
  88
  89         TRACE
  90
  91         g_key_file_load_from_file(keyfile, config_name, G_KEY_FILE_NONE, NULL);
  92
  93         load_database_real(keyfile);
  94
  95         g_key_file_free(keyfile);
  96         g_free(config_name);
  97 }
  98
  99
 100 static void signal_cb(gint sig)
 101 {
 102         if (sig == SIGTERM || sig == SIGINT)
 103         {
 104                 gchar *signame;
 105
 106                 switch (sig)
 107                 {
 108                         case SIGTERM: signame = "SIGTERM"; break;
 109                         case SIGINT: signame = "SIGINT"; break;
 110                         default: signame = "unknown"; break;
 111                 }
 112                 debug("Received %s, cleaning up", signame);
 113
 114                 irc_goodbye(&irc_conn);
 115
 116                 main_quit();
 117         }
 118 }
 119
 120
 121 void main_quit()
 122 {
 123 #ifndef DEBUG
 124         closelog();
 125 #endif
 126         irc_finalize(&irc_conn);
 127         socket_finalize(&socket_info);
 128
 129         g_main_loop_quit(main_loop);
 130 }
 131
 132
 133
 134 static gboolean socket_input_cb(GIOChannel *ioc, GIOCondition cond, gpointer data)
 135 {
 136         gint fd, sock;
 137         static gchar buf[1024];
 138         static gchar msg[1024];
 139         struct sockaddr_in caddr;
 140         guint caddr_len, len, msg_len;
 141
 142         caddr_len = sizeof(caddr);
 143
 144         fd = g_io_channel_unix_get_fd(ioc);
 145         sock = accept(fd, (struct sockaddr *)&caddr, &caddr_len);
 146
 147         TRACE
 148         while ((len = socket_fd_gets(sock, buf, sizeof(buf))) != -1)
 149         {
 150                 if (strncmp("quit", buf, 4) == 0)
 151                 {
 152                         signal_cb(SIGTERM);
 153                 }
 154                 else if (strncmp("reload", buf, 6) == 0)
 155                 {
 156                         load_database();
 157                 }
 158                 else if (strncmp("userlist", buf, 8) == 0)
 159                 {
 160                         if (userlist)
 161                         {
 162                                 send(sock, userlist, strlen(userlist), 0);
 163                                 send(sock, "\n", 1, 0);
 164                         }
 165                         else
 166                                 send(sock, "error\n", 6, 0);
 167                 }
 168                 else
 169                 {
 170                         msg_len = g_snprintf(msg, sizeof msg, "%s\r\n", buf);
 171                         send(irc_conn.socket, msg, msg_len, 0);
 172                         vdebug(msg);
 173                 }
 174         }
 175         socket_fd_close(sock);
 176
 177         return TRUE;
 178 }
 179
 180
 181 static void hash_add_to_list(gpointer key, gpointer value, gpointer user_data)
 182 {
 183         if (key != NULL)
 184         {
 185                 words = g_list_insert_sorted(words, key, (GCompareFunc) strcmp);
 186         }
 187 }
 188
 189
 190 static gint write_file(const gchar *filename, const gchar *text)
 191 {
 192         FILE *fp;
 193         gint bytes_written, len;
 194
 195         if (filename == NULL)
 196         {
 197                 return ENOENT;
 198         }
 199
 200         len = strlen(text);
 201
 202         fp = g_fopen(filename, "w");
 203         if (fp != NULL)
 204         {
 205                 bytes_written = fwrite(text, sizeof (gchar), len, fp);
 206                 fclose(fp);
 207
 208                 if (len != bytes_written)
 209                 {
 210                         debug("written only %d bytes, had to write %d bytes to %s",     bytes_written, len, filename);
 211                         return EIO;
 212                 }
 213         }
 214         else
 215         {
 216                 debug("could not write to file %s (%s)", filename, g_strerror(errno));
 217                 return errno;
 218         }
 219         return 0;
 220 }
 221
 222
 223 void help_system_query(const gchar *line, guint len)
 224 {
 225         gchar *msg = irc_get_message(line, len);
 226         gchar *result;
 227
 228         if (strncmp("?? ", msg, 3) != 0)
 229                 return;
 230
 231         msg += 3;
 232
 233         if (strncmp("keywords", msg, 8) == 0)
 234         {
 235                 GList *item;
 236                 GString *str = g_string_sized_new(256);
 237
 238                 words = NULL;
 239
 240                 g_hash_table_foreach(config->data, hash_add_to_list, NULL);
 241
 242                 for (item = words; item != NULL; item = g_list_next(item))
 243                 {
 244                         g_string_append(str, item->data);
 245                         g_string_append_c(str, ' ');
 246                 }
 247
 248                 irc_send_message(&irc_conn, NULL, "%s: %s", msg, str->str);
 249                 g_list_free(words);
 250                 g_string_free(str, TRUE);
 251         }
 252         else
 253         {
 254                 result = g_hash_table_lookup(config->data, msg);
 255                 if (result)
 256                         irc_send_message(&irc_conn, NULL, "%s: %s", msg, result);
 257         }
 258 }
 259
 260
 261 // return value:
 262 //  0  - added
 263 //  1  - updated
 264 // -1  - error
 265 gint help_system_learn(const gchar *keyword, const gchar *text)
 266 {
 267         gchar *config_name;
 268         gchar *data;
 269         gchar *key;
 270         gint ret = 0;
 271         GKeyFile *keyfile;
 272
 273         TRACE
 274
 275         if (keyword == NULL || text == NULL)
 276                 return -1;
 277
 278         config_name = g_build_filename(getenv("HOME"), ".vomak", "database", NULL);
 279         keyfile = g_key_file_new();
 280
 281         g_key_file_load_from_file(keyfile, config_name, G_KEY_FILE_NONE, NULL);
 282
 283         key = g_hash_table_lookup(config->data, keyword);
 284         if (key != NULL)
 285                 ret = 1; // if key is non-NULL it is already available and gets updated
 286
 287         g_key_file_set_string(keyfile, CONFIG_SECTION_DATABASE, keyword, text);
 288
 289         data = g_key_file_to_data(keyfile, NULL, NULL);
 290         write_file(config_name, data);
 291         g_free(data);
 292
 293         load_database_real(keyfile);
 294
 295         g_key_file_free(keyfile);
 296         g_free(config_name);
 297
 298         return ret;
 299 }
 300
 301
 302 static void config_free()
 303 {
 304         TRACE
 305         g_free(config->socketname);
 306         g_free(config->socketperm);
 307         g_free(config->server);
 308         g_free(config->channel);
 309         g_free(config->servername);
 310         g_free(config->nickname);
 311         g_free(config->username);
 312         g_free(config->realname);
 313         g_free(config->nickserv_password);
 314         //~ g_hash_table_destroy(config->data);
 315         g_free(config);
 316         config = NULL;
 317 }
 318
 319
 320 static config_t *config_read()
 321 {
 322         GKeyFile *keyfile = g_key_file_new();
 323         gchar *config_name = g_build_filename(getenv("HOME"), ".vomak", "config", NULL);
 324         config_t *config = g_new0(config_t, 1);
 325
 326         TRACE
 327
 328         g_key_file_load_from_file(keyfile, config_name, G_KEY_FILE_NONE, NULL);
 329
 330         config->socketname = g_key_file_get_string(keyfile, CONFIG_SECTION_GENERAL, "socketname", NULL);
 331         config->socketperm = g_key_file_get_string(keyfile, CONFIG_SECTION_GENERAL, "socketperm", NULL);
 332         config->server = g_key_file_get_string(keyfile, CONFIG_SECTION_GENERAL, "server", NULL);
 333         config->port = g_key_file_get_integer(keyfile, CONFIG_SECTION_GENERAL, "port", NULL);
 334         config->channel = g_key_file_get_string(keyfile, CONFIG_SECTION_GENERAL, "channel", NULL);
 335         config->servername = g_key_file_get_string(keyfile, CONFIG_SECTION_GENERAL, "servername", NULL);
 336         config->nickname = g_key_file_get_string(keyfile, CONFIG_SECTION_GENERAL, "nickname", NULL);
 337         config->username = g_key_file_get_string(keyfile, CONFIG_SECTION_GENERAL, "username", NULL);
 338         config->realname = g_key_file_get_string(keyfile, CONFIG_SECTION_GENERAL, "realname", NULL);
 339         config->nickserv_password = g_key_file_get_string(keyfile, CONFIG_SECTION_GENERAL, "nickserv_password", NULL);
 340
 341         g_key_file_free(keyfile);
 342         g_free(config_name);
 343
 344         // if anything could not be read, abort. We don't use default values
 345         if (config->socketname == NULL ||
 346                 config->socketperm == NULL ||
 347                 config->server == NULL ||
 348                 config->channel == NULL ||
 349                 config->servername == NULL ||
 350                 config->nickname == NULL ||
 351                 config->username == NULL ||
 352                 config->realname == NULL)
 353         {
 354                 fprintf(stderr, "Config file does not exist or is not complete.\n");
 355                 exit(1);
 356         }
 357
 358         return config;
 359 }
 360
 361
 362 static void init_socket()
 363 {
 364         TRACE
 365
 366     /* create unix domain socket for remote operation */
 367         socket_info.lock_socket = -1;
 368         socket_info.lock_socket_tag = 0;
 369         socket_init(&socket_info, config->socketname);
 370
 371         if (socket_info.lock_socket >= 0)
 372         {
 373                 mode_t mode;
 374                 sscanf(config->socketperm, "%o", &mode);
 375                 /// FIXME for some reason the sticky bit is set when socketperm is "0640"
 376                 chmod(config->socketname, mode);
 377                 socket_info.read_ioc = g_io_channel_unix_new(socket_info.lock_socket);
 378                 g_io_channel_set_flags(socket_info.read_ioc, G_IO_FLAG_NONBLOCK, NULL);
 379                 socket_info.lock_socket_tag = g_io_add_watch(socket_info.read_ioc,
 380                                                 G_IO_IN|G_IO_PRI|G_IO_ERR, socket_input_cb, NULL);
 381         }
 382 }
 383
 384
 385 static gboolean mark_connect(gpointer data)
 386 {
 387         TRACE
 388
 389         // delay the internal connected status to skip parsing of MOTD messages
 390         irc_conn.connected = TRUE;
 391
 392         return FALSE;
 393 }
 394
 395
 396 void set_user_list(const gchar *list)
 397 {
 398         g_free(userlist);
 399         userlist = g_strdup(list);
 400 }
 401
 402
 403 gint main(gint argc, gchar **argv)
 404 {
 405         irc_conn.connected = FALSE;
 406
 407         // init stuff
 408         main_loop = g_main_loop_new(NULL, FALSE);
 409         config = config_read();
 410         load_database();
 411         init_socket();
 412         irc_connect(&irc_conn);
 413         signal(SIGTERM, signal_cb);
 414         signal(SIGINT, signal_cb);
 415
 416         g_timeout_add(15000, mark_connect, NULL);
 417         g_timeout_add(180000, irc_query_names, &irc_conn);
 418
 419         // if not a debug build, deattach from console and go into background
 420 #ifndef DEBUG
 421         signal(SIGTTOU, SIG_IGN);
 422         signal(SIGTTIN, SIG_IGN);
 423         signal(SIGTSTP, SIG_IGN);
 424         openlog("vomak", LOG_PID, LOG_DAEMON);
 425
 426         if (daemon(1, 0) < 0)
 427         {
 428                 g_printerr("Unable to daemonize\n");
 429                 return -1;
 430         }
 431 #endif
 432
 433         // main loop
 434         g_main_loop_run(main_loop);
 435
 436         config_free();
 437
 438         return 0;
 439 }