libpurple/protocols.c

   1 /*
   2  * purple
   3  *
   4  * Purple is the legal property of its developers, whose names are too numerous
   5  * to list here.  Please refer to the COPYRIGHT file distributed with this
   6  * source distribution.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  21  *
  22  */
  23 #include "internal.h"
  24 #include "conversation.h"
  25 #include "debug.h"
  26 #include "network.h"
  27 #include "notify.h"
  28 #include "protocol.h"
  29 #include "purpleaccountoption.h"
  30 #include "request.h"
  31 #include "util.h"
  32
  33 static GHashTable *protocols = NULL;
  34
  35 /**************************************************************************
  36  * GBoxed code for PurpleProtocolChatEntry
  37  **************************************************************************/
  38
  39 static PurpleProtocolChatEntry *
  40 purple_protocol_chat_entry_copy(PurpleProtocolChatEntry *pce)
  41 {
  42         PurpleProtocolChatEntry *pce_copy;
  43
  44         g_return_val_if_fail(pce != NULL, NULL);
  45
  46         pce_copy  = g_new(PurpleProtocolChatEntry, 1);
  47         *pce_copy = *pce;
  48
  49         return pce_copy;
  50 }
  51
  52 GType
  53 purple_protocol_chat_entry_get_type(void)
  54 {
  55         static GType type = 0;
  56
  57         if (type == 0) {
  58                 type = g_boxed_type_register_static("PurpleProtocolChatEntry",
  59                                 (GBoxedCopyFunc)purple_protocol_chat_entry_copy,
  60                                 (GBoxedFreeFunc)g_free);
  61         }
  62
  63         return type;
  64 }
  65
  66 /**************************************************************************/
  67 /* Protocol API                                                           */
  68 /**************************************************************************/
  69 void
  70 purple_protocol_got_account_idle(PurpleAccount *account, gboolean idle,
  71                                                    time_t idle_time)
  72 {
  73         g_return_if_fail(account != NULL);
  74         g_return_if_fail(purple_account_is_connected(account));
  75
  76         purple_presence_set_idle(purple_account_get_presence(account),
  77                                                    idle, idle_time);
  78 }
  79
  80 void
  81 purple_protocol_got_account_login_time(PurpleAccount *account, time_t login_time)
  82 {
  83         PurplePresence *presence;
  84
  85         g_return_if_fail(account != NULL);
  86         g_return_if_fail(purple_account_is_connected(account));
  87
  88         if (login_time == 0)
  89                 login_time = time(NULL);
  90
  91         presence = purple_account_get_presence(account);
  92
  93         purple_presence_set_login_time(presence, login_time);
  94 }
  95
  96 void
  97 purple_protocol_got_account_status(PurpleAccount *account, const char *status_id, ...)
  98 {
  99         PurplePresence *presence;
 100         PurpleStatus *status;
 101         va_list args;
 102
 103         g_return_if_fail(account   != NULL);
 104         g_return_if_fail(status_id != NULL);
 105         g_return_if_fail(purple_account_is_connected(account));
 106
 107         presence = purple_account_get_presence(account);
 108         status   = purple_presence_get_status(presence, status_id);
 109
 110         g_return_if_fail(status != NULL);
 111
 112         va_start(args, status_id);
 113         purple_status_set_active_with_attrs(status, TRUE, args);
 114         va_end(args);
 115 }
 116
 117 void
 118 purple_protocol_got_account_actions(PurpleAccount *account)
 119 {
 120
 121         g_return_if_fail(account != NULL);
 122         g_return_if_fail(purple_account_is_connected(account));
 123
 124         purple_signal_emit(purple_accounts_get_handle(), "account-actions-changed",
 125                            account);
 126 }
 127
 128 void
 129 purple_protocol_got_user_idle(PurpleAccount *account, const char *name,
 130                 gboolean idle, time_t idle_time)
 131 {
 132         PurplePresence *presence;
 133         GSList *list;
 134
 135         g_return_if_fail(account != NULL);
 136         g_return_if_fail(name    != NULL);
 137         g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
 138
 139         if ((list = purple_blist_find_buddies(account, name)) == NULL)
 140                 return;
 141
 142         while (list) {
 143                 presence = purple_buddy_get_presence(list->data);
 144                 list = g_slist_delete_link(list, list);
 145                 purple_presence_set_idle(presence, idle, idle_time);
 146         }
 147 }
 148
 149 void
 150 purple_protocol_got_user_login_time(PurpleAccount *account, const char *name,
 151                 time_t login_time)
 152 {
 153         GSList *list;
 154         PurplePresence *presence;
 155
 156         g_return_if_fail(account != NULL);
 157         g_return_if_fail(name    != NULL);
 158
 159         if ((list = purple_blist_find_buddies(account, name)) == NULL)
 160                 return;
 161
 162         if (login_time == 0)
 163                 login_time = time(NULL);
 164
 165         while (list) {
 166                 PurpleBuddy *buddy = list->data;
 167                 presence = purple_buddy_get_presence(buddy);
 168                 list = g_slist_delete_link(list, list);
 169
 170                 if (purple_presence_get_login_time(presence) != login_time)
 171                 {
 172                         purple_presence_set_login_time(presence, login_time);
 173
 174                         purple_signal_emit(purple_blist_get_handle(), "buddy-got-login-time", buddy);
 175                 }
 176         }
 177 }
 178
 179 void
 180 purple_protocol_got_user_status(PurpleAccount *account, const char *name,
 181                 const char *status_id, ...)
 182 {
 183         GSList *list, *l;
 184         PurpleBuddy *buddy;
 185         PurplePresence *presence;
 186         PurpleStatus *status;
 187         PurpleStatus *old_status;
 188         va_list args;
 189
 190         g_return_if_fail(account   != NULL);
 191         g_return_if_fail(name      != NULL);
 192         g_return_if_fail(status_id != NULL);
 193         g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
 194
 195         if((list = purple_blist_find_buddies(account, name)) == NULL)
 196                 return;
 197
 198         for(l = list; l != NULL; l = l->next) {
 199                 buddy = l->data;
 200
 201                 presence = purple_buddy_get_presence(buddy);
 202                 status   = purple_presence_get_status(presence, status_id);
 203
 204                 if(NULL == status)
 205                         /*
 206                          * TODO: This should never happen, right?  We should call
 207                          *       g_warning() or something.
 208                          */
 209                         continue;
 210
 211                 old_status = purple_presence_get_active_status(presence);
 212
 213                 va_start(args, status_id);
 214                 purple_status_set_active_with_attrs(status, TRUE, args);
 215                 va_end(args);
 216
 217                 purple_buddy_update_status(buddy, old_status);
 218         }
 219
 220         g_slist_free(list);
 221
 222         /* The buddy is no longer online, they are therefore by definition not
 223          * still typing to us. */
 224         if (!purple_status_is_online(status)) {
 225                 purple_serv_got_typing_stopped(purple_account_get_connection(account), name);
 226                 purple_protocol_got_media_caps(account, name);
 227         }
 228 }
 229
 230 void purple_protocol_got_user_status_deactive(PurpleAccount *account, const char *name,
 231                                         const char *status_id)
 232 {
 233         GSList *list, *l;
 234         PurpleBuddy *buddy;
 235         PurplePresence *presence;
 236         PurpleStatus *status;
 237
 238         g_return_if_fail(account   != NULL);
 239         g_return_if_fail(name      != NULL);
 240         g_return_if_fail(status_id != NULL);
 241         g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
 242
 243         if((list = purple_blist_find_buddies(account, name)) == NULL)
 244                 return;
 245
 246         for(l = list; l != NULL; l = l->next) {
 247                 buddy = l->data;
 248
 249                 presence = purple_buddy_get_presence(buddy);
 250                 status   = purple_presence_get_status(presence, status_id);
 251
 252                 if(NULL == status)
 253                         continue;
 254
 255                 if (purple_status_is_active(status)) {
 256                         purple_status_set_active(status, FALSE);
 257                         purple_buddy_update_status(buddy, status);
 258                 }
 259         }
 260
 261         g_slist_free(list);
 262 }
 263
 264 static void
 265 do_protocol_change_account_status(PurpleAccount *account,
 266                                                                 PurpleStatus *old_status, PurpleStatus *new_status)
 267 {
 268         PurpleProtocol *protocol;
 269
 270         if (purple_status_is_online(new_status) &&
 271                 purple_account_is_disconnected(account) &&
 272                 purple_network_is_available())
 273         {
 274                 purple_account_connect(account);
 275                 return;
 276         }
 277
 278         if (!purple_status_is_online(new_status))
 279         {
 280                 if (!purple_account_is_disconnected(account))
 281                         purple_account_disconnect(account);
 282                 /* Clear out the unsaved password if we switch to offline status */
 283                 if (!purple_account_get_remember_password(account))
 284                         purple_account_set_password(account, NULL, NULL, NULL);
 285
 286                 return;
 287         }
 288
 289         if (purple_account_is_connecting(account))
 290                 /*
 291                  * We don't need to call the set_status protocol function because
 292                  * the protocol will take care of setting its status during the
 293                  * connection process.
 294                  */
 295                 return;
 296
 297         protocol = purple_protocols_find(purple_account_get_protocol_id(account));
 298
 299         if (protocol == NULL)
 300                 return;
 301
 302         if (!purple_account_is_disconnected(account))
 303                 purple_protocol_server_iface_set_status(protocol, account, new_status);
 304 }
 305
 306 void
 307 purple_protocol_change_account_status(PurpleAccount *account,
 308                                                                 PurpleStatus *old_status, PurpleStatus *new_status)
 309 {
 310         g_return_if_fail(account    != NULL);
 311         g_return_if_fail(new_status != NULL);
 312         g_return_if_fail(!purple_status_is_exclusive(new_status) || old_status != NULL);
 313
 314         purple_signal_emit(purple_accounts_get_handle(), "account-status-changing",
 315                                         account, old_status, new_status);
 316
 317         do_protocol_change_account_status(account, old_status, new_status);
 318
 319         purple_signal_emit(purple_accounts_get_handle(), "account-status-changed",
 320                                         account, old_status, new_status);
 321 }
 322
 323 GList *
 324 purple_protocol_get_statuses(PurpleAccount *account, PurplePresence *presence)
 325 {
 326         GList *statuses = NULL;
 327         GList *l;
 328         PurpleStatus *status;
 329
 330         g_return_val_if_fail(account  != NULL, NULL);
 331         g_return_val_if_fail(presence != NULL, NULL);
 332
 333         for (l = purple_account_get_status_types(account); l != NULL; l = l->next)
 334         {
 335                 status = purple_status_new((PurpleStatusType *)l->data, presence);
 336                 statuses = g_list_prepend(statuses, status);
 337         }
 338
 339         statuses = g_list_reverse(statuses);
 340
 341         return statuses;
 342 }
 343
 344 static void
 345 purple_protocol_attention(PurpleConversation *conv, const char *who,
 346         guint type, PurpleMessageFlags flags, time_t mtime)
 347 {
 348         PurpleAccount *account = purple_conversation_get_account(conv);
 349         purple_signal_emit(purple_conversations_get_handle(),
 350                 flags == PURPLE_MESSAGE_SEND ? "sent-attention" : "got-attention",
 351                 account, who, conv, type);
 352 }
 353
 354 void
 355 purple_protocol_send_attention(PurpleConnection *gc, const char *who, guint type_code)
 356 {
 357         PurpleAttentionType *attn;
 358         PurpleProtocol *protocol;
 359         PurpleIMConversation *im;
 360         PurpleBuddy *buddy;
 361         const char *alias;
 362         gchar *description;
 363
 364         g_return_if_fail(gc != NULL);
 365         g_return_if_fail(who != NULL);
 366
 367         protocol = purple_protocols_find(purple_account_get_protocol_id(purple_connection_get_account(gc)));
 368         g_return_if_fail(PURPLE_IS_PROTOCOL_ATTENTION(protocol));
 369
 370         attn = purple_get_attention_type_from_code(purple_connection_get_account(gc), type_code);
 371
 372         if ((buddy = purple_blist_find_buddy(purple_connection_get_account(gc), who)) != NULL)
 373                 alias = purple_buddy_get_contact_alias(buddy);
 374         else
 375                 alias = who;
 376
 377         if (attn && purple_attention_type_get_outgoing_desc(attn)) {
 378                 description = g_strdup_printf(purple_attention_type_get_outgoing_desc(attn), alias);
 379         } else {
 380                 description = g_strdup_printf(_("Requesting %s's attention..."), alias);
 381         }
 382
 383         purple_debug_info("server", "serv_send_attention: sending '%s' to %s\n",
 384                         description, who);
 385
 386         if (!purple_protocol_attention_send(PURPLE_PROTOCOL_ATTENTION(protocol), gc, who, type_code))
 387                 return;
 388
 389         im = purple_im_conversation_new(purple_connection_get_account(gc), who);
 390         purple_conversation_write_system_message(PURPLE_CONVERSATION(im), description, 0);
 391         purple_protocol_attention(PURPLE_CONVERSATION(im), who, type_code, PURPLE_MESSAGE_SEND, time(NULL));
 392
 393         g_free(description);
 394 }
 395
 396 static void
 397 got_attention(PurpleConnection *gc, int id, const char *who, guint type_code)
 398 {
 399         PurpleMessageFlags flags;
 400         PurpleAttentionType *attn;
 401         PurpleBuddy *buddy;
 402         const char *alias;
 403         gchar *description;
 404         time_t mtime;
 405
 406         mtime = time(NULL);
 407
 408         attn = purple_get_attention_type_from_code(purple_connection_get_account(gc), type_code);
 409
 410         /* PURPLE_MESSAGE_NOTIFY is for attention messages. */
 411         flags = PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NOTIFY | PURPLE_MESSAGE_RECV;
 412
 413         /* TODO: if (attn->icon_name) is non-null, use it to lookup an emoticon and display
 414          * it next to the attention command. And if it is null, display a generic icon. */
 415
 416         if ((buddy = purple_blist_find_buddy(purple_connection_get_account(gc), who)) != NULL)
 417                 alias = purple_buddy_get_contact_alias(buddy);
 418         else
 419                 alias = who;
 420
 421         if (attn && purple_attention_type_get_incoming_desc(attn)) {
 422                 description = g_strdup_printf(purple_attention_type_get_incoming_desc(attn), alias);
 423         } else {
 424                 description = g_strdup_printf(_("%s has requested your attention!"), alias);
 425         }
 426
 427         purple_debug_info("server", "got_attention: got '%s' from %s\n",
 428                         description, who);
 429
 430         if (id == -1)
 431                 purple_serv_got_im(gc, who, description, flags, mtime);
 432         else
 433                 purple_serv_got_chat_in(gc, id, who, flags, description, mtime);
 434
 435         /* TODO: sounds (depending on PurpleAttentionType), shaking, etc. */
 436
 437         g_free(description);
 438 }
 439
 440 void
 441 purple_protocol_got_attention(PurpleConnection *gc, const char *who, guint type_code)
 442 {
 443         PurpleConversation *conv = NULL;
 444         PurpleAccount *account = purple_connection_get_account(gc);
 445
 446         got_attention(gc, -1, who, type_code);
 447         conv =
 448                 purple_conversations_find_with_account(who, account);
 449         if (conv)
 450                 purple_protocol_attention(conv, who, type_code, PURPLE_MESSAGE_RECV,
 451                         time(NULL));
 452 }
 453
 454 void
 455 purple_protocol_got_attention_in_chat(PurpleConnection *gc, int id, const char *who, guint type_code)
 456 {
 457         got_attention(gc, id, who, type_code);
 458 }
 459
 460 gboolean
 461 purple_protocol_initiate_media(PurpleAccount *account,
 462                            const char *who,
 463                            PurpleMediaSessionType type)
 464 {
 465 #ifdef USE_VV
 466         PurpleConnection *gc = NULL;
 467         PurpleProtocol *protocol = NULL;
 468
 469         if (account)
 470                 gc = purple_account_get_connection(account);
 471         if (gc)
 472                 protocol = purple_connection_get_protocol(gc);
 473
 474         if (protocol) {
 475                 /* should check that the protocol supports this media type here? */
 476                 return purple_protocol_media_iface_initiate_session(protocol, account, who, type);
 477         } else
 478 #endif
 479         return FALSE;
 480 }
 481
 482 PurpleMediaCaps
 483 purple_protocol_get_media_caps(PurpleAccount *account, const char *who)
 484 {
 485 #ifdef USE_VV
 486         PurpleConnection *gc = NULL;
 487         PurpleProtocol *protocol = NULL;
 488
 489         if (account)
 490                 gc = purple_account_get_connection(account);
 491         if (gc)
 492                 protocol = purple_connection_get_protocol(gc);
 493
 494         if (protocol)
 495                 return purple_protocol_media_iface_get_caps(protocol, account, who);
 496 #endif
 497         return PURPLE_MEDIA_CAPS_NONE;
 498 }
 499
 500 void
 501 purple_protocol_got_media_caps(PurpleAccount *account, const char *name)
 502 {
 503 #ifdef USE_VV
 504         GSList *list;
 505
 506         g_return_if_fail(account != NULL);
 507         g_return_if_fail(name    != NULL);
 508
 509         if ((list = purple_blist_find_buddies(account, name)) == NULL)
 510                 return;
 511
 512         while (list) {
 513                 PurpleBuddy *buddy = list->data;
 514                 PurpleMediaCaps oldcaps = purple_buddy_get_media_caps(buddy);
 515                 PurpleMediaCaps newcaps = 0;
 516                 const gchar *bname = purple_buddy_get_name(buddy);
 517                 list = g_slist_delete_link(list, list);
 518
 519
 520                 newcaps = purple_protocol_get_media_caps(account, bname);
 521                 purple_buddy_set_media_caps(buddy, newcaps);
 522
 523                 if (oldcaps == newcaps)
 524                         continue;
 525
 526                 purple_signal_emit(purple_blist_get_handle(),
 527                                 "buddy-caps-changed", buddy,
 528                                 newcaps, oldcaps);
 529         }
 530 #endif
 531 }
 532
 533 gssize
 534 purple_protocol_get_max_message_size(PurpleProtocol *protocol)
 535 {
 536         g_return_val_if_fail(PURPLE_IS_PROTOCOL(protocol), 0);
 537
 538         return purple_protocol_client_iface_get_max_message_size(protocol, NULL);
 539 }
 540
 541 /**************************************************************************
 542  * Protocols API
 543  **************************************************************************/
 544 /*
 545  * Negative if a before b, 0 if equal, positive if a after b.
 546  */
 547 static gint
 548 compare_protocol(PurpleProtocol *a, PurpleProtocol *b)
 549 {
 550         const gchar *aname = purple_protocol_get_name(a);
 551         const gchar *bname = purple_protocol_get_name(b);
 552
 553         if (aname) {
 554                 if (bname)
 555                         return strcmp(aname, bname);
 556                 else
 557                         return -1;
 558         } else {
 559                 if (bname)
 560                         return 1;
 561                 else
 562                         return 0;
 563         }
 564 }
 565
 566 PurpleProtocol *
 567 purple_protocols_find(const char *id)
 568 {
 569         g_return_val_if_fail(protocols != NULL && id != NULL, NULL);
 570
 571         return g_hash_table_lookup(protocols, id);
 572 }
 573
 574 PurpleProtocol *
 575 purple_protocols_add(GType protocol_type, GError **error)
 576 {
 577         PurpleProtocol *protocol;
 578         PurpleProtocolClass *klass;
 579
 580         if (protocol_type == G_TYPE_INVALID) {
 581                 g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 582                                     _("Protocol type is not registered"));
 583                 return NULL;
 584         }
 585
 586         if (!g_type_is_a(protocol_type, PURPLE_TYPE_PROTOCOL)) {
 587                 g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 588                                     _("Protocol type does not inherit PurpleProtocol"));
 589                 return NULL;
 590         }
 591
 592         if (G_TYPE_IS_ABSTRACT(protocol_type)) {
 593                 g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 594                                     _("Protocol type is abstract"));
 595                 return NULL;
 596         }
 597
 598         protocol = g_object_new(protocol_type, NULL);
 599         if (!protocol) {
 600                 g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 601                                     _("Could not create protocol instance"));
 602                 return NULL;
 603         }
 604
 605         if (!purple_protocol_get_id(protocol)) {
 606                 g_set_error_literal(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 607                                     _("Protocol does not provide an ID"));
 608
 609                 g_object_unref(protocol);
 610                 return NULL;
 611         }
 612
 613         if (purple_protocols_find(purple_protocol_get_id(protocol))) {
 614                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 615                             _("A protocol with the ID %s is already added."),
 616                             purple_protocol_get_id(protocol));
 617
 618                 g_object_unref(protocol);
 619                 return NULL;
 620         }
 621
 622         /* Make sure the protocol implements the required functions */
 623         klass = PURPLE_PROTOCOL_GET_CLASS(protocol);
 624
 625         if (!klass->login        || !klass->close    ||
 626             !klass->status_types || !klass->list_icon )
 627         {
 628                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 629                             _("Protocol %s does not implement all the functions in "
 630                             "PurpleProtocolClass"), purple_protocol_get_id(protocol));
 631
 632                 g_object_unref(protocol);
 633                 return NULL;
 634         }
 635
 636         g_hash_table_insert(protocols, g_strdup(purple_protocol_get_id(protocol)),
 637                             protocol);
 638
 639         purple_debug_info("protocols", "Added protocol %s\n",
 640                           purple_protocol_get_id(protocol));
 641
 642         purple_signal_emit(purple_protocols_get_handle(), "protocol-added",
 643                            protocol);
 644         return protocol;
 645 }
 646
 647 gboolean purple_protocols_remove(PurpleProtocol *protocol, GError **error)
 648 {
 649         g_return_val_if_fail(PURPLE_IS_PROTOCOL(protocol), FALSE);
 650         g_return_val_if_fail(purple_protocol_get_id(protocol) != NULL, FALSE);
 651
 652         if (purple_protocols_find(purple_protocol_get_id(protocol)) == NULL) {
 653                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 654                             _("Protocol %s is not added."),
 655                             purple_protocol_get_id(protocol));
 656
 657                 return FALSE;
 658         }
 659
 660         purple_debug_info("protocols", "Removing protocol %s\n",
 661                           purple_protocol_get_id(protocol));
 662
 663         purple_signal_emit(purple_protocols_get_handle(), "protocol-removed",
 664                            protocol);
 665
 666         g_hash_table_remove(protocols, purple_protocol_get_id(protocol));
 667         return TRUE;
 668 }
 669
 670 GList *
 671 purple_protocols_get_all(void)
 672 {
 673         GList *ret = NULL;
 674         PurpleProtocol *protocol;
 675         GHashTableIter iter;
 676
 677         g_hash_table_iter_init(&iter, protocols);
 678         while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&protocol))
 679                 ret = g_list_insert_sorted(ret, protocol, (GCompareFunc)compare_protocol);
 680
 681         return ret;
 682 }
 683
 684 /**************************************************************************
 685  * Protocols Subsystem API
 686  **************************************************************************/
 687 void
 688 purple_protocols_init(void)
 689 {
 690         void *handle = purple_protocols_get_handle();
 691
 692         protocols = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
 693                         (GDestroyNotify)g_object_unref);
 694
 695         purple_signal_register(handle, "protocol-added",
 696                                purple_marshal_VOID__POINTER,
 697                                G_TYPE_NONE, 1, PURPLE_TYPE_PROTOCOL);
 698         purple_signal_register(handle, "protocol-removed",
 699                                purple_marshal_VOID__POINTER,
 700                                G_TYPE_NONE, 1, PURPLE_TYPE_PROTOCOL);
 701 }
 702
 703 void *
 704 purple_protocols_get_handle(void)
 705 {
 706         static int handle;
 707
 708         return &handle;
 709 }
 710
 711 void
 712 purple_protocols_uninit(void)
 713 {
 714         g_hash_table_destroy(protocols);
 715 }
 716