libpurple/plugins/signals-test.c

   1 /*
   2  * Signals test plugin.
   3  *
   4  * Copyright (C) 2003 Christian Hammond.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * 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
  19  * 02111-1301, USA.
  20  */
  21 #define SIGNAL_TEST_PLUGIN_ID "core-signals-test"
  22
  23 #include "internal.h"
  24
  25 #include <stdio.h>
  26
  27 #include "connection.h"
  28 #include "conversation.h"
  29 #include "core.h"
  30 #include "debug.h"
  31 #include "xfer.h"
  32 #include "signals.h"
  33 #include "version.h"
  34 #include "status.h"
  35 #include "sound.h"
  36
  37 /**************************************************************************
  38  * Account subsystem signal callbacks
  39  **************************************************************************/
  40 static void
  41 account_connecting_cb(PurpleAccount *account, void *data)
  42 {
  43         purple_debug_misc("signals test", "account-connecting (%s)\n",
  44                                         purple_account_get_username(account));
  45 }
  46
  47 static void
  48 account_setting_info_cb(PurpleAccount *account, const char *info, void *data)
  49 {
  50         purple_debug_misc("signals test", "account-setting-info (%s, %s)\n",
  51                                         purple_account_get_username(account), info);
  52 }
  53
  54 static void
  55 account_set_info_cb(PurpleAccount *account, const char *info, void *data)
  56 {
  57         purple_debug_misc("signals test", "account-set-info (%s, %s)\n",
  58                                         purple_account_get_username(account), info);
  59 }
  60
  61 static void
  62 account_status_changed(PurpleAccount *account, PurpleStatus *old, PurpleStatus *new,
  63                                                 gpointer data)
  64 {
  65         purple_debug_misc("signals test", "account-status-changed (%s, %s, %s)\n",
  66                                         purple_account_get_username(account),
  67                                         purple_status_get_name(old),
  68                                         purple_status_get_name(new));
  69 }
  70
  71 static void
  72 account_alias_changed(PurpleAccount *account, const char *old, gpointer data)
  73 {
  74         purple_debug_misc("signals test", "account-alias-changed (%s, %s, %s)\n",
  75                                         purple_account_get_username(account),
  76                                         old, purple_account_get_private_alias(account));
  77 }
  78
  79 static int
  80 account_authorization_requested_cb(PurpleAccount *account, const char *user, const char *message, char *response, gpointer data)
  81 {
  82         purple_debug_misc("signals test", "account-authorization-requested (%s, %s, %s)\n",
  83                         purple_account_get_username(account), user, message);
  84         return PURPLE_ACCOUNT_RESPONSE_PASS;
  85 }
  86
  87 static void
  88 account_authorization_granted_cb(PurpleAccount *account, const char *user, const char *message, gpointer data)
  89 {
  90         purple_debug_misc("signals test", "account-authorization-granted (%s, %s, %s)\n",
  91                         purple_account_get_username(account), user, message);
  92 }
  93
  94 static void
  95 account_authorization_denied_cb(PurpleAccount *account, const char *user, const char *message, gpointer data)
  96 {
  97         purple_debug_misc("signals test", "account-authorization-denied (%s, %s, %s)\n",
  98                         purple_account_get_username(account), user, message);
  99 }
 100
 101 /**************************************************************************
 102  * Buddy Icons signal callbacks
 103  **************************************************************************/
 104 static void
 105 buddy_icon_changed_cb(PurpleBuddy *buddy)
 106 {
 107         purple_debug_misc("signals test", "buddy icon changed (%s)\n",
 108                                         purple_buddy_get_name(buddy));
 109 }
 110
 111 /**************************************************************************
 112  * Buddy List subsystem signal callbacks
 113  **************************************************************************/
 114 static void
 115 buddy_status_changed_cb(PurpleBuddy *buddy, PurpleStatus *old_status,
 116                         PurpleStatus *status, void *data)
 117 {
 118         purple_debug_misc("signals test", "buddy-status-changed (%s %s to %s)\n",
 119                           purple_buddy_get_name(buddy),
 120                           purple_status_get_id(old_status),
 121                           purple_status_get_id(status));
 122 }
 123
 124 static void
 125 buddy_idle_changed_cb(PurpleBuddy *buddy, gboolean old_idle, gboolean idle,
 126                       void *data)
 127 {
 128         purple_debug_misc("signals test", "buddy-idle-changed (%s %s)\n",
 129                           purple_buddy_get_name(buddy),
 130                           old_idle ? "unidled" : "idled");
 131 }
 132
 133 static void
 134 buddy_signed_on_cb(PurpleBuddy *buddy, void *data)
 135 {
 136         purple_debug_misc("signals test", "buddy-signed-on (%s)\n",
 137                           purple_buddy_get_name(buddy));
 138 }
 139
 140 static void
 141 buddy_signed_off_cb(PurpleBuddy *buddy, void *data)
 142 {
 143         purple_debug_misc("signals test", "buddy-signed-off (%s)\n",
 144                           purple_buddy_get_name(buddy));
 145 }
 146
 147 static void
 148 blist_node_added_cb(PurpleBlistNode *bnode, void *data)
 149 {
 150         const char *name;
 151         if (PURPLE_IS_GROUP(bnode))
 152                 name = purple_group_get_name(PURPLE_GROUP(bnode));
 153         else if (PURPLE_IS_CONTACT(bnode))
 154                 /* Close enough */
 155                 name = purple_contact_get_alias(PURPLE_CONTACT(bnode));
 156         else if (PURPLE_IS_BUDDY(bnode))
 157                 name = purple_buddy_get_name(PURPLE_BUDDY(bnode));
 158         else
 159                 name = "(unknown)";
 160
 161         purple_debug_misc("signals test", "blist_node_added_cb (%s)\n",
 162                           name ? name : "(null)");
 163 }
 164
 165 static void
 166 blist_node_removed_cb(PurpleBlistNode *bnode, void *data)
 167 {
 168         const char *name;
 169         if (PURPLE_IS_GROUP(bnode))
 170                 name = purple_group_get_name(PURPLE_GROUP(bnode));
 171         else if (PURPLE_IS_CONTACT(bnode))
 172                 /* Close enough */
 173                 name = purple_contact_get_alias(PURPLE_CONTACT(bnode));
 174         else if (PURPLE_IS_BUDDY(bnode))
 175                 name = purple_buddy_get_name(PURPLE_BUDDY(bnode));
 176         else
 177                 name = "(unknown)";
 178
 179         purple_debug_misc("signals test", "blist_node_removed_cb (%s)\n",
 180                           name ? name : "(null)");
 181 }
 182
 183 static void
 184 blist_node_aliased(PurpleBlistNode *node, const char *old_alias)
 185 {
 186         PurpleContact *p = PURPLE_CONTACT(node);
 187         PurpleBuddy *b = PURPLE_BUDDY(node);
 188         PurpleChat *c = PURPLE_CHAT(node);
 189         PurpleGroup *g = PURPLE_GROUP(node);
 190
 191         if (PURPLE_IS_CONTACT(node)) {
 192                 purple_debug_misc("signals test",
 193                                   "blist-node-aliased (Contact: %s, %s)\n",
 194                                   purple_contact_get_alias(p), old_alias);
 195         } else if (PURPLE_IS_BUDDY(node)) {
 196                 purple_debug_misc("signals test",
 197                                   "blist-node-aliased (Buddy: %s, %s)\n",
 198                                   purple_buddy_get_name(b), old_alias);
 199         } else if (PURPLE_IS_CHAT(node)) {
 200                 purple_debug_misc("signals test",
 201                                   "blist-node-aliased (Chat: %s, %s)\n",
 202                                   purple_chat_get_name(c), old_alias);
 203         } else if (PURPLE_IS_GROUP(node)) {
 204                 purple_debug_misc("signals test",
 205                                   "blist-node-aliased (Group: %s, %s)\n",
 206                                   purple_group_get_name(g), old_alias);
 207         }
 208 }
 209
 210 static void
 211 blist_node_extended_menu_cb(PurpleBlistNode *node, void *data)
 212 {
 213         PurpleContact *p = PURPLE_CONTACT(node);
 214         PurpleBuddy *b = PURPLE_BUDDY(node);
 215         PurpleChat *c = PURPLE_CHAT(node);
 216         PurpleGroup *g = PURPLE_GROUP(node);
 217
 218         if (PURPLE_IS_CONTACT(node)) {
 219                 purple_debug_misc("signals test",
 220                                   "blist-node-extended-menu (Contact: %s)\n",
 221                                   purple_contact_get_alias(p));
 222         } else if (PURPLE_IS_BUDDY(node)) {
 223                 purple_debug_misc("signals test",
 224                                   "blist-node-extended-menu (Buddy: %s)\n",
 225                                   purple_buddy_get_name(b));
 226         } else if (PURPLE_IS_CHAT(node)) {
 227                 purple_debug_misc("signals test",
 228                                   "blist-node-extended-menu (Chat: %s)\n",
 229                                   purple_chat_get_name(c));
 230         } else if (PURPLE_IS_GROUP(node)) {
 231                 purple_debug_misc("signals test",
 232                                   "blist-node-extended-menu (Group: %s)\n",
 233                                   purple_group_get_name(g));
 234         }
 235 }
 236
 237
 238 /**************************************************************************
 239  * Connection subsystem signal callbacks
 240  **************************************************************************/
 241 static void
 242 signing_on_cb(PurpleConnection *gc, void *data)
 243 {
 244         purple_debug_misc("signals test", "signing-on (%s)\n",
 245                                         purple_account_get_username(purple_connection_get_account(gc)));
 246 }
 247
 248 static void
 249 signed_on_cb(PurpleConnection *gc, void *data)
 250 {
 251         purple_debug_misc("signals test", "signed-on (%s)\n",
 252                                         purple_account_get_username(purple_connection_get_account(gc)));
 253 }
 254
 255 static void
 256 signing_off_cb(PurpleConnection *gc, void *data)
 257 {
 258         purple_debug_misc("signals test", "signing-off (%s)\n",
 259                                         purple_account_get_username(purple_connection_get_account(gc)));
 260 }
 261
 262 static void
 263 signed_off_cb(PurpleConnection *gc, void *data)
 264 {
 265         purple_debug_misc("signals test", "signed-off (%s)\n",
 266                                         purple_account_get_username(purple_connection_get_account(gc)));
 267 }
 268
 269 static void
 270 connection_error_cb(PurpleConnection *gc,
 271                     PurpleConnectionError err,
 272                     const gchar *desc,
 273                     void *data)
 274 {
 275         const gchar *username =
 276                 purple_account_get_username(purple_connection_get_account(gc));
 277         purple_debug_misc("signals test", "connection-error (%s, %u, %s)\n",
 278                 username, err, desc);
 279 }
 280
 281 /**************************************************************************
 282  * Conversation subsystem signal callbacks
 283  **************************************************************************/
 284 static gboolean
 285 writing_im_msg_cb(PurpleConversation *conv, PurpleMessage *pmsg)
 286 {
 287         purple_debug_misc("signals test", "writing-im-msg (%s, %s)\n",
 288                 purple_conversation_get_name(conv),
 289                 purple_message_get_contents(pmsg));
 290
 291         return FALSE;
 292
 293 }
 294
 295 static void
 296 wrote_im_msg_cb(PurpleConversation *conv, PurpleMessage *msg, gpointer data)
 297 {
 298         purple_debug_misc("signals test", "wrote-im-msg (%s, %s)\n",
 299                 purple_conversation_get_name(conv),
 300                 purple_message_get_contents(msg));
 301 }
 302
 303 static void
 304 sending_im_msg_cb(PurpleAccount *account, PurpleMessage *msg, void *data)
 305 {
 306         purple_debug_misc("signals test", "sending-im-msg (%s, %s, %s)\n",
 307                 purple_account_get_username(account),
 308                 purple_message_get_recipient(msg),
 309                 purple_message_get_contents(msg));
 310
 311 }
 312
 313 static void
 314 sent_im_msg_cb(PurpleAccount *account, PurpleMessage *msg, void *data)
 315 {
 316         purple_debug_misc("signals test", "sent-im-msg (%s, %s, %s)\n",
 317                 purple_account_get_username(account),
 318                 purple_message_get_recipient(msg),
 319                 purple_message_get_contents(msg));
 320 }
 321
 322 static gboolean
 323 receiving_im_msg_cb(PurpleAccount *account, char **sender, char **buffer,
 324                                     PurpleConversation *conv, PurpleMessageFlags *flags, void *data)
 325 {
 326         purple_debug_misc("signals test", "receiving-im-msg (%s, %s, %s, %s, %d)\n",
 327                                         purple_account_get_username(account), *sender, *buffer,
 328                                         (conv != NULL) ? purple_conversation_get_name(conv) : "(null)", *flags);
 329
 330         return FALSE;
 331 }
 332
 333 static void
 334 received_im_msg_cb(PurpleAccount *account, char *sender, char *buffer,
 335                                    PurpleConversation *conv, PurpleMessageFlags flags, void *data)
 336 {
 337         purple_debug_misc("signals test", "received-im-msg (%s, %s, %s, %s, %d)\n",
 338                                         purple_account_get_username(account), sender, buffer,
 339                                         (conv != NULL) ? purple_conversation_get_name(conv) : "(null)", flags);
 340 }
 341
 342 static gboolean
 343 writing_chat_msg_cb(PurpleAccount *account, const char *who, char **buffer,
 344                                 PurpleConversation *conv, PurpleMessageFlags flags, void *data)
 345 {
 346         purple_debug_misc("signals test", "writing-chat-msg (%s, %s)\n",
 347                                         purple_conversation_get_name(conv), *buffer);
 348
 349         return FALSE;
 350 }
 351
 352 static void
 353 wrote_chat_msg_cb(PurpleConversation *conv, PurpleMessage *msg, gpointer data)
 354 {
 355         purple_debug_misc("signals test", "wrote-chat-msg (%s, %s)\n",
 356                 purple_conversation_get_name(conv),
 357                 purple_message_get_contents(msg));
 358 }
 359
 360 static gboolean
 361 sending_chat_msg_cb(PurpleAccount *account, PurpleMessage *msg, int id, void *data)
 362 {
 363         purple_debug_misc("signals test", "sending-chat-msg (%s, %s, %d)\n",
 364                 purple_account_get_username(account),
 365                 purple_message_get_contents(msg), id);
 366
 367         return FALSE;
 368 }
 369
 370 static void
 371 sent_chat_msg_cb(PurpleAccount *account, PurpleMessage *msg, int id, void *data)
 372 {
 373         purple_debug_misc("signals test", "sent-chat-msg (%s, %s, %d)\n",
 374                 purple_account_get_username(account),
 375                 purple_message_get_contents(msg), id);
 376 }
 377
 378 static gboolean
 379 receiving_chat_msg_cb(PurpleAccount *account, char **sender, char **buffer,
 380                                          PurpleConversation *chat, PurpleMessageFlags *flags, void *data)
 381 {
 382         purple_debug_misc("signals test",
 383                                         "receiving-chat-msg (%s, %s, %s, %s, %d)\n",
 384                                         purple_account_get_username(account), *sender, *buffer,
 385                                         purple_conversation_get_name(chat), *flags);
 386
 387         return FALSE;
 388 }
 389
 390 static void
 391 received_chat_msg_cb(PurpleAccount *account, char *sender, char *buffer,
 392                                          PurpleConversation *chat, PurpleMessageFlags flags, void *data)
 393 {
 394         purple_debug_misc("signals test",
 395                                         "received-chat-msg (%s, %s, %s, %s, %d)\n",
 396                                         purple_account_get_username(account), sender, buffer,
 397                                         purple_conversation_get_name(chat), flags);
 398 }
 399
 400 static void
 401 conversation_created_cb(PurpleConversation *conv, void *data)
 402 {
 403         purple_debug_misc("signals test", "conversation-created (%s)\n",
 404                                         purple_conversation_get_name(conv));
 405 }
 406
 407 static void
 408 deleting_conversation_cb(PurpleConversation *conv, void *data)
 409 {
 410         purple_debug_misc("signals test", "deleting-conversation (%s)\n",
 411                                         purple_conversation_get_name(conv));
 412 }
 413
 414 static void
 415 buddy_typing_cb(PurpleAccount *account, const char *name, void *data)
 416 {
 417         purple_debug_misc("signals test", "buddy-typing (%s, %s)\n",
 418                                         purple_account_get_username(account), name);
 419 }
 420
 421 static void
 422 buddy_typing_stopped_cb(PurpleAccount *account, const char *name, void *data)
 423 {
 424         purple_debug_misc("signals test", "buddy-typing-stopped (%s, %s)\n",
 425                                         purple_account_get_username(account), name);
 426 }
 427
 428 static gboolean
 429 chat_user_joining_cb(PurpleConversation *conv, const char *user,
 430                                           PurpleChatUserFlags flags, void *data)
 431 {
 432         purple_debug_misc("signals test", "chat-user-joining (%s, %s, %d)\n",
 433                                         purple_conversation_get_name(conv), user, flags);
 434
 435         return FALSE;
 436 }
 437
 438 static void
 439 chat_user_joined_cb(PurpleConversation *conv, const char *user,
 440                                          PurpleChatUserFlags flags, gboolean new_arrival, void *data)
 441 {
 442         purple_debug_misc("signals test", "chat-user-joined (%s, %s, %d, %d)\n",
 443                                         purple_conversation_get_name(conv), user, flags, new_arrival);
 444 }
 445
 446 static void
 447 chat_user_flags_cb(PurpleChatUser *cb, PurpleChatUserFlags oldflags,
 448                                          PurpleChatUserFlags newflags, void *data)
 449 {
 450         purple_debug_misc("signals test", "chat-user-flags (%s, %s, %d, %d)\n",
 451                                         purple_conversation_get_name(PURPLE_CONVERSATION(
 452                                         purple_chat_user_get_chat(cb))),
 453                                         purple_chat_user_get_name(cb), oldflags, newflags);
 454 }
 455
 456 static gboolean
 457 chat_user_leaving_cb(PurpleConversation *conv, const char *user,
 458                                           const char *reason, void *data)
 459 {
 460         purple_debug_misc("signals test", "chat-user-leaving (%s, %s, %s)\n",
 461                                         purple_conversation_get_name(conv), user, reason);
 462
 463         return FALSE;
 464 }
 465
 466 static void
 467 chat_user_left_cb(PurpleConversation *conv, const char *user,
 468                                    const char *reason, void *data)
 469 {
 470         purple_debug_misc("signals test", "chat-user-left (%s, %s, %s)\n",
 471                                         purple_conversation_get_name(conv), user, reason);
 472 }
 473
 474 static void
 475 chat_inviting_user_cb(PurpleConversation *conv, const char *name,
 476                                           char **reason, void *data)
 477 {
 478         purple_debug_misc("signals test", "chat-inviting-user (%s, %s, %s)\n",
 479                                         purple_conversation_get_name(conv), name, *reason);
 480 }
 481
 482 static void
 483 chat_invited_user_cb(PurpleConversation *conv, const char *name,
 484                                           const char *reason, void *data)
 485 {
 486         purple_debug_misc("signals test", "chat-invited-user (%s, %s, %s)\n",
 487                                         purple_conversation_get_name(conv), name, reason);
 488 }
 489
 490 static gint
 491 chat_invited_cb(PurpleAccount *account, const char *inviter,
 492                                 const char *room_name, const char *message,
 493                                 const GHashTable *components, void *data)
 494 {
 495         purple_debug_misc("signals test", "chat-invited (%s, %s, %s, %s)\n",
 496                                         purple_account_get_username(account), inviter,
 497                                         room_name, message);
 498
 499         return 0;
 500 }
 501
 502 static void
 503 chat_joined_cb(PurpleConversation *conv, void *data)
 504 {
 505         purple_debug_misc("signals test", "chat-joined (%s)\n",
 506                                         purple_conversation_get_name(conv));
 507 }
 508
 509 static void
 510 chat_left_cb(PurpleConversation *conv, void *data)
 511 {
 512         purple_debug_misc("signals test", "chat-left (%s)\n",
 513                                         purple_conversation_get_name(conv));
 514 }
 515
 516 static void
 517 chat_topic_changed_cb(PurpleConversation *conv, const char *who,
 518                                           const char *topic, void *data)
 519 {
 520         purple_debug_misc("signals test",
 521                                         "chat-topic-changed (%s topic changed to: \"%s\" by %s)\n",
 522                                         purple_conversation_get_name(conv), topic,
 523                                         (who) ? who : "unknown");
 524 }
 525 /**************************************************************************
 526  * Core signal callbacks
 527  **************************************************************************/
 528 static void
 529 quitting_cb(void *data)
 530 {
 531         purple_debug_misc("signals test", "quitting ()\n");
 532 }
 533
 534 static void
 535 printhash(gpointer key, gpointer value, gpointer data)
 536 {
 537         char *a = (char *)key;
 538         char *b = (char *)value;
 539         GString *str = (GString *)data;
 540         g_string_append_printf(str, "   [%s] = [%s]\n", a, b ? b : "(null)");
 541 }
 542
 543 static gboolean
 544 uri_handler(const char *proto, const char *cmd, GHashTable *params)
 545 {
 546         GString *str = g_string_new("\n{\n");
 547         g_hash_table_foreach(params, printhash, str);
 548         g_string_append_c(str, '}');
 549         purple_debug_misc("signals test", "uri handler (%s, %s, %s)\n", proto, cmd, str->str);
 550         g_string_free(str, TRUE);
 551         return FALSE;
 552 }
 553
 554 /**************************************************************************
 555  * File transfer signal callbacks
 556  **************************************************************************/
 557 static void
 558 ft_recv_accept_cb(PurpleXfer *xfer, gpointer data) {
 559         purple_debug_misc("signals test", "file receive accepted\n");
 560 }
 561
 562 static void
 563 ft_send_accept_cb(PurpleXfer *xfer, gpointer data) {
 564         purple_debug_misc("signals test", "file send accepted\n");
 565 }
 566
 567 static void
 568 ft_recv_start_cb(PurpleXfer *xfer, gpointer data) {
 569         purple_debug_misc("signals test", "file receive started\n");
 570 }
 571
 572 static void
 573 ft_send_start_cb(PurpleXfer *xfer, gpointer data) {
 574         purple_debug_misc("signals test", "file send started\n");
 575 }
 576
 577 static void
 578 ft_recv_cancel_cb(PurpleXfer *xfer, gpointer data) {
 579         purple_debug_misc("signals test", "file receive cancelled\n");
 580 }
 581
 582 static void
 583 ft_send_cancel_cb(PurpleXfer *xfer, gpointer data) {
 584         purple_debug_misc("signals test", "file send cancelled\n");
 585 }
 586
 587 static void
 588 ft_recv_complete_cb(PurpleXfer *xfer, gpointer data) {
 589         purple_debug_misc("signals test", "file receive completed\n");
 590 }
 591
 592 static void
 593 ft_send_complete_cb(PurpleXfer *xfer, gpointer data) {
 594         purple_debug_misc("signals test", "file send completed\n");
 595 }
 596
 597 /**************************************************************************
 598  * Sound signal callbacks
 599  **************************************************************************/
 600 static int
 601 sound_playing_event_cb(PurpleSoundEventID event, const PurpleAccount *account) {
 602         if (account != NULL)
 603                 purple_debug_misc("signals test", "sound playing event: %d for account: %s\n",
 604                             event, purple_account_get_username(account));
 605         else
 606                 purple_debug_misc("signals test", "sound playing event: %d\n", event);
 607
 608         return 0;
 609 }
 610
 611 /**************************************************************************
 612  * Notify signals callbacks
 613  **************************************************************************/
 614 static void
 615 notify_email_cb(char *subject, char *from, char *to, char *url) {
 616         purple_debug_misc("signals test", "notify email: subject=%s, from=%s, to=%s, url=%s\n",
 617                                         subject, from, to, url);
 618 }
 619
 620 static void
 621 notify_emails_cb(char **subjects, char **froms, char **tos, char **urls, guint count) {
 622         guint i;
 623         purple_debug_misc("signals test", "notify emails: count=%u\n", count);
 624         for(i=0; i<count && i<5; i++) {
 625                 if(subjects[i]==NULL || froms[i]==NULL || tos[i]==NULL || urls[i]==NULL) continue;
 626                 purple_debug_misc("signals test", "notify emails[%u]: subject=%s, from=%s, to=%s, url=%s\n",
 627                         i, subjects[i], froms[i], tos[i], urls[i]);
 628         }
 629 }
 630
 631 /**************************************************************************
 632  * Jabber signals callbacks
 633  **************************************************************************/
 634 static gboolean
 635 jabber_iq_received(PurpleConnection *pc, const char *type, const char *id,
 636                    const char *from, PurpleXmlNode *iq)
 637 {
 638         purple_debug_misc("signals test", "jabber IQ (type=%s, id=%s, from=%s) %p\n",
 639                           type, id, from ? from : "(null)", iq);
 640
 641         /* We don't want the plugin to stop processing */
 642         return FALSE;
 643 }
 644
 645 static gboolean
 646 jabber_message_received(PurpleConnection *pc, const char *type, const char *id,
 647                         const char *from, const char *to, PurpleXmlNode *message)
 648 {
 649         purple_debug_misc("signals test", "jabber message (type=%s, id=%s, "
 650                           "from=%s to=%s) %p\n",
 651                           type ? type : "(null)", id ? id : "(null)",
 652                           from ? from : "(null)", to ? to : "(null)", message);
 653
 654         /* We don't want the plugin to stop processing */
 655         return FALSE;
 656 }
 657
 658 static gboolean
 659 jabber_presence_received(PurpleConnection *pc, const char *type,
 660                          const char *from, PurpleXmlNode *presence)
 661 {
 662         purple_debug_misc("signals test", "jabber presence (type=%s, from=%s) %p\n",
 663                           type ? type : "(null)", from ? from : "(null)", presence);
 664
 665         /* We don't want the plugin to stop processing */
 666         return FALSE;
 667 }
 668
 669 static gboolean
 670 jabber_watched_iq(PurpleConnection *pc, const char *type, const char *id,
 671                   const char *from, PurpleXmlNode *child)
 672 {
 673         purple_debug_misc("signals test", "jabber watched IQ (type=%s, id=%s, from=%s)\n"
 674                           "child %p name=%s, namespace=%s\n",
 675                           type, id, from, child, child->name,
 676                           purple_xmlnode_get_namespace(child));
 677
 678         if (purple_strequal(type, "get") || purple_strequal(type, "set")) {
 679                 /* Send the requisite reply */
 680                 PurpleXmlNode *iq = purple_xmlnode_new("iq");
 681                 purple_xmlnode_set_attrib(iq, "to", from);
 682                 purple_xmlnode_set_attrib(iq, "id", id);
 683                 purple_xmlnode_set_attrib(iq, "type", "result");
 684
 685                 purple_signal_emit(purple_connection_get_protocol(pc),
 686                                    "jabber-sending-xmlnode", pc, &iq);
 687                 if (iq != NULL)
 688                         purple_xmlnode_free(iq);
 689         }
 690
 691         /* Cookie monster eats IQ stanzas; the protocol shouldn't keep processing */
 692         return TRUE;
 693 }
 694
 695 /**************************************************************************
 696  * Plugin stuff
 697  **************************************************************************/
 698 static PurplePluginInfo *
 699 plugin_query(GError **error)
 700 {
 701         const gchar * const authors[] = {
 702                 "Christian Hammond <chipx86@gnupdate.org>",
 703                 NULL
 704         };
 705
 706         return purple_plugin_info_new(
 707                 "id",          SIGNAL_TEST_PLUGIN_ID,
 708                 "name",        N_("Signals Test"),
 709                 "version",     DISPLAY_VERSION,
 710                 "category",    N_("Testing"),
 711                 "summary",     N_("Test to see that all signals are working properly."),
 712                 "description", N_("Test to see that all signals are working properly."),
 713                 "authors",     authors,
 714                 "website",     PURPLE_WEBSITE,
 715                 "abi-version", PURPLE_ABI_VERSION,
 716                 NULL
 717         );
 718 }
 719
 720 static gboolean
 721 plugin_load(PurplePlugin *plugin, GError **error)
 722 {
 723         void *core_handle     = purple_get_core();
 724         void *blist_handle    = purple_blist_get_handle();
 725         void *conn_handle     = purple_connections_get_handle();
 726         void *conv_handle     = purple_conversations_get_handle();
 727         void *accounts_handle = purple_accounts_get_handle();
 728         void *ft_handle       = purple_xfers_get_handle();
 729         void *sound_handle    = purple_sounds_get_handle();
 730         void *notify_handle   = purple_notify_get_handle();
 731         void *jabber_handle   = purple_protocols_find("prpl-jabber");
 732
 733         /* Accounts subsystem signals */
 734         purple_signal_connect(accounts_handle, "account-connecting",
 735                                                 plugin, PURPLE_CALLBACK(account_connecting_cb), NULL);
 736         purple_signal_connect(accounts_handle, "account-setting-info",
 737                                                 plugin, PURPLE_CALLBACK(account_setting_info_cb), NULL);
 738         purple_signal_connect(accounts_handle, "account-set-info",
 739                                                 plugin, PURPLE_CALLBACK(account_set_info_cb), NULL);
 740         purple_signal_connect(accounts_handle, "account-status-changed",
 741                                                 plugin, PURPLE_CALLBACK(account_status_changed), NULL);
 742         purple_signal_connect(accounts_handle, "account-alias-changed",
 743                                                 plugin, PURPLE_CALLBACK(account_alias_changed), NULL);
 744         purple_signal_connect(accounts_handle, "account-authorization-requested",
 745                                                 plugin, PURPLE_CALLBACK(account_authorization_requested_cb), NULL);
 746         purple_signal_connect(accounts_handle, "account-authorization-denied",
 747                                                 plugin, PURPLE_CALLBACK(account_authorization_denied_cb), NULL);
 748         purple_signal_connect(accounts_handle, "account-authorization-granted",
 749                                                 plugin, PURPLE_CALLBACK(account_authorization_granted_cb), NULL);
 750
 751         /* Buddy List subsystem signals */
 752         purple_signal_connect(blist_handle, "buddy-status-changed",
 753                                                 plugin, PURPLE_CALLBACK(buddy_status_changed_cb), NULL);
 754         purple_signal_connect(blist_handle, "buddy-idle-changed",
 755                                                 plugin, PURPLE_CALLBACK(buddy_idle_changed_cb), NULL);
 756         purple_signal_connect(blist_handle, "buddy-signed-on",
 757                                                 plugin, PURPLE_CALLBACK(buddy_signed_on_cb), NULL);
 758         purple_signal_connect(blist_handle, "buddy-signed-off",
 759                                                 plugin, PURPLE_CALLBACK(buddy_signed_off_cb), NULL);
 760         purple_signal_connect(blist_handle, "blist-node-added",
 761                                                 plugin, PURPLE_CALLBACK(blist_node_added_cb), NULL);
 762         purple_signal_connect(blist_handle, "blist-node-removed",
 763                                                 plugin, PURPLE_CALLBACK(blist_node_removed_cb), NULL);
 764         purple_signal_connect(blist_handle, "buddy-icon-changed",
 765                                                 plugin, PURPLE_CALLBACK(buddy_icon_changed_cb), NULL);
 766         purple_signal_connect(blist_handle, "blist-node-aliased",
 767                                                 plugin, PURPLE_CALLBACK(blist_node_aliased), NULL);
 768         purple_signal_connect(blist_handle, "blist-node-extended-menu",
 769                                                 plugin, PURPLE_CALLBACK(blist_node_extended_menu_cb), NULL);
 770
 771         /* Connection subsystem signals */
 772         purple_signal_connect(conn_handle, "signing-on",
 773                                                 plugin, PURPLE_CALLBACK(signing_on_cb), NULL);
 774         purple_signal_connect(conn_handle, "signed-on",
 775                                                 plugin, PURPLE_CALLBACK(signed_on_cb), NULL);
 776         purple_signal_connect(conn_handle, "signing-off",
 777                                                 plugin, PURPLE_CALLBACK(signing_off_cb), NULL);
 778         purple_signal_connect(conn_handle, "signed-off",
 779                                                 plugin, PURPLE_CALLBACK(signed_off_cb), NULL);
 780         purple_signal_connect(conn_handle, "connection-error",
 781                                                 plugin, PURPLE_CALLBACK(connection_error_cb), NULL);
 782
 783         /* Conversations subsystem signals */
 784         purple_signal_connect(conv_handle, "writing-im-msg",
 785                                                 plugin, PURPLE_CALLBACK(writing_im_msg_cb), NULL);
 786         purple_signal_connect(conv_handle, "wrote-im-msg",
 787                                                 plugin, PURPLE_CALLBACK(wrote_im_msg_cb), NULL);
 788         purple_signal_connect(conv_handle, "sending-im-msg",
 789                                                 plugin, PURPLE_CALLBACK(sending_im_msg_cb), NULL);
 790         purple_signal_connect(conv_handle, "sent-im-msg",
 791                                                 plugin, PURPLE_CALLBACK(sent_im_msg_cb), NULL);
 792         purple_signal_connect(conv_handle, "receiving-im-msg",
 793                                                 plugin, PURPLE_CALLBACK(receiving_im_msg_cb), NULL);
 794         purple_signal_connect(conv_handle, "received-im-msg",
 795                                                 plugin, PURPLE_CALLBACK(received_im_msg_cb), NULL);
 796         purple_signal_connect(conv_handle, "writing-chat-msg",
 797                                                 plugin, PURPLE_CALLBACK(writing_chat_msg_cb), NULL);
 798         purple_signal_connect(conv_handle, "wrote-chat-msg",
 799                                                 plugin, PURPLE_CALLBACK(wrote_chat_msg_cb), NULL);
 800         purple_signal_connect(conv_handle, "sending-chat-msg",
 801                                                 plugin, PURPLE_CALLBACK(sending_chat_msg_cb), NULL);
 802         purple_signal_connect(conv_handle, "sent-chat-msg",
 803                                                 plugin, PURPLE_CALLBACK(sent_chat_msg_cb), NULL);
 804         purple_signal_connect(conv_handle, "receiving-chat-msg",
 805                                                 plugin, PURPLE_CALLBACK(receiving_chat_msg_cb), NULL);
 806         purple_signal_connect(conv_handle, "received-chat-msg",
 807                                                 plugin, PURPLE_CALLBACK(received_chat_msg_cb), NULL);
 808         purple_signal_connect(conv_handle, "conversation-created",
 809                                                 plugin, PURPLE_CALLBACK(conversation_created_cb), NULL);
 810         purple_signal_connect(conv_handle, "deleting-conversation",
 811                                                 plugin, PURPLE_CALLBACK(deleting_conversation_cb), NULL);
 812         purple_signal_connect(conv_handle, "buddy-typing",
 813                                                 plugin, PURPLE_CALLBACK(buddy_typing_cb), NULL);
 814         purple_signal_connect(conv_handle, "buddy-typing-stopped",
 815                                                 plugin, PURPLE_CALLBACK(buddy_typing_stopped_cb), NULL);
 816         purple_signal_connect(conv_handle, "chat-user-joining",
 817                                                 plugin, PURPLE_CALLBACK(chat_user_joining_cb), NULL);
 818         purple_signal_connect(conv_handle, "chat-user-joined",
 819                                                 plugin, PURPLE_CALLBACK(chat_user_joined_cb), NULL);
 820         purple_signal_connect(conv_handle, "chat-user-flags",
 821                                                 plugin, PURPLE_CALLBACK(chat_user_flags_cb), NULL);
 822         purple_signal_connect(conv_handle, "chat-user-leaving",
 823                                                 plugin, PURPLE_CALLBACK(chat_user_leaving_cb), NULL);
 824         purple_signal_connect(conv_handle, "chat-user-left",
 825                                                 plugin, PURPLE_CALLBACK(chat_user_left_cb), NULL);
 826         purple_signal_connect(conv_handle, "chat-inviting-user",
 827                                                 plugin, PURPLE_CALLBACK(chat_inviting_user_cb), NULL);
 828         purple_signal_connect(conv_handle, "chat-invited-user",
 829                                                 plugin, PURPLE_CALLBACK(chat_invited_user_cb), NULL);
 830         purple_signal_connect(conv_handle, "chat-invited",
 831                                                 plugin, PURPLE_CALLBACK(chat_invited_cb), NULL);
 832         purple_signal_connect(conv_handle, "chat-joined",
 833                                                 plugin, PURPLE_CALLBACK(chat_joined_cb), NULL);
 834         purple_signal_connect(conv_handle, "chat-left",
 835                                                 plugin, PURPLE_CALLBACK(chat_left_cb), NULL);
 836         purple_signal_connect(conv_handle, "chat-topic-changed",
 837                                                 plugin, PURPLE_CALLBACK(chat_topic_changed_cb), NULL);
 838
 839         /* Core signals */
 840         purple_signal_connect(core_handle, "quitting",
 841                                                 plugin, PURPLE_CALLBACK(quitting_cb), NULL);
 842         purple_signal_connect(core_handle, "uri-handler",
 843                                                 plugin, PURPLE_CALLBACK(uri_handler), NULL);
 844
 845         /* File transfer signals */
 846         purple_signal_connect(ft_handle, "file-recv-accept",
 847                                                 plugin, PURPLE_CALLBACK(ft_recv_accept_cb), NULL);
 848         purple_signal_connect(ft_handle, "file-recv-start",
 849                                                 plugin, PURPLE_CALLBACK(ft_recv_start_cb), NULL);
 850         purple_signal_connect(ft_handle, "file-recv-cancel",
 851                                                 plugin, PURPLE_CALLBACK(ft_recv_cancel_cb), NULL);
 852         purple_signal_connect(ft_handle, "file-recv-complete",
 853                                                 plugin, PURPLE_CALLBACK(ft_recv_complete_cb), NULL);
 854         purple_signal_connect(ft_handle, "file-send-accept",
 855                                                 plugin, PURPLE_CALLBACK(ft_send_accept_cb), NULL);
 856         purple_signal_connect(ft_handle, "file-send-start",
 857                                                 plugin, PURPLE_CALLBACK(ft_send_start_cb), NULL);
 858         purple_signal_connect(ft_handle, "file-send-cancel",
 859                                                 plugin, PURPLE_CALLBACK(ft_send_cancel_cb), NULL);
 860         purple_signal_connect(ft_handle, "file-send-complete",
 861                                                 plugin, PURPLE_CALLBACK(ft_send_complete_cb), NULL);
 862
 863         /* Sound signals */
 864         purple_signal_connect(sound_handle, "playing-sound-event", plugin,
 865                             PURPLE_CALLBACK(sound_playing_event_cb), NULL);
 866
 867         /* Notify signals */
 868         purple_signal_connect(notify_handle, "displaying-email-notification",
 869                                                 plugin, PURPLE_CALLBACK(notify_email_cb), NULL);
 870         purple_signal_connect(notify_handle, "displaying-emails-notification",
 871                                                 plugin, PURPLE_CALLBACK(notify_emails_cb), NULL);
 872
 873         /* Jabber signals */
 874         if (jabber_handle) {
 875                 purple_signal_connect(jabber_handle, "jabber-receiving-iq", plugin,
 876                                       PURPLE_CALLBACK(jabber_iq_received), NULL);
 877                 purple_signal_connect(jabber_handle, "jabber-receiving-message", plugin,
 878                                       PURPLE_CALLBACK(jabber_message_received), NULL);
 879                 purple_signal_connect(jabber_handle, "jabber-receiving-presence", plugin,
 880                                       PURPLE_CALLBACK(jabber_presence_received), NULL);
 881
 882                 /* IQ namespace signals */
 883                 purple_signal_emit(jabber_handle, "jabber-register-namespace-watcher",
 884                                    "bogus_node", "super-duper-namespace");
 885                 /* The above is equivalent to doing:
 886                         int result = GPOINTER_TO_INT(purple_plugin_ipc_call(jabber_handle, "register_namespace_watcher", &ok, "bogus_node", "super-duper-namespace"));
 887                  */
 888
 889                 purple_signal_connect(jabber_handle, "jabber-watched-iq", plugin,
 890                                       PURPLE_CALLBACK(jabber_watched_iq), NULL);
 891         }
 892
 893         return TRUE;
 894 }
 895
 896 static gboolean
 897 plugin_unload(PurplePlugin *plugin, GError **error)
 898 {
 899         void *jabber_handle = purple_protocols_find("prpl-jabber");
 900
 901         purple_signals_disconnect_by_handle(plugin);
 902
 903         if (jabber_handle) {
 904                 /* Unregister watched namespaces */
 905                 purple_signal_emit(jabber_handle, "jabber-unregister-namespace-watcher",
 906                                    "bogus_node", "super-duper-namespace");
 907                 /* The above is equivalent to doing:
 908                    int result = GPOINTER_TO_INT(purple_plugin_ipc_call(jabber_handle, "unregister_namespace_watcher", &ok, "bogus_node", "super-duper-namespace"));
 909                  */
 910         }
 911
 912         return TRUE;
 913 }
 914
 915 PURPLE_PLUGIN_INIT(signalstest, plugin_query, plugin_load, plugin_unload);