thrasher.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 <glib.h>
  20 #include <signal.h>
  21 #include <string.h>
  22 #include <unistd.h>
  23 #include <sys/socket.h>
  24
  25 #include "purple.h"
  26 #include "thrasher.h"
  27 #include "thblist.h"
  28 #include "thconnection.h"
  29 #include "thperl.h"
  30 #include "thft.h"
  31 #include "threquest.h"
  32 #include "thconversations.h"
  33
  34 GHashTable *account_to_connection = NULL;
  35 GHashTable *jid_to_account = NULL;
  36
  37 void debug_print(PurpleDebugLevel level, const char *category, const char *arg_s);
  38 gboolean is_enabled(PurpleDebugLevel level, const char *category);
  39
  40 static PurpleEventLoopUiOps glib_eventloops =
  41 {
  42     thrasher_wrapper_set_timeout_add,
  43     thrasher_wrapper_call_source_remove,
  44     thrasher_wrapper_set_input_add,
  45     thrasher_wrapper_call_source_remove,
  46     NULL,
  47     NULL,
  48
  49     /* padding */
  50     NULL,
  51     NULL,
  52     NULL
  53 };
  54 static PurpleCoreUiOps thrasher_core_uiops =
  55 {
  56     NULL,
  57     NULL,
  58     NULL,
  59     NULL,
  60
  61     /* padding */
  62     NULL,
  63     NULL,
  64     NULL,
  65     NULL
  66 };
  67
  68
  69 static PurpleConnectionUiOps thrasher_conn_uiops =
  70 {
  71     // connect progress
  72     NULL,
  73     // connected,
  74     thrasher_connection,
  75     // disconnected
  76     NULL,
  77     // connection-specific notices, effectively unused
  78     NULL,
  79     // report disconnect
  80     NULL,
  81     // computer network connected
  82     NULL,
  83     // computer network disconnected
  84     NULL,
  85     // report disconnect reason
  86     NULL,
  87     // reserved 1
  88     NULL,
  89     // reserved 2
  90     NULL,
  91     // reserved 3
  92     NULL
  93 };
  94
  95 void thrasher_init()
  96 {
  97      purple_core_set_ui_ops(&thrasher_core_uiops);
  98      purple_eventloop_set_ui_ops(&glib_eventloops);
  99      purple_connections_set_ui_ops(&thrasher_conn_uiops);
 100
 101      if (!purple_core_init(UI_ID))
 102           error(EXIT_FAILURE, 0, "libpurple init failed");
 103
 104      thrasher_blist_init();
 105      thrasher_connection_init();
 106      thrasher_xfer_init();
 107      thrasher_perl_init();
 108      thrasher_request_init();
 109      thrasher_conversations_init();
 110
 111      // This hash table has no ownership on the pointers stored in it
 112      account_to_connection = g_hash_table_new(g_direct_hash,
 113                                               g_direct_equal);
 114      // Automatically cleans up keys, does not own stored pointers
 115      jid_to_account = g_hash_table_new_full(g_str_hash, g_str_equal,
 116                                             g_free, NULL);
 117
 118      purple_set_blist(purple_blist_new());
 119
 120      purple_signal_connect(purple_connections_get_handle(),
 121                            "signing-off",
 122                            thrasher_connection_get_handle(),
 123                            PURPLE_CALLBACK(thrasher_signing_off_cb),
 124                            NULL);
 125 }
 126
 127 void thrasher_whoami (PurpleAccount * pa)
 128 {
 129     if (pa)
 130         purple_debug_info("thrasher",
 131                           "You are user [%s]\n",
 132                           pa->username);
 133 }
 134
 135 void thrasher_signing_off_cb(PurpleConnection *gc) {
 136     g_return_if_fail(gc);
 137
 138     PurpleAccount* pa = purple_connection_get_account(gc);
 139     g_return_if_fail(pa);
 140
 141     if (g_hash_table_lookup(account_to_connection, pa)) {
 142         char *jid = thrasher_account_get_jid(pa);
 143         g_hash_table_remove(jid_to_account, jid);
 144         g_hash_table_remove(account_to_connection, pa);
 145     }
 146 }
 147
 148 void
 149 thrasher_logout (PurpleAccount *pa)
 150 {
 151     g_return_if_fail(pa);
 152
 153     purple_account_set_enabled(pa, UI_ID, FALSE);
 154
 155     // Only disconnect if we haven't already
 156     if (g_hash_table_lookup(account_to_connection, pa)) {
 157         purple_account_disconnect(pa);
 158     } else {
 159         purple_debug_info("thrasher",
 160                           "Declined to log out unconnected account\n");
 161     }
 162
 163     if (pa->ui_data) {
 164         Thrasher_PurpleAccount_UI_Data* ui_data = pa->ui_data;
 165         pa->ui_data = NULL;
 166         g_hash_table_destroy(ui_data->pending_send_file);
 167         g_free(ui_data);
 168     }
 169 }
 170
 171 PurpleAccount * thrasher_get_account_by_jid(const char* jid) {
 172     g_return_val_if_fail(jid, NULL);
 173     return g_hash_table_lookup(jid_to_account, jid);
 174 }
 175
 176 PurpleConnection * thrasher_get_connection_by_account
 177     (const PurpleAccount* account) {
 178     g_return_val_if_fail(account, NULL);
 179     return g_hash_table_lookup(account_to_connection, account);
 180 }
 181
 182 // An error can occur during the login, when the protocol decides
 183 // there's going to be a connection error before it even returns the
 184 // connection to us. In that case, our user data won't exist on the
 185 // connection, but the connection error still needs to propagate back
 186 // to the user. In that case, we use this value. This rather ties
 187 // us to a single thread.
 188
 189 static char *current_login_jid = NULL;
 190 static uint got_error = 0;
 191
 192 char * get_current_login_jid () {
 193     return current_login_jid;
 194 }
 195
 196 void set_got_error (uint new_val) {
 197     got_error = new_val;
 198 }
 199
 200 PurpleAccount *
 201 thrasher_login (char *service, char *username, char *password, char *jid,
 202                 GHashTable *other_args)
 203 {
 204     got_error = 0;
 205     current_login_jid = jid;
 206     gchar *user_dir;
 207
 208     if (purple_get_core() == 0)
 209         error(EXIT_FAILURE, 0, "Purple core is uninitialized");
 210
 211     purple_debug_info("thrasher",
 212                       "Thrasher login initiated\n");
 213
 214     /* Test service for validity */
 215
 216     /* Test user for validity */
 217     /* We need to verify there is NO path redirection in the user name! */
 218     /* We also need to verify username is NOT longer than MAX_NAME_LEN */
 219
 220     /* Test password for validity */
 221
 222
 223     /* Validate the root_dir and build us a filename */
 224     user_dir = g_build_filename(USER_ROOT_DIR, service, username, NULL);
 225
 226     purple_util_set_user_dir(user_dir);
 227
 228     g_free(user_dir);
 229
 230     PurpleAccount *account;
 231     PurpleSavedStatus *status;
 232
 233     /* Need to research these... */
 234     purple_blist_load();
 235     purple_prefs_load();
 236     purple_pounces_load(); /* Don't believe we need this */
 237
 238     /* Setup the account and throw it back */
 239     account = purple_account_new(username, service);
 240     g_hash_table_insert(jid_to_account, g_strdup(jid), account);
 241     purple_account_set_password(account, password);
 242
 243     Thrasher_PurpleAccount_UI_Data* ui_data
 244         = g_new(Thrasher_PurpleAccount_UI_Data, 1);
 245     ui_data->jid = g_strdup(jid); /* Store the JID with the account */
 246     ui_data->pending_send_file = g_hash_table_new(g_str_hash,
 247                                                   g_str_equal);
 248     account->ui_data = ui_data;
 249
 250     if (other_args) {
 251         GHashTableIter iter;
 252         gpointer key, value;
 253         char *char_key, *char_value;
 254
 255         g_hash_table_iter_init(&iter, other_args);
 256         while (g_hash_table_iter_next(&iter, &key, &value)) {
 257             char_value = (char *)value;
 258             char_key = (char *)key;
 259             if (!strncmp(key, "int_", 4))
 260             {
 261                 char_key += 4;
 262                 int int_value = atoi(char_value);
 263                 purple_debug_info("thrasher",
 264                                   "Setting account #: %s -> %d\n",
 265                                   char_key, int_value);
 266                 purple_account_set_int(account, char_key, atoi(char_value));
 267             } else if (!strncmp(key, "bool_", 5)) {
 268                 char_key += 5;
 269                 int value = (*char_value == '0' ||
 270                              *char_value == 0) ? FALSE: TRUE;
 271                 purple_debug_info("thrasher",
 272                                   "Setting account bool: %s -> %d\n",
 273                                   char_key, value);
 274                 purple_account_set_bool(account, char_key, value);
 275             } else {
 276                 purple_debug_info("thrasher",
 277                                   "Setting account string: %s -> %s\n",
 278                                   char_key, char_value);
 279                 purple_account_set_string(account, char_key,
 280                                           char_value);
 281             }
 282         }
 283     }
 284
 285     purple_account_set_enabled(account, UI_ID, TRUE);
 286     status = purple_savedstatus_new(NULL, PURPLE_STATUS_AVAILABLE);
 287     purple_savedstatus_activate(status);
 288
 289     current_login_jid = NULL;
 290
 291     if (got_error) {
 292         purple_debug_info("thrasher",
 293                           "got an error during initial login\n");
 294         return NULL;
 295     }
 296
 297 #ifdef TH_DEBUG
 298     purple_debug_info("thrasher",
 299                       "Supported protocols\n");
 300     GList *iter; int i;
 301     iter = purple_plugins_get_protocols();
 302     for (i = 0; iter; iter = iter->next) {
 303         PurplePlugin *plugin = iter->data;
 304         PurplePluginInfo *info = plugin->info;
 305         if (info && info->name) {
 306             purple_debug_info("thrasher",
 307                               "\t%d: %s\n",
 308                               i++,
 309                               info->name);
 310         }
 311     }
 312 #endif
 313
 314
 315 /* Not sure how I got in this state, but write a catch nonetheless */
 316     if (!purple_plugins_get_protocols())
 317         error(EXIT_FAILURE, 0, "libpurple reports NO supported protocols, this is a BAD thing");
 318
 319     return account;
 320 }
 321
 322 /*
 323  * How to send message to remote user
 324  *
 325  * pa      = PurpleAccount ptr
 326  * name    = recipient name char*
 327  * message = message char*
 328  *
 329  * If the conversation data can be created this returns TRUE, else it returns FALSE
 330  *
 331  * Get the conversation if it already exists
 332  * (Per the code flow, we may be able to set type to NULL and let it figure it out.)
 333 */
 334
 335 gboolean
 336 thrasher_send_msg (PurpleAccount *pa, const char *name, const char *message)
 337 {
 338     PurpleConversation *conv = thrasher_find_conversation_with_account(pa,
 339                                                                        name);
 340     PurpleConvIm       *im;
 341
 342     /* Get the IM specific data */
 343     im = purple_conversation_get_im_data(conv);
 344
 345     if (im) {
 346         purple_conv_im_send(im, message);
 347         return TRUE;
 348     }
 349
 350     purple_debug_info("thrasher",
 351                       "Failed in purple_conv_im_send\n");
 352
 353     return FALSE;
 354 }
 355
 356 void thrasher_connection (PurpleConnection *conn)
 357 {
 358      PurpleAccount *account = purple_connection_get_account(conn);
 359
 360      g_hash_table_insert(account_to_connection, account, conn);
 361
 362      thrasher_wrapper_connection(thrasher_account_get_jid(account));
 363 }
 364
 365 PurpleConnection* thrasher_connection_for_account(PurpleAccount
 366                                                   *account) {
 367     g_return_val_if_fail(account, NULL);
 368
 369     return g_hash_table_lookup(account_to_connection, account);
 370 }
 371
 372 /*
 373  * thrasher_account_get_jid
 374  */
 375 gchar*
 376 thrasher_account_get_jid(PurpleAccount *account)
 377 {
 378     g_return_val_if_fail(account, NULL);
 379
 380     Thrasher_PurpleAccount_UI_Data* ui_data = account->ui_data;
 381     return ui_data->jid;
 382 }
 383
 384 /*
 385  * thrasher_account_get_pending_send_file
 386  */
 387 GHashTable*
 388 thrasher_account_get_pending_send_file(PurpleAccount *account) {
 389     g_return_val_if_fail(account, NULL);
 390
 391     Thrasher_PurpleAccount_UI_Data* ui_data = account->ui_data;
 392     g_return_val_if_fail(ui_data, NULL);
 393     return ui_data->pending_send_file;
 394 }