thblist.c

   1 /*
   2  * Thrasher Bird - XMPP transport via libpurple
   3  * Copyright (C) 2008 Barracuda Networks, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with Thrasher Bird; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  18  */
  19 #include <stdlib.h>
  20 #include "blist.h"
  21 #include "thperl.h"
  22 #include "thrasher.h"
  23 #include "thblist.h"
  24 #include "status.h"
  25
  26 #include <server.h>
  27 #include <account.h>
  28
  29 void thrasher_buddy_status_changed (PurpleBuddy *buddy, PurpleStatus *old,
  30                                     PurpleStatus *new);
  31 void thrasher_buddy_signed_on (PurpleBuddy *buddy);
  32 void thrasher_buddy_signed_off (PurpleBuddy *buddy);
  33 void thrasher_buddy_added (PurpleBuddy *buddy);
  34 void thrasher_buddy_add_request (PurpleAccount *account, const char *remote_user,
  35                            const char *id, const char *alias,
  36                            const char *message);
  37 static void * thrasher_buddy_request_authorize
  38     (PurpleAccount *account,
  39      const char *remote_user,
  40      const char *id,
  41      const char *alias,
  42      const char *message,
  43      gboolean on_list,
  44      PurpleAccountRequestAuthorizationCb authorize_cb,
  45      PurpleAccountRequestAuthorizationCb deny_cb,
  46      void *user_data);
  47 void thrasher_buddy_removed (PurpleBuddy *buddy);
  48 static gpointer thrasher_blist_get_handle (void);
  49 static char* status_text_for_buddy(PurpleBuddy *buddy, PurpleStatus *status);
  50
  51 static PurpleAccountUiOps thrasher_account_uiops =
  52 {
  53     // notify added
  54     thrasher_buddy_add_request,
  55
  56     // status changed
  57     NULL,
  58
  59     // request add
  60     thrasher_buddy_add_request,
  61
  62     // request_authorize
  63     thrasher_buddy_request_authorize,
  64
  65     // close_account_request
  66     NULL,
  67     // save_node
  68     NULL,
  69     // remove_node
  70     NULL,
  71     // save_account
  72     NULL,
  73     // Reserved
  74     NULL
  75 };
  76
  77 struct _PurpleStatusType
  78 {
  79     PurpleStatusPrimitive primitive;
  80
  81     char *id;
  82     char *name;
  83     char *primary_attr_id;
  84
  85     gboolean saveable;
  86     gboolean user_settable;
  87     gboolean independent;
  88
  89     GList *attrs;
  90 };
  91
  92
  93 struct _PurpleStatus
  94 {
  95     struct _PurpleStatusType *type;
  96     PurplePresence *presence;
  97
  98     const char *title;
  99
 100     gboolean active;
 101
 102     GHashTable *attr_values;
 103 };
 104
 105 /**
 106  * @brief This is the callback for the buddy-status-changed signal
 107  * @param buddy PurpleBuddy struct
 108  * @param old (unused)
 109  * @param new @buddy new PurpleStatus
 110  */
 111 void thrasher_buddy_status_changed (PurpleBuddy *buddy,
 112                                     PurpleStatus *old,
 113                                     PurpleStatus *new)
 114 {
 115     PurpleGroup *group;
 116     const char *group_name = NULL;
 117     const char *alias      = NULL;
 118
 119     g_return_if_fail(buddy != NULL);
 120     g_return_if_fail(new != NULL);
 121
 122     group = purple_buddy_get_group(buddy);
 123
 124     if (group)
 125         group_name = purple_group_get_name(group);
 126
 127     alias = purple_buddy_get_alias_only(buddy);
 128
 129     char* message = status_text_for_buddy(buddy, new);
 130     if (! message) {
 131         message = g_strdup(purple_status_get_attr_string(new, "message"));
 132     }
 133
 134     thrasher_wrapper_presence_in(thrasher_account_get_jid(buddy->account),
 135                                  purple_buddy_get_name(buddy),
 136                                  alias,
 137                                  group_name,
 138                                  purple_status_type_get_primitive(new->type),
 139                                  message);
 140     g_free(message);
 141 }
 142
 143 /* Returns a string that becomes owned by the caller or NULL. */
 144 static char*
 145 status_text_for_buddy(PurpleBuddy *buddy,
 146                       PurpleStatus *status) {
 147     if (! buddy) {
 148         return NULL;
 149     }
 150     if (! buddy->account->gc) {
 151         return NULL;
 152     }
 153
 154     const char *prpl_id = purple_account_get_protocol_id(buddy->account);
 155     if (prpl_id) {
 156         PurplePlugin *prpl = purple_find_prpl(prpl_id);
 157         if (prpl) {
 158             PurplePluginProtocolInfo *prpl_info
 159                 = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
 160             if (prpl_info && prpl_info->status_text) {
 161                 char* status_text = prpl_info->status_text(buddy);
 162                 if (status && status_text
 163                            && purple_status_is_available(status)
 164                            && 0 == strcmp(prpl_id, "prpl-icq")
 165                            && 0 == strcmp(status_text,
 166                                           purple_status_get_name(status))) {
 167                     /* The oscar prpl's status_text tries to suppress
 168                      * a redundant "Available" message, but won't if
 169                      * it's in the message attribute instead of the
 170                      * status name. libpurple's initial log on does
 171                      * not set this in the message, but subsequent
 172                      * status changes will.
 173                      */
 174                     status_text = g_strdup("");
 175                 }
 176                 return status_text;
 177             }
 178         }
 179     }
 180     return NULL;
 181 }
 182 void thrasher_buddy_authorize (const char *jid,
 183                                const char *legacy_username) {
 184     g_return_if_fail(jid);
 185     g_return_if_fail(legacy_username);
 186
 187     PurpleAccount *account = thrasher_get_account_by_jid(jid);
 188     g_return_if_fail(account);
 189
 190     PurpleConnection *gc =
 191         thrasher_get_connection_by_account(account);
 192     g_return_if_fail(gc);
 193
 194     purple_debug_info("thrasher", "Authorizing %s for jid %s (%s)\n",
 195                       legacy_username, jid,
 196                       purple_account_get_username(account));
 197
 198     // defensive; probably only add_permit is necesary
 199     serv_rem_deny(gc, legacy_username);
 200
 201     serv_add_permit(gc, legacy_username);
 202 }
 203
 204 void thrasher_buddy_deauthorize (const char *jid,
 205                                  const char *legacy_username) {
 206     g_return_if_fail(jid);
 207     g_return_if_fail(legacy_username);
 208
 209     PurpleAccount *account = thrasher_get_account_by_jid(jid);
 210     g_return_if_fail(account);
 211
 212     PurpleConnection *gc =
 213         thrasher_get_connection_by_account(account);
 214     g_return_if_fail(gc);
 215
 216     purple_debug_info("thrasher", "Deauthorizing %s for jid %s\n",
 217                       legacy_username, jid);
 218
 219     // no corresponding deny, we don't have a reperesentation for that
 220     serv_rem_permit(gc, legacy_username);
 221 }
 222
 223 void thrasher_buddy_signed_on (PurpleBuddy *buddy)
 224 {
 225     PurplePresence *presence;
 226
 227     presence = purple_buddy_get_presence(buddy);
 228
 229     if (!presence)
 230         return;
 231
 232     // libpurple uses this to populate some stuff about the
 233     // buddy, particularly useful for XMPP file transfers but
 234     // probably the cause of random other errors if we don't fill this
 235     // out.
 236     PurpleAccount* account = buddy->account;
 237     g_return_if_fail(account);
 238     PurpleConnection* connection = thrasher_connection_for_account(account);
 239     g_return_if_fail(connection);
 240
 241     purple_debug_info("thblist",
 242                       "getting server info for %s\n\n---------\n\n",
 243                       buddy->name);
 244     serv_get_info(connection, buddy->name);
 245
 246     /* Currently active status may be PURPLE_STATUS_UNAVAILABLE
 247      * (translates XMPP dnd) instead of just "available".
 248      */
 249     PurpleStatus *status = purple_presence_get_active_status(presence);
 250
 251     thrasher_buddy_status_changed(buddy,
 252                                   NULL,
 253                                   status);
 254 }
 255
 256 void thrasher_buddy_signed_off (PurpleBuddy *buddy)
 257 {
 258     PurplePresence *presence;
 259
 260     presence = purple_buddy_get_presence(buddy);
 261
 262     if (!presence)
 263         return;
 264
 265     thrasher_buddy_status_changed(buddy,
 266                                   NULL,
 267                                   purple_presence_get_status(presence, "offline"));
 268 }
 269
 270 static void * thrasher_buddy_request_authorize
 271     (PurpleAccount *account,
 272      const char *remote_user,
 273      const char *id,
 274      const char *alias,
 275      const char *message,
 276      gboolean on_list,
 277      PurpleAccountRequestAuthorizationCb authorize_cb,
 278      PurpleAccountRequestAuthorizationCb deny_cb,
 279      void *user_data) {
 280     // authorize_cb sometimes NULL?!?
 281     purple_debug_info("thrasher", "request authorize, empty cb: %s\n",
 282                       authorize_cb ? "FALSE" : "TRUE");
 283     thrasher_buddy_add_request(account, remote_user, "", alias, message);
 284
 285     if (authorize_cb) {
 286         authorize_cb(user_data);
 287     }
 288
 289     void *uihandle = NULL;
 290     return uihandle;
 291 }
 292
 293 /* thrasher_buddy_add_request
 294  *
 295  * Triggered on a buddy-added signal, this allows us to push new subscriptions.
 296  *
 297  */
 298 void thrasher_buddy_added (PurpleBuddy *buddy) {
 299     PurplePresence *presence = purple_buddy_get_presence(buddy);
 300     PurpleStatus *status     = purple_presence_get_active_status(presence);
 301     PurpleStatusType *type   = purple_status_get_type(status);
 302
 303     const char *jid = thrasher_account_get_jid(buddy->account);
 304     const char *sender = purple_buddy_get_name(buddy);
 305     const guint status_int = purple_status_type_get_primitive(type);
 306
 307     purple_debug_info("thrasher",
 308                       "buddy added to %s: %s\n",
 309                       jid, sender);
 310
 311     thrasher_wrapper_subscription_add(jid, sender, status_int);
 312 }
 313
 314
 315 void thrasher_buddy_add_request (PurpleAccount *account, const char *remote_user,
 316                            const char *id, const char *alias,
 317                            const char *message)
 318 {
 319     const char *jid = thrasher_account_get_jid(account);
 320     purple_debug_info("thrasher",
 321                       "legacy user %s aka %s added %s to roster\n",
 322                       remote_user, alias, jid);
 323     thrasher_wrapper_legacy_user_add_user(jid, remote_user);
 324 }
 325
 326
 327 void thrasher_buddy_removed (PurpleBuddy *buddy)
 328 {
 329 /*    printf("Removed buddy:\t[%s]\t[%s]\n", purple_buddy_get_name(buddy),
 330  *        purple_status_get_name( purple_presence_get_active_status( purple_buddy_get_presence(buddy) ) )
 331  *   );
 332  *
 333     PurplePresence *presence = purple_buddy_get_presence(buddy);
 334     PurpleStatus *status     = purple_presence_get_active_status(presence);
 335     PurpleStatusType *type   = purple_status_get_type(status);
 336     PurpleGroup *group       = purple_buddy_get_group(buddy);
 337
 338     * Need to fire jid, sender, group_name, alias, and status back to perl */
 339
 340     // jid = thrasher_account_get_jid(buddy->account)
 341     // sender = purple_buddy_get_name(buddy)
 342     // group_name = purple_group_get_name(group)
 343     // alias = purple_buddy_get_alias_only(buddy)
 344     // status = purple_status_type_get_primitive(type)
 345 }
 346
 347
 348 static gpointer
 349 thrasher_blist_get_handle ()
 350 {
 351     static int handle;
 352     return &handle;
 353 }
 354
 355
 356 void thrasher_blist_init()
 357 {
 358     purple_accounts_set_ui_ops(&thrasher_account_uiops);
 359
 360     purple_signal_connect(purple_blist_get_handle(),
 361                           "buddy-status-changed",
 362                           thrasher_blist_get_handle(),
 363                           PURPLE_CALLBACK(thrasher_buddy_status_changed),
 364                           NULL);
 365
 366     purple_signal_connect(purple_blist_get_handle(),
 367                           "buddy-signed-on",
 368                           thrasher_blist_get_handle(),
 369                           PURPLE_CALLBACK(thrasher_buddy_signed_on),
 370                           NULL);
 371
 372     purple_signal_connect(purple_blist_get_handle(),
 373                           "buddy-signed-off",
 374                           thrasher_blist_get_handle(),
 375                           PURPLE_CALLBACK(thrasher_buddy_signed_off),
 376                           NULL);
 377
 378     // It looks like this only comes in for things already on our roster.
 379     purple_signal_connect(purple_blist_get_handle(),
 380                           "buddy-added",
 381                           thrasher_blist_get_handle(),
 382                           PURPLE_CALLBACK(thrasher_buddy_added),
 383                           NULL);
 384
 385     /*
 386     purple_signal_connect(purple_blist_get_handle(),
 387                           "buddy-removed",
 388                           thrasher_blist_get_handle(),
 389                           PURPLE_CALLBACK(thrasher_buddy_removed),
 390                           NULL);
 391     */
 392 }
 393
 394