irc.c

   1 /*
   2  *      irc.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  *      Copyright 2008 Dominic Hopf
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; version 2 of the License.
  10  *
  11  *      This program is distributed in the hope that it will be useful,
  12  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *      GNU General Public License for more details.
  15  *
  16  *      You should have received a copy of the GNU General Public License
  17  *      along with this program; if not, write to the Free Software
  18  *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  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 <strings.h>
  34 #include <signal.h>
  35 #ifndef DEBUG
  36 # include <syslog.h>
  37 #endif
  38
  39 #include <glib.h>
  40
  41 #include "vomak.h"
  42 #include "socket.h"
  43 #include "irc.h"
  44
  45
  46 config_t *config;
  47
  48
  49
  50 gboolean irc_query_names(gpointer data)
  51 {
  52         irc_conn_t *irc = data;
  53         static gchar msg[1024];
  54         guint msg_len;
  55
  56         TRACE
  57
  58         msg_len = g_snprintf(msg, sizeof msg, "NAMES #%s\r\n", config->channel);
  59         send(irc->socket, msg, msg_len, 0);
  60
  61         return TRUE;
  62 }
  63
  64
  65 static void irc_send_private_message(irc_conn_t *irc_conn, const gchar *target, const gchar *format, ...)
  66 {
  67         static gchar tmp_msg[1024];
  68         static gchar msg[1024];
  69         guint msg_len;
  70         va_list ap;
  71
  72         if (target == NULL)
  73                 return;
  74
  75         va_start(ap, format);
  76         g_vsnprintf(tmp_msg, sizeof tmp_msg, format, ap);
  77         va_end(ap);
  78
  79         msg_len = g_snprintf(msg, sizeof msg, "PRIVMSG %s :%s, %s\r\n", target, target, tmp_msg);
  80         send(irc_conn->socket, msg, msg_len, 0);
  81 }
  82
  83
  84 static gchar *get_nickname(const gchar *line, guint len)
  85 {
  86         static gchar result[20];
  87         guint i, j = 0;
  88
  89         // :eht16!n=enrico@uvena.de PRIVMSG #eht16 :df
  90         for (i = 0; i < len; i++)
  91         {
  92                 if (line[i] == '!' || line[i] == '=' || j >= 19)
  93                         break;
  94
  95                 if (line[i] == ':')
  96                         continue;
  97
  98                 result[j++] = line[i];
  99         }
 100         result[j] = '\0';
 101
 102         return result;
 103 }
 104
 105
 106 static gchar *get_private_message_sender(const gchar *line, guint len)
 107 {
 108         guint i;
 109
 110         // :eht16!n=enrico@uvena.de PRIVMSG GeanyTestBot :hi
 111         for (i = 0; i < len; i++)
 112         {
 113                 if (line[i] != ' ')
 114                         continue;
 115
 116                 if (strncmp("PRIVMSG", line + i + 1, 7) == 0)
 117                 {
 118                         static gchar name[20];
 119                         g_snprintf(name, sizeof(name), "%s :", config->nickname);
 120                         // if the receiver of the message is me, then it's a private message and we return the
 121                         // sender's nickname, otherwise NULL
 122                         if (strncmp(name, line + i + 9, strlen(config->nickname) + 2) == 0)
 123                                 return get_nickname(line, len);
 124                         else
 125                                 return NULL;
 126                 }
 127         }
 128
 129         return NULL;
 130 }
 131
 132
 133 static gint get_response(const gchar *line, guint len)
 134 {
 135         static gchar result[4];
 136         guint i, j = 0;
 137         gboolean in_response = FALSE;
 138
 139         // :kornbluth.freenode.net 353 GeanyTestBot @ #eht16 :GeanyTestBot eht16
 140         // :kornbluth.freenode.net 366 GeanyTestBot #eht16 :End of /NAMES list.
 141         for (i = 0; i < len; i++)
 142         {
 143                 // before a response code
 144                 if (line[i] != ' ' && ! in_response)
 145                         continue;
 146
 147                 // after a response code
 148                 if (line[i] == ' ' && in_response)
 149                 {
 150                         in_response = FALSE;
 151                         break;
 152                 }
 153
 154                 if (line[i] == ' ' )
 155                         i++; // skip the space
 156
 157                 result[j++] = line[i];
 158                 in_response = TRUE;
 159         }
 160         result[j] = '\0';
 161
 162         return atoi(result);
 163 }
 164
 165
 166 gchar *irc_get_message(const gchar *line, guint len)
 167 {
 168         static gchar result[1024] = { 0 };
 169         guint i, j = 0;
 170         gint state = 0; // represents the current part of the whole line, separated by spaces
 171
 172         // :eht16!n=enrico@uvena.de PRIVMSG #eht16 :df foo: var
 173         // -> df foo: var
 174         for (i = 0; i < len; i++)
 175         {
 176                 if (state < 3)
 177                 {
 178                         if (line[i] == ' ')
 179                         {
 180                                 state++;
 181                                 i++; // skip the ':'
 182                                 continue;
 183                         }
 184                 }
 185                 else if (line[i] != '\r' && line[i] != '\n')
 186                 {
 187                         result[j++] = line[i];
 188                 }
 189         }
 190         result[j] = '\0';
 191
 192         return result;
 193 }
 194
 195
 196 static gchar *irc_get_message_with_name(const gchar *line, guint len, const gchar *name)
 197 {
 198         gchar *tmp;
 199         gsize name_len;
 200
 201         tmp = irc_get_message(line, len);
 202         name_len = strlen(name);
 203
 204         if (strncmp(tmp, name, name_len) == 0)
 205                 tmp += name_len;
 206
 207         return tmp;
 208 }
 209
 210
 211 // returns a nickname argument given to cmd, it may also be "cmd for nickname", then the "for" is
 212 // skipped
 213 static gchar *get_argument_target(const gchar *line, guint len, const gchar *cmd)
 214 {
 215         static gchar result[20];
 216         gchar *tmp;
 217         gchar **parts;
 218
 219         // :eht16!n=enrico@uvena.de PRIVMSG #eht16 :!beer for me
 220         tmp = irc_get_message(line, len);
 221
 222         // -> !beer for me
 223         parts = g_strsplit(tmp, " ", -1);
 224         if (parts == NULL || parts[0] == NULL)
 225         {
 226                 g_strfreev(parts);
 227                 return NULL;
 228         }
 229
 230         // if cmd doesn't match, skip it
 231         if (parts[0] != NULL && strcmp(parts[0], cmd) != 0)
 232         {
 233                 g_strfreev(parts);
 234                 return NULL;
 235         }
 236
 237         if (parts[1] == NULL)
 238         {
 239                 g_strfreev(parts);
 240                 return NULL;
 241         }
 242
 243         if (strcmp("for", parts[1]) == 0)
 244         {
 245                 if (parts[2] != NULL)
 246                 {
 247                         if (strcmp(parts[2], "me") == 0)
 248                         {
 249                                 g_strfreev(parts);
 250                                 return NULL; // if we return NULL, the nickname of the caller is used, aka "me"
 251                         }
 252                         else
 253                                 g_strlcpy(result, parts[2], sizeof(result));
 254                 }
 255                 else
 256                         g_strlcpy(result, parts[1], sizeof(result));
 257         }
 258         else if (strcmp(parts[1], "me") == 0)
 259         {
 260                 g_strfreev(parts);
 261                 return NULL; // if we return NULL, the nickname of the caller is used, aka "me"
 262         }
 263         else
 264         {
 265                 g_strlcpy(result, parts[1], sizeof(result));
 266         }
 267
 268         g_strfreev(parts);
 269         return result;
 270 }
 271
 272
 273 // Parses the line and puts the first argument in arg1, all further arguments are concatenated
 274 // in arg2. arg1 and arg2 should be freed when no longer needed.
 275 // If arg1 and arg2 were set successfully, TRUE is returned, if any error occurs, FALSE is returned
 276 // and arg1 and arg2 are set to NULL.
 277 static gboolean get_argument_two(const gchar *line, guint len, const gchar *cmd,
 278                                                                  gchar **arg1, gchar **arg2)
 279 {
 280         gchar *tmp;
 281         gchar **parts;
 282
 283         *arg1 = NULL;
 284         *arg2 = NULL;
 285
 286         // :eht16!n=enrico@uvena.de PRIVMSG #eht16 :!learn keyword text to be added
 287         tmp = irc_get_message(line, len);
 288
 289         // -> !learn keyword text to be added
 290         parts = g_strsplit(tmp, " ", 3);
 291         if (parts == NULL || parts[0] == NULL)
 292         {
 293                 g_strfreev(parts);
 294                 return FALSE;
 295         }
 296
 297         // if cmd doesn't match, skip it
 298         if (parts[0] != NULL && strcmp(parts[0], cmd) != 0)
 299         {
 300                 g_strfreev(parts);
 301                 return FALSE;
 302         }
 303
 304         if (parts[1] == NULL || parts[2] == NULL)
 305         {
 306                 g_strfreev(parts);
 307                 return FALSE;
 308         }
 309
 310         *arg1 = g_strdup(parts[1]);
 311         *arg2 = g_strdup(parts[2]);
 312
 313         g_strfreev(parts);
 314
 315         return TRUE;
 316 }
 317
 318
 319 static gboolean process_line(irc_conn_t *irc_conn, const gchar *line, guint len)
 320 {
 321         static gchar msg[1024];
 322         guint msg_len;
 323         gint response = get_response(line, len);
 324         static gchar tmp_userlist[1024];
 325         gchar *priv_sender;
 326
 327         // An error occurred, try to quit cleanly and print the error
 328         if (response > 400 && response < 503)
 329         {
 330                 // ignore Freenode's info messages sent with error code 477
 331                 // (see http://freenode.net/faq.shtml#freenode-info)
 332                 if (response != 477 || strstr(line, "[freenode-info]") == NULL)
 333                 {
 334                         g_print("Error: %s", line);
 335 #ifndef DEBUG
 336                         syslog(LOG_WARNING, "received error: %d (%s)", response, g_strstrip((gchar*) line));
 337 #endif
 338                         main_quit();
 339                         return FALSE;
 340                 }
 341         }
 342         // retrieve user name list
 343         else if (response == 353)
 344         {
 345                 gchar *names = irc_get_message(line, len);
 346                 if (tmp_userlist[0] == '\0')
 347                         g_strlcpy(tmp_userlist, strchr(names, ':') + 1, sizeof(tmp_userlist));
 348                 else
 349                         g_strlcat(tmp_userlist, strchr(names, ':') + 1, sizeof(tmp_userlist));
 350         }
 351         // retrieve end of user name list
 352         else if (response == 366)
 353         {
 354                 if (tmp_userlist[0] != '\0')
 355                 {
 356                         set_user_list(tmp_userlist);
 357                         tmp_userlist[0] = '\0';
 358                 }
 359         }
 360         else if (! irc_conn->connected)
 361         {
 362                 // don't do anything else until we got finished connecting (to skip MOTD messages)
 363         }
 364         // PING-PONG
 365         else if (strncmp("PING :", line, 6) == 0)
 366         {
 367                 msg_len = g_snprintf(msg, sizeof msg, "PONG %s\r\n", line + 6); // 7 = "PING :"
 368                 debug("PONG: -%s-\n", msg);
 369                 send(irc_conn->socket, msg, msg_len, 0);
 370         }
 371         // handle private message
 372         else if ((priv_sender = get_private_message_sender(line, len)) != NULL)
 373         {
 374                 // to be able to send private messages to users, you need to register your bot's
 375                 // nickname with Nickserv (at least on Freenode)
 376                 irc_send_private_message(irc_conn, priv_sender, "I don't like private messages!");
 377         }
 378         // !test
 379         else if (strstr(line, ":!test") != NULL)
 380         {
 381                 irc_send_message(irc_conn, get_nickname(line, len), "I don't like tests!");
 382         }
 383         // !roulette
 384         else if (strstr(line, ":!roulette") != NULL)
 385         {
 386                 gint32 rand = g_random_int();
 387                 if (rand % 6 == 0)
 388                 {
 389                         irc_send_message(irc_conn, NULL, "*bang*");
 390                         irc_send_message(irc_conn, get_nickname(line, len), "You are dead.");
 391                 }
 392                 else
 393                         irc_send_message(irc_conn, NULL, "*click*");
 394         }
 395         // !coffee
 396         else if (strstr(line, ":!coffee") != NULL)
 397         {
 398                 gchar *arg = get_argument_target(line, len, "!coffee");
 399
 400                 if (arg == NULL)
 401                         arg = get_nickname(line, len);
 402
 403                 irc_send_message(irc_conn, NULL,
 404                         "A nice sexy waitress brings %s a big cup of coffee!", arg);
 405         }
 406         // !coke
 407         else if (strstr(line, ":!coke") != NULL)
 408         {
 409                 gchar *arg = get_argument_target(line, len, "!coke");
 410
 411                 if (arg == NULL)
 412                         arg = get_nickname(line, len);
 413
 414                 irc_send_message(irc_conn, NULL,
 415                         "A nice sexy waitress brings %s a cool bottle of coke!", arg);
 416         }
 417         // !beer
 418         else if (strstr(line, ":!beer") != NULL)
 419         {
 420                 gchar *arg = get_argument_target(line, len, "!beer");
 421
 422                 if (arg == NULL)
 423                         arg = get_nickname(line, len);
 424
 425                 irc_send_message(irc_conn, NULL,
 426                         "A nice sexy waitress brings %s a nice bottle of beer!", arg);
 427         }
 428         // !help
 429         else if (strstr(line, ":!help") != NULL)
 430         {
 431                 irc_send_message(irc_conn, get_nickname(line, len), "please use ?? help");
 432         }
 433         // !learn
 434         /// TODO require op privileges for !learn
 435         else if (strstr(line, ":!learn") != NULL)
 436         {
 437                 gchar *arg1, *arg2;
 438
 439                 if (get_argument_two(line, len, "!learn", &arg1, &arg2))
 440                 {
 441                         gint result = help_system_learn(arg1, arg2);
 442                         gchar *text;
 443
 444                         switch (result)
 445                         {
 446                                 case 0:
 447                                 {
 448                                         text = g_strdup_printf("new keyword \"%s\" was added.", arg1);
 449                                         break;
 450                                 }
 451                                 case 1:
 452                                 {
 453                                         text = g_strdup_printf("existing keyword \"%s\" was updated.", arg1);
 454                                         break;
 455                                 }
 456                                 default:
 457                                 {
 458                                         text = g_strdup("an error occurred. Database not updated.");
 459                                         break;
 460                                 }
 461                         }
 462                         irc_send_message(irc_conn, get_nickname(line, len), "%s", text);
 463
 464                         g_free(text);
 465                         g_free(arg1);
 466                         g_free(arg2);
 467                 }
 468                 else
 469                         irc_send_message(irc_conn, get_nickname(line, len),
 470                                 "wrong usage of !learn. Use \"?? learn\" for usage information.");
 471         }
 472
 473         // !alias-command
 474         else if (strstr(line, ":!alias") != NULL)
 475         {
 476                 gchar *arg1, *arg2;
 477
 478                 if (get_argument_two(line, len, "!alias", &arg1, &arg2))
 479                 {
 480                         gchar *text;
 481                         gint result;
 482
 483                         // detect if arg2 has more than one word by scanning for spaces in
 484                         // the string
 485                         if (strchr(arg2, ' '))
 486                         {
 487                                 text = "You gave me more than two arguments for !alias. I can not handle this.";
 488                                 irc_send_message(irc_conn, get_nickname(line, len), "%s", text);
 489                         }
 490
 491                         else
 492                         {
 493                                 gchar *alias = g_strconcat("@", arg2, NULL);
 494                                 result = help_system_learn(arg1, alias);
 495                                 g_free(alias);
 496
 497                                 switch (result)
 498                                 {
 499                                         case 0:
 500                                         {
 501                                                 text = g_strdup_printf("new alias \"%s\" was added.", arg1);
 502                                                 break;
 503                                         }
 504                                         case 1:
 505                                         {
 506                                                 text = g_strdup_printf("existing alias \"%s\" was updated.", arg1);
 507                                                 break;
 508                                         }
 509                                         default:
 510                                         {
 511                                                 text = g_strdup("An error occurred. Database not updated.");
 512                                                 break;
 513                                         }
 514                                 }
 515
 516                                 irc_send_message(irc_conn, get_nickname(line, len), "%s", text);
 517                         }
 518
 519                         g_free(text);
 520                         g_free(arg1);
 521                         g_free(arg2);
 522                 }
 523         }
 524
 525
 526         // ?? ...
 527         else if (strstr(line, ":?? ") != NULL)
 528         {
 529                 help_system_query(line, len);
 530         }
 531         // Hi /me, acts on "hello $nickname" and "hi $nickname", hi and hello are case-insensitive
 532         // Thanks /me
 533         else if (strstr(line, config->nickname) != NULL)
 534         {
 535                 gchar *tmp_msg = irc_get_message(line, len);
 536                 gchar *tmp_msg2 = irc_get_message_with_name(line, len, config->nickname);
 537
 538                 if (strncasecmp("hi", tmp_msg, 2) == 0 || strncasecmp("hello", tmp_msg, 5) == 0 ||
 539                         strcasecmp(", hi", tmp_msg2) == 0 || strcasecmp(", hello", tmp_msg2) == 0)
 540                 {
 541                         irc_send_message(irc_conn, NULL,
 542         "Hi %s. My name is %s and I'm here to offer additional services to you! "
 543         "Try \"?? help\" for general information and \"?? vomak\" for information about me.",
 544                                 get_nickname(line, len), config->nickname);
 545                 }
 546                 else if (strncasecmp("thanks", tmp_msg, 6) == 0 || strncasecmp("thx", tmp_msg, 3) == 0 ||
 547                                  strcasecmp(", thanks", tmp_msg2) == 0 || strcasecmp(", thx", tmp_msg2) == 0)
 548                 {
 549                         irc_send_message(irc_conn, get_nickname(line, len),
 550                                 "no problem. It was a pleasure to serve you.");
 551                 }
 552         }
 553
 554         return TRUE;
 555 }
 556
 557
 558 static gboolean input_cb(GIOChannel *source, GIOCondition cond, gpointer data)
 559 {
 560 #if 1
 561         gchar buf[1024];
 562         guint buf_len;
 563         irc_conn_t *irc = data;
 564         gboolean ret = TRUE;
 565
 566         if ((buf_len = socket_fd_gets(irc->socket, buf, sizeof(buf))) != -1)
 567         {
 568                 ret = process_line(irc, buf, buf_len);
 569         }
 570 #else
 571         gsize buf_len;
 572         irc_conn_t *irc = data;
 573
 574         if (cond & (G_IO_IN | G_IO_PRI))
 575         {
 576                 gchar *buf = NULL;
 577                 GIOStatus rv;
 578                 GError *err = NULL;
 579
 580                 do
 581                 {
 582                         rv = g_io_channel_read_line(source, &buf, &buf_len, NULL, &err);
 583                         if (buf != NULL)
 584                         {
 585                                 buf_len -= 2;
 586                                 buf[buf_len] = '\0'; // skip trailing \r\n
 587
 588                                 process_line(irc, buf, buf_len);
 589                                 g_free(buf);
 590                         }
 591                         if (err != NULL)
 592                         {
 593                                 debug("%s: error: %s", __func__, err->message);
 594                                 g_error_free(err);
 595                                 err = NULL;
 596                         }
 597                 }
 598                 while (rv == G_IO_STATUS_NORMAL || rv == G_IO_STATUS_AGAIN);
 599                 debug("%s: status %d\n", __func__, rv);
 600         }
 601 #endif
 602         return ret;
 603 }
 604
 605
 606 void irc_send_message(irc_conn_t *irc_conn, const gchar *target, const gchar *format, ...)
 607 {
 608         static gchar tmp_msg[1024];
 609         static gchar msg[1024];
 610         guint msg_len;
 611         va_list ap;
 612
 613         va_start(ap, format);
 614         g_vsnprintf(tmp_msg, sizeof tmp_msg, format, ap);
 615         va_end(ap);
 616
 617         if (target)
 618                 msg_len = g_snprintf(msg, sizeof msg, "PRIVMSG #%s :%s, %s\r\n", config->channel, target, tmp_msg);
 619         else
 620                 msg_len = g_snprintf(msg, sizeof msg, "PRIVMSG #%s :%s\r\n", config->channel, tmp_msg);
 621
 622         send(irc_conn->socket, msg, msg_len, 0);
 623 }
 624
 625
 626 void irc_goodbye(irc_conn_t *irc)
 627 {
 628         guint len;
 629         gchar msg[256];
 630
 631         len = g_strlcpy(msg, "QUIT :Good bye. It was a pleasure to serve you\r\n", sizeof msg);
 632         send(irc->socket, msg, len, 0);
 633 }
 634
 635
 636 gint irc_finalize(irc_conn_t *irc_conn)
 637 {
 638         if (irc_conn->socket < 0)
 639                 return -1;
 640
 641         if (irc_conn->lock_tag > 0)
 642                 g_source_remove(irc_conn->lock_tag);
 643
 644         if (irc_conn->read_ioc)
 645         {
 646                 g_io_channel_shutdown(irc_conn->read_ioc, TRUE, NULL);
 647                 g_io_channel_unref(irc_conn->read_ioc);
 648                 irc_conn->read_ioc = NULL;
 649         }
 650         socket_fd_close(irc_conn->socket);
 651         irc_conn->socket = -1;
 652
 653         return 0;
 654 }
 655
 656
 657 void irc_connect(irc_conn_t *irc_conn)
 658 {
 659         struct hostent *he;
 660         struct sockaddr_in their_addr;
 661         gchar msg[256];
 662         guint msg_len;
 663
 664         TRACE
 665
 666         // Connect the socket to the server
 667         if ((he = gethostbyname(config->server)) == NULL)
 668         {
 669                 perror("gethostbyname");
 670                 exit(1);
 671         }
 672
 673         if ((irc_conn->socket = socket(PF_INET, SOCK_STREAM, 0)) == -1)
 674         {
 675                 perror("socket");
 676                 exit(1);
 677         }
 678
 679         their_addr.sin_family = PF_INET;
 680         their_addr.sin_port = htons(6667);
 681         their_addr.sin_addr = *((struct in_addr *)he->h_addr_list[0]);
 682         memset(&(their_addr.sin_zero), '\0', 8);
 683
 684         if (connect(irc_conn->socket, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1)
 685         {
 686                 perror("connect");
 687                 exit(1);
 688         }
 689         // say who we are
 690         msg_len = g_snprintf(msg, sizeof(msg), "USER %s %s %s :%s\r\nNICK %s\r\n",
 691                         config->username, config->servername, config->servername, config->realname, config->nickname);
 692         if (send(irc_conn->socket, msg, msg_len, 0) == -1)
 693         {
 694                 perror("send USER");
 695         }
 696         // identify our nick
 697         if (NZV(config->nickserv_password))
 698         {
 699                 msg_len = g_snprintf(msg, sizeof(msg), "PRIVMSG nickserv :identify %s\r\n", config->nickserv_password);
 700                 if (send(irc_conn->socket, msg, msg_len, 0) == -1)
 701                 {
 702                         perror("send NICKSERV");
 703                 }
 704         }
 705         // join the channel
 706         g_snprintf(msg, sizeof msg, "JOIN #%s\r\n ", config->channel);
 707         if (send(irc_conn->socket, msg, strlen(msg), 0) == -1)
 708         {
 709                 perror("send");
 710         }
 711
 712         // input callback, attached to the main loop
 713         irc_conn->read_ioc = g_io_channel_unix_new(irc_conn->socket);
 714         //~ g_io_channel_set_flags(irc_conn.read_ioc, G_IO_FLAG_NONBLOCK, NULL);
 715         g_io_channel_set_encoding(irc_conn->read_ioc, NULL, NULL);
 716         irc_conn->lock_tag = g_io_add_watch(irc_conn->read_ioc, G_IO_IN|G_IO_PRI|G_IO_ERR, input_cb, irc_conn);
 717 }