HGKeeper

/**

* @file core.c Purple Core API

* @ingroup core

/* purple

* Purple is the legal property of its developers, whose names are too numerous

* to list here. Please refer to the COPYRIGHT file distributed with this

* source distribution.

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA

#include "internal.h"

#include "cipher.h"

#include "certificate.h"

#include "cmds.h"

#include "connection.h"

#include "conversation.h"

#include "core.h"

#include "debug.h"

#include "dnsquery.h"

#include "ft.h"

#include "idle.h"

#include "imgstore.h"

#include "network.h"

#include "notify.h"

#include "plugin.h"

#include "pounce.h"

#include "prefs.h"

#include "privacy.h"

#include "proxy.h"

#include "savedstatuses.h"

#include "signals.h"

#include "smiley.h"

#include "sound.h"

#include "sound-theme-loader.h"

#include "sslconn.h"

#include "status.h"

#include "stun.h"

#include "theme-manager.h"

#include "util.h"

#ifdef HAVE_DBUS

# ifndef DBUS_API_SUBJECT_TO_CHANGE

# define DBUS_API_SUBJECT_TO_CHANGE

# endif

# include <dbus/dbus.h>

# include "dbus-purple.h"

# include "dbus-server.h"

# include "dbus-bindings.h"

#endif

struct PurpleCore

{

char *ui;

void *reserved;

};

static PurpleCoreUiOps *_ops = NULL;

static PurpleCore *_core = NULL;

STATIC_PROTO_INIT

gboolean

purple_core_init(const char *ui)

{

PurpleCoreUiOps *ops;

PurpleCore *core;

g_return_val_if_fail(ui != NULL, FALSE);

g_return_val_if_fail(purple_get_core() == NULL, FALSE);

#ifdef ENABLE_NLS

bindtextdomain(PACKAGE, LOCALEDIR);

#endif

#ifdef _WIN32

wpurple_init();

#endif

#if !GLIB_CHECK_VERSION(2, 36, 0)

/* GLib type system is automaticaly initialized since 2.36. */

g_type_init();

#endif

_core = core = g_new0(PurpleCore, 1);

core->ui = g_strdup(ui);

core->reserved = NULL;

ops = purple_core_get_ui_ops();

/* The signals subsystem is important and should be first. */

purple_signals_init();

purple_util_init();

purple_signal_register(core, "uri-handler",

purple_marshal_BOOLEAN__POINTER_POINTER_POINTER,

purple_value_new(PURPLE_TYPE_BOOLEAN), 3,

purple_value_new(PURPLE_TYPE_STRING), /* Protocol */

purple_value_new(PURPLE_TYPE_STRING), /* Command */

purple_value_new(PURPLE_TYPE_BOXED, "GHashTable *")); /* Parameters */

purple_signal_register(core, "quitting", purple_marshal_VOID, NULL, 0);

/* The prefs subsystem needs to be initialized before static protocols

* for protocol prefs to work. */

purple_prefs_init();

purple_debug_init();

if (ops != NULL)

{

if (ops->ui_prefs_init != NULL)

ops->ui_prefs_init();

if (ops->debug_ui_init != NULL)

ops->debug_ui_init();

}

#ifdef HAVE_DBUS

purple_dbus_init();

#endif

purple_ciphers_init();

purple_cmds_init();

/* Since plugins get probed so early we should probably initialize their

* subsystem right away too.

purple_plugins_init();

/* Initialize all static protocols. */

static_proto_init();

purple_plugins_probe(G_MODULE_SUFFIX);

purple_theme_manager_init();

/* The buddy icon code uses the imgstore, so init it early. */

purple_imgstore_init();

/* Accounts use status, buddy icons and connection signals, so

* initialize these before accounts

purple_status_init();

purple_buddy_icons_init();

purple_connections_init();

purple_accounts_init();

purple_savedstatuses_init();

purple_notify_init();

purple_certificate_init();

purple_conversations_init();

purple_blist_init();

purple_log_init();

purple_network_init();

purple_privacy_init();

purple_pounces_init();

purple_proxy_init();

purple_dnsquery_init();

purple_sound_init();

purple_ssl_init();

purple_stun_init();

purple_xfers_init();

purple_idle_init();

purple_smileys_init();

* Call this early on to try to auto-detect our IP address and

* hopefully save some time later.

purple_network_get_my_ip(-1);

if (ops != NULL && ops->ui_init != NULL)

ops->ui_init();

/* The UI may have registered some theme types, so refresh them */

purple_theme_manager_refresh();

return TRUE;

}

void

purple_core_quit(void)

{

PurpleCoreUiOps *ops;

PurpleCore *core = purple_get_core();

g_return_if_fail(core != NULL);

/* The self destruct sequence has been initiated */

purple_signal_emit(purple_get_core(), "quitting");

/* Transmission ends */

purple_connections_disconnect_all();

* Certificates must be destroyed before the SSL plugins, because

* PurpleCertificates contain pointers to PurpleCertificateSchemes,

* and the PurpleCertificateSchemes will be unregistered when the

* SSL plugin is uninit.

purple_certificate_uninit();

/* The SSL plugins must be uninit before they're unloaded */

purple_ssl_uninit();

/* Unload all non-loader, non-prpl plugins before shutting down

* subsystems. */

purple_debug_info("main", "Unloading normal plugins\n");

purple_plugins_unload(PURPLE_PLUGIN_STANDARD);

/* Save .xml files, remove signals, etc. */

purple_smileys_uninit();

purple_idle_uninit();

purple_pounces_uninit();

purple_blist_uninit();

purple_ciphers_uninit();

purple_notify_uninit();

purple_conversations_uninit();

purple_connections_uninit();

purple_buddy_icons_uninit();

purple_savedstatuses_uninit();

purple_status_uninit();

purple_accounts_uninit();

purple_sound_uninit();

purple_theme_manager_uninit();

purple_xfers_uninit();

purple_proxy_uninit();

purple_dnsquery_uninit();

purple_imgstore_uninit();

purple_network_uninit();

/* Everything after unloading all plugins must not fail if prpls aren't

* around */

purple_debug_info("main", "Unloading all plugins\n");

purple_plugins_destroy_all();

ops = purple_core_get_ui_ops();

if (ops != NULL && ops->quit != NULL)

ops->quit();

/* Everything after prefs_uninit must not try to read any prefs */

purple_prefs_uninit();

purple_plugins_uninit();

#ifdef HAVE_DBUS

purple_dbus_uninit();

#endif

purple_cmds_uninit();

/* Everything after util_uninit cannot try to write things to the confdir */

purple_util_uninit();

purple_log_uninit();

purple_signals_uninit();

g_free(core->ui);

g_free(core);

#ifdef _WIN32

wpurple_cleanup();

#endif

_core = NULL;

}

gboolean

purple_core_quit_cb(gpointer unused)

{

purple_core_quit();

return FALSE;

}

const char *

purple_core_get_version(void)

{

return VERSION;

}

const char *

purple_core_get_ui(void)

{

PurpleCore *core = purple_get_core();

g_return_val_if_fail(core != NULL, NULL);

return core->ui;

}

PurpleCore *

purple_get_core(void)

{

return _core;

}

void

purple_core_set_ui_ops(PurpleCoreUiOps *ops)

{

_ops = ops;

}

PurpleCoreUiOps *

purple_core_get_ui_ops(void)

{

return _ops;

}

#ifdef HAVE_DBUS

static char *purple_dbus_owner_user_dir(void)

{

DBusMessage *msg = NULL, *reply = NULL;

DBusConnection *dbus_connection = NULL;

DBusError dbus_error;

char *remote_user_dir = NULL;

if ((dbus_connection = purple_dbus_get_connection()) == NULL)

return NULL;

if ((msg = dbus_message_new_method_call(DBUS_SERVICE_PURPLE, DBUS_PATH_PURPLE, DBUS_INTERFACE_PURPLE, "PurpleUserDir")) == NULL)

return NULL;

dbus_error_init(&dbus_error);

reply = dbus_connection_send_with_reply_and_block(dbus_connection, msg, 5000, &dbus_error);

dbus_message_unref(msg);

dbus_error_free(&dbus_error);

if (reply)

{

dbus_error_init(&dbus_error);

dbus_message_get_args(reply, &dbus_error, DBUS_TYPE_STRING, &remote_user_dir, DBUS_TYPE_INVALID);

remote_user_dir = g_strdup(remote_user_dir);

dbus_error_free(&dbus_error);

dbus_message_unref(reply);

}

return remote_user_dir;

}

#endif /* HAVE_DBUS */

gboolean

purple_core_ensure_single_instance()

{

gboolean is_single_instance = TRUE;

#ifdef HAVE_DBUS

/* in the future, other mechanisms might have already set this to FALSE */

if (is_single_instance)

{

if (!purple_dbus_is_owner())

{

const char *user_dir = purple_user_dir();

char *dbus_owner_user_dir = purple_dbus_owner_user_dir();

is_single_instance = !purple_strequal(dbus_owner_user_dir, user_dir);

g_free(dbus_owner_user_dir);

}

#endif /* HAVE_DBUS */

return is_single_instance;

}

static gboolean

move_and_symlink_dir(const char *path, const char *basename, const char *old_base, const char *new_base, const char *relative)

{

char *new_name = g_build_filename(new_base, basename, NULL);

#ifndef _WIN32

char *old_name;

#endif

if (g_rename(path, new_name))

{

purple_debug_error("core", "Error renaming %s to %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

path, new_name, g_strerror(errno));

g_free(new_name);

return FALSE;

}

g_free(new_name);

#ifndef _WIN32

/* NOTE: This new_name is relative. */

new_name = g_build_filename(relative, basename, NULL);

old_name = g_build_filename(old_base, basename, NULL);

if (symlink(new_name, old_name))

{

purple_debug_warning("core", "Error symlinking %s to %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

old_name, new_name, g_strerror(errno));

}

g_free(old_name);

g_free(new_name);

#endif

return TRUE;

}

gboolean

purple_core_migrate(void)

{

const char *user_dir = purple_user_dir();

char *old_user_dir = g_strconcat(purple_home_dir(),

G_DIR_SEPARATOR_S ".gaim", NULL);

char *status_file;

FILE *fp;

GDir *dir;

GError *err;

const char *entry;

#ifndef _WIN32

char *logs_dir;

#endif

char *old_icons_dir;

if (!g_file_test(old_user_dir, G_FILE_TEST_EXISTS))

{

/* ~/.gaim doesn't exist, so there's nothing to migrate. */

g_free(old_user_dir);

return TRUE;

}

status_file = g_strconcat(user_dir, G_DIR_SEPARATOR_S "migrating", NULL);

if (g_file_test(user_dir, G_FILE_TEST_EXISTS))

{

/* If we're here, we have both ~/.gaim and .purple. */

if (!g_file_test(status_file, G_FILE_TEST_EXISTS))

{

/* There's no "migrating" status file,

* so ~/.purple is all up to date. */

g_free(status_file);

g_free(old_user_dir);

return TRUE;

}

/* If we're here, it's time to migrate from ~/.gaim to ~/.purple. */

/* Ensure the user directory exists */

if (!g_file_test(user_dir, G_FILE_TEST_IS_DIR))

{

if (g_mkdir(user_dir, S_IRUSR | S_IWUSR | S_IXUSR) == -1)

{

purple_debug_error("core", "Error creating directory %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

user_dir, g_strerror(errno));

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

/* This writes ~/.purple/migrating, which allows us to detect

* incomplete migrations and properly retry. */

if (!(fp = g_fopen(status_file, "w")))

{

purple_debug_error("core", "Error opening file %s for writing: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

status_file, g_strerror(errno));

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

fclose(fp);

/* Open ~/.gaim so we can loop over its contents. */

err = NULL;

if (!(dir = g_dir_open(old_user_dir, 0, &err)))

{

purple_debug_error("core", "Error opening directory %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

status_file,

(err ? err->message : "Unknown error"));

if (err)

g_error_free(err);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

/* Loop over the contents of ~/.gaim */

while ((entry = g_dir_read_name(dir)))

{

char *name = g_build_filename(old_user_dir, entry, NULL);

#ifndef _WIN32

/* Deal with symlinks... */

if (g_file_test(name, G_FILE_TEST_IS_SYMLINK))

{

/* We're only going to duplicate a logs symlink. */

if (purple_strequal(entry, "logs"))

{

char *link;

err = NULL;

if ((link = g_file_read_link(name, &err)) == NULL)

{

char *name_utf8 = g_filename_to_utf8(name, -1, NULL, NULL, NULL);

purple_debug_error("core", "Error reading symlink %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

name_utf8 ? name_utf8 : name, err->message);

g_free(name_utf8);

g_error_free(err);

g_free(name);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

logs_dir = g_build_filename(user_dir, "logs", NULL);

if (purple_strequal(link, "../.purple/logs") ||

purple_strequal(link, logs_dir))

{

/* If the symlink points to the new directory, we're

* likely just trying again after a failed migration,

* so there's no need to fail here. */

g_free(link);

g_free(logs_dir);

continue;

}

/* In case we are trying again after a failed migration, we need

* to unlink any existing symlink. If it's a directory, this

* will fail, and so will the symlink below, which is good

* because the user should sort things out. */

g_unlink(logs_dir);

/* Relative links will most likely still be

* valid from ~/.purple, though it's not

* guaranteed. Oh well. */

if (symlink(link, logs_dir))

{

purple_debug_error("core", "Error symlinking %s to %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

logs_dir, link, g_strerror(errno));

g_free(link);

g_free(name);

g_free(logs_dir);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

g_free(link);

g_free(logs_dir);

continue;

}

/* Ignore all other symlinks. */

continue;

}

#endif

/* Deal with directories... */

if (g_file_test(name, G_FILE_TEST_IS_DIR))

{

if (purple_strequal(entry, "icons"))

{

/* This is a special case for the Album plugin, which

* stores data in the icons folder. We're not copying

* the icons directory over because previous bugs

* meant that it filled up with junk for many users.

* This is a great time to purge it. */

GDir *icons_dir;

char *new_icons_dir;

const char *icons_entry;

err = NULL;

if (!(icons_dir = g_dir_open(name, 0, &err)))

{

purple_debug_error("core", "Error opening directory %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

name,

(err ? err->message : "Unknown error"));

if (err)

g_error_free(err);

g_free(name);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

new_icons_dir = g_build_filename(user_dir, "icons", NULL);

/* Ensure the new icon directory exists */

if (!g_file_test(new_icons_dir, G_FILE_TEST_IS_DIR))

{

if (g_mkdir(new_icons_dir, S_IRUSR | S_IWUSR | S_IXUSR) == -1)

{

purple_debug_error("core", "Error creating directory %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

new_icons_dir, g_strerror(errno));

g_free(new_icons_dir);

g_dir_close(icons_dir);

g_free(name);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

while ((icons_entry = g_dir_read_name(icons_dir)))

{

char *icons_name = g_build_filename(name, icons_entry, NULL);

if (g_file_test(icons_name, G_FILE_TEST_IS_DIR))

{

if (!move_and_symlink_dir(icons_name, icons_entry,

name, new_icons_dir, "../../.purple/icons"))

{

g_free(icons_name);

g_free(new_icons_dir);

g_dir_close(icons_dir);

g_free(name);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

g_free(icons_name);

}

g_dir_close(icons_dir);

}

else if (purple_strequal(entry, "plugins"))

{

/* Do nothing, because we broke plugin compatibility.

* This means that the plugins directory gets left behind. */

}

else

{

/* All other directories are moved and symlinked. */

if (!move_and_symlink_dir(name, entry, old_user_dir, user_dir, "../.purple"))

{

g_free(name);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

else if (g_file_test(name, G_FILE_TEST_IS_REGULAR))

{

/* Regular files are copied. */

char *new_name;

FILE *new_file;

if (!(fp = g_fopen(name, "rb")))

{

purple_debug_error("core", "Error opening file %s for reading: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

name, g_strerror(errno));

g_free(name);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

new_name = g_build_filename(user_dir, entry, NULL);

if (!(new_file = g_fopen(new_name, "wb")))

{

purple_debug_error("core", "Error opening file %s for writing: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

new_name, g_strerror(errno));

fclose(fp);

g_free(new_name);

g_free(name);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

while (!feof(fp))

{

unsigned char buf[256];

size_t size;

size = fread(buf, 1, sizeof(buf), fp);

if (size != sizeof(buf) && !feof(fp))

{

purple_debug_error("core", "Error reading %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

name, g_strerror(errno));

fclose(new_file);

fclose(fp);

g_free(new_name);

g_free(name);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

if (!fwrite(buf, size, 1, new_file) && ferror(new_file) != 0)

{

purple_debug_error("core", "Error writing %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

new_name, g_strerror(errno));

fclose(new_file);

fclose(fp);

g_free(new_name);

g_free(name);

g_dir_close(dir);

g_free(status_file);

g_free(old_user_dir);

return FALSE;

}

if (fclose(new_file))

{

purple_debug_error("core", "Error writing: %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

new_name, g_strerror(errno));

}

if (fclose(fp))

{

purple_debug_warning("core", "Error closing %s: %s\n",

name, g_strerror(errno));

}

g_free(new_name);

}

else

purple_debug_warning("core", "Not a regular file or directory: %s\n", name);

g_free(name);

}

/* The migration was successful, so delete the status file. */

if (g_unlink(status_file))

{

purple_debug_error("core", "Error unlinking file %s: %s. Please report this at " PURPLE_DEVEL_WEBSITE "\n",

status_file, g_strerror(errno));

g_free(status_file);

return FALSE;

}

old_icons_dir = g_build_filename(old_user_dir, "icons", NULL);

_purple_buddy_icon_set_old_icons_dir(old_icons_dir);

g_free(old_icons_dir);

g_free(old_user_dir);

g_free(status_file);

return TRUE;

}

GHashTable* purple_core_get_ui_info() {

PurpleCoreUiOps *ops = purple_core_get_ui_ops();

if(NULL == ops || NULL == ops->get_ui_info)

return NULL;

return ops->get_ui_info();

}

pidgin/pidgin