finch/finch.c

   1 /**
   2  * finch
   3  *
   4  * Finch 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 #include <internal.h>
  23 #include "finch.h"
  24
  25 #include "account.h"
  26 #include "conversation.h"
  27 #include "core.h"
  28 #include "debug.h"
  29 #include "eventloop.h"
  30 #include "ft.h"
  31 #include "log.h"
  32 #include "notify.h"
  33 #include "prefs.h"
  34 #include "prpl.h"
  35 #include "pounce.h"
  36 #include "savedstatuses.h"
  37 #include "sound.h"
  38 #include "status.h"
  39 #include "util.h"
  40 #include "whiteboard.h"
  41
  42 #include "gntdebug.h"
  43 #include "gntprefs.h"
  44 #include "gntui.h"
  45 #include "gntidle.h"
  46
  47 #define _GNU_SOURCE
  48 #include <getopt.h>
  49
  50 #include "config.h"
  51 #include "package_revision.h"
  52
  53 static void
  54 debug_init(void)
  55 {
  56         finch_debug_init();
  57         purple_debug_set_ui_ops(finch_debug_get_ui_ops());
  58 }
  59
  60 static GHashTable *ui_info = NULL;
  61 static GHashTable *finch_ui_get_info(void)
  62 {
  63         if (ui_info == NULL) {
  64                 ui_info = g_hash_table_new(g_str_hash, g_str_equal);
  65
  66                 g_hash_table_insert(ui_info, "name", (char*)_("Finch"));
  67                 g_hash_table_insert(ui_info, "version", VERSION);
  68                 g_hash_table_insert(ui_info, "website", "http://pidgin.im");
  69                 g_hash_table_insert(ui_info, "dev_website", "http://developer.pidgin.im");
  70                 g_hash_table_insert(ui_info, "client_type", "console");
  71
  72                 /*
  73                  * This is the client key for "Finch."  It is owned by the AIM
  74                  * account "markdoliner."  Please don't use this key for other
  75                  * applications.  You can either not specify a client key, in
  76                  * which case the default "libpurple" key will be used, or you
  77                  * can register for your own client key at
  78                  * http://developer.aim.com/manageKeys.jsp
  79                  */
  80                 g_hash_table_insert(ui_info, "prpl-aim-clientkey", "ma19sqWV9ymU6UYc");
  81                 g_hash_table_insert(ui_info, "prpl-icq-clientkey", "ma19sqWV9ymU6UYc");
  82
  83                 /*
  84                  * This is the distid for Finch, given to us by AOL.  Please
  85                  * don't use this for other applications.  You can just not
  86                  * specify a distid and libpurple will use a default.
  87                  */
  88                 g_hash_table_insert(ui_info, "prpl-aim-distid", GINT_TO_POINTER(1552));
  89                 g_hash_table_insert(ui_info, "prpl-icq-distid", GINT_TO_POINTER(1552));
  90         }
  91
  92         return ui_info;
  93 }
  94
  95 static void
  96 finch_quit(void)
  97 {
  98         gnt_ui_uninit();
  99         if (ui_info)
 100                 g_hash_table_destroy(ui_info);
 101 }
 102
 103 static PurpleCoreUiOps core_ops =
 104 {
 105         finch_prefs_init,
 106         debug_init,
 107         gnt_ui_init,
 108         finch_quit,
 109         finch_ui_get_info,
 110
 111         /* padding */
 112         NULL,
 113         NULL,
 114         NULL
 115 };
 116
 117 static PurpleCoreUiOps *
 118 gnt_core_get_ui_ops(void)
 119 {
 120         return &core_ops;
 121 }
 122
 123 /* Anything IO-related is directly copied from gtkpurple's source tree */
 124
 125 #define FINCH_READ_COND  (G_IO_IN | G_IO_HUP | G_IO_ERR)
 126 #define FINCH_WRITE_COND (G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL)
 127
 128 typedef struct _PurpleGntIOClosure {
 129         PurpleInputFunction function;
 130         guint result;
 131         gpointer data;
 132
 133 } PurpleGntIOClosure;
 134
 135 static void purple_gnt_io_destroy(gpointer data)
 136 {
 137         g_free(data);
 138 }
 139
 140 static gboolean purple_gnt_io_invoke(GIOChannel *source, GIOCondition condition, gpointer data)
 141 {
 142         PurpleGntIOClosure *closure = data;
 143         PurpleInputCondition purple_cond = 0;
 144
 145         if (condition & FINCH_READ_COND)
 146                 purple_cond |= PURPLE_INPUT_READ;
 147         if (condition & FINCH_WRITE_COND)
 148                 purple_cond |= PURPLE_INPUT_WRITE;
 149
 150 #if 0
 151         purple_debug(PURPLE_DEBUG_MISC, "gtk_eventloop",
 152                            "CLOSURE: callback for %d, fd is %d\n",
 153                            closure->result, g_io_channel_unix_get_fd(source));
 154 #endif
 155
 156 #ifdef _WIN32
 157         if(! purple_cond) {
 158 #if DEBUG
 159                 purple_debug_misc("gnt_eventloop",
 160                            "CLOSURE received GIOCondition of 0x%x, which does not"
 161                            " match 0x%x (READ) or 0x%x (WRITE)\n",
 162                            condition, FINCH_READ_COND, FINCH_WRITE_COND);
 163 #endif /* DEBUG */
 164
 165                 return TRUE;
 166         }
 167 #endif /* _WIN32 */
 168
 169         closure->function(closure->data, g_io_channel_unix_get_fd(source),
 170                           purple_cond);
 171
 172         return TRUE;
 173 }
 174
 175 static guint gnt_input_add(gint fd, PurpleInputCondition condition, PurpleInputFunction function,
 176                                                            gpointer data)
 177 {
 178         PurpleGntIOClosure *closure = g_new0(PurpleGntIOClosure, 1);
 179         GIOChannel *channel;
 180         GIOCondition cond = 0;
 181
 182         closure->function = function;
 183         closure->data = data;
 184
 185         if (condition & PURPLE_INPUT_READ)
 186                 cond |= FINCH_READ_COND;
 187         if (condition & PURPLE_INPUT_WRITE)
 188                 cond |= FINCH_WRITE_COND;
 189
 190         channel = g_io_channel_unix_new(fd);
 191         closure->result = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, cond,
 192                                               purple_gnt_io_invoke, closure, purple_gnt_io_destroy);
 193
 194         g_io_channel_unref(channel);
 195         return closure->result;
 196 }
 197
 198 static PurpleEventLoopUiOps eventloop_ops =
 199 {
 200         g_timeout_add,
 201         g_source_remove,
 202         gnt_input_add,
 203         g_source_remove,
 204         NULL, /* input_get_error */
 205 #if GLIB_CHECK_VERSION(2,14,0)
 206         g_timeout_add_seconds,
 207 #else
 208         NULL,
 209 #endif
 210
 211         /* padding */
 212         NULL,
 213         NULL,
 214         NULL
 215 };
 216
 217 static PurpleEventLoopUiOps *
 218 gnt_eventloop_get_ui_ops(void)
 219 {
 220         return &eventloop_ops;
 221 }
 222
 223 /* This is mostly copied from gtkpurple's source tree */
 224 static void
 225 show_usage(const char *name, gboolean terse)
 226 {
 227         char *text;
 228
 229         if (terse) {
 230                 text = g_strdup_printf(_("%s. Try `%s -h' for more information.\n"), DISPLAY_VERSION, name);
 231         } else {
 232                 text = g_strdup_printf(_("%s\n"
 233                        "Usage: %s [OPTION]...\n\n"
 234                        "  -c, --config=DIR    use DIR for config files\n"
 235                        "  -d, --debug         print debugging messages to stderr\n"
 236                        "  -h, --help          display this help and exit\n"
 237                        "  -n, --nologin       don't automatically login\n"
 238                        "  -v, --version       display the current version and exit\n"), DISPLAY_VERSION, name);
 239         }
 240
 241         purple_print_utf8_to_console(stdout, text);
 242         g_free(text);
 243 }
 244
 245 static int
 246 init_libpurple(int argc, char **argv)
 247 {
 248         char *path;
 249         int opt;
 250         gboolean opt_help = FALSE;
 251         gboolean opt_nologin = FALSE;
 252         gboolean opt_version = FALSE;
 253         char *opt_config_dir_arg = NULL;
 254         gboolean debug_enabled = FALSE;
 255
 256         struct option long_options[] = {
 257                 {"config",   required_argument, NULL, 'c'},
 258                 {"debug",    no_argument,       NULL, 'd'},
 259                 {"help",     no_argument,       NULL, 'h'},
 260                 {"nologin",  no_argument,       NULL, 'n'},
 261                 {"version",  no_argument,       NULL, 'v'},
 262                 {0, 0, 0, 0}
 263         };
 264
 265 #ifdef ENABLE_NLS
 266         bindtextdomain(PACKAGE, LOCALEDIR);
 267         bind_textdomain_codeset(PACKAGE, "UTF-8");
 268         textdomain(PACKAGE);
 269 #endif
 270
 271 #ifdef HAVE_SETLOCALE
 272         setlocale(LC_ALL, "");
 273 #endif
 274
 275         /* scan command-line options */
 276         opterr = 1;
 277         while ((opt = getopt_long(argc, argv,
 278 #ifndef _WIN32
 279                                   "c:dhn::v",
 280 #else
 281                                   "c:dhn::v",
 282 #endif
 283                                   long_options, NULL)) != -1) {
 284                 switch (opt) {
 285                 case 'c':       /* config dir */
 286                         g_free(opt_config_dir_arg);
 287                         opt_config_dir_arg = g_strdup(optarg);
 288                         break;
 289                 case 'd':       /* debug */
 290                         debug_enabled = TRUE;
 291                         break;
 292                 case 'h':       /* help */
 293                         opt_help = TRUE;
 294                         break;
 295                 case 'n':       /* no autologin */
 296                         opt_nologin = TRUE;
 297                         break;
 298                 case 'v':       /* version */
 299                         opt_version = TRUE;
 300                         break;
 301                 case '?':       /* show terse help */
 302                 default:
 303                         show_usage(argv[0], TRUE);
 304                         return 0;
 305                         break;
 306                 }
 307         }
 308
 309         /* show help message */
 310         if (opt_help) {
 311                 show_usage(argv[0], FALSE);
 312                 return 0;
 313         }
 314         /* show version message */
 315         if (opt_version) {
 316                 /* Translators may want to transliterate the name.
 317                  It is not to be translated. */
 318                 printf("%s %s (%s)\n", _("Finch"), DISPLAY_VERSION, REVISION);
 319                 return 0;
 320         }
 321
 322         /* set a user-specified config directory */
 323         if (opt_config_dir_arg != NULL) {
 324                 purple_util_set_user_dir(opt_config_dir_arg);
 325                 g_free(opt_config_dir_arg);
 326         }
 327
 328         /*
 329          * We're done piddling around with command line arguments.
 330          * Fire up this baby.
 331          */
 332
 333         /* We don't want debug-messages to show up and corrupt the display */
 334         purple_debug_set_enabled(debug_enabled);
 335
 336         /* If we're using a custom configuration directory, we
 337          * do NOT want to migrate, or weird things will happen. */
 338         if (opt_config_dir_arg == NULL)
 339         {
 340                 if (!purple_core_migrate())
 341                 {
 342                         char *old = g_strconcat(purple_home_dir(),
 343                                                 G_DIR_SEPARATOR_S ".gaim", NULL);
 344                         char *text = g_strdup_printf(_(
 345                                 "%s encountered errors migrating your settings "
 346                                 "from %s to %s. Please investigate and complete the "
 347                                 "migration by hand. Please report this error at http://developer.pidgin.im"), _("Finch"),
 348                                 old, purple_user_dir());
 349
 350                         g_free(old);
 351
 352                         purple_print_utf8_to_console(stderr, text);
 353                         g_free(text);
 354
 355                         return 0;
 356                 }
 357         }
 358
 359         purple_core_set_ui_ops(gnt_core_get_ui_ops());
 360         purple_eventloop_set_ui_ops(gnt_eventloop_get_ui_ops());
 361         purple_idle_set_ui_ops(finch_idle_get_ui_ops());
 362
 363         path = g_build_filename(purple_user_dir(), "plugins", NULL);
 364         purple_plugins_add_search_path(path);
 365         g_free(path);
 366
 367         purple_plugins_add_search_path(LIBDIR);
 368
 369         if (!purple_core_init(FINCH_UI))
 370         {
 371                 fprintf(stderr,
 372                                 "Initialization of the Purple core failed. Dumping core.\n"
 373                                 "Please report this!\n");
 374                 abort();
 375         }
 376
 377         /* TODO: Move blist loading into purple_blist_init() */
 378         purple_set_blist(purple_blist_new());
 379         purple_blist_load();
 380
 381         /* TODO: should this be moved into finch_prefs_init() ? */
 382         finch_prefs_update_old();
 383
 384         /* load plugins we had when we quit */
 385         purple_plugins_load_saved("/finch/plugins/loaded");
 386
 387         /* TODO: Move pounces loading into purple_pounces_init() */
 388         purple_pounces_load();
 389
 390         if (opt_nologin)
 391         {
 392                 /* Set all accounts to "offline" */
 393                 PurpleSavedStatus *saved_status;
 394
 395                 /* If we've used this type+message before, lookup the transient status */
 396                 saved_status = purple_savedstatus_find_transient_by_type_and_message(
 397                                                         PURPLE_STATUS_OFFLINE, NULL);
 398
 399                 /* If this type+message is unique then create a new transient saved status */
 400                 if (saved_status == NULL)
 401                         saved_status = purple_savedstatus_new(NULL, PURPLE_STATUS_OFFLINE);
 402
 403                 /* Set the status for each account */
 404                 purple_savedstatus_activate(saved_status);
 405         }
 406         else
 407         {
 408                 /* Everything is good to go--sign on already */
 409                 if (!purple_prefs_get_bool("/purple/savedstatus/startup_current_status"))
 410                         purple_savedstatus_activate(purple_savedstatus_get_startup());
 411                 purple_accounts_restore_current_statuses();
 412         }
 413
 414         return 1;
 415 }
 416
 417 static gboolean gnt_start(int *argc, char ***argv)
 418 {
 419         /* Initialize the libpurple stuff */
 420         if (!init_libpurple(*argc, *argv))
 421                 return FALSE;
 422
 423         purple_blist_show();
 424         return TRUE;
 425 }
 426
 427 int main(int argc, char *argv[])
 428 {
 429         signal(SIGPIPE, SIG_IGN);
 430
 431         g_thread_init(NULL);
 432
 433         g_set_prgname("Finch");
 434         g_set_application_name(_("Finch"));
 435
 436         if (gnt_start(&argc, &argv)) {
 437                 gnt_main();
 438
 439 #ifdef STANDALONE
 440                 purple_core_quit();
 441 #endif
 442         }
 443
 444         return 0;
 445 }
 446