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