libpurple/protocols/irc/cmds.c

   1 /**
   2  * purple
   3  *
   4  * Copyright (C) 2003, Ethan Blanton <eblanton@cs.purdue.edu>
   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; either version 2 of the License, or
   9  * (at your option) any later version.
  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  02111-1301  USA
  19  */
  20
  21 #include "internal.h"
  22 #include <purple.h>
  23
  24 #include "irc.h"
  25
  26
  27 static void irc_do_mode(struct irc_conn *irc, const char *target, const char *sign, char **ops);
  28
  29 int irc_cmd_default(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
  30 {
  31         PurpleConversation *convo = purple_conversations_find_with_account(target, irc->account);
  32         char *buf;
  33
  34         if (!convo)
  35                 return 1;
  36
  37         buf = g_strdup_printf(_("Unknown command: %s"), cmd);
  38         purple_conversation_write_system_message(convo, buf, PURPLE_MESSAGE_NO_LOG);
  39         g_free(buf);
  40
  41         return 1;
  42 }
  43
  44 int irc_cmd_away(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
  45 {
  46         char *buf, *message;
  47
  48         if (args[0] && !purple_strequal(cmd, "back")) {
  49                 message = purple_markup_strip_html(args[0]);
  50                 purple_util_chrreplace(message, '\n', ' ');
  51                 buf = irc_format(irc, "v:", "AWAY", message);
  52                 g_free(message);
  53         } else {
  54                 buf = irc_format(irc, "v", "AWAY");
  55         }
  56         irc_send(irc, buf);
  57         g_free(buf);
  58
  59         return 0;
  60 }
  61
  62 int irc_cmd_ctcp(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
  63 {
  64         /* we have defined args as args[0] is target and args[1] is ctcp command */
  65         char *buf;
  66         GString *string;
  67
  68         /* check if we have args */
  69         if (!args || !args[0] || !args[1])
  70                 return 0;
  71
  72         /* TODO:strip newlines or send each line as separate ctcp or something
  73          * actually, this shouldn't be done here but somewhere else since irc should support escaping newlines */
  74
  75         string = g_string_new(args[1]);
  76         g_string_prepend_c (string,'\001');
  77         g_string_append_c (string,'\001');
  78         buf = irc_format(irc, "vn:", "PRIVMSG", args[0], string->str);
  79         g_string_free(string,TRUE);
  80
  81         irc_send(irc, buf);
  82         g_free(buf);
  83
  84         return 1;
  85 }
  86
  87 int irc_cmd_ctcp_action(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
  88 {
  89         PurpleConnection *gc = purple_account_get_connection(irc->account);
  90         char *action, *escaped, *dst, **newargs;
  91         const char *src;
  92         char *msg;
  93         PurpleConversation *convo;
  94         PurpleMessage *pmsg;
  95
  96         if (!args || !args[0] || !gc)
  97                 return 0;
  98
  99         convo = purple_conversations_find_with_account(target, irc->account);
 100
 101         msg = g_strdup_printf("/me %s", args[0]);
 102
 103         /* XXX: we'd prefer to keep this in conversation.c */
 104         if (PURPLE_IS_IM_CONVERSATION(convo)) {
 105                 pmsg = purple_message_new_outgoing(
 106                         purple_conversation_get_name(convo), msg, 0);
 107
 108                 purple_signal_emit(purple_conversations_get_handle(),
 109                         "sending-im-msg", irc->account, pmsg);
 110         } else {
 111                 pmsg = purple_message_new_outgoing(NULL, msg, 0);
 112
 113                 purple_signal_emit(purple_conversations_get_handle(),
 114                         "sending-chat-msg", irc->account, pmsg,
 115                         purple_chat_conversation_get_id(PURPLE_CHAT_CONVERSATION(convo)));
 116         }
 117
 118         g_free(msg);
 119         if (purple_message_is_empty(pmsg))
 120                 return 0;
 121         msg = g_strdup(purple_message_get_contents(pmsg)); /* XXX: is it really necessary? */
 122
 123         if (strncmp(msg, "/me ", 4) != 0) {
 124                 newargs = g_new0(char *, 2);
 125                 newargs[0] = g_strdup(target);
 126                 newargs[1] = msg;
 127
 128                 irc_cmd_privmsg(irc, cmd, target, (const char **)newargs);
 129
 130                 g_free(newargs[0]);
 131                 g_free(newargs);
 132         } else {
 133                 action = g_malloc(strlen(&msg[4]) + 10);
 134
 135                 sprintf(action, "\001ACTION ");
 136
 137                 src = &msg[4];
 138                 dst = action + 8;
 139                 while (*src) {
 140                         if (*src == '\n') {
 141                                 if (*(src + 1) == '\0') {
 142                                         break;
 143                                 } else {
 144                                         *dst++ = ' ';
 145                                         src++;
 146                                         continue;
 147                                 }
 148                         }
 149                         *dst++ = *src++;
 150                 }
 151                 *dst++ = '\001';
 152                 *dst = '\0';
 153
 154                 newargs = g_new0(char *, 2);
 155                 newargs[0] = g_strdup(target);
 156                 newargs[1] = action;
 157                 irc_cmd_privmsg(irc, cmd, target, (const char **)newargs);
 158                 g_free(newargs[0]);
 159                 g_free(newargs);
 160                 g_free(action);
 161         }
 162
 163         /* XXX: we'd prefer to keep this in conversation.c */
 164         if (PURPLE_IS_IM_CONVERSATION(convo)) {
 165                 purple_signal_emit(purple_conversations_get_handle(),
 166                         "sent-im-msg", irc->account, pmsg);
 167         } else {
 168                 purple_signal_emit(purple_conversations_get_handle(),
 169                         "sent-chat-msg", irc->account, pmsg,
 170                         purple_chat_conversation_get_id(PURPLE_CHAT_CONVERSATION(convo)));
 171         }
 172
 173         g_free(msg);
 174
 175         if (convo) {
 176                 escaped = g_markup_escape_text(args[0], -1);
 177                 action = g_strdup_printf("/me %s", escaped);
 178                 g_free(escaped);
 179                 if (action[strlen(action) - 1] == '\n')
 180                         action[strlen(action) - 1] = '\0';
 181                 if (PURPLE_IS_CHAT_CONVERSATION(convo))
 182                         purple_serv_got_chat_in(gc, purple_chat_conversation_get_id(PURPLE_CHAT_CONVERSATION(convo)),
 183                                          purple_connection_get_display_name(gc),
 184                                          PURPLE_MESSAGE_SEND, action, time(NULL));
 185                 else
 186                         purple_conversation_write_message(convo, purple_message_new_outgoing(
 187                                 purple_connection_get_display_name(gc), action, 0));
 188                 g_free(action);
 189         }
 190
 191         return 1;
 192 }
 193
 194 int irc_cmd_ctcp_version(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 195 {
 196         char *buf;
 197
 198         if (!args || !args[0])
 199                 return 0;
 200
 201         buf = irc_format(irc, "vn:", "PRIVMSG", args[0], "\001VERSION\001");
 202         irc_send(irc, buf);
 203         g_free(buf);
 204
 205         return 0;
 206 }
 207
 208 int irc_cmd_invite(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 209 {
 210         char *buf;
 211
 212         if (!args || !args[0] || !(args[1] || target))
 213                 return 0;
 214
 215         buf = irc_format(irc, "vnc", "INVITE", args[0], args[1] ? args[1] : target);
 216         irc_send(irc, buf);
 217         g_free(buf);
 218
 219         return 0;
 220 }
 221
 222 int irc_cmd_join(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 223 {
 224         char *buf;
 225
 226         if (!args || !args[0])
 227                 return 0;
 228
 229         if (args[1])
 230                 buf = irc_format(irc, "vcv", "JOIN", args[0], args[1]);
 231         else
 232                 buf = irc_format(irc, "vc", "JOIN", args[0]);
 233         irc_send(irc, buf);
 234         g_free(buf);
 235
 236         return 0;
 237 }
 238
 239 int irc_cmd_kick(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 240 {
 241         char *buf;
 242
 243         if (!args || !args[0])
 244                 return 0;
 245
 246         if (!purple_conversations_find_chat_with_account(target, irc->account))
 247                 return 0;
 248
 249         if (args[1])
 250                 buf = irc_format(irc, "vcn:", "KICK", target, args[0], args[1]);
 251         else
 252                 buf = irc_format(irc, "vcn", "KICK", target, args[0]);
 253         irc_send(irc, buf);
 254         g_free(buf);
 255
 256         return 0;
 257 }
 258
 259 int irc_cmd_list(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 260 {
 261         purple_roomlist_show_with_account(irc->account);
 262
 263         return 0;
 264 }
 265
 266 int irc_cmd_mode(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 267 {
 268         PurpleConnection *gc;
 269         char *buf;
 270
 271         if (!args)
 272                 return 0;
 273
 274         if (purple_strequal(cmd, "mode")) {
 275                 if (!args[0] && irc_ischannel(target))
 276                         buf = irc_format(irc, "vc", "MODE", target);
 277                 else if (args[0] && (*args[0] == '+' || *args[0] == '-'))
 278                         buf = irc_format(irc, "vcn", "MODE", target, args[0]);
 279                 else if (args[0])
 280                         buf = irc_format(irc, "vn", "MODE", args[0]);
 281                 else
 282                         return 0;
 283         } else if (purple_strequal(cmd, "umode")) {
 284                 if (!args[0])
 285                         return 0;
 286                 gc = purple_account_get_connection(irc->account);
 287                 buf = irc_format(irc, "vnc", "MODE", purple_connection_get_display_name(gc), args[0]);
 288         } else {
 289                 return 0;
 290         }
 291
 292         irc_send(irc, buf);
 293         g_free(buf);
 294
 295         return 0;
 296 }
 297
 298 int irc_cmd_names(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 299 {
 300         char *buf;
 301
 302         if (!args || (!args[0] && !irc_ischannel(target)))
 303                 return 0;
 304
 305         buf = irc_format(irc, "vc", "NAMES", args[0] ? args[0] : target);
 306         irc_send(irc, buf);
 307         g_free(buf);
 308
 309         return 0;
 310 }
 311
 312 int irc_cmd_nick(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 313 {
 314         char *buf;
 315
 316         if (!args || !args[0])
 317                 return 0;
 318
 319         buf = irc_format(irc, "v:", "NICK", args[0]);
 320         g_free(irc->reqnick);
 321         irc->reqnick = g_strdup(args[0]);
 322         irc->nickused = FALSE;
 323         irc_send(irc, buf);
 324         g_free(buf);
 325
 326         return 0;
 327 }
 328
 329 int irc_cmd_op(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 330 {
 331         char **nicks, **ops, *sign, *mode;
 332         int i = 0, used = 0;
 333
 334         if (!args || !args[0] || !*args[0])
 335                 return 0;
 336
 337         if (purple_strequal(cmd, "op")) {
 338                 sign = "+";
 339                 mode = "o";
 340         } else if (purple_strequal(cmd, "deop")) {
 341                 sign = "-";
 342                 mode = "o";
 343         } else if (purple_strequal(cmd, "voice")) {
 344                 sign = "+";
 345                 mode = "v";
 346         } else if (purple_strequal(cmd, "devoice")) {
 347                 sign = "-";
 348                 mode = "v";
 349         } else {
 350                 purple_debug(PURPLE_DEBUG_ERROR, "irc", "invalid 'op' command '%s'\n", cmd);
 351                 return 0;
 352         }
 353
 354         nicks = g_strsplit(args[0], " ", -1);
 355
 356         for (i = 0; nicks[i]; i++)
 357                 /* nothing */;
 358         ops = g_new0(char *, i * 2 + 1);
 359
 360         for (i = 0; nicks[i]; i++) {
 361                 if (*nicks[i]) {
 362                         ops[used++] = mode;
 363                         ops[used++] = nicks[i];
 364                 }
 365         }
 366
 367         irc_do_mode(irc, target, sign, ops);
 368         g_free(ops);
 369         g_strfreev(nicks);
 370
 371         return 0;
 372 }
 373
 374 int irc_cmd_part(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 375 {
 376         char *buf;
 377
 378         if (!args)
 379                 return 0;
 380
 381         if (args[1])
 382                 buf = irc_format(irc, "vc:", "PART", args[0] ? args[0] : target, args[1]);
 383         else
 384                 buf = irc_format(irc, "vc", "PART", args[0] ? args[0] : target);
 385         irc_send(irc, buf);
 386         g_free(buf);
 387
 388         return 0;
 389 }
 390
 391 int irc_cmd_ping(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 392 {
 393         char *stamp;
 394         char *buf;
 395
 396         if (args && args[0]) {
 397                 if (irc_ischannel(args[0]))
 398                         return 0;
 399                 stamp = g_strdup_printf("\001PING %lu\001", time(NULL));
 400                 buf = irc_format(irc, "vn:", "PRIVMSG", args[0], stamp);
 401                 g_free(stamp);
 402         } else if (target) {
 403                 stamp = g_strdup_printf("%s %lu", target, time(NULL));
 404                 buf = irc_format(irc, "v:", "PING", stamp);
 405                 g_free(stamp);
 406         } else {
 407                 stamp = g_strdup_printf("%lu", time(NULL));
 408                 buf = irc_format(irc, "vv", "PING", stamp);
 409                 g_free(stamp);
 410         }
 411         irc_send(irc, buf);
 412         g_free(buf);
 413
 414         return 0;
 415 }
 416
 417 int irc_cmd_privmsg(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 418 {
 419         int max_privmsg_arg_len;
 420         const char *cur, *end;
 421         gchar *salvaged;
 422         char *msg, *buf;
 423
 424         if (!args || !args[0] || !args[1])
 425                 return 0;
 426
 427         max_privmsg_arg_len = IRC_MAX_MSG_SIZE - strlen(args[0]) - 64;
 428         salvaged = purple_utf8_salvage(args[1]);
 429         cur = salvaged;
 430         end = salvaged;
 431         while (*end && *cur) {
 432                 end = strchr(cur, '\n');
 433                 if (!end)
 434                         end = cur + strlen(cur);
 435                 if (end - cur > max_privmsg_arg_len) {
 436                         /* this call is used to find the last valid character position in the first
 437                          * max_privmsg_arg_len bytes of the utf-8 message
 438                          */
 439                         g_utf8_validate(cur, max_privmsg_arg_len, &end);
 440                 }
 441
 442                 msg = g_strndup(cur, end - cur);
 443
 444                 if(purple_strequal(cmd, "notice"))
 445                         buf = irc_format(irc, "vt:", "NOTICE", args[0], msg);
 446                 else
 447                         buf = irc_format(irc, "vt:", "PRIVMSG", args[0], msg);
 448
 449                 irc_send(irc, buf);
 450                 g_free(msg);
 451                 g_free(buf);
 452                 cur = end;
 453                 if(*cur == '\n') {
 454                         cur++;
 455                 }
 456         }
 457
 458         g_free(salvaged);
 459
 460         return 0;
 461 }
 462
 463 int irc_cmd_quit(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 464 {
 465         char *buf;
 466
 467         if (!irc->quitting) {
 468                 /*
 469                  * Use purple_account_get_string(irc->account, "quitmsg", IRC_DEFAULT_QUIT)
 470                  * and uncomment the appropriate account preference in irc.c if we
 471                  * decide we want custom quit messages.
 472                  */
 473                 buf = irc_format(irc, "v:", "QUIT", (args && args[0]) ? args[0] : IRC_DEFAULT_QUIT);
 474                 irc_send(irc, buf);
 475                 g_free(buf);
 476
 477                 irc->quitting = TRUE;
 478
 479                 if (!purple_account_is_disconnecting(irc->account))
 480                         purple_account_set_status(irc->account, "offline", TRUE, NULL);
 481         }
 482
 483         return 0;
 484 }
 485
 486 int irc_cmd_quote(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 487 {
 488         char *buf;
 489
 490         if (!args || !args[0])
 491                 return 0;
 492
 493         buf = irc_format(irc, "n", args[0]);
 494         irc_send(irc, buf);
 495         g_free(buf);
 496
 497         return 0;
 498 }
 499
 500 int irc_cmd_query(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 501 {
 502         PurpleIMConversation *im;
 503         PurpleConnection *gc;
 504
 505         if (!args || !args[0])
 506                 return 0;
 507
 508         im = purple_im_conversation_new(irc->account, args[0]);
 509         purple_conversation_present(PURPLE_CONVERSATION(im));
 510
 511         if (args[1]) {
 512                 gc = purple_account_get_connection(irc->account);
 513                 irc_cmd_privmsg(irc, cmd, target, args);
 514                 purple_conversation_write_message(PURPLE_CONVERSATION(im),
 515                         purple_message_new_outgoing(
 516                                 purple_connection_get_display_name(gc), args[1], 0));
 517         }
 518
 519         return 0;
 520 }
 521
 522 int irc_cmd_remove(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 523 {
 524         char *buf;
 525
 526         if (!args || !args[0])
 527                 return 0;
 528
 529         if (!irc_ischannel(target)) /* not a channel, punt */
 530                 return 0;
 531
 532         if (args[1])
 533                 buf = irc_format(irc, "vcn:", "REMOVE", target, args[0], args[1]);
 534         else
 535                 buf = irc_format(irc, "vcn", "REMOVE", target, args[0]);
 536         irc_send(irc, buf);
 537         g_free(buf);
 538
 539         return 0;
 540 }
 541
 542 int irc_cmd_service(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 543 {
 544         char *capital_cmd, *buf;
 545
 546         if (!args || !args[0])
 547                 return 0;
 548
 549         /* cmd will be one of nickserv, chanserv, memoserv or operserv */
 550         capital_cmd = g_ascii_strup(cmd, -1);
 551         buf = irc_format(irc, "v:", capital_cmd, args[0]);
 552         irc_send(irc, buf);
 553         g_free(capital_cmd);
 554         g_free(buf);
 555
 556         return 0;
 557 }
 558
 559 int irc_cmd_time(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 560 {
 561         char *buf;
 562
 563         buf = irc_format(irc, "v", "TIME");
 564         irc_send(irc, buf);
 565         g_free(buf);
 566
 567         return 0;
 568 }
 569
 570 int irc_cmd_topic(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 571 {
 572         char *buf;
 573         const char *topic;
 574         PurpleChatConversation *chat;
 575
 576         if (!args)
 577                 return 0;
 578
 579         chat = purple_conversations_find_chat_with_account(target, irc->account);
 580         if (!chat)
 581                 return 0;
 582
 583         if (!args[0]) {
 584                 topic = purple_chat_conversation_get_topic (chat);
 585
 586                 if (topic) {
 587                         char *tmp, *tmp2;
 588                         tmp = g_markup_escape_text(topic, -1);
 589                         tmp2 = purple_markup_linkify(tmp);
 590                         buf = g_strdup_printf(_("current topic is: %s"), tmp2);
 591                         g_free(tmp);
 592                         g_free(tmp2);
 593                 } else
 594                         buf = g_strdup(_("No topic is set"));
 595                 purple_conversation_write_system_message(
 596                         PURPLE_CONVERSATION(chat), buf, PURPLE_MESSAGE_NO_LOG);
 597                 g_free(buf);
 598
 599                 return 0;
 600         }
 601
 602         buf = irc_format(irc, "vt:", "TOPIC", target, args[0]);
 603         irc_send(irc, buf);
 604         g_free(buf);
 605
 606         return 0;
 607 }
 608
 609 int irc_cmd_wallops(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 610 {
 611         char *buf;
 612
 613         if (!args || !args[0])
 614                 return 0;
 615
 616         if (purple_strequal(cmd, "wallops"))
 617                 buf = irc_format(irc, "v:", "WALLOPS", args[0]);
 618         else if (purple_strequal(cmd, "operwall"))
 619                 buf = irc_format(irc, "v:", "OPERWALL", args[0]);
 620         else
 621                 return 0;
 622
 623         irc_send(irc, buf);
 624         g_free(buf);
 625
 626         return 0;
 627 }
 628
 629 int irc_cmd_whois(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 630 {
 631         char *buf;
 632
 633         if (!args || !args[0])
 634                 return 0;
 635
 636         if (args[1]) {
 637                 buf = irc_format(irc, "vvn", "WHOIS", args[0], args[1]);
 638                 irc->whois.nick = g_strdup(args[1]);
 639         } else {
 640                 buf = irc_format(irc, "vn", "WHOIS", args[0]);
 641                 irc->whois.nick = g_strdup(args[0]);
 642         }
 643
 644         irc_send(irc, buf);
 645         g_free(buf);
 646
 647         return 0;
 648 }
 649
 650 int irc_cmd_whowas(struct irc_conn *irc, const char *cmd, const char *target, const char **args)
 651 {
 652         char *buf;
 653
 654         if (!args || !args[0])
 655                 return 0;
 656
 657         buf = irc_format(irc, "vn", "WHOWAS", args[0]);
 658
 659         irc->whois.nick = g_strdup(args[0]);
 660         irc_send(irc, buf);
 661         g_free(buf);
 662
 663         return 0;
 664 }
 665
 666 static void irc_do_mode(struct irc_conn *irc, const char *target, const char *sign, char **ops)
 667 {
 668         char *buf, mode[5];
 669         int i = 0;
 670
 671         if (!sign)
 672                 return;
 673
 674         while (ops[i]) {
 675                 if (ops[i + 2] && ops[i + 4]) {
 676                         g_snprintf(mode, sizeof(mode), "%s%s%s%s", sign,
 677                                    ops[i], ops[i + 2], ops[i + 4]);
 678                         buf = irc_format(irc, "vcvnnn", "MODE", target, mode,
 679                                          ops[i + 1], ops[i + 3], ops[i + 5]);
 680                         i += 6;
 681                 } else if (ops[i + 2]) {
 682                         g_snprintf(mode, sizeof(mode), "%s%s%s",
 683                                    sign, ops[i], ops[i + 2]);
 684                         buf = irc_format(irc, "vcvnn", "MODE", target, mode,
 685                                          ops[i + 1], ops[i + 3]);
 686                         i += 4;
 687                 } else {
 688                         g_snprintf(mode, sizeof(mode), "%s%s", sign, ops[i]);
 689                         buf = irc_format(irc, "vcvn", "MODE", target, mode, ops[i + 1]);
 690                         i += 2;
 691                 }
 692                 irc_send(irc, buf);
 693                 g_free(buf);
 694         }
 695
 696         return;
 697 }