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 "accountopt.h"
  25 #include "conversation.h"
  26 #include "debug.h"
  27 #include "network.h"
  28 #include "notify.h"
  29 #include "protocol.h"
  30 #include "request.h"
  31 #include "util.h"
  32
  33 static GHashTable *protocols = NULL;
  34
  35 /**************************************************************************/
  36 /* Attention Type API                                                     */
  37 /**************************************************************************/
  38
  39 struct _PurpleAttentionType
  40 {
  41         const char *name;                  /* Shown in GUI elements */
  42         const char *incoming_description;  /* Shown when sent */
  43         const char *outgoing_description;  /* Shown when receied */
  44         const char *icon_name;             /* Icon to display (optional) */
  45         const char *unlocalized_name;      /* Unlocalized name for UIs needing it */
  46 };
  47
  48
  49 PurpleAttentionType *
  50 purple_attention_type_new(const char *ulname, const char *name,
  51                                                 const char *inc_desc, const char *out_desc)
  52 {
  53         PurpleAttentionType *attn = g_new0(PurpleAttentionType, 1);
  54
  55         purple_attention_type_set_name(attn, name);
  56         purple_attention_type_set_incoming_desc(attn, inc_desc);
  57         purple_attention_type_set_outgoing_desc(attn, out_desc);
  58         purple_attention_type_set_unlocalized_name(attn, ulname);
  59
  60         return attn;
  61 }
  62
  63
  64 void
  65 purple_attention_type_set_name(PurpleAttentionType *type, const char *name)
  66 {
  67         g_return_if_fail(type != NULL);
  68
  69         type->name = name;
  70 }
  71
  72 void
  73 purple_attention_type_set_incoming_desc(PurpleAttentionType *type, const char *desc)
  74 {
  75         g_return_if_fail(type != NULL);
  76
  77         type->incoming_description = desc;
  78 }
  79
  80 void
  81 purple_attention_type_set_outgoing_desc(PurpleAttentionType *type, const char *desc)
  82 {
  83         g_return_if_fail(type != NULL);
  84
  85         type->outgoing_description = desc;
  86 }
  87
  88 void
  89 purple_attention_type_set_icon_name(PurpleAttentionType *type, const char *name)
  90 {
  91         g_return_if_fail(type != NULL);
  92
  93         type->icon_name = name;
  94 }
  95
  96 void
  97 purple_attention_type_set_unlocalized_name(PurpleAttentionType *type, const char *ulname)
  98 {
  99         g_return_if_fail(type != NULL);
 100
 101         type->unlocalized_name = ulname;
 102 }
 103
 104 const char *
 105 purple_attention_type_get_name(const PurpleAttentionType *type)
 106 {
 107         g_return_val_if_fail(type != NULL, NULL);
 108
 109         return type->name;
 110 }
 111
 112 const char *
 113 purple_attention_type_get_incoming_desc(const PurpleAttentionType *type)
 114 {
 115         g_return_val_if_fail(type != NULL, NULL);
 116
 117         return type->incoming_description;
 118 }
 119
 120 const char *
 121 purple_attention_type_get_outgoing_desc(const PurpleAttentionType *type)
 122 {
 123         g_return_val_if_fail(type != NULL, NULL);
 124
 125         return type->outgoing_description;
 126 }
 127
 128 const char *
 129 purple_attention_type_get_icon_name(const PurpleAttentionType *type)
 130 {
 131         g_return_val_if_fail(type != NULL, NULL);
 132
 133         if(type->icon_name == NULL || *(type->icon_name) == '\0')
 134                 return NULL;
 135
 136         return type->icon_name;
 137 }
 138
 139 const char *
 140 purple_attention_type_get_unlocalized_name(const PurpleAttentionType *type)
 141 {
 142         g_return_val_if_fail(type != NULL, NULL);
 143
 144         return type->unlocalized_name;
 145 }
 146
 147 /**************************************************************************
 148  * GBoxed code for PurpleAttentionType
 149  **************************************************************************/
 150
 151 static PurpleAttentionType *
 152 purple_attention_type_copy(PurpleAttentionType *attn)
 153 {
 154         PurpleAttentionType *attn_copy;
 155
 156         g_return_val_if_fail(attn != NULL, NULL);
 157
 158         attn_copy  = g_new(PurpleAttentionType, 1);
 159         *attn_copy = *attn;
 160
 161         return attn_copy;
 162 }
 163
 164 GType
 165 purple_attention_type_get_type(void)
 166 {
 167         static GType type = 0;
 168
 169         if (type == 0) {
 170                 type = g_boxed_type_register_static("PurpleAttentionType",
 171                                 (GBoxedCopyFunc)purple_attention_type_copy,
 172                                 (GBoxedFreeFunc)g_free);
 173         }
 174
 175         return type;
 176 }
 177
 178 /**************************************************************************
 179  * GBoxed code for PurpleProtocolChatEntry
 180  **************************************************************************/
 181
 182 static PurpleProtocolChatEntry *
 183 purple_protocol_chat_entry_copy(PurpleProtocolChatEntry *pce)
 184 {
 185         PurpleProtocolChatEntry *pce_copy;
 186
 187         g_return_val_if_fail(pce != NULL, NULL);
 188
 189         pce_copy  = g_new(PurpleProtocolChatEntry, 1);
 190         *pce_copy = *pce;
 191
 192         return pce_copy;
 193 }
 194
 195 GType
 196 purple_protocol_chat_entry_get_type(void)
 197 {
 198         static GType type = 0;
 199
 200         if (type == 0) {
 201                 type = g_boxed_type_register_static("PurpleProtocolChatEntry",
 202                                 (GBoxedCopyFunc)purple_protocol_chat_entry_copy,
 203                                 (GBoxedFreeFunc)g_free);
 204         }
 205
 206         return type;
 207 }
 208
 209 /**************************************************************************/
 210 /* Protocol API                                                           */
 211 /**************************************************************************/
 212 void
 213 purple_protocol_got_account_idle(PurpleAccount *account, gboolean idle,
 214                                                    time_t idle_time)
 215 {
 216         g_return_if_fail(account != NULL);
 217         g_return_if_fail(purple_account_is_connected(account));
 218
 219         purple_presence_set_idle(purple_account_get_presence(account),
 220                                                    idle, idle_time);
 221 }
 222
 223 void
 224 purple_protocol_got_account_login_time(PurpleAccount *account, time_t login_time)
 225 {
 226         PurplePresence *presence;
 227
 228         g_return_if_fail(account != NULL);
 229         g_return_if_fail(purple_account_is_connected(account));
 230
 231         if (login_time == 0)
 232                 login_time = time(NULL);
 233
 234         presence = purple_account_get_presence(account);
 235
 236         purple_presence_set_login_time(presence, login_time);
 237 }
 238
 239 void
 240 purple_protocol_got_account_status(PurpleAccount *account, const char *status_id, ...)
 241 {
 242         PurplePresence *presence;
 243         PurpleStatus *status;
 244         va_list args;
 245
 246         g_return_if_fail(account   != NULL);
 247         g_return_if_fail(status_id != NULL);
 248         g_return_if_fail(purple_account_is_connected(account));
 249
 250         presence = purple_account_get_presence(account);
 251         status   = purple_presence_get_status(presence, status_id);
 252
 253         g_return_if_fail(status != NULL);
 254
 255         va_start(args, status_id);
 256         purple_status_set_active_with_attrs(status, TRUE, args);
 257         va_end(args);
 258 }
 259
 260 void
 261 purple_protocol_got_account_actions(PurpleAccount *account)
 262 {
 263
 264         g_return_if_fail(account != NULL);
 265         g_return_if_fail(purple_account_is_connected(account));
 266
 267         purple_signal_emit(purple_accounts_get_handle(), "account-actions-changed",
 268                            account);
 269 }
 270
 271 void
 272 purple_protocol_got_user_idle(PurpleAccount *account, const char *name,
 273                 gboolean idle, time_t idle_time)
 274 {
 275         PurplePresence *presence;
 276         GSList *list;
 277
 278         g_return_if_fail(account != NULL);
 279         g_return_if_fail(name    != NULL);
 280         g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
 281
 282         if ((list = purple_blist_find_buddies(account, name)) == NULL)
 283                 return;
 284
 285         while (list) {
 286                 presence = purple_buddy_get_presence(list->data);
 287                 list = g_slist_delete_link(list, list);
 288                 purple_presence_set_idle(presence, idle, idle_time);
 289         }
 290 }
 291
 292 void
 293 purple_protocol_got_user_login_time(PurpleAccount *account, const char *name,
 294                 time_t login_time)
 295 {
 296         GSList *list;
 297         PurplePresence *presence;
 298
 299         g_return_if_fail(account != NULL);
 300         g_return_if_fail(name    != NULL);
 301
 302         if ((list = purple_blist_find_buddies(account, name)) == NULL)
 303                 return;
 304
 305         if (login_time == 0)
 306                 login_time = time(NULL);
 307
 308         while (list) {
 309                 PurpleBuddy *buddy = list->data;
 310                 presence = purple_buddy_get_presence(buddy);
 311                 list = g_slist_delete_link(list, list);
 312
 313                 if (purple_presence_get_login_time(presence) != login_time)
 314                 {
 315                         purple_presence_set_login_time(presence, login_time);
 316
 317                         purple_signal_emit(purple_blist_get_handle(), "buddy-got-login-time", buddy);
 318                 }
 319         }
 320 }
 321
 322 void
 323 purple_protocol_got_user_status(PurpleAccount *account, const char *name,
 324                 const char *status_id, ...)
 325 {
 326         GSList *list, *l;
 327         PurpleBuddy *buddy;
 328         PurplePresence *presence;
 329         PurpleStatus *status;
 330         PurpleStatus *old_status;
 331         va_list args;
 332
 333         g_return_if_fail(account   != NULL);
 334         g_return_if_fail(name      != NULL);
 335         g_return_if_fail(status_id != NULL);
 336         g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
 337
 338         if((list = purple_blist_find_buddies(account, name)) == NULL)
 339                 return;
 340
 341         for(l = list; l != NULL; l = l->next) {
 342                 buddy = l->data;
 343
 344                 presence = purple_buddy_get_presence(buddy);
 345                 status   = purple_presence_get_status(presence, status_id);
 346
 347                 if(NULL == status)
 348                         /*
 349                          * TODO: This should never happen, right?  We should call
 350                          *       g_warning() or something.
 351                          */
 352                         continue;
 353
 354                 old_status = purple_presence_get_active_status(presence);
 355
 356                 va_start(args, status_id);
 357                 purple_status_set_active_with_attrs(status, TRUE, args);
 358                 va_end(args);
 359
 360                 purple_buddy_update_status(buddy, old_status);
 361         }
 362
 363         g_slist_free(list);
 364
 365         /* The buddy is no longer online, they are therefore by definition not
 366          * still typing to us. */
 367         if (!purple_status_is_online(status)) {
 368                 purple_serv_got_typing_stopped(purple_account_get_connection(account), name);
 369                 purple_protocol_got_media_caps(account, name);
 370         }
 371 }
 372
 373 void purple_protocol_got_user_status_deactive(PurpleAccount *account, const char *name,
 374                                         const char *status_id)
 375 {
 376         GSList *list, *l;
 377         PurpleBuddy *buddy;
 378         PurplePresence *presence;
 379         PurpleStatus *status;
 380
 381         g_return_if_fail(account   != NULL);
 382         g_return_if_fail(name      != NULL);
 383         g_return_if_fail(status_id != NULL);
 384         g_return_if_fail(purple_account_is_connected(account) || purple_account_is_connecting(account));
 385
 386         if((list = purple_blist_find_buddies(account, name)) == NULL)
 387                 return;
 388
 389         for(l = list; l != NULL; l = l->next) {
 390                 buddy = l->data;
 391
 392                 presence = purple_buddy_get_presence(buddy);
 393                 status   = purple_presence_get_status(presence, status_id);
 394
 395                 if(NULL == status)
 396                         continue;
 397
 398                 if (purple_status_is_active(status)) {
 399                         purple_status_set_active(status, FALSE);
 400                         purple_buddy_update_status(buddy, status);
 401                 }
 402         }
 403
 404         g_slist_free(list);
 405 }
 406
 407 static void
 408 do_protocol_change_account_status(PurpleAccount *account,
 409                                                                 PurpleStatus *old_status, PurpleStatus *new_status)
 410 {
 411         PurpleProtocol *protocol;
 412
 413         if (purple_status_is_online(new_status) &&
 414                 purple_account_is_disconnected(account) &&
 415                 purple_network_is_available())
 416         {
 417                 purple_account_connect(account);
 418                 return;
 419         }
 420
 421         if (!purple_status_is_online(new_status))
 422         {
 423                 if (!purple_account_is_disconnected(account))
 424                         purple_account_disconnect(account);
 425                 /* Clear out the unsaved password if we switch to offline status */
 426                 if (!purple_account_get_remember_password(account))
 427                         purple_account_set_password(account, NULL, NULL, NULL);
 428
 429                 return;
 430         }
 431
 432         if (purple_account_is_connecting(account))
 433                 /*
 434                  * We don't need to call the set_status protocol function because
 435                  * the protocol will take care of setting its status during the
 436                  * connection process.
 437                  */
 438                 return;
 439
 440         protocol = purple_protocols_find(purple_account_get_protocol_id(account));
 441
 442         if (protocol == NULL)
 443                 return;
 444
 445         if (!purple_account_is_disconnected(account))
 446                 purple_protocol_server_iface_set_status(protocol, account, new_status);
 447 }
 448
 449 void
 450 purple_protocol_change_account_status(PurpleAccount *account,
 451                                                                 PurpleStatus *old_status, PurpleStatus *new_status)
 452 {
 453         g_return_if_fail(account    != NULL);
 454         g_return_if_fail(new_status != NULL);
 455         g_return_if_fail(!purple_status_is_exclusive(new_status) || old_status != NULL);
 456
 457         purple_signal_emit(purple_accounts_get_handle(), "account-status-changing",
 458                                         account, old_status, new_status);
 459
 460         do_protocol_change_account_status(account, old_status, new_status);
 461
 462         purple_signal_emit(purple_accounts_get_handle(), "account-status-changed",
 463                                         account, old_status, new_status);
 464 }
 465
 466 GList *
 467 purple_protocol_get_statuses(PurpleAccount *account, PurplePresence *presence)
 468 {
 469         GList *statuses = NULL;
 470         GList *l;
 471         PurpleStatus *status;
 472
 473         g_return_val_if_fail(account  != NULL, NULL);
 474         g_return_val_if_fail(presence != NULL, NULL);
 475
 476         for (l = purple_account_get_status_types(account); l != NULL; l = l->next)
 477         {
 478                 status = purple_status_new((PurpleStatusType *)l->data, presence);
 479                 statuses = g_list_prepend(statuses, status);
 480         }
 481
 482         statuses = g_list_reverse(statuses);
 483
 484         return statuses;
 485 }
 486
 487 static void
 488 purple_protocol_attention(PurpleConversation *conv, const char *who,
 489         guint type, PurpleMessageFlags flags, time_t mtime)
 490 {
 491         PurpleAccount *account = purple_conversation_get_account(conv);
 492         purple_signal_emit(purple_conversations_get_handle(),
 493                 flags == PURPLE_MESSAGE_SEND ? "sent-attention" : "got-attention",
 494                 account, who, conv, type);
 495 }
 496
 497 void
 498 purple_protocol_send_attention(PurpleConnection *gc, const char *who, guint type_code)
 499 {
 500         PurpleAttentionType *attn;
 501         PurpleProtocol *protocol;
 502         PurpleIMConversation *im;
 503         PurpleBuddy *buddy;
 504         const char *alias;
 505         gchar *description;
 506
 507         g_return_if_fail(gc != NULL);
 508         g_return_if_fail(who != NULL);
 509
 510         protocol = purple_protocols_find(purple_account_get_protocol_id(purple_connection_get_account(gc)));
 511         g_return_if_fail(PURPLE_PROTOCOL_IMPLEMENTS(protocol, ATTENTION_IFACE, send));
 512
 513         attn = purple_get_attention_type_from_code(purple_connection_get_account(gc), type_code);
 514
 515         if ((buddy = purple_blist_find_buddy(purple_connection_get_account(gc), who)) != NULL)
 516                 alias = purple_buddy_get_contact_alias(buddy);
 517         else
 518                 alias = who;
 519
 520         if (attn && purple_attention_type_get_outgoing_desc(attn)) {
 521                 description = g_strdup_printf(purple_attention_type_get_outgoing_desc(attn), alias);
 522         } else {
 523                 description = g_strdup_printf(_("Requesting %s's attention..."), alias);
 524         }
 525
 526         purple_debug_info("server", "serv_send_attention: sending '%s' to %s\n",
 527                         description, who);
 528
 529         if (!purple_protocol_attention_iface_send(protocol, gc, who, type_code))
 530                 return;
 531
 532         im = purple_im_conversation_new(purple_connection_get_account(gc), who);
 533         purple_conversation_write_system_message(PURPLE_CONVERSATION(im), description, 0);
 534         purple_protocol_attention(PURPLE_CONVERSATION(im), who, type_code, PURPLE_MESSAGE_SEND, time(NULL));
 535
 536         g_free(description);
 537 }
 538
 539 static void
 540 got_attention(PurpleConnection *gc, int id, const char *who, guint type_code)
 541 {
 542         PurpleMessageFlags flags;
 543         PurpleAttentionType *attn;
 544         PurpleBuddy *buddy;
 545         const char *alias;
 546         gchar *description;
 547         time_t mtime;
 548
 549         mtime = time(NULL);
 550
 551         attn = purple_get_attention_type_from_code(purple_connection_get_account(gc), type_code);
 552
 553         /* PURPLE_MESSAGE_NOTIFY is for attention messages. */
 554         flags = PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NOTIFY | PURPLE_MESSAGE_RECV;
 555
 556         /* TODO: if (attn->icon_name) is non-null, use it to lookup an emoticon and display
 557          * it next to the attention command. And if it is null, display a generic icon. */
 558
 559         if ((buddy = purple_blist_find_buddy(purple_connection_get_account(gc), who)) != NULL)
 560                 alias = purple_buddy_get_contact_alias(buddy);
 561         else
 562                 alias = who;
 563
 564         if (attn && purple_attention_type_get_incoming_desc(attn)) {
 565                 description = g_strdup_printf(purple_attention_type_get_incoming_desc(attn), alias);
 566         } else {
 567                 description = g_strdup_printf(_("%s has requested your attention!"), alias);
 568         }
 569
 570         purple_debug_info("server", "got_attention: got '%s' from %s\n",
 571                         description, who);
 572
 573         if (id == -1)
 574                 purple_serv_got_im(gc, who, description, flags, mtime);
 575         else
 576                 purple_serv_got_chat_in(gc, id, who, flags, description, mtime);
 577
 578         /* TODO: sounds (depending on PurpleAttentionType), shaking, etc. */
 579
 580         g_free(description);
 581 }
 582
 583 void
 584 purple_protocol_got_attention(PurpleConnection *gc, const char *who, guint type_code)
 585 {
 586         PurpleConversation *conv = NULL;
 587         PurpleAccount *account = purple_connection_get_account(gc);
 588
 589         got_attention(gc, -1, who, type_code);
 590         conv =
 591                 purple_conversations_find_with_account(who, account);
 592         if (conv)
 593                 purple_protocol_attention(conv, who, type_code, PURPLE_MESSAGE_RECV,
 594                         time(NULL));
 595 }
 596
 597 void
 598 purple_protocol_got_attention_in_chat(PurpleConnection *gc, int id, const char *who, guint type_code)
 599 {
 600         got_attention(gc, id, who, type_code);
 601 }
 602
 603 gboolean
 604 purple_protocol_initiate_media(PurpleAccount *account,
 605                            const char *who,
 606                            PurpleMediaSessionType type)
 607 {
 608 #ifdef USE_VV
 609         PurpleConnection *gc = NULL;
 610         PurpleProtocol *protocol = NULL;
 611
 612         if (account)
 613                 gc = purple_account_get_connection(account);
 614         if (gc)
 615                 protocol = purple_connection_get_protocol(gc);
 616
 617         if (protocol) {
 618                 /* should check that the protocol supports this media type here? */
 619                 return purple_protocol_media_iface_initiate_session(protocol, account, who, type);
 620         } else
 621 #endif
 622         return FALSE;
 623 }
 624
 625 PurpleMediaCaps
 626 purple_protocol_get_media_caps(PurpleAccount *account, const char *who)
 627 {
 628 #ifdef USE_VV
 629         PurpleConnection *gc = NULL;
 630         PurpleProtocol *protocol = NULL;
 631
 632         if (account)
 633                 gc = purple_account_get_connection(account);
 634         if (gc)
 635                 protocol = purple_connection_get_protocol(gc);
 636
 637         if (protocol)
 638                 return purple_protocol_media_iface_get_caps(protocol, account, who);
 639 #endif
 640         return PURPLE_MEDIA_CAPS_NONE;
 641 }
 642
 643 void
 644 purple_protocol_got_media_caps(PurpleAccount *account, const char *name)
 645 {
 646 #ifdef USE_VV
 647         GSList *list;
 648
 649         g_return_if_fail(account != NULL);
 650         g_return_if_fail(name    != NULL);
 651
 652         if ((list = purple_blist_find_buddies(account, name)) == NULL)
 653                 return;
 654
 655         while (list) {
 656                 PurpleBuddy *buddy = list->data;
 657                 PurpleMediaCaps oldcaps = purple_buddy_get_media_caps(buddy);
 658                 PurpleMediaCaps newcaps = 0;
 659                 const gchar *bname = purple_buddy_get_name(buddy);
 660                 list = g_slist_delete_link(list, list);
 661
 662
 663                 newcaps = purple_protocol_get_media_caps(account, bname);
 664                 purple_buddy_set_media_caps(buddy, newcaps);
 665
 666                 if (oldcaps == newcaps)
 667                         continue;
 668
 669                 purple_signal_emit(purple_blist_get_handle(),
 670                                 "buddy-caps-changed", buddy,
 671                                 newcaps, oldcaps);
 672         }
 673 #endif
 674 }
 675
 676 gssize
 677 purple_protocol_get_max_message_size(PurpleProtocol *protocol)
 678 {
 679         g_return_val_if_fail(PURPLE_IS_PROTOCOL(protocol), 0);
 680
 681         return purple_protocol_client_iface_get_max_message_size(protocol, NULL);
 682 }
 683
 684 /**************************************************************************/
 685 /* Protocol Action API                                                    */
 686 /**************************************************************************/
 687
 688 PurpleProtocolAction *
 689 purple_protocol_action_new(const char* label,
 690                 PurpleProtocolActionCallback callback)
 691 {
 692         PurpleProtocolAction *action;
 693
 694         g_return_val_if_fail(label != NULL && callback != NULL, NULL);
 695
 696         action = g_new0(PurpleProtocolAction, 1);
 697
 698         action->label    = g_strdup(label);
 699         action->callback = callback;
 700
 701         return action;
 702 }
 703
 704 void
 705 purple_protocol_action_free(PurpleProtocolAction *action)
 706 {
 707         g_return_if_fail(action != NULL);
 708
 709         g_free(action->label);
 710         g_free(action);
 711 }
 712
 713 /**************************************************************************
 714  * GBoxed code for PurpleProtocolAction
 715  **************************************************************************/
 716
 717 static PurpleProtocolAction *
 718 purple_protocol_action_copy(PurpleProtocolAction *action)
 719 {
 720         g_return_val_if_fail(action != NULL, NULL);
 721
 722         return purple_protocol_action_new(action->label, action->callback);
 723 }
 724
 725 GType
 726 purple_protocol_action_get_type(void)
 727 {
 728         static GType type = 0;
 729
 730         if (type == 0) {
 731                 type = g_boxed_type_register_static("PurpleProtocolAction",
 732                                 (GBoxedCopyFunc)purple_protocol_action_copy,
 733                                 (GBoxedFreeFunc)purple_protocol_action_free);
 734         }
 735
 736         return type;
 737 }
 738
 739 /**************************************************************************
 740  * Protocols API
 741  **************************************************************************/
 742 /*
 743  * Negative if a before b, 0 if equal, positive if a after b.
 744  */
 745 static gint
 746 compare_protocol(PurpleProtocol *a, PurpleProtocol *b)
 747 {
 748         const gchar *aname = purple_protocol_get_name(a);
 749         const gchar *bname = purple_protocol_get_name(b);
 750
 751         if (aname) {
 752                 if (bname)
 753                         return strcmp(aname, bname);
 754                 else
 755                         return -1;
 756         } else {
 757                 if (bname)
 758                         return 1;
 759                 else
 760                         return 0;
 761         }
 762 }
 763
 764 PurpleProtocol *
 765 purple_protocols_find(const char *id)
 766 {
 767         g_return_val_if_fail(protocols != NULL && id != NULL, NULL);
 768
 769         return g_hash_table_lookup(protocols, id);
 770 }
 771
 772 PurpleProtocol *
 773 purple_protocols_add(GType protocol_type, GError **error)
 774 {
 775         PurpleProtocol *protocol;
 776         PurpleProtocolClass *klass;
 777
 778         if (protocol_type == G_TYPE_INVALID) {
 779                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 780                             _("Protocol type is not registered"));
 781                 return NULL;
 782         }
 783
 784         if (!g_type_is_a(protocol_type, PURPLE_TYPE_PROTOCOL)) {
 785                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 786                             _("Protocol type does not inherit PurpleProtocol"));
 787                 return NULL;
 788         }
 789
 790         if (G_TYPE_IS_ABSTRACT(protocol_type)) {
 791                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 792                             _("Protocol type is abstract"));
 793                 return NULL;
 794         }
 795
 796         protocol = g_object_new(protocol_type, NULL);
 797         klass = PURPLE_PROTOCOL_GET_CLASS(protocol);
 798
 799         if (!protocol) {
 800                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 801                             _("Could not create protocol instance"));
 802                 return NULL;
 803         }
 804
 805         if (!purple_protocol_get_id(protocol)) {
 806                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 807                             _("Protocol does not provide an ID"));
 808
 809                 g_object_unref(protocol);
 810                 return NULL;
 811         }
 812
 813         if (purple_protocols_find(purple_protocol_get_id(protocol))) {
 814                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 815                             _("A protocol with the ID %s is already added."),
 816                             purple_protocol_get_id(protocol));
 817
 818                 g_object_unref(protocol);
 819                 return NULL;
 820         }
 821
 822         /* Make sure the protocol implements the required functions */
 823         if (!klass->login        || !klass->close    ||
 824             !klass->status_types || !klass->list_icon )
 825         {
 826                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 827                             _("Protocol %s does not implement all the functions in "
 828                             "PurpleProtocolClass"), purple_protocol_get_id(protocol));
 829
 830                 g_object_unref(protocol);
 831                 return NULL;
 832         }
 833
 834         g_hash_table_insert(protocols, g_strdup(purple_protocol_get_id(protocol)),
 835                             protocol);
 836
 837         purple_debug_info("protocols", "Added protocol %s\n",
 838                           purple_protocol_get_id(protocol));
 839
 840         purple_signal_emit(purple_protocols_get_handle(), "protocol-added",
 841                            protocol);
 842         return protocol;
 843 }
 844
 845 gboolean purple_protocols_remove(PurpleProtocol *protocol, GError **error)
 846 {
 847         g_return_val_if_fail(PURPLE_IS_PROTOCOL(protocol), FALSE);
 848         g_return_val_if_fail(purple_protocol_get_id(protocol) != NULL, FALSE);
 849
 850         if (purple_protocols_find(purple_protocol_get_id(protocol)) == NULL) {
 851                 g_set_error(error, PURPLE_PROTOCOLS_DOMAIN, 0,
 852                             _("Protocol %s is not added."),
 853                             purple_protocol_get_id(protocol));
 854
 855                 return FALSE;
 856         }
 857
 858         purple_debug_info("protocols", "Removing protocol %s\n",
 859                           purple_protocol_get_id(protocol));
 860
 861         purple_signal_emit(purple_protocols_get_handle(), "protocol-removed",
 862                            protocol);
 863
 864         g_hash_table_remove(protocols, purple_protocol_get_id(protocol));
 865         return TRUE;
 866 }
 867
 868 GList *
 869 purple_protocols_get_all(void)
 870 {
 871         GList *ret = NULL;
 872         PurpleProtocol *protocol;
 873         GHashTableIter iter;
 874
 875         g_hash_table_iter_init(&iter, protocols);
 876         while (g_hash_table_iter_next(&iter, NULL, (gpointer *)&protocol))
 877                 ret = g_list_insert_sorted(ret, protocol, (GCompareFunc)compare_protocol);
 878
 879         return ret;
 880 }
 881
 882 /**************************************************************************
 883  * Protocols Subsystem API
 884  **************************************************************************/
 885 void
 886 purple_protocols_init(void)
 887 {
 888         void *handle = purple_protocols_get_handle();
 889
 890         protocols = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
 891                         (GDestroyNotify)g_object_unref);
 892
 893         purple_signal_register(handle, "protocol-added",
 894                                purple_marshal_VOID__POINTER,
 895                                G_TYPE_NONE, 1, PURPLE_TYPE_PROTOCOL);
 896         purple_signal_register(handle, "protocol-removed",
 897                                purple_marshal_VOID__POINTER,
 898                                G_TYPE_NONE, 1, PURPLE_TYPE_PROTOCOL);
 899 }
 900
 901 void *
 902 purple_protocols_get_handle(void)
 903 {
 904         static int handle;
 905
 906         return &handle;
 907 }
 908
 909 void
 910 purple_protocols_uninit(void)
 911 {
 912         g_hash_table_destroy(protocols);
 913 }
 914