src/IRCParser.c

   1
   2 #include "IRCParser.h"
   3 #include "UserNode.h"
   4 #include "ChanNode.h"
   5 #include "ChanUser.h"
   6 #include "IRCEvents.h"
   7 #include "ClientSocket.h"
   8 #include "WHOHandler.h"
   9 #include "lang.h"
  10 #include "DBHelper.h"
  11 #include "BanNode.h"
  12 #include "ModeNode.h"
  13
  14 struct irc_cmd *irc_commands = NULL;
  15
  16 static void parse_line(struct ClientSocket *client, char *line);
  17 static void register_irc_function(char *command, irc_cmd_t *func);
  18 static void parse_raw(struct ClientSocket *client, char *from, char *cmd, char **argv, int argc);
  19
  20 int parse_lines(struct ClientSocket *client, char *lines, int len) {
  21     int i, used = 0;
  22     char *line = lines;
  23     for(i = 0; i < len; i++) {
  24         if(lines[i] == '\r') //just zero it out :D
  25             lines[i] = 0;
  26         if(lines[i] == '\n') {
  27             lines[i] = 0;
  28             parse_line(client, line);
  29             line = lines+(i+1);
  30             used = i+1;
  31         }
  32     }
  33     return used;
  34 }
  35
  36 static void parse_line(struct ClientSocket *client, char *line) {
  37     int argc = 0;
  38     char *argv[MAXNUMPARAMS];
  39     printf("[recv %lu] %s\n", (unsigned long) strlen(line), line);
  40     if(line[0] == ':')
  41         line++;
  42     else
  43         argv[argc++] = NULL;
  44     while(*line) {
  45         //skip leading spaces
  46         while (*line == ' ')
  47             *line++ = 0;
  48         if (*line == ':') {
  49            //the rest is a single parameter
  50            argv[argc++] = line + 1;
  51            break;
  52         }
  53         argv[argc++] = line;
  54         if (argc >= MAXNUMPARAMS)
  55             break;
  56         while (*line != ' ' && *line)
  57             line++;
  58     }
  59     if(argc >= 2) {
  60         parse_raw(client, argv[0], argv[1], argv+2, argc-2);
  61     }
  62 }
  63
  64 static void register_irc_function(char *command, irc_cmd_t *func) {
  65     struct irc_cmd *irc_cmd = malloc(sizeof(*irc_cmd));
  66     if (!irc_cmd)
  67     {
  68         perror("malloc() failed");
  69         return;
  70     }
  71     irc_cmd->cmd = command;
  72     irc_cmd->func = func;
  73     irc_cmd->next = irc_commands;
  74     irc_commands = irc_cmd;
  75 }
  76
  77 static void parse_raw(struct ClientSocket *client, char *from, char *cmd, char **argv, int argc) {
  78     struct irc_cmd *irc_cmd;
  79     int ret = 0;
  80     for(irc_cmd = irc_commands; irc_cmd; irc_cmd = irc_cmd->next) {
  81         if(!stricmp(irc_cmd->cmd, cmd)) {
  82             ret = irc_cmd->func(client, from, argv, argc);
  83             break;
  84         }
  85     }
  86     if(!irc_cmd) {
  87         event_raw(client, from, cmd, argv, argc);
  88     } else if(!ret) {
  89         fprintf(stderr,"PARSE ERROR: %s\n", cmd);
  90     }
  91 }
  92
  93 static USERLIST_CALLBACK(got_channel_userlist) {
  94     struct ChanUser *chanuser = data;
  95     event_join(chanuser);
  96 }
  97
  98 static IRC_CMD(raw_001) {
  99     client->flags |= SOCKET_FLAG_READY;
 100     event_bot_ready(client);
 101     return 1;
 102 }
 103
 104 static IRC_CMD(raw_join) {
 105     if(from == NULL || argc < 1) return 0;
 106     struct UserNode *user = getUserByMask(from);
 107     struct ChanNode *chan = getChanByName(argv[0]);
 108     if(!chan && !(user->flags & USERFLAG_ISBOT)) return 0;
 109     if(user == NULL) {
 110         user = addUserMask(from);
 111     }
 112     if(chan == NULL) {
 113         chan = addChannel(argv[0]);
 114         //request member list
 115         chan->chanbot = user;
 116         struct ChanUser *chanuser = addChanUser(chan, user); //it must be a bot
 117         get_userlist(chan, got_channel_userlist, chanuser);
 118         putsock(client, "MODE %s", chan->name);
 119         putsock(client, "MODE %s +b", chan->name);
 120     } else if(!isUserOnChan(user, chan) && (chan->flags & CHANFLAG_RECEIVED_USERLIST)) {
 121         struct ChanUser *chanuser = addChanUser(chan, user);
 122         event_join(chanuser);
 123     }
 124     return 1;
 125 }
 126
 127 static IRC_CMD(raw_part) {
 128     if(from == NULL || argc < 1) return 0;
 129     struct UserNode *user = getUserByMask(from);
 130     if(user == NULL) return 0;
 131     struct ChanNode *chan = getChanByName(argv[0]);
 132     if(chan == NULL) return 0;
 133     if(isUserOnChan(user, chan) && (chan->flags & CHANFLAG_RECEIVED_USERLIST)) {
 134         struct ChanUser *chanuser = getChanUser(user, chan);
 135         delChanUser(chanuser, 0); //we need to free the chanuser manually!
 136         event_part(chanuser, (argc > 1 ? argv[1] : NULL));
 137         free(chanuser);
 138         if(chan->chanbot == user) {
 139             //check if theres another bot in the channel - otherwise free it
 140             checkChannelVisibility(chan);
 141         }
 142     }
 143     if(user->channel == NULL && !(user->flags & USERFLAG_ISBOT)) {
 144         //remove the user
 145         delUser(user, 1);
 146     }
 147     return 1;
 148 }
 149
 150 static IRC_CMD(raw_quit) {
 151     if(from == NULL || argc < 1) return 0;
 152     struct UserNode *user = getUserByMask(from);
 153     if(user == NULL) return 0;
 154     delUser(user, 0); //a little bit crazy, but we want to delete the user on the channel's userlists - but not the users channel list
 155     event_quit(user, argv[0]);
 156     if(user->flags & USERFLAG_ISBOT) {
 157         //check if there are other bots in the users channel - otherwise free them
 158         struct ChanUser *chanuser, *next;
 159         for(chanuser = getUserChannels(user, NULL); chanuser; chanuser = next) {
 160             next = getUserChannels(user, chanuser);
 161             checkChannelVisibility(chanuser->chan);
 162         }
 163     }
 164     delUser(user, 1); //now we fully free the user
 165     return 1;
 166 }
 167
 168 void bot_disconnect(struct ClientSocket *client) {
 169     struct UserNode *user = client->user;
 170     struct ChanUser *chanuser, *next;
 171     delUser(user, 0);
 172     event_quit(user, "disconnected");
 173     for(chanuser = getUserChannels(user, NULL); chanuser; chanuser = next) {
 174         next = getUserChannels(user, chanuser);
 175         checkChannelVisibility(chanuser->chan);
 176         free(chanuser);
 177     }
 178     user->channel = NULL;
 179 }
 180
 181 static IRC_CMD(raw_kick) {
 182     if(from == NULL || argc < 3) return 0;
 183     struct UserNode *user = getUserByMask(from);
 184     struct UserNode *target = getUserByNick(argv[1]);
 185     struct ChanNode *chan = getChanByName(argv[0]);
 186     if(chan == NULL || target == NULL) return 0;
 187     if(isUserOnChan(target, chan) && (chan->flags & CHANFLAG_RECEIVED_USERLIST)) {
 188         if(user == NULL) {
 189             user = createTempUser(from);
 190             user->flags |= USERFLAG_ISTMPUSER;
 191         }
 192         struct ChanUser *chanuser = getChanUser(target, chan);
 193         delChanUser(chanuser, 0); //we need to free the chanuser manually!
 194         event_kick(user, chanuser, argv[1]);
 195         free(chanuser);
 196         if(target->flags & USERFLAG_ISBOT) {
 197             //check if theres another bot in the channel - otherwise free it
 198             checkChannelVisibility(chan);
 199         }
 200     }
 201     if(target->channel == NULL && !(target->flags & USERFLAG_ISBOT)) {
 202         //remove the user
 203         delUser(target, 1);
 204     }
 205     return 1;
 206 }
 207
 208 static IRC_CMD(raw_topic) {
 209     if(from == NULL || argc < 2) return 0;
 210     struct UserNode *user = getUserByMask(from);
 211     struct ChanNode *chan = getChanByName(argv[0]);
 212     if(chan == NULL) return 0;
 213     if(chan->chanbot != client->user) return 1; //just ignore it to prevent event duplicates
 214     if(user == NULL) {
 215         user = createTempUser(from);
 216         user->flags |= USERFLAG_ISTMPUSER;
 217     }
 218     event_topic(user, chan, argv[1]);
 219     strcpy(chan->topic, argv[1]);
 220     return 1;
 221 }
 222
 223 static IRC_CMD(raw_privmsg) {
 224     if(from == NULL || argc < 2) return 0;
 225     struct UserNode *user = getUserByMask(from);
 226     if(user == NULL) {
 227         user = createTempUser(from);
 228         user->flags |= USERFLAG_ISTMPUSER;
 229     }
 230     if(argv[0][0] == '#') { //Channel message
 231         struct ChanNode *chan = getChanByName(argv[0]);
 232         if(chan && chan->chanbot == client->user) {
 233             if(argv[1][0] == '\001') {
 234                 char *cmd = &argv[1][1];
 235                 char *text = strstr(cmd, " ");
 236                 if(text) {
 237                     *text = '\0';
 238                     text++;
 239                     if(strlen(text) && text[strlen(text)-1] == '\001')
 240                         text[strlen(text)-1] = '\0';
 241                 } else if(strlen(cmd) && cmd[strlen(cmd)-1] == '\001')
 242                     cmd[strlen(cmd)-1] = '\0';
 243                 event_chanctcp(user, chan, cmd, text);
 244             } else
 245                 event_chanmsg(user, chan, argv[1]);
 246         }
 247     } else {
 248         struct UserNode *target = getUserByNick(argv[0]);
 249         if(target) {
 250             if(argv[1][0] == '\001') {
 251                 char *cmd = &argv[1][1];
 252                 char *text = strstr(cmd, " ");
 253                 if(text) {
 254                     *text = '\0';
 255                     text++;
 256                     if(strlen(text) && text[strlen(text)-1] == '\001')
 257                         text[strlen(text)-1] = '\0';
 258                 } else if(strlen(cmd) && cmd[strlen(cmd)-1] == '\001')
 259                     cmd[strlen(cmd)-1] = '\0';
 260                 event_privctcp(user, target, cmd, text);
 261             } else
 262                 event_privmsg(user, target, argv[1]);
 263         }
 264     }
 265     return 1;
 266 }
 267
 268 static IRC_CMD(raw_notice) {
 269     if(from == NULL || argc < 2) return 0;
 270     struct UserNode *user = getUserByMask(from);
 271     if(user == NULL) {
 272         user = createTempUser(from);
 273         user->flags |= USERFLAG_ISTMPUSER;
 274     }
 275     if(argv[0][0] == '#') { //Channel notice
 276         struct ChanNode *chan = getChanByName(argv[0]);
 277         if(chan && chan->chanbot == client->user)
 278             event_channotice(user, chan, argv[1]);
 279     } else {
 280         struct UserNode *target = getUserByNick(argv[0]);
 281         if(target)
 282             event_privnotice(user, target, argv[1]);
 283     }
 284     return 1;
 285 }
 286
 287 static IRC_CMD(raw_nick) {
 288     if(from == NULL || argc == 0) return 0;
 289     struct UserNode *user = getUserByMask(from);
 290     if(user == NULL) return 0;
 291     event_nick(user, argv[0]);
 292     renameUser(user, argv[0]);
 293     return 1;
 294 }
 295
 296 static IRC_CMD(raw_ping) {
 297     if(argc == 0) return 0;
 298     putsock(client, "PONG :%s", argv[0]);
 299     return 1;
 300 }
 301
 302 static IRC_CMD(raw_354) {
 303     recv_whohandler_354(client, argv, argc);
 304     return 1;
 305 }
 306
 307 static IRC_CMD(raw_315) {
 308     recv_whohandler_315(client, argv, argc);
 309     return 1;
 310 }
 311
 312 static IRC_CMD(raw_324) { //MODE LIST
 313     //Watchcat #pktest +stnzN
 314     if(from == NULL || argc < 3) return 0;
 315     struct ChanNode *chan = getChanByName(argv[1]);
 316     if(chan == NULL) return 0;
 317     parseModes(chan->modes, argv[2], argv+3, argc-3);
 318     return 1;
 319 }
 320
 321 static IRC_CMD(raw_invite) {
 322     if(from == NULL || argc < 2) return 0;
 323     struct UserNode *user = getUserByMask(from);
 324     if(user == NULL) {
 325         user = createTempUser(from);
 326         user->flags |= USERFLAG_ISTMPUSER;
 327     }
 328     event_invite(client, user, argv[1]);
 329     return 1;
 330 }
 331
 332 static IRC_CMD(raw_mode) {
 333     if(from == NULL || argc < 2) return 0;
 334     struct UserNode *user = getUserByMask(from);
 335     if(user == NULL) {
 336         user = createTempUser(from);
 337         user->flags |= USERFLAG_ISTMPUSER;
 338     }
 339     if(argv[0][0] == '#') {
 340         //ChannelMode
 341         struct ChanNode *chan = getChanByName(argv[0]);
 342         if(!chan) return 0;
 343         if(chan->chanbot != client->user) return 1;
 344         event_mode(user, chan, argv[1], argv+2, argc-2);
 345         parseModes(chan->modes, argv[1], argv+2, argc-2);
 346     } else {
 347         //UserMode
 348     }
 349     return 1;
 350 }
 351
 352 static IRC_CMD(raw_367) {
 353     //Watchcat #pktest pk911!*@* TestBot!~bot@pktest.user.WebGamesNet 1315863279
 354     struct ChanNode *chan = getChanByName(argv[1]);
 355     if(!chan) return 0;
 356     struct BanNode *ban;
 357     while((ban = getMatchingChannelBan(chan, argv[2]))) {
 358         removeChannelBan(ban);
 359     }
 360     addChannelBan(chan, argv[2]);
 361     return 1;
 362 }
 363
 364 void init_parser() {
 365     //all the raws we receive...
 366     register_irc_function("001", raw_001);
 367     register_irc_function("324", raw_324);
 368     register_irc_function("367", raw_367);
 369     register_irc_function("INVITE", raw_invite);
 370     register_irc_function("NOTICE", raw_notice);
 371     register_irc_function("TOPIC", raw_topic);
 372     register_irc_function("KICK", raw_kick);
 373     register_irc_function("PART", raw_part);
 374     register_irc_function("QUIT", raw_quit);
 375     register_irc_function("JOIN", raw_join);
 376     register_irc_function("MODE", raw_mode);
 377     register_irc_function("NICK", raw_nick);
 378     register_irc_function("354", raw_354);
 379     register_irc_function("315", raw_315);
 380     register_irc_function("PING", raw_ping);
 381     register_irc_function("PRIVMSG", raw_privmsg);
 382 }
 383
 384 void free_parser() {
 385     struct irc_cmd *cmd, *next;
 386     for(cmd = irc_commands; cmd; cmd = next) {
 387         next = cmd->next;
 388         free(cmd);
 389     }
 390 }
 391
 392 void reply(struct ClientSocket *client, struct UserNode *user, const char *text, ...) {
 393     const char *reply_format = get_language_string(user, text);
 394     if(reply_format == NULL)
 395         reply_format = text;
 396     loadUserSettings(user);
 397     char formatBuf[MAXLEN];
 398     sprintf(formatBuf, "%s %s :%s", ((user->flags & USERFLAG_REPLY_PRIVMSG) ? "PRIVMSG" : "NOTICE"), user->nick, reply_format);
 399     va_list arg_list;
 400     char sendBuf[MAXLEN];
 401     int pos;
 402     if (!(client->flags & SOCKET_FLAG_CONNECTED)) return;
 403     sendBuf[0] = '\0';
 404     va_start(arg_list, text);
 405     pos = vsnprintf(sendBuf, MAXLEN - 2, formatBuf, arg_list);
 406     va_end(arg_list);
 407     if (pos < 0 || pos > (MAXLEN - 2)) pos = MAXLEN - 2;
 408     sendBuf[pos] = '\n';
 409     sendBuf[pos+1] = '\0';
 410     write_socket(client, sendBuf, pos+1);
 411 }
 412
 413 char* merge_argv(char **argv, int start, int end) {
 414     return merge_argv_char(argv, start, end, ' ');
 415 }
 416
 417 char* merge_argv_char(char **argv, int start, int end, char seperator) {
 418     int i;
 419     char *p = NULL;
 420     for(i = start; i < end; i++) {
 421         p = argv[i];
 422         while(*p) p++;
 423         *p = seperator;
 424     }
 425     if(p) *p = '\0';
 426     return argv[start];
 427 }