Trac is being migrated to new services! Issues can be found in our new YouTrack instance and WIKI pages can be found on our website.

akronix: diff-current-to-2.10.9.patch

File diff-current-to-2.10.9.patch, 234.8 KB (added by akronix, 9 years ago)

patch Instantbird 2.10.9 libpurple vs pidgin libpurple 2.10.9

  • libpurple/account.c

    diff -ru extract/pidgin-2.10.9/libpurple/account.c libpurple/account.c
    old new  
    3030#include "debug.h"
    3131#include "network.h"
    3232#include "notify.h"
    33 #include "pounce.h"
    3433#include "prefs.h"
    3534#include "privacy.h"
    3635#include "prpl.h"
     
    4140#include "util.h"
    4241#include "xmlnode.h"
    4342
     43#define schedule_accounts_save()
     44
    4445typedef struct
    4546{
    4647        PurpleConnectionErrorInfo *current_error;
     
    8990static void set_current_error(PurpleAccount *account,
    9091        PurpleConnectionErrorInfo *new_err);
    9192
     93#if 0
    9294/*********************************************************************
    9395 * Writing to disk                                                   *
    9496 *********************************************************************/
     
    961963
    962964        return ret;
    963965}
     966#endif
    964967
    965968static void
    966969load_accounts(void)
     
    969972
    970973        accounts_loaded = TRUE;
    971974
     975#if 0
    972976        node = purple_util_read_xml_from_file("accounts.xml", _("accounts"));
    973977
    974978        if (node == NULL)
     
    985989        xmlnode_free(node);
    986990
    987991        _purple_buddy_icons_account_loaded_cb();
     992#endif
    988993}
    989994
    990995
     
    10971102
    10981103        purple_presence_destroy(account->presence);
    10991104
     1105#if 0
    11001106        if(account->system_log)
    11011107                purple_log_free(account->system_log);
     1108#endif
    11021109
    11031110        while (account->deny) {
    11041111                g_free(account->deny->data);
     
    12821289
    12831290        gc = purple_account_get_connection(account);
    12841291        _purple_connection_destroy(gc);
     1292
     1293        /*
     1294        XXXFlo: disable this until the UI for requesting a password
     1295                from the user works in Instantbird
    12851296        if (!purple_account_get_remember_password(account))
    12861297                purple_account_set_password(account, NULL);
     1298        */
    12871299        purple_account_set_connection(account, NULL);
    12881300
    12891301        account->disconnecting = FALSE;
     
    19771989purple_account_set_int(PurpleAccount *account, const char *name, int value)
    19781990{
    19791991        PurpleAccountSetting *setting;
     1992        PurpleAccountUiOps *ui_ops;
    19801993
    19811994        g_return_if_fail(account != NULL);
    19821995        g_return_if_fail(name    != NULL);
     
    19882001
    19892002        g_hash_table_insert(account->settings, g_strdup(name), setting);
    19902003
     2004        ui_ops = purple_accounts_get_ui_ops();
     2005
     2006        if (ui_ops != NULL && ui_ops->set_int != NULL)
     2007                ui_ops->set_int(account, name, value);
     2008
    19912009        schedule_accounts_save();
    19922010}
    19932011
     
    19962014                                                const char *value)
    19972015{
    19982016        PurpleAccountSetting *setting;
     2017        PurpleAccountUiOps *ui_ops;
    19992018
    20002019        g_return_if_fail(account != NULL);
    20012020        g_return_if_fail(name    != NULL);
     
    20072026
    20082027        g_hash_table_insert(account->settings, g_strdup(name), setting);
    20092028
     2029        ui_ops = purple_accounts_get_ui_ops();
     2030
     2031        if (ui_ops != NULL && ui_ops->set_string != NULL)
     2032                ui_ops->set_string(account, name, value);
     2033
    20102034        schedule_accounts_save();
    20112035}
    20122036
     
    20142038purple_account_set_bool(PurpleAccount *account, const char *name, gboolean value)
    20152039{
    20162040        PurpleAccountSetting *setting;
     2041        PurpleAccountUiOps *ui_ops;
    20172042
    20182043        g_return_if_fail(account != NULL);
    20192044        g_return_if_fail(name    != NULL);
     
    20252050
    20262051        g_hash_table_insert(account->settings, g_strdup(name), setting);
    20272052
     2053        ui_ops = purple_accounts_get_ui_ops();
     2054
     2055        if (ui_ops != NULL && ui_ops->set_bool != NULL)
     2056                ui_ops->set_bool(account, name, value);
     2057
    20282058        schedule_accounts_save();
    20292059}
    20302060
     
    22042234
    22052235        p = purple_find_prpl(purple_account_get_protocol_id(account));
    22062236
    2207         return ((p && p->info->name) ? _(p->info->name) : _("Unknown"));
     2237        return ((p && p->info->name) ? p->info->name : _("Unknown"));
    22082238}
    22092239
    22102240PurpleConnection *
     
    23962426                                                const char *default_value)
    23972427{
    23982428        PurpleAccountSetting *setting;
     2429        const char *value;
    23992430
    24002431        g_return_val_if_fail(account != NULL, default_value);
    24012432        g_return_val_if_fail(name    != NULL, default_value);
     
    24072438
    24082439        g_return_val_if_fail(setting->type == PURPLE_PREF_STRING, default_value);
    24092440
    2410         return setting->value.string;
     2441        value = setting->value.string;
     2442        if (value == NULL || !*value)
     2443                return default_value;
     2444
     2445        return value;
    24112446}
    24122447
    24132448gboolean
     
    24952530        return setting->value.boolean;
    24962531}
    24972532
     2533#if 0
    24982534PurpleLog *
    24992535purple_account_get_log(PurpleAccount *account, gboolean create)
    25002536{
     
    25252561                account->system_log = NULL;
    25262562        }
    25272563}
     2564#endif
    25282565
    25292566void
    25302567purple_account_add_buddy(PurpleAccount *account, PurpleBuddy *buddy)
     
    29633000                        purple_conversation_destroy(conv);
    29643001        }
    29653002
    2966         /* Remove this account's pounces */
    2967         purple_pounce_destroy_all_by_account(account);
    2968 
    29693003        /* This will cause the deletion of an old buddy icon. */
    29703004        purple_buddy_icons_set_account_icon(account, NULL, 0);
    29713005
     
    31473181                                                 purple_marshal_VOID__POINTER, NULL, 1,
    31483182                                                 purple_value_new(PURPLE_TYPE_SUBTYPE, PURPLE_SUBTYPE_ACCOUNT));
    31493183
     3184        purple_signal_register(handle, "account-status-changing",
     3185                                                 purple_marshal_VOID__POINTER_POINTER_POINTER, NULL, 3,
     3186                                                 purple_value_new(PURPLE_TYPE_SUBTYPE,
     3187                                                                                PURPLE_SUBTYPE_ACCOUNT),
     3188                                                 purple_value_new(PURPLE_TYPE_SUBTYPE,
     3189                                                                                PURPLE_SUBTYPE_STATUS),
     3190                                                 purple_value_new(PURPLE_TYPE_SUBTYPE,
     3191                                                                                PURPLE_SUBTYPE_STATUS));
     3192
    31503193        purple_signal_register(handle, "account-status-changed",
    31513194                                                 purple_marshal_VOID__POINTER_POINTER_POINTER, NULL, 3,
    31523195                                                 purple_value_new(PURPLE_TYPE_SUBTYPE,
     
    32323275purple_accounts_uninit(void)
    32333276{
    32343277        gpointer handle = purple_accounts_get_handle();
     3278#if 0
    32353279        if (save_timer != 0)
    32363280        {
    32373281                purple_timeout_remove(save_timer);
    32383282                save_timer = 0;
    32393283                sync_accounts();
    32403284        }
    3241 
     3285#endif
    32423286        for (; accounts; accounts = g_list_delete_link(accounts, accounts))
    32433287                purple_account_destroy(accounts->data);
    32443288
  • libpurple/account.h

    diff -ru extract/pidgin-2.10.9/libpurple/account.h libpurple/account.h
    old new  
    115115         */
    116116        void (*close_account_request)(void *ui_handle);
    117117
     118        void (*set_int)(PurpleAccount *account, const char *name, int value);
     119        void (*set_string)(PurpleAccount *account, const char *name, const char *value);
     120        void (*set_bool)(PurpleAccount *account, const char *name, gboolean value);
     121
    118122        void (*_purple_reserved1)(void);
    119123        void (*_purple_reserved2)(void);
    120124        void (*_purple_reserved3)(void);
     
    944948 *       if the log has already been closed, which not all loggers deal
    945949 *       with appropriately.
    946950 */
    947 PurpleLog *purple_account_get_log(PurpleAccount *account, gboolean create);
     951/* PurpleLog *purple_account_get_log(PurpleAccount *account, gboolean create); */
    948952
    949953/**
    950954 * Frees the system log of an account
    951955 *
    952956 * @param account The account.
    953957 */
    954 void purple_account_destroy_log(PurpleAccount *account);
     958/* void purple_account_destroy_log(PurpleAccount *account); */
    955959
    956960/**
    957961 * Adds a buddy to the server-side buddy list for the specified account.
  • libpurple/blist.c

    diff -ru extract/pidgin-2.10.9/libpurple/blist.c libpurple/blist.c
    old new  
    2828#include "dbus-maybe.h"
    2929#include "debug.h"
    3030#include "notify.h"
    31 #include "pounce.h"
    3231#include "prefs.h"
    3332#include "privacy.h"
    3433#include "prpl.h"
     
    126125}
    127126
    128127
     128#if 0
    129129/*********************************************************************
    130130 * Writing to disk                                                   *
    131131 *********************************************************************/
     
    600600                        parse_chat(group, cnode);
    601601        }
    602602}
     603#endif
    603604
    604605/* TODO: Make static and rename to load_blist */
    605606void
    606607purple_blist_load()
    607608{
     609#if 0
    608610        xmlnode *purple, *blist, *privacy;
     611#endif
    609612
    610613        blist_loaded = TRUE;
    611614
     615#if 0
    612616        purple = purple_util_read_xml_from_file("blist.xml", _("buddy list"));
    613617
    614618        if (purple == NULL)
     
    670674
    671675        /* This tells the buddy icon code to do its thing. */
    672676        _purple_buddy_icons_blist_loaded_cb();
     677#endif
    673678}
    674679
    675680
     
    16231628                ((PurpleContact*)bnode->parent)->totalsize--;
    16241629                /* the group totalsize will be taken care of by remove_contact below */
    16251630
    1626                 if (bnode->parent->parent != (PurpleBlistNode*)g)
     1631                if (bnode->parent->parent != (PurpleBlistNode*)g) {
     1632                        purple_signal_emit(purple_blist_get_handle(), "buddy-removed-from-group", buddy);
    16271633                        serv_move_buddy(buddy, (PurpleGroup *)bnode->parent->parent, g);
     1634                }
    16281635
    16291636                if (bnode->next)
    16301637                        bnode->next->prev = bnode->prev;
     
    21852192        if (ops && ops->remove_node)
    21862193                ops->remove_node(node);
    21872194
    2188         /* Remove this buddy's pounces */
    2189         purple_pounce_destroy_all_by_buddy(buddy);
    2190 
    21912195        /* Signal that the buddy has been removed before freeing the memory for it */
    21922196        purple_signal_emit(purple_blist_get_handle(), "buddy-removed", buddy);
    21932197
     
    30913095
    30923096        if (!ops)
    30933097                return;
    3094 
     3098#if 0
    30953099        if (!ops->save_node) {
    30963100                ops->save_node = purple_blist_save_node;
    30973101                overrode = TRUE;
     
    31113115                purple_debug_warning("blist", "Only some of the blist saving UI ops "
    31123116                                "were overridden. This probably is not what you want!\n");
    31133117        }
     3118#endif
    31143119}
    31153120
    31163121PurpleBlistUiOps *
     
    31923197                                                 purple_value_new(PURPLE_TYPE_SUBTYPE,
    31933198                                                                                PURPLE_SUBTYPE_BLIST_BUDDY));
    31943199
     3200        purple_signal_register(handle, "buddy-removed-from-group",
     3201                                                 purple_marshal_VOID__POINTER, NULL, 1,
     3202                                                 purple_value_new(PURPLE_TYPE_SUBTYPE,
     3203                                                                                PURPLE_SUBTYPE_BLIST_BUDDY));
     3204
    31953205        purple_signal_register(handle, "buddy-icon-changed",
    31963206                                                 purple_marshal_VOID__POINTER, NULL, 1,
    31973207                                                 purple_value_new(PURPLE_TYPE_SUBTYPE,
     
    32383248        if (purplebuddylist == NULL)
    32393249                return;
    32403250
     3251#if 0
    32413252        if (save_timer != 0) {
    32423253                purple_timeout_remove(save_timer);
    32433254                save_timer = 0;
    32443255                purple_blist_sync();
    32453256        }
     3257#endif
    32463258
    32473259        purple_blist_destroy();
    32483260
  • libpurple/blist.h

    diff -ru extract/pidgin-2.10.9/libpurple/blist.h libpurple/blist.h
    old new  
    106106 */
    107107#define PURPLE_CHAT(obj) ((PurpleChat *)(obj))
    108108
     109#if 0
     110#include "media.h"
     111#else
     112/** extracted from media.h */
     113/** Media caps */
     114typedef enum {
     115        PURPLE_MEDIA_CAPS_NONE = 0,
     116        PURPLE_MEDIA_CAPS_AUDIO = 1,
     117        PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION = 1 << 1,
     118        PURPLE_MEDIA_CAPS_VIDEO = 1 << 2,
     119        PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION = 1 << 3,
     120        PURPLE_MEDIA_CAPS_AUDIO_VIDEO = 1 << 4,
     121        PURPLE_MEDIA_CAPS_MODIFY_SESSION = 1 << 5,
     122        PURPLE_MEDIA_CAPS_CHANGE_DIRECTION = 1 << 6
     123} PurpleMediaCaps;
     124
     125/** Media session types */
     126typedef enum {
     127        PURPLE_MEDIA_NONE       = 0,
     128        PURPLE_MEDIA_RECV_AUDIO = 1 << 0,
     129        PURPLE_MEDIA_SEND_AUDIO = 1 << 1,
     130        PURPLE_MEDIA_RECV_VIDEO = 1 << 2,
     131        PURPLE_MEDIA_SEND_VIDEO = 1 << 3,
     132        PURPLE_MEDIA_AUDIO = PURPLE_MEDIA_RECV_AUDIO | PURPLE_MEDIA_SEND_AUDIO,
     133        PURPLE_MEDIA_VIDEO = PURPLE_MEDIA_RECV_VIDEO | PURPLE_MEDIA_SEND_VIDEO
     134} PurpleMediaSessionType;
     135#endif
    109136#include "account.h"
    110137#include "buddyicon.h"
    111 #include "media.h"
    112138#include "status.h"
    113139
    114140/**************************************************************************/
     
    10881114 * the buddy list is saved automatically, so you should not need to
    10891115 * call this.
    10901116 */
    1091 void purple_blist_schedule_save(void);
     1117/* void purple_blist_schedule_save(void); */
    10921118
    10931119/**
    10941120 * Requests from the user information needed to add a buddy to the
  • libpurple/buddyicon.c

    diff -ru extract/pidgin-2.10.9/libpurple/buddyicon.c libpurple/buddyicon.c
    old new  
    187187
    188188        g_return_if_fail(filename != NULL);
    189189
     190        if (!purple_buddy_icons_is_caching())
     191                return;
     192
    190193        /* It's possible that there are other references to this icon
    191194         * cache file that are not currently loaded into memory. */
    192195        if (GPOINTER_TO_INT(g_hash_table_lookup(icon_file_cache, filename)))
     
    11231126}
    11241127
    11251128void
    1126 _purple_buddy_icons_account_loaded_cb()
     1129purple_buddy_icons_account_loaded(PurpleAccount *account)
    11271130{
    1128         const char *dirname = purple_buddy_icons_get_cache_dir();
    1129         GList *cur;
     1131        const char *account_icon_file = purple_account_get_string(account, "buddy_icon", NULL);
    11301132
    1131         for (cur = purple_accounts_get_all(); cur != NULL; cur = cur->next)
     1133        if (account_icon_file != NULL)
    11321134        {
    1133                 PurpleAccount *account = cur->data;
    1134                 const char *account_icon_file = purple_account_get_string(account, "buddy_icon", NULL);
    1135 
    1136                 if (account_icon_file != NULL)
     1135                const char *dirname = purple_buddy_icons_get_cache_dir();
     1136                char *path = g_build_filename(dirname, account_icon_file, NULL);
     1137                if (!g_file_test(path, G_FILE_TEST_EXISTS))
    11371138                {
    1138                         char *path = g_build_filename(dirname, account_icon_file, NULL);
    1139                         if (!g_file_test(path, G_FILE_TEST_EXISTS))
    1140                         {
    1141                                 purple_account_set_string(account, "buddy_icon", NULL);
    1142                         } else {
    1143                                 ref_filename(account_icon_file);
    1144                         }
    1145                         g_free(path);
     1139                        purple_account_set_string(account, "buddy_icon", NULL);
     1140                } else {
     1141                        ref_filename(account_icon_file);
    11461142                }
     1143                g_free(path);
    11471144        }
    11481145}
    11491146
    11501147void
     1148_purple_buddy_icons_account_loaded_cb()
     1149{
     1150        GList *cur;
     1151
     1152        for (cur = purple_accounts_get_all(); cur != NULL; cur = cur->next)
     1153                purple_buddy_icons_account_loaded(cur->data);
     1154}
     1155
     1156void
    11511157_purple_buddy_icons_blist_loaded_cb()
    11521158{
    11531159        PurpleBlistNode *node = purple_blist_get_root();
  • libpurple/buddyicon.h

    diff -ru extract/pidgin-2.10.9/libpurple/buddyicon.h libpurple/buddyicon.h
    old new  
    270270purple_buddy_icons_get_account_icon_timestamp(PurpleAccount *account);
    271271
    272272/**
     273 * References the current icon of the loaded account.
     274 *
     275 * UIs should call this after loading an account, if the accounts
     276 * aren't stored in the accounts.xml libpurple file.
     277 *
     278 * @param account The account
     279 */
     280void
     281purple_buddy_icons_account_loaded(PurpleAccount *account);
     282
     283/**
    273284 * Returns a boolean indicating if a given blist node has a custom buddy icon.
    274285 *
    275286 * @param node The blist node.
  • libpurple/cmds.c

    Only in extract/pidgin-2.10.9/libpurple: certificate.c
    Only in extract/pidgin-2.10.9/libpurple: certificate.h
    diff -ru extract/pidgin-2.10.9/libpurple/cmds.c libpurple/cmds.c
    old new  
    2727#include "util.h"
    2828#include "cmds.h"
    2929
     30static PurpleCommandsUiOps *cmds_ui_ops = NULL;
    3031static GList *cmds = NULL;
    3132static guint next_id = 1;
    3233
    33 typedef struct _PurpleCmd {
     34struct _PurpleCmd {
    3435        PurpleCmdId id;
    3536        gchar *cmd;
    3637        gchar *args;
     
    4041        PurpleCmdFunc func;
    4142        gchar *help;
    4243        void *data;
    43 } PurpleCmd;
     44};
    4445
    4546
    4647static gint cmds_compare_func(const PurpleCmd *a, const PurpleCmd *b)
     
    5960{
    6061        PurpleCmdId id;
    6162        PurpleCmd *c;
     63        PurpleCommandsUiOps *ops;
    6264
    6365        g_return_val_if_fail(cmd != NULL && *cmd != '\0', 0);
    6466        g_return_val_if_fail(args != NULL, 0);
     
    7981
    8082        cmds = g_list_insert_sorted(cmds, c, (GCompareFunc)cmds_compare_func);
    8183
     84        ops = purple_cmds_get_ui_ops();
     85        if (ops && ops->register_command)
     86                ops->register_command(cmd, p, f, prpl_id, helpstr, c);
     87
    8288        purple_signal_emit(purple_cmds_get_handle(), "cmd-added", cmd, p, f);
    8389
    8490        return id;
     
    102108                c = l->data;
    103109
    104110                if (c->id == id) {
     111                        PurpleCommandsUiOps *ops = purple_cmds_get_ui_ops();
     112                        if (ops && ops->unregister_command)
     113                                ops->unregister_command(c->cmd, c->prpl_id);
     114
    105115                        cmds = g_list_remove(cmds, c);
    106116                        purple_signal_emit(purple_cmds_get_handle(), "cmd-removed", c->cmd);
    107117                        purple_cmd_free(c);
     
    301311
    302312}
    303313
     314gboolean purple_cmd_execute(PurpleCmd *c, PurpleConversation *conv,
     315                            const gchar *cmdline)
     316{
     317        gchar *err = NULL;
     318        gchar **args = NULL;
     319        PurpleCmdRet ret = PURPLE_CMD_RET_CONTINUE;
     320
     321        if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM) {
     322                if (!(c->flags & PURPLE_CMD_FLAG_IM))
     323                        return FALSE;
     324        }
     325        else if (purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT) {
     326                if (!(c->flags & PURPLE_CMD_FLAG_CHAT))
     327                        return FALSE;
     328        }
     329        else
     330                return FALSE;
     331
     332        /* XXX: Don't worry much about the markup version of the command
     333           line, there's not a single use case... */
     334        /* this checks the allow bad args flag for us */
     335        if (!purple_cmd_parse_args(c, cmdline, cmdline, &args)) {
     336                g_strfreev(args);
     337                return FALSE;
     338        }
     339
     340        ret = c->func(conv, c->cmd, args, &err, c->data);
     341
     342        g_free(err);
     343        g_strfreev(args);
     344
     345        return ret == PURPLE_CMD_RET_OK;
     346}
    304347
    305348GList *purple_cmd_list(PurpleConversation *conv)
    306349{
     
    368411        return &handle;
    369412}
    370413
     414void
     415purple_cmds_set_ui_ops(PurpleCommandsUiOps *ops)
     416{
     417        cmds_ui_ops = ops;
     418}
     419
     420PurpleCommandsUiOps *
     421purple_cmds_get_ui_ops(void)
     422{
     423        /* It is perfectly acceptable for cmds_ui_ops to be NULL; this just
     424         * means that the default libpurple implementation will be used.
     425         */
     426        return cmds_ui_ops;
     427}
     428
    371429void purple_cmds_init(void)
    372430{
    373431        gpointer handle = purple_cmds_get_handle();
  • libpurple/cmds.h

    diff -ru extract/pidgin-2.10.9/libpurple/cmds.h libpurple/cmds.h
    old new  
    3131/**************************************************************************/
    3232/*@{*/
    3333
     34typedef struct _PurpleCmd PurpleCmd;
     35
    3436/** The possible results of running a command with purple_cmd_do_command(). */
    3537typedef enum _PurpleCmdStatus {
    3638        PURPLE_CMD_STATUS_OK,
     
    9698        PURPLE_CMD_FLAG_ALLOW_WRONG_ARGS = 0x08
    9799} PurpleCmdFlag;
    98100
     101/**
     102 * Command UI operations;  UIs should implement this if they want to handle
     103 * commands themselves, rather than relying on the core.
     104 *
     105 * @see @ref ui-ops
     106 */
     107typedef struct
     108{
     109        /** If implemented, the UI is responsible for handling commands. */
     110        /* @see purple_cmd_register for the argument values. */
     111        void (*register_command)(const gchar *name, PurpleCmdPriority p,
     112                                 PurpleCmdFlag f, const gchar *prpl_id,
     113                                 const gchar *helpstr, PurpleCmd *cmd);
     114
     115        /** Should be implemented if register_command is implemented.
     116         *  name and prpl_id should have the same value that were used
     117         *  for the register_command call.
     118         */
     119        void (*unregister_command)(const gchar *name, const gchar *prpl_id);
     120
     121        void (*_purple_reserved1)(void);
     122        void (*_purple_reserved2)(void);
     123        void (*_purple_reserved3)(void);
     124        void (*_purple_reserved4)(void);
     125} PurpleCommandsUiOps;
    99126
    100127/*@}*/
    101128
     
    194221                                  const gchar *markup, gchar **errormsg);
    195222
    196223/**
     224 * Execute a specific command.
     225 *
     226 * The UI calls this to execute a command, after parsing the
     227 * command name.
     228 *
     229 * @param c The command to execute.
     230 * @param conv The conversation the command was typed in.
     231 * @param cmdline The command the user typed (only the arguments).
     232 *            The caller should remove the prefix and the command name.
     233 *            It should not contain any formatting, and should be
     234 *            in plain text (no html entities).
     235 * @return TRUE if the command handled the cmdline, FALSE otherwise.
     236 */
     237gboolean purple_cmd_execute(PurpleCmd *c, PurpleConversation *conv,
     238                            const gchar *cmdline);
     239
     240/**
    197241 * List registered commands.
    198242 *
    199243 * Returns a <tt>GList</tt> (which must be freed by the caller) of all commands
     
    230274gpointer purple_cmds_get_handle(void);
    231275
    232276/**
     277 * Sets the UI operations structure to be used when registering and
     278 * unregistering commands.  The UI operations need only be set if the
     279 * UI wants to handle the commands itself; otherwise, leave it as NULL.
     280 *
     281 * @param ops The UI operations structure.
     282 */
     283void purple_cmds_set_ui_ops(PurpleCommandsUiOps *ops);
     284
     285/**
     286 * Returns the UI operations structure to be used when registering and
     287 * unregistering commands.
     288 *
     289 * @return The UI operations structure.
     290 */
     291PurpleCommandsUiOps *purple_cmds_get_ui_ops(void);
     292
     293/**
    233294 * Initialize the commands subsystem.
    234295 * @since 2.5.0
    235296 */
  • libpurple/connection.c

    Only in libpurple: config.h
    diff -ru extract/pidgin-2.10.9/libpurple/connection.c libpurple/connection.c
    old new  
    350350                /* Set the time the account came online */
    351351                purple_presence_set_login_time(presence, time(NULL));
    352352
     353#if 0
    353354                if (purple_prefs_get_bool("/purple/logging/log_system"))
    354355                {
    355356                        PurpleLog *log = purple_account_get_log(account, TRUE);
     
    365366                                g_free(msg);
    366367                        }
    367368                }
     369#endif
    368370
    369371                if (ops != NULL && ops->connected != NULL)
    370372                        ops->connected(gc);
     
    381383        else if (gc->state == PURPLE_DISCONNECTED) {
    382384                PurpleAccount *account = purple_connection_get_account(gc);
    383385
     386#if 0
    384387                if (purple_prefs_get_bool("/purple/logging/log_system"))
    385388                {
    386389                        PurpleLog *log = purple_account_get_log(account, FALSE);
     
    397400                }
    398401
    399402                purple_account_destroy_log(account);
     403#endif
    400404
    401405                if (ops != NULL && ops->disconnected != NULL)
    402406                        ops->disconnected(gc);
  • libpurple/conversation.c

    diff -ru extract/pidgin-2.10.9/libpurple/conversation.c libpurple/conversation.c
    old new  
    153153
    154154        type = purple_conversation_get_type(conv);
    155155
     156#if 0
    156157        /* Always linkfy the text for display, unless we're
    157158         * explicitly asked to do otheriwse*/
    158159        if (!(msgflags & PURPLE_MESSAGE_INVISIBLE)) {
     
    167168                sent = g_strdup(displayed);
    168169        } else
    169170                sent = g_strdup(message);
     171#else
     172        /* send and display as is, linkification has already been
     173           handled by the conversation binding */
     174        displayed = g_strdup(message);
     175        sent = g_strdup(message);
     176#endif
    170177
    171178        msgflags |= PURPLE_MESSAGE_SEND;
    172179
     
    238245        g_free(sent);
    239246}
    240247
     248#if 0
    241249static void
    242250open_log(PurpleConversation *conv)
    243251{
     
    245253                                                           PURPLE_LOG_IM, conv->name, conv->account,
    246254                                                           conv, time(NULL), NULL));
    247255}
     256#endif
    248257
    249258/* Functions that deal with PurpleConvMessage */
    250259
     
    307316
    308317        account = purple_conversation_get_account(conv);
    309318
     319#if 0
    310320        purple_conversation_close_logs(conv);
    311321        open_log(conv);
     322#endif
    312323
    313324        gc = purple_account_get_connection(account);
    314325
     
    398409                        purple_buddy_icon_unref(icon);
    399410                }
    400411
     412#if 0
    401413                if (purple_prefs_get_bool("/purple/logging/log_ims"))
    402414                {
    403415                        purple_conversation_set_logging(conv, TRUE);
    404416                        open_log(conv);
    405417                }
     418#endif
    406419        }
    407420        else if (type == PURPLE_CONV_TYPE_CHAT)
    408421        {
     
    422435                        purple_conv_chat_set_nick(conv->u.chat,
    423436                                                                        purple_account_get_username(account));
    424437
     438#if 0
    425439                if (purple_prefs_get_bool("/purple/logging/log_chats"))
    426440                {
    427441                        purple_conversation_set_logging(conv, TRUE);
    428442                        open_log(conv);
    429443                }
     444#endif
    430445        }
    431446
    432447        conversations = g_list_prepend(conversations, conv);
     
    598613                ops->destroy_conversation(conv);
    599614        conv->ui_data = NULL;
    600615
     616#if 0
    601617        purple_conversation_close_logs(conv);
     618#endif
    602619
    603620        purple_conversation_clear_message_history(conv);
    604621
     
    800817        return conv->name;
    801818}
    802819
     820#if 0
    803821void
    804822purple_conversation_set_logging(PurpleConversation *conv, gboolean log)
    805823{
     
    829847        g_list_free(conv->logs);
    830848        conv->logs = NULL;
    831849}
     850#endif
    832851
    833852PurpleConvIm *
    834853purple_conversation_get_im_data(const PurpleConversation *conv)
     
    10081027                }
    10091028        }
    10101029
     1030#if 0
    10111031        if (!(flags & PURPLE_MESSAGE_NO_LOG) && purple_conversation_is_logging(conv)) {
    10121032                GList *log;
    10131033
     
    10201040                        log = log->next;
    10211041                }
    10221042        }
     1043#endif
    10231044
    10241045        if (ops && ops->write_conv)
    10251046                ops->write_conv(conv, who, alias, displayed, flags, mtime);
     
    12421263
    12431264        if ((flags & PURPLE_MESSAGE_RECV) == PURPLE_MESSAGE_RECV) {
    12441265                purple_conv_im_set_typing_state(im, PURPLE_NOT_TYPING);
     1266                purple_conv_im_update_typing(im);
    12451267        }
    12461268
    12471269        /* Pass this on to either the ops structure or the default write func. */
  • libpurple/conversation.h

    diff -ru extract/pidgin-2.10.9/libpurple/conversation.h libpurple/conversation.h
    old new  
    568568 * @param conv The conversation.
    569569 * @param log  @c TRUE if logging should be enabled, or @c FALSE otherwise.
    570570 */
    571 void purple_conversation_set_logging(PurpleConversation *conv, gboolean log);
     571/* void purple_conversation_set_logging(PurpleConversation *conv, gboolean log); */
    572572
    573573/**
    574574 * Returns whether or not logging is enabled for this conversation.
     
    577577 *
    578578 * @return @c TRUE if logging is enabled, or @c FALSE otherwise.
    579579 */
    580 gboolean purple_conversation_is_logging(const PurpleConversation *conv);
     580/* gboolean purple_conversation_is_logging(const PurpleConversation *conv); */
    581581
    582582/**
    583583 * Closes any open logs for this conversation.
     
    588588 *
    589589 * @param conv The conversation.
    590590 */
    591 void purple_conversation_close_logs(PurpleConversation *conv);
     591/* void purple_conversation_close_logs(PurpleConversation *conv); */
    592592
    593593/**
    594594 * Returns the specified conversation's IM-specific data.
  • libpurple/core.c

    diff -ru extract/pidgin-2.10.9/libpurple/core.c libpurple/core.c
    old new  
    2525 */
    2626#include "internal.h"
    2727#include "cipher.h"
    28 #include "certificate.h"
    2928#include "cmds.h"
    3029#include "connection.h"
    3130#include "conversation.h"
     
    3837#include "network.h"
    3938#include "notify.h"
    4039#include "plugin.h"
    41 #include "pounce.h"
    4240#include "prefs.h"
    4341#include "privacy.h"
    4442#include "proxy.h"
    45 #include "savedstatuses.h"
    4643#include "signals.h"
    4744#include "smiley.h"
    48 #include "sound.h"
    49 #include "sound-theme-loader.h"
    5045#include "sslconn.h"
    5146#include "status.h"
    5247#include "stun.h"
    53 #include "theme-manager.h"
    5448#include "util.h"
    5549
    5650#ifdef HAVE_DBUS
     
    6357#  include "dbus-bindings.h"
    6458#endif
    6559
     60#include <libxml/parser.h>
     61
    6662struct PurpleCore
    6763{
    6864        char *ui;
     
    7369static PurpleCoreUiOps *_ops  = NULL;
    7470static PurpleCore      *_core = NULL;
    7571
     72#ifdef STATIC_PROTO_INIT
    7673STATIC_PROTO_INIT
     74#endif
    7775
    7876gboolean
    7977purple_core_init(const char *ui)
     
    117115         * for protocol prefs to work. */
    118116        purple_prefs_init();
    119117
    120         purple_debug_init();
    121 
    122118        if (ops != NULL)
    123119        {
    124120                if (ops->ui_prefs_init != NULL)
     
    140136         */
    141137        purple_plugins_init();
    142138
     139#ifdef STATIC_PROTO_INIT
    143140        /* Initialize all static protocols. */
    144141        static_proto_init();
     142#endif
    145143
    146         purple_plugins_probe(G_MODULE_SUFFIX);
     144        if (ops != NULL && ops->register_plugins != NULL)
     145                ops->register_plugins();
    147146
    148         purple_theme_manager_init();
     147        purple_plugins_probe(G_MODULE_SUFFIX);
    149148
    150149        /* The buddy icon code uses the imgstore, so init it early. */
    151150        purple_imgstore_init();
     
    158157        purple_connections_init();
    159158
    160159        purple_accounts_init();
    161         purple_savedstatuses_init();
    162160        purple_notify_init();
    163         purple_certificate_init();
    164161        purple_conversations_init();
    165162        purple_blist_init();
    166163        purple_log_init();
    167164        purple_network_init();
    168165        purple_privacy_init();
    169         purple_pounces_init();
    170166        purple_proxy_init();
    171167        purple_dnsquery_init();
    172         purple_sound_init();
    173168        purple_ssl_init();
    174169        purple_stun_init();
    175170        purple_xfers_init();
     
    184179        if (ops != NULL && ops->ui_init != NULL)
    185180                ops->ui_init();
    186181
    187         /* The UI may have registered some theme types, so refresh them */
    188         purple_theme_manager_refresh();
    189 
    190182        return TRUE;
    191183}
    192184
     
    204196        /* Transmission ends */
    205197        purple_connections_disconnect_all();
    206198
     199#if 0
    207200        /*
    208201         * Certificates must be destroyed before the SSL plugins, because
    209202         * PurpleCertificates contain pointers to PurpleCertificateSchemes,
     
    211204         * SSL plugin is uninit.
    212205         */
    213206        purple_certificate_uninit();
     207#endif
    214208
    215209        /* The SSL plugins must be uninit before they're unloaded */
    216210        purple_ssl_uninit();
     
    223217        /* Save .xml files, remove signals, etc. */
    224218        purple_smileys_uninit();
    225219        purple_idle_uninit();
    226         purple_pounces_uninit();
    227220        purple_blist_uninit();
    228221        purple_ciphers_uninit();
    229222        purple_notify_uninit();
    230223        purple_conversations_uninit();
    231224        purple_connections_uninit();
    232225        purple_buddy_icons_uninit();
    233         purple_savedstatuses_uninit();
    234226        purple_status_uninit();
    235227        purple_accounts_uninit();
    236         purple_sound_uninit();
    237         purple_theme_manager_uninit();
    238228        purple_xfers_uninit();
    239229        purple_proxy_uninit();
    240230        purple_dnsquery_uninit();
     
    271261        wpurple_cleanup();
    272262#endif
    273263
     264        xmlCleanupParser();
     265
    274266        _core = NULL;
    275267}
    276268
     
    403395        return TRUE;
    404396}
    405397
     398#if 0
    406399gboolean
    407400purple_core_migrate(void)
    408401{
     
    750743        g_free(status_file);
    751744        return TRUE;
    752745}
     746#endif
    753747
    754748GHashTable* purple_core_get_ui_info() {
    755749        PurpleCoreUiOps *ops = purple_core_get_ui_ops();
  • libpurple/core.h

    diff -ru extract/pidgin-2.10.9/libpurple/core.h libpurple/core.h
    old new  
    7171         */
    7272        GHashTable* (*get_ui_info)(void);
    7373
     74        /** Called during the initialization of the core to give the
     75         *  UI a chance to register static plugins.
     76         */
     77        void (*register_plugins)(void);
     78
    7479        void (*_purple_reserved1)(void);
    7580        void (*_purple_reserved2)(void);
    7681        void (*_purple_reserved3)(void);
     
    164169 * @return A boolean indicating success or migration failure. On failure,
    165170 *         the application must display an error to the user and then exit.
    166171 */
    167 gboolean purple_core_migrate(void);
     172/* gboolean purple_core_migrate(void); */
    168173
    169174/**
    170175 * Ensures that only one instance is running.  If libpurple is built with D-Bus
  • libpurple/debug.c

    Only in extract/pidgin-2.10.9/libpurple: dbus-analyze-functions.py
    Only in extract/pidgin-2.10.9/libpurple: dbus-analyze-signals.py
    Only in extract/pidgin-2.10.9/libpurple: dbus-analyze-types.py
    Only in extract/pidgin-2.10.9/libpurple: dbus-bindings.h
    Only in extract/pidgin-2.10.9/libpurple: dbus-define-api.h
    Only in extract/pidgin-2.10.9/libpurple: dbus-purple.h
    Only in extract/pidgin-2.10.9/libpurple: dbus-server.c
    Only in extract/pidgin-2.10.9/libpurple: dbus-server.h
    Only in extract/pidgin-2.10.9/libpurple: dbus-types.h
    Only in extract/pidgin-2.10.9/libpurple: dbus-useful.c
    Only in extract/pidgin-2.10.9/libpurple: dbus-useful.h
    diff -ru extract/pidgin-2.10.9/libpurple/debug.c libpurple/debug.c
    old new  
    3131static PurpleDebugUiOps *debug_ui_ops = NULL;
    3232
    3333/*
    34  * This determines whether debug info should be written to the
    35  * console or not.
    36  *
    37  * It doesn't make sense to make this a normal Purple preference
    38  * because it's a command line option.  This will always be FALSE,
    39  * unless the user explicitly started the UI with the -d flag.
    40  * It doesn't matter what this value was the last time Purple was
    41  * started, so it doesn't make sense to save it in prefs.
    42  */
    43 static gboolean debug_enabled = FALSE;
    44 
    45 /*
    4634 * These determine whether verbose or unsafe debugging are desired.  I
    4735 * don't want to make these purple preferences because their values should
    4836 * not be remembered across instances of the UI.
     
    5038static gboolean debug_verbose = FALSE;
    5139static gboolean debug_unsafe = FALSE;
    5240
    53 static void
    54 purple_debug_vargs(PurpleDebugLevel level, const char *category,
    55                                  const char *format, va_list args)
     41void
     42purple_debug_with_location(PurpleDebugLevel level, const char *category,
     43                           const char *file, int line, const char *function,
     44                           const char *format, ...)
    5645{
     46        va_list args;
    5747        PurpleDebugUiOps *ops;
    5848        char *arg_s = NULL;
    5949
     
    6151        g_return_if_fail(format != NULL);
    6252
    6353        ops = purple_debug_get_ui_ops();
    64 
    65         if (!debug_enabled && ((ops == NULL) || (ops->print == NULL) ||
    66                         (ops->is_enabled && !ops->is_enabled(level, category))))
     54        if ((ops == NULL) ||
     55            (ops->print_with_location == NULL && ops->print == NULL) ||
     56            (ops->is_enabled && !ops->is_enabled(level, category)))
    6757                return;
    6858
    69         arg_s = g_strdup_vprintf(format, args);
    70 
    71         if (debug_enabled) {
    72                 gchar *ts_s;
    73                 const char *mdate;
    74                 time_t mtime = time(NULL);
    75 
    76 
    77                 mdate = purple_utf8_strftime("%H:%M:%S", localtime(&mtime));
    78                 ts_s = g_strdup_printf("(%s) ", mdate);
    79 
    80                 if (category == NULL)
    81                         g_print("%s%s", ts_s, arg_s);
    82                 else
    83                         g_print("%s%s: %s", ts_s, category, arg_s);
    84 
    85                 g_free(ts_s);
    86         }
     59        va_start(args, format);
    8760
    88         if (ops != NULL && ops->print != NULL)
     61        arg_s = g_strdup_vprintf(format, args);
     62        if (ops->print_with_location != NULL)
     63                ops->print_with_location(level, category, file, line, function, arg_s);
     64        else
    8965                ops->print(level, category, arg_s);
    90 
    9166        g_free(arg_s);
    92 }
    93 
    94 void
    95 purple_debug(PurpleDebugLevel level, const char *category,
    96                    const char *format, ...)
    97 {
    98         va_list args;
    99 
    100         g_return_if_fail(level != PURPLE_DEBUG_ALL);
    101         g_return_if_fail(format != NULL);
    102 
    103         va_start(args, format);
    104         purple_debug_vargs(level, category, format, args);
    105         va_end(args);
    106 }
    10767
    108 void
    109 purple_debug_misc(const char *category, const char *format, ...)
    110 {
    111         va_list args;
    112 
    113         g_return_if_fail(format != NULL);
    114 
    115         va_start(args, format);
    116         purple_debug_vargs(PURPLE_DEBUG_MISC, category, format, args);
    11768        va_end(args);
    11869}
    11970
    120 void
    121 purple_debug_info(const char *category, const char *format, ...)
    122 {
    123         va_list args;
     71/* This is kept for ABI compatibility only. Should be removed once we
     72 * change the version number and thus can safely assume that all old
     73 * plugins will be disabled.
     74 * New code uses purple_debug_with_location. */
     75#undef purple_debug
     76#undef purple_debug_misc
     77#undef purple_debug_info
     78#undef purple_debug_warning
     79#undef purple_debug_error
     80#undef purple_debug_fatal
    12481
    125         g_return_if_fail(format != NULL);
    126 
    127         va_start(args, format);
    128         purple_debug_vargs(PURPLE_DEBUG_INFO, category, format, args);
    129         va_end(args);
    130 }
    131 
    132 void
    133 purple_debug_warning(const char *category, const char *format, ...)
     82static void
     83purple_debug_vargs(PurpleDebugLevel level, const char *category,
     84                                 const char *format, va_list args)
    13485{
    135         va_list args;
     86        PurpleDebugUiOps *ops;
     87        char *arg_s = NULL;
    13688
     89        g_return_if_fail(level != PURPLE_DEBUG_ALL);
    13790        g_return_if_fail(format != NULL);
    13891
    139         va_start(args, format);
    140         purple_debug_vargs(PURPLE_DEBUG_WARNING, category, format, args);
    141         va_end(args);
    142 }
    143 
    144 void
    145 purple_debug_error(const char *category, const char *format, ...)
    146 {
    147         va_list args;
     92        ops = purple_debug_get_ui_ops();
    14893
    149         g_return_if_fail(format != NULL);
     94        if ((ops == NULL) || (ops->print == NULL) ||
     95            (ops->is_enabled && !ops->is_enabled(level, category)))
     96                return;
    15097
    151         va_start(args, format);
    152         purple_debug_vargs(PURPLE_DEBUG_ERROR, category, format, args);
    153         va_end(args);
     98        arg_s = g_strdup_vprintf(format, args);
     99        ops->print(level, category, arg_s);
     100        g_free(arg_s);
    154101}
    155102
    156103void
    157 purple_debug_fatal(const char *category, const char *format, ...)
     104purple_debug(PurpleDebugLevel level, const char *category,
     105                   const char *format, ...)
    158106{
    159107        va_list args;
    160108
     109        g_return_if_fail(level != PURPLE_DEBUG_ALL);
    161110        g_return_if_fail(format != NULL);
    162111
    163112        va_start(args, format);
    164         purple_debug_vargs(PURPLE_DEBUG_FATAL, category, format, args);
     113        purple_debug_vargs(level, category, format, args);
    165114        va_end(args);
    166115}
    167116
    168 void
    169 purple_debug_set_enabled(gboolean enabled)
    170 {
    171         debug_enabled = enabled;
    172 }
    173 
    174 gboolean
    175 purple_debug_is_enabled()
    176 {
    177         return debug_enabled;
    178 }
     117#define PURPLE_IMPL_DEBUG_HELPER(name, NAME)                              \
     118 void                                                                     \
     119 purple_debug_##name(const char *category, const char *format, ...)       \
     120 {                                                                        \
     121         va_list args;                                                    \
     122                                                                          \
     123         g_return_if_fail(format != NULL);                                \
     124                                                                          \
     125         va_start(args, format);                                          \
     126         purple_debug_vargs(PURPLE_DEBUG_##NAME, category, format, args); \
     127         va_end(args);                                                    \
     128 }
     129
     130PURPLE_IMPL_DEBUG_HELPER(misc, MISC)
     131PURPLE_IMPL_DEBUG_HELPER(info, INFO)
     132PURPLE_IMPL_DEBUG_HELPER(warning, WARNING)
     133PURPLE_IMPL_DEBUG_HELPER(error, ERROR)
     134PURPLE_IMPL_DEBUG_HELPER(fatal, FATAL)
     135/* End of the code kept for ABI compatibility */
    179136
    180137void
    181138purple_debug_set_ui_ops(PurpleDebugUiOps *ops)
     
    212169{
    213170        return debug_ui_ops;
    214171}
    215 
    216 void
    217 purple_debug_init(void)
    218 {
    219         /* Read environment variables once per init */
    220         if(g_getenv("PURPLE_UNSAFE_DEBUG"))
    221                 purple_debug_set_unsafe(TRUE);
    222 
    223         if(g_getenv("PURPLE_VERBOSE_DEBUG"))
    224                 purple_debug_set_verbose(TRUE);
    225 
    226         purple_prefs_add_none("/purple/debug");
    227 
    228         /*
    229          * This pref is obsolete and no longer referenced anywhere. It only
    230          * survives here because it would be an API break if we removed it.
    231          * Remove this when we get to 3.0.0 :)
    232          */
    233         purple_prefs_add_bool("/purple/debug/timestamps", TRUE);
    234 }
    235 
  • libpurple/debug.h

    diff -ru extract/pidgin-2.10.9/libpurple/debug.h libpurple/debug.h
    old new  
    5050{
    5151        void (*print)(PurpleDebugLevel level, const char *category,
    5252                                  const char *arg_s);
     53        void (*print_with_location)(PurpleDebugLevel level, const char *category,
     54                                    const char *file, int line,
     55                                    const char *function, const char *arg_s);
    5356        gboolean (*is_enabled)(PurpleDebugLevel level,
    5457                        const char *category);
    5558
     
    6669/**************************************************************************/
    6770/** @name Debug API                                                       */
    6871/**************************************************************************/
     72
    6973/**
    7074 * Outputs debug information.
    7175 *
    7276 * @param level    The debug level.
    7377 * @param category The category (or @c NULL).
     78 * @param file     The file containing the calling code.
     79 * @param line     The line number.
     80 * @param function The calling function.
    7481 * @param format   The format string.
    7582 */
     83void purple_debug_with_location(PurpleDebugLevel level, const char *category,
     84                                const char *file, int line,
     85                                const char *function, const char *format, ...);
     86
     87#ifndef _MSC_VER
     88/* The use of __VA_ARGS__ will cause gcc to annoyingly output this warning:
     89 *  warning: anonymous variadic macros were introduced in C99
     90 * Tell it to shut up...
     91 */
     92#pragma GCC system_header
     93#endif
     94
     95/**
     96 * Outputs debug information.
     97 *
     98 * @param level    The debug level.
     99 * @param category The category (or @c NULL).
     100 * @param format   The format string.
     101 */
     102/*
    76103void purple_debug(PurpleDebugLevel level, const char *category,
    77104                                const char *format, ...) G_GNUC_PRINTF(3, 4);
     105*/
     106#define purple_debug(level, category, ...)                              \
     107        purple_debug_with_location(level, category, __FILE__, __LINE__, \
     108                                   __FUNCTION__, __VA_ARGS__)
    78109
    79110/**
    80111 * Outputs misc. level debug information.
     
    87118 *
    88119 * @see purple_debug()
    89120 */
     121/*
    90122void purple_debug_misc(const char *category, const char *format, ...) G_GNUC_PRINTF(2, 3);
     123*/
     124#define purple_debug_misc(category, ...) \
     125        purple_debug(PURPLE_DEBUG_MISC, category, __VA_ARGS__)
    91126
    92127/**
    93128 * Outputs info level debug information.
     
    100135 *
    101136 * @see purple_debug()
    102137 */
     138/*
    103139void purple_debug_info(const char *category, const char *format, ...) G_GNUC_PRINTF(2, 3);
     140*/
     141#define purple_debug_info(category, ...) \
     142        purple_debug(PURPLE_DEBUG_INFO, category, __VA_ARGS__)
    104143
    105144/**
    106145 * Outputs warning level debug information.
     
    113152 *
    114153 * @see purple_debug()
    115154 */
     155/*
    116156void purple_debug_warning(const char *category, const char *format, ...) G_GNUC_PRINTF(2, 3);
     157*/
     158#define purple_debug_warning(category, ...) \
     159        purple_debug(PURPLE_DEBUG_WARNING, category, __VA_ARGS__)
    117160
    118161/**
    119162 * Outputs error level debug information.
     
    126169 *
    127170 * @see purple_debug()
    128171 */
     172/*
    129173void purple_debug_error(const char *category, const char *format, ...) G_GNUC_PRINTF(2, 3);
     174*/
     175#define purple_debug_error(category, ...) \
     176        purple_debug(PURPLE_DEBUG_ERROR, category, __VA_ARGS__)
    130177
    131178/**
    132179 * Outputs fatal error level debug information.
    133180 *
    134  * This is a wrapper for purple_debug(), and uses PURPLE_DEBUG_ERROR as
     181 * This is a wrapper for purple_debug(), and uses PURPLE_DEBUG_FATAL as
    135182 * the level.
    136183 *
    137184 * @param category The category (or @c NULL).
     
    139186 *
    140187 * @see purple_debug()
    141188 */
     189/*
    142190void purple_debug_fatal(const char *category, const char *format, ...) G_GNUC_PRINTF(2, 3);
    143 
    144 /**
    145  * Enable or disable printing debug output to the console.
    146  *
    147  * @param enabled TRUE to enable debug output or FALSE to disable it.
    148  */
    149 void purple_debug_set_enabled(gboolean enabled);
    150 
    151 /**
    152  * Check if console debug output is enabled.
    153  *
    154  * @return TRUE if debugging is enabled, FALSE if it is not.
    155  */
    156 gboolean purple_debug_is_enabled(void);
     191*/
     192#define purple_debug_fatal(category, ...) \
     193        purple_debug(PURPLE_DEBUG_FATAL, category, __VA_ARGS__)
    157194
    158195/**
    159196 * Enable or disable verbose debugging.  This ordinarily should only be called
     
    224261
    225262/*@}*/
    226263
    227 /**************************************************************************/
    228 /** @name Debug Subsystem                                                 */
    229 /**************************************************************************/
    230 /*@{*/
    231 
    232 /**
    233  * Initializes the debug subsystem.
    234  */
    235 void purple_debug_init(void);
    236 
    237 /*@}*/
    238 
    239264#ifdef __cplusplus
    240265}
    241266#endif
  • libpurple/dnsquery.c

    Only in extract/pidgin-2.10.9/libpurple: desktopitem.c
    Only in extract/pidgin-2.10.9/libpurple: desktopitem.h
    diff -ru extract/pidgin-2.10.9/libpurple/dnsquery.c libpurple/dnsquery.c
    old new  
    3838#include <resolv.h>
    3939#endif
    4040
    41 #if (defined(__APPLE__) || defined (__unix__)) && !defined(__osf__)
    42 #define PURPLE_DNSQUERY_USE_FORK
    43 #endif
    4441/**************************************************************************
    4542 * DNS query API
    4643 **************************************************************************/
     
    900897                return FALSE;
    901898        }
    902899
    903         if (purple_dnsquery_ui_resolve(query_data))
    904                 /* The UI is handling the resolve; we're done */
    905                 return FALSE;
    906 
    907         resolve_host(query_data);
    908 
     900        g_return_val_if_fail(purple_dnsquery_ui_resolve(query_data), FALSE);
     901        /* The UI is handling the resolve; we're done */
    909902        return FALSE;
    910903}
    911904
  • libpurple/eventloop.c

    diff -ru extract/pidgin-2.10.9/libpurple/eventloop.c libpurple/eventloop.c
    old new  
    2525 */
    2626#include "internal.h"
    2727#include "eventloop.h"
     28#include "debug.h"
    2829
    2930static PurpleEventLoopUiOps *eventloop_ui_ops = NULL;
    3031
     
    5657}
    5758
    5859guint
    59 purple_input_add(int source, PurpleInputCondition condition, PurpleInputFunction func, gpointer user_data)
     60purple_input_add_with_location(int source, PurpleInputCondition condition,
     61                               PurpleInputFunction func, gpointer user_data,
     62                               const char *file, int line, const char *function)
    6063{
    6164        PurpleEventLoopUiOps *ops = purple_eventloop_get_ui_ops();
    6265
     66        purple_debug_with_location(PURPLE_DEBUG_MISC, "eventloop",
     67                                   file, line, function,
     68                                   "purple_input_add, fd = %i", source);
    6369        return ops->input_add(source, condition, func, user_data);
    6470}
    6571
     72
     73
    6674gboolean
    67 purple_input_remove(guint tag)
     75purple_input_remove_with_location(guint tag, const char *file, int line,
     76                                  const char *function)
    6877{
    6978        PurpleEventLoopUiOps *ops = purple_eventloop_get_ui_ops();
    7079
     80        purple_debug_with_location(PURPLE_DEBUG_MISC, "eventloop",
     81                                   file, line, function,
     82                                   "purple_input_remove, handle = %i", tag);
     83
    7184        return ops->input_remove(tag);
    7285}
    7386
  • libpurple/eventloop.h

    diff -ru extract/pidgin-2.10.9/libpurple/eventloop.h libpurple/eventloop.h
    old new  
    217217 * @return The resulting handle (will be greater than 0).
    218218 * @see g_io_add_watch_full
    219219 */
    220 guint purple_input_add(int fd, PurpleInputCondition cond,
    221                        PurpleInputFunction func, gpointer user_data);
     220/* guint purple_input_add(int fd, PurpleInputCondition cond,
     221                       PurpleInputFunction func, gpointer user_data); */
     222guint purple_input_add_with_location(int fd, PurpleInputCondition cond,
     223                                     PurpleInputFunction func,
     224                                     gpointer user_data,
     225                                     const char *file, int line,
     226                                     const char *function);
     227
     228#define purple_input_add(fd, cond, func, user_data)                   \
     229  purple_input_add_with_location(fd, cond, func, user_data, __FILE__, \
     230                                 __LINE__, __FUNCTION__)
    222231
    223232/**
    224233 * Removes an input handler.
     
    226235 * @param handle The handle of the input handler. Note that this is the return
    227236 *               value from purple_input_add(), <i>not</i> the file descriptor.
    228237 */
    229 gboolean purple_input_remove(guint handle);
     238/* gboolean purple_input_remove(guint handle); */
     239gboolean purple_input_remove_with_location(guint handle, const char *file,
     240                                           int line, const char *function);
     241
     242#define purple_input_remove(handle)                                          \
     243  purple_input_remove_with_location(handle, __FILE__, __LINE__, __FUNCTION__)
    230244
    231245/**
    232246 * Get the current error status for an input.
  • libpurple/ft.c

    Only in extract/pidgin-2.10.9/libpurple: example
    diff -ru extract/pidgin-2.10.9/libpurple/ft.c libpurple/ft.c
    old new  
    279279        const char *message, gboolean is_error, gboolean print_thumbnail)
    280280{
    281281        PurpleConversation *conv = NULL;
    282         PurpleMessageFlags flags = PURPLE_MESSAGE_SYSTEM;
     282        PurpleMessageFlags flags = PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LINKIFY;
    283283        char *escaped;
    284284        gconstpointer thumbnail_data;
    285285        gsize size;
  • libpurple/idle.c

    Only in extract/pidgin-2.10.9/libpurple: gaim-compat.h
    Only in extract/pidgin-2.10.9/libpurple: gconf
    Only in libpurple: gettext.c
    Only in libpurple: gettext.h
    diff -ru extract/pidgin-2.10.9/libpurple/idle.c libpurple/idle.c
    old new  
    2424
    2525#include "connection.h"
    2626#include "debug.h"
    27 #include "eventloop.h"
    2827#include "idle.h"
    29 #include "log.h"
    30 #include "prefs.h"
    31 #include "savedstatuses.h"
    3228#include "signals.h"
    3329
    34 typedef enum
    35 {
    36         PURPLE_IDLE_NOT_AWAY = 0,
    37         PURPLE_IDLE_AUTO_AWAY,
    38         PURPLE_IDLE_AWAY_BUT_NOT_AUTO_AWAY
    39 
    40 } PurpleAutoAwayState;
    41 
    42 static PurpleIdleUiOps *idle_ui_ops = NULL;
    43 
    4430/**
    4531 * This is needed for the I'dle Mak'er plugin to work correctly.  We
    4632 * use it to determine if we're the ones who set our accounts idle
     
    5137 */
    5238static GList *idled_accts = NULL;
    5339
    54 static guint idle_timer = 0;
    55 
    56 static time_t last_active_time = 0;
    57 
    5840static void
    5941set_account_idle(PurpleAccount *account, int time_idle)
    6042{
     
    9072        purple_presence_set_idle(presence, FALSE, 0);
    9173}
    9274
    93 
    94 static gboolean no_away = FALSE;
    95 static gint time_until_next_idle_event;
    96 /*
    97  * This function should be called when you think your idle state
    98  * may have changed.  Maybe you're over the 10-minute mark and
    99  * Purple should start reporting idle time to the server.  Maybe
    100  * you've returned from being idle.  Maybe your auto-away message
    101  * should be set.
    102  *
    103  * There is no harm to calling this many many times, other than
    104  * it will be kinda slow.  This is called by a timer set when
    105  * Purple starts.  It is also called when you send an IM, a chat, etc.
    106  *
    107  * This function has 3 sections.
    108  * 1. Get your idle time.  It will query XScreenSaver or Windows
    109  *    or use the Purple idle time.  Whatever.
    110  * 2. Set or unset your auto-away message.
    111  * 3. Report your current idle time to the IM server.
    112  */
    113 
    114 static void
    115 check_idleness(void)
     75static time_t global_time_idle = 0;
     76void
     77purple_idle_set(time_t time_idle)
    11678{
    117         time_t time_idle;
    118         gboolean auto_away;
    119         const gchar *idle_reporting;
    120         gboolean report_idle = TRUE;
    121         gint away_seconds = 0;
    122         gint idle_recheck_interval = 0;
    123         gint idle_poll_seconds = purple_prefs_get_int("/purple/away/mins_before_away") * 60;
    124         purple_signal_emit(purple_blist_get_handle(), "update-idle");
    125 
    126         idle_reporting = purple_prefs_get_string("/purple/away/idle_reporting");
    127         auto_away = purple_prefs_get_bool("/purple/away/away_when_idle");
    128 
    129         if (purple_strequal(idle_reporting, "system") &&
    130                 (idle_ui_ops != NULL) && (idle_ui_ops->get_time_idle != NULL))
    131         {
    132                 /* Use system idle time (mouse or keyboard movement, etc.) */
    133                 time_idle = idle_ui_ops->get_time_idle();
    134                 idle_recheck_interval = 1;
    135         }
    136         else if (purple_strequal(idle_reporting, "purple"))
    137         {
    138                 /* Use 'Purple idle' */
    139                 time_idle = time(NULL) - last_active_time;
    140                 idle_recheck_interval = 0;
    141         }
    142         else
    143         {
    144                 /* Don't report idle time */
    145                 time_idle = 0;
    146                 report_idle = FALSE;
    147 
    148                 /* If we're not reporting idle, we can still do auto-away.
    149                  * First try "system" and if that isn't possible, use "purple" */
    150                 if (auto_away)
    151                 {
    152                         if ((idle_ui_ops != NULL) && (idle_ui_ops->get_time_idle != NULL))
    153                         {
    154                                 time_idle = idle_ui_ops->get_time_idle();
    155                                 idle_recheck_interval = 1;
    156                         }
    157                         else
    158                         {
    159                                 time_idle = time(NULL) - last_active_time;
    160                                 idle_recheck_interval = 0;
    161                         }
    162                 }
    163                 else
    164                 {
    165                         if (!no_away)
    166                         {
    167                                 no_away = TRUE;
    168                                 purple_savedstatus_set_idleaway(FALSE);
    169                         }
    170                         time_until_next_idle_event = 0;
    171                         return;
    172                 }
    173         }
    174 
    175         time_until_next_idle_event = idle_poll_seconds - time_idle;
    176         if (time_until_next_idle_event < 0)
    177         {
    178                 /* If we're already idle, check again as appropriate. */
    179                 time_until_next_idle_event = idle_recheck_interval;
    180         }
    181 
    182         if (auto_away || !no_away)
    183                 away_seconds = 60 * purple_prefs_get_int("/purple/away/mins_before_away");
    184 
    185         if (auto_away && time_idle > away_seconds)
    186         {
    187                 purple_savedstatus_set_idleaway(TRUE);
    188                 no_away = FALSE;
    189         }
    190         else if (purple_savedstatus_is_idleaway() && time_idle < away_seconds)
    191         {
    192                 purple_savedstatus_set_idleaway(FALSE);
    193                 if (time_until_next_idle_event == 0 || (away_seconds - time_idle) < time_until_next_idle_event)
    194                         time_until_next_idle_event = away_seconds - time_idle;
    195         }
    196 
    197         /* Idle reporting stuff */
    198         if (report_idle && (time_idle >= idle_poll_seconds))
     79        if (time_idle)
    19980        {
    20081                GList *l;
    20182                for (l = purple_connections_get_all(); l != NULL; l = l->next)
     
    20485                        set_account_idle(purple_connection_get_account(gc), time_idle);
    20586                }
    20687        }
    207         else if (!report_idle || (time_idle < idle_poll_seconds ))
     88        else
    20889        {
    20990                while (idled_accts != NULL)
    21091                        set_account_unidle(idled_accts->data);
    21192        }
     93        global_time_idle = time_idle;
    21294}
    21395
    21496
    215 /*
    216  * Check idle and set the timer to fire at the next idle-worth event
    217  */
    218 static gboolean
    219 check_idleness_timer(void)
    220 {
    221         check_idleness();
    222         if (time_until_next_idle_event == 0)
    223                 idle_timer = 0;
    224         else
    225         {
    226                 /* +1 for the boundary,
    227                  * +1 more for g_timeout_add_seconds rounding. */
    228                 idle_timer = purple_timeout_add_seconds(time_until_next_idle_event + 2, (GSourceFunc)check_idleness_timer, NULL);
    229         }
    230         return FALSE;
    231 }
    232 
    233 static void
    234 im_msg_sent_cb(PurpleAccount *account, const char *receiver,
    235                            const char *message, void *data)
    236 {
    237         /* Check our idle time after an IM is sent */
    238         check_idleness();
    239 }
    240 
    24197static void
    24298signing_on_cb(PurpleConnection *gc, void *data)
    24399{
    244100        /* When signing on a new account, check if the account should be idle */
    245         check_idleness();
     101        if (global_time_idle)
     102                set_account_idle(purple_connection_get_account(gc), global_time_idle);
    246103}
    247104
    248105static void
    249106signing_off_cb(PurpleConnection *gc, void *data)
    250107{
    251         PurpleAccount *account;
    252 
    253         account = purple_connection_get_account(gc);
    254         set_account_unidle(account);
    255 }
    256 
    257 static void
    258 idle_reporting_cb(const char *name, PurplePrefType type, gconstpointer val, gpointer data)
    259 {
    260         if (idle_timer)
    261                 purple_timeout_remove(idle_timer);
    262         idle_timer = 0;
    263         check_idleness_timer();
    264 }
    265 
    266 void
    267 purple_idle_touch()
    268 {
    269         time(&last_active_time);
    270         if (!no_away)
    271         {
    272                 if (idle_timer)
    273                         purple_timeout_remove(idle_timer);
    274                 idle_timer = 0;
    275                 check_idleness_timer();
    276         }
    277 }
    278 
    279 void
    280 purple_idle_set(time_t time)
    281 {
    282         last_active_time = time;
    283 }
    284 
    285 void
    286 purple_idle_set_ui_ops(PurpleIdleUiOps *ops)
    287 {
    288         idle_ui_ops = ops;
    289 }
    290 
    291 PurpleIdleUiOps *
    292 purple_idle_get_ui_ops(void)
    293 {
    294         return idle_ui_ops;
     108        set_account_unidle(purple_connection_get_account(gc));
    295109}
    296110
    297111static void *
     
    302116        return &handle;
    303117}
    304118
    305 static gboolean _do_purple_idle_touch_cb(gpointer data)
    306 {
    307         int idle_poll_minutes = purple_prefs_get_int("/purple/away/mins_before_away");
    308 
    309          /* +1 more for g_timeout_add_seconds rounding. */
    310         idle_timer = purple_timeout_add_seconds((idle_poll_minutes * 60) + 2, (GSourceFunc)check_idleness_timer, NULL);
    311 
    312         purple_idle_touch();
    313 
    314         return FALSE;
    315 }
    316 
    317 
    318119void
    319120purple_idle_init()
    320121{
    321         purple_signal_connect(purple_conversations_get_handle(), "sent-im-msg",
    322                                                 purple_idle_get_handle(),
    323                                                 PURPLE_CALLBACK(im_msg_sent_cb), NULL);
    324122        purple_signal_connect(purple_connections_get_handle(), "signing-on",
    325123                                                purple_idle_get_handle(),
    326124                                                PURPLE_CALLBACK(signing_on_cb), NULL);
    327125        purple_signal_connect(purple_connections_get_handle(), "signing-off",
    328126                                                purple_idle_get_handle(),
    329127                                                PURPLE_CALLBACK(signing_off_cb), NULL);
    330 
    331         purple_prefs_connect_callback(purple_idle_get_handle(), "/purple/away/idle_reporting",
    332                                       idle_reporting_cb, NULL);
    333 
    334         /* Initialize the idleness asynchronously so it doesn't check idleness,
    335          * and potentially try to change the status before the UI is initialized */
    336         purple_timeout_add(0, _do_purple_idle_touch_cb, NULL);
    337 
    338128}
    339129
    340130void
    341131purple_idle_uninit()
    342132{
    343133        purple_signals_disconnect_by_handle(purple_idle_get_handle());
    344         purple_prefs_disconnect_by_handle(purple_idle_get_handle());
    345 
    346         /* Remove the idle timer */
    347         if (idle_timer > 0)
    348                 purple_timeout_remove(idle_timer);
    349         idle_timer = 0;
    350134}
  • libpurple/idle.h

    diff -ru extract/pidgin-2.10.9/libpurple/idle.h libpurple/idle.h
    old new  
    2828
    2929#include <time.h>
    3030
    31 /**
    32  * Idle UI operations.
    33  */
    34 typedef struct
    35 {
    36         time_t (*get_time_idle)(void);
    37 
    38         void (*_purple_reserved1)(void);
    39         void (*_purple_reserved2)(void);
    40         void (*_purple_reserved3)(void);
    41         void (*_purple_reserved4)(void);
    42 } PurpleIdleUiOps;
    43 
    4431#ifdef __cplusplus
    4532extern "C" {
    4633#endif
     
    5138/*@{*/
    5239
    5340/**
    54  * Touch our idle tracker.  This signifies that the user is
    55  * 'active'.  The conversation code calls this when the
    56  * user sends an IM, for example.
    57  */
    58 void purple_idle_touch(void);
    59 
    60 /**
    61  * Fake our idle time by setting the time at which our
    62  * accounts purportedly became idle.  This is used by
    63  * the I'dle Mak'er plugin.
     41 * Set as idle (if the timestamp is provided) or as unidle if the
     42 * timestamp is 0.
    6443 */
    6544void purple_idle_set(time_t time);
    6645
     
    7251/*@{*/
    7352
    7453/**
    75  * Sets the UI operations structure to be used for idle reporting.
    76  *
    77  * @param ops The UI operations structure.
    78  */
    79 void purple_idle_set_ui_ops(PurpleIdleUiOps *ops);
    80 
    81 /**
    82  * Returns the UI operations structure used for idle reporting.
    83  *
    84  * @return The UI operations structure in use.
    85  */
    86 PurpleIdleUiOps *purple_idle_get_ui_ops(void);
    87 
    88 /**
    8954 * Initializes the idle system.
    9055 */
    9156void purple_idle_init(void);
  • libpurple/internal.h

    diff -ru extract/pidgin-2.10.9/libpurple/internal.h libpurple/internal.h
    old new  
    4545 * taken from an email to the texinfo mailing list by Manuel Guerrero.
    4646 * Thank you Manuel, and thank you Alex's good friend Google.
    4747 */
     48
     49#include <locale.h>
     50#include "gettext.h"
     51
     52#define _(String) (purple_get_text(PACKAGE, String))
     53#define N_(String) (String)
     54#define ngettext(Singular, Plural, Number) dngettext(PACKAGE, Singular, Plural, Number)
     55#define dngettext(Domain, Singular, Plural, Number) (purple_get_plural_text(Domain, Singular, Plural, Number))
     56
    4857#ifdef ENABLE_NLS
    49 #  include <locale.h>
    5058#  include <libintl.h>
    51 #  define _(String) ((const char *)dgettext(PACKAGE, String))
    5259#  ifdef gettext_noop
     60#    undef N_
    5361#    define N_(String) gettext_noop (String)
    54 #  else
    55 #    define N_(String) (String)
    5662#  endif
    57 #else
    58 #  include <locale.h>
    59 #  define N_(String) (String)
    60 #  ifndef _
    61 #    define _(String) ((const char *)String)
    62 #  endif
    63 #  define ngettext(Singular, Plural, Number) ((Number == 1) ? ((const char *)Singular) : ((const char *)Plural))
    64 #  define dngettext(Domain, Singular, Plural, Number) ((Number == 1) ? ((const char *)Singular) : ((const char *)Plural))
    6563#endif
    6664
    6765#ifdef HAVE_ENDIAN_H
     
    9997#include <langinfo.h>
    10098#endif
    10199
    102 #include <gmodule.h>
    103 
    104100#ifdef PURPLE_PLUGINS
     101# include <gmodule.h>
    105102# ifdef HAVE_DLFCN_H
    106103#  include <dlfcn.h>
    107104# endif
     
    139136#include "win32dep.h"
    140137#endif
    141138
    142 #ifdef HAVE_CONFIG_H
     139#ifdef SIZEOF_TIME_T
    143140#if SIZEOF_TIME_T == 4
    144141#       define PURPLE_TIME_T_MODIFIER "lu"
    145142#elif SIZEOF_TIME_T == 8
  • libpurple/log.h

    Only in extract/pidgin-2.10.9/libpurple: log.c
    diff -ru extract/pidgin-2.10.9/libpurple/log.h libpurple/log.h
    old new  
    1 /**
    2  * @file log.h Logging API
    3  * @ingroup core
    4  * @see @ref log-signals
    5  */
    6 
    7 /* purple
    8  *
    9  * Purple is the legal property of its developers, whose names are too numerous
    10  * to list here.  Please refer to the COPYRIGHT file distributed with this
    11  * source distribution.
    12  *
    13  * This program is free software; you can redistribute it and/or modify
    14  * it under the terms of the GNU General Public License as published by
    15  * the Free Software Foundation; either version 2 of the License, or
    16  * (at your option) any later version.
    17  *
    18  * This program is distributed in the hope that it will be useful,
    19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    21  * GNU General Public License for more details.
    22  *
    23  * You should have received a copy of the GNU General Public License
    24  * along with this program; if not, write to the Free Software
    25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
    26  */
    271#ifndef _PURPLE_LOG_H_
    282#define _PURPLE_LOG_H_
    293
    30 #include <stdio.h>
    31 
    32 
    33 /********************************************************
    34  * DATA STRUCTURES **************************************
    35  ********************************************************/
    36 
    37 typedef struct _PurpleLog PurpleLog;
    38 typedef struct _PurpleLogLogger PurpleLogLogger;
    39 typedef struct _PurpleLogCommonLoggerData PurpleLogCommonLoggerData;
    40 typedef struct _PurpleLogSet PurpleLogSet;
    41 
    42 typedef enum {
    43         PURPLE_LOG_IM,
    44         PURPLE_LOG_CHAT,
    45         PURPLE_LOG_SYSTEM
    46 } PurpleLogType;
    47 
    48 typedef enum {
    49         PURPLE_LOG_READ_NO_NEWLINE = 1
    50 } PurpleLogReadFlags;
    51 
    52 #include "account.h"
    53 #include "conversation.h"
    54 
    55 typedef void (*PurpleLogSetCallback) (GHashTable *sets, PurpleLogSet *set);
    56 
    57 /**
    58  * A log logger.
    59  *
    60  * This struct gets filled out and is included in the PurpleLog.  It contains everything
    61  * needed to write and read from logs.
    62  */
    63 struct _PurpleLogLogger {
    64         char *name;               /**< The logger's name */
    65         char *id;                 /**< an identifier to refer to this logger */
    66 
    67         /** This gets called when the log is first created.
    68             I don't think this is actually needed. */
    69         void (*create)(PurpleLog *log);
    70 
    71         /** This is used to write to the log file */
    72         gsize (*write)(PurpleLog *log,
    73                      PurpleMessageFlags type,
    74                      const char *from,
    75                      time_t time,
    76                      const char *message);
    77 
    78         /** Called when the log is destroyed */
    79         void (*finalize)(PurpleLog *log);
    80 
    81         /** This function returns a sorted GList of available PurpleLogs */
    82         GList *(*list)(PurpleLogType type, const char *name, PurpleAccount *account);
    83 
    84         /** Given one of the logs returned by the logger's list function,
    85          *  this returns the contents of the log in GtkIMHtml markup */
    86         char *(*read)(PurpleLog *log, PurpleLogReadFlags *flags);
    87 
    88         /** Given one of the logs returned by the logger's list function,
    89          *  this returns the size of the log in bytes */
    90         int (*size)(PurpleLog *log);
    91 
    92         /** Returns the total size of all the logs. If this is undefined a default
    93          *  implementation is used */
    94         int (*total_size)(PurpleLogType type, const char *name, PurpleAccount *account);
    95 
    96         /** This function returns a sorted GList of available system PurpleLogs */
    97         GList *(*list_syslog)(PurpleAccount *account);
    98 
    99         /** Adds PurpleLogSets to a GHashTable. By passing the data in the PurpleLogSets
    100          *  to list, the caller can get every available PurpleLog from the logger.
    101          *  Loggers using purple_log_common_writer() (or otherwise storing their
    102          *  logs in the same directory structure as the stock loggers) do not
    103          *  need to implement this function.
    104          *
    105          *  Loggers which implement this function must create a PurpleLogSet,
    106          *  then call @a cb with @a sets and the newly created PurpleLogSet. */
    107         void (*get_log_sets)(PurpleLogSetCallback cb, GHashTable *sets);
    108 
    109         /* Attempts to delete the specified log, indicating success or failure */
    110         gboolean (*remove)(PurpleLog *log);
    111 
    112         /* Tests whether a log is deletable */
    113         gboolean (*is_deletable)(PurpleLog *log);
    114 
    115         void (*_purple_reserved1)(void);
    116         void (*_purple_reserved2)(void);
    117         void (*_purple_reserved3)(void);
    118         void (*_purple_reserved4)(void);
    119 };
    120 
    121 /**
    122  * A log.  Not the wooden type.
    123  */
    124 struct _PurpleLog {
    125         PurpleLogType type;                     /**< The type of log this is */
    126         char *name;                           /**< The name of this log */
    127         PurpleAccount *account;                 /**< The account this log is taking
    128                                                    place on */
    129         PurpleConversation *conv;               /**< The conversation being logged */
    130         time_t time;                          /**< The time this conversation
    131                                                    started, converted to the local timezone */
    132 
    133         PurpleLogLogger *logger;                /**< The logging mechanism this log
    134                                                    is to use */
    135         void *logger_data;                    /**< Data used by the log logger */
    136         struct tm *tm;                        /**< The time this conversation
    137                                                    started, saved with original
    138                                                    timezone data, if available and
    139                                                    if struct tm has the BSD
    140                                                    timezone fields, else @c NULL.
    141                                                    Do NOT modify anything in this struct.*/
    142 
    143         /* IMPORTANT: Some code in log.c allocates these without zeroing them.
    144          * IMPORTANT: Update that code if you add members here. */
    145 };
    146 
    147 /**
    148  * A common logger_data struct containing a file handle and path, as well
    149  * as a pointer to something else for additional data.
    150  */
    151 struct _PurpleLogCommonLoggerData {
    152         char *path;
    153         FILE *file;
    154         void *extra_data;
    155 };
    156 
    157 /**
    158  * Describes available logs.
    159  *
    160  * By passing the elements of this struct to purple_log_get_logs(), the caller
    161  * can get all available PurpleLogs.
    162  */
    163 struct _PurpleLogSet {
    164         PurpleLogType type;                     /**< The type of logs available */
    165         char *name;                           /**< The name of the logs available */
    166         PurpleAccount *account;                 /**< The account the available logs
    167                                                    took place on. This will be
    168                                                    @c NULL if the account no longer
    169                                                    exists. (Depending on a
    170                                                    logger's implementation of
    171                                                    list, it may not be possible
    172                                                    to load such logs.) */
    173         gboolean buddy;                       /**< Is this (account, name) a buddy
    174                                                    on the buddy list? */
    175         char *normalized_name;                /**< The normalized version of
    176                                                    @a name. It must be set, and
    177                                                    may be set to the same pointer
    178                                                    value as @a name. */
    179 
    180         /* IMPORTANT: Some code in log.c allocates these without zeroing them.
    181          * IMPORTANT: Update that code if you add members here. */
    182 };
    183 
    184 #ifdef __cplusplus
    185 extern "C" {
    186 #endif
    187 
    188 /***************************************/
    189 /** @name Log Functions                */
    190 /***************************************/
    191 /*@{*/
    192 
    193 /**
    194  * Creates a new log
    195  *
    196  * @param type        The type of log this is.
    197  * @param name        The name of this conversation (buddy name, chat name,
    198  *                    etc.)
    199  * @param account     The account the conversation is occurring on
    200  * @param conv        The conversation being logged
    201  * @param time        The time this conversation started
    202  * @param tm          The time this conversation started, with timezone data,
    203  *                    if available and if struct tm has the BSD timezone fields.
    204  * @return            The new log
    205  */
    206 PurpleLog *purple_log_new(PurpleLogType type, const char *name, PurpleAccount *account,
    207                       PurpleConversation *conv, time_t time, const struct tm *tm);
    208 
    209 /**
    210  * Frees a log
    211  *
    212  * @param log         The log to destroy
    213  */
    214 void purple_log_free(PurpleLog *log);
    215 
    216 /**
    217  * Writes to a log file. Assumes you have checked preferences already.
    218  *
    219  * @param log          The log to write to
    220  * @param type         The type of message being logged
    221  * @param from         Whom this message is coming from, or @c NULL for
    222  *                     system messages
    223  * @param time         A timestamp in UNIX time
    224  * @param message      The message to log
    225  */
    226 void purple_log_write(PurpleLog *log,
    227                     PurpleMessageFlags type,
    228                     const char *from,
    229                     time_t time,
    230                     const char *message);
    231 
    232 /**
    233  * Reads from a log
    234  *
    235  * @param log   The log to read from
    236  * @param flags The returned logging flags.
    237  *
    238  * @return The contents of this log in Purple Markup.
    239  */
    240 char *purple_log_read(PurpleLog *log, PurpleLogReadFlags *flags);
    241 
    242 /**
    243  * Returns a list of all available logs
    244  *
    245  * @param type                The type of the log
    246  * @param name                The name of the log
    247  * @param account             The account
    248  * @return                    A sorted list of PurpleLogs
    249  */
    250 GList *purple_log_get_logs(PurpleLogType type, const char *name, PurpleAccount *account);
    251 
    252 /**
    253  * Returns a GHashTable of PurpleLogSets.
    254  *
    255  * A "log set" here means the information necessary to gather the
    256  * PurpleLogs for a given buddy/chat. This information would be passed
    257  * to purple_log_list to get a list of PurpleLogs.
    258  *
    259  * The primary use of this function is to get a list of everyone the
    260  * user has ever talked to (assuming he or she uses logging).
    261  *
    262  * The GHashTable that's returned will free all log sets in it when
    263  * destroyed. If a PurpleLogSet is removed from the GHashTable, it
    264  * must be freed with purple_log_set_free().
    265  *
    266  * @return A GHashTable of all available unique PurpleLogSets
    267  */
    268 GHashTable *purple_log_get_log_sets(void);
    269 
    270 /**
    271  * Returns a list of all available system logs
    272  *
    273  * @param account The account
    274  * @return        A sorted list of PurpleLogs
    275  */
    276 GList *purple_log_get_system_logs(PurpleAccount *account);
    277 
    278 /**
    279  * Returns the size of a log
    280  *
    281  * @param log                 The log
    282  * @return                    The size of the log, in bytes
    283  */
    284 int purple_log_get_size(PurpleLog *log);
    285 
    286 /**
    287  * Returns the size, in bytes, of all available logs in this conversation
    288  *
    289  * @param type                The type of the log
    290  * @param name                The name of the log
    291  * @param account             The account
    292  * @return                    The size in bytes
    293  */
    294 int purple_log_get_total_size(PurpleLogType type, const char *name, PurpleAccount *account);
    295 
    296 /**
    297  * Returns the activity score of a log, based on total size in bytes,
    298  * which is then decayed based on age
    299  *
    300  * @param type                The type of the log
    301  * @param name                The name of the log
    302  * @param account             The account
    303  * @return                    The activity score
    304  *
    305  * @since 2.6.0
    306  */
    307 int purple_log_get_activity_score(PurpleLogType type, const char *name, PurpleAccount *account);
    308 
    309 /**
    310  * Tests whether a log is deletable
    311  *
    312  * A return value of @c FALSE indicates that purple_log_delete() will fail on this
    313  * log, unless something changes between the two calls.  A return value of @c TRUE,
    314  * however, does not guarantee the log can be deleted.
    315  *
    316  * @param log                 The log
    317  * @return                    A boolean indicating if the log is deletable
    318  */
    319 gboolean purple_log_is_deletable(PurpleLog *log);
    320 
    321 /**
    322  * Deletes a log
    323  *
    324  * @param log                 The log
    325  * @return                    A boolean indicating success or failure
    326  */
    327 gboolean purple_log_delete(PurpleLog *log);
    328 
    329 /**
    330  * Returns the default logger directory Purple uses for a given account
    331  * and username.  This would be where Purple stores logs created by
    332  * the built-in text or HTML loggers.
    333  *
    334  * @param type                The type of the log.
    335  * @param name                The name of the log.
    336  * @param account             The account.
    337  * @return                    The default logger directory for Purple.
    338  */
    339 char *purple_log_get_log_dir(PurpleLogType type, const char *name, PurpleAccount *account);
    340 
    341 /**
    342  * Implements GCompareFunc for PurpleLogs
    343  *
    344  * @param y                   A PurpleLog
    345  * @param z                   Another PurpleLog
    346  * @return                    A value as specified by GCompareFunc
    347  */
    348 gint purple_log_compare(gconstpointer y, gconstpointer z);
    349 
    350 /**
    351  * Implements GCompareFunc for PurpleLogSets
    352  *
    353  * @param y                   A PurpleLogSet
    354  * @param z                   Another PurpleLogSet
    355  * @return                    A value as specified by GCompareFunc
    356  */
    357 gint purple_log_set_compare(gconstpointer y, gconstpointer z);
    358 
    359 /**
    360  * Frees a log set
    361  *
    362  * @param set         The log set to destroy
    363  */
    364 void purple_log_set_free(PurpleLogSet *set);
    365 
    366 /*@}*/
    367 
    368 /******************************************/
    369 /** @name Common Logger Functions         */
    370 /******************************************/
    371 /*@{*/
    372 
    373 /**
    374  * Opens a new log file in the standard Purple log location
    375  * with the given file extension, named for the current time,
    376  * for writing.  If a log file is already open, the existing
    377  * file handle is retained.  The log's logger_data value is
    378  * set to a PurpleLogCommonLoggerData struct containing the log
    379  * file handle and log path.
    380  *
    381  * This function is intended to be used as a "common"
    382  * implementation of a logger's @c write function.
    383  * It should only be passed to purple_log_logger_new() and never
    384  * called directly.
    385  *
    386  * @param log   The log to write to.
    387  * @param ext   The file extension to give to this log file.
    388  */
    389 void purple_log_common_writer(PurpleLog *log, const char *ext);
    390 
    391 /**
    392  * Returns a sorted GList of PurpleLogs of the requested type.
    393  *
    394  * This function should only be used with logs that are written
    395  * with purple_log_common_writer().  It's intended to be used as
    396  * a "common" implementation of a logger's @c list function.
    397  * It should only be passed to purple_log_logger_new() and never
    398  * called directly.
    399  *
    400  * @param type     The type of the logs being listed.
    401  * @param name     The name of the log.
    402  * @param account  The account of the log.
    403  * @param ext      The file extension this log format uses.
    404  * @param logger   A reference to the logger struct for this log.
    405  *
    406  * @return A sorted GList of PurpleLogs matching the parameters.
    407  */
    408 GList *purple_log_common_lister(PurpleLogType type, const char *name,
    409                                                           PurpleAccount *account, const char *ext,
    410                                                           PurpleLogLogger *logger);
    411 
    412 /**
    413  * Returns the total size of all the logs for a given user, with
    414  * a given extension.
    415  *
    416  * This function should only be used with logs that are written
    417  * with purple_log_common_writer().  It's intended to be used as
    418  * a "common" implementation of a logger's @c total_size function.
    419  * It should only be passed to purple_log_logger_new() and never
    420  * called directly.
    421  *
    422  * @param type     The type of the logs being sized.
    423  * @param name     The name of the logs to size
    424  *                 (e.g. the username or chat name).
    425  * @param account  The account of the log.
    426  * @param ext      The file extension this log format uses.
    427  *
    428  * @return The size of all the logs with the specified extension
    429  *         for the specified user.
    430  */
    431 int purple_log_common_total_sizer(PurpleLogType type, const char *name,
    432                                                                 PurpleAccount *account, const char *ext);
    433 
    434 /**
    435  * Returns the size of a given PurpleLog.
    436  *
    437  * This function should only be used with logs that are written
    438  * with purple_log_common_writer().  It's intended to be used as
    439  * a "common" implementation of a logger's @c size function.
    440  * It should only be passed to purple_log_logger_new() and never
    441  * called directly.
    442  *
    443  * @param log      The PurpleLog to size.
    444  *
    445  * @return An integer indicating the size of the log in bytes.
    446  */
    447 int purple_log_common_sizer(PurpleLog *log);
    448 
    449 /**
    450  * Deletes a log
    451  *
    452  * This function should only be used with logs that are written
    453  * with purple_log_common_writer().  It's intended to be used as
    454  * a "common" implementation of a logger's @c delete function.
    455  * It should only be passed to purple_log_logger_new() and never
    456  * called directly.
    457  *
    458  * @param log      The PurpleLog to delete.
    459  *
    460  * @return A boolean indicating success or failure.
    461  */
    462 gboolean purple_log_common_deleter(PurpleLog *log);
    463 
    464 /**
    465  * Checks to see if a log is deletable
    466  *
    467  * This function should only be used with logs that are written
    468  * with purple_log_common_writer().  It's intended to be used as
    469  * a "common" implementation of a logger's @c is_deletable function.
    470  * It should only be passed to purple_log_logger_new() and never
    471  * called directly.
    472  *
    473  * @param log      The PurpleLog to check.
    474  *
    475  * @return A boolean indicating if the log is deletable.
    476  */
    477 gboolean purple_log_common_is_deletable(PurpleLog *log);
    478 
    479 /*@}*/
    480 
    481 /******************************************/
    482 /** @name Logger Functions                */
    483 /******************************************/
    484 /*@{*/
    485 
    486 /**
    487  * Creates a new logger
    488  *
    489  * @param id           The logger's id.
    490  * @param name         The logger's name.
    491  * @param functions    The number of functions being passed. The following
    492  *                     functions are currently available (in order): @c create,
    493  *                     @c write, @c finalize, @c list, @c read, @c size,
    494  *                     @c total_size, @c list_syslog, @c get_log_sets,
    495  *                     @c remove, @c is_deletable.
    496  *                     For details on these functions, see PurpleLogLogger.
    497  *                     Functions may not be skipped. For example, passing
    498  *                     @c create and @c write is acceptable (for a total of
    499  *                     two functions). Passing @c create and @c finalize,
    500  *                     however, is not. To accomplish that, the caller must
    501  *                     pass @c create, @c NULL (a placeholder for @c write),
    502  *                     and @c finalize (for a total of 3 functions).
    503  *
    504  * @return The new logger
    505  */
    506 PurpleLogLogger *purple_log_logger_new(const char *id, const char *name, int functions, ...);
    507 
    508 /**
    509  * Frees a logger
    510  *
    511  * @param logger       The logger to free
    512  */
    513 void purple_log_logger_free(PurpleLogLogger *logger);
    514 
    515 /**
    516  * Adds a new logger
    517  *
    518  * @param logger       The new logger to add
    519  */
    520 void purple_log_logger_add (PurpleLogLogger *logger);
    521 
    522 /**
    523  *
    524  * Removes a logger
    525  *
    526  * @param logger       The logger to remove
    527  */
    528 void purple_log_logger_remove (PurpleLogLogger *logger);
    529 
    530 /**
    531  *
    532  * Sets the current logger
    533  *
    534  * @param logger       The logger to set
    535  */
    536 void purple_log_logger_set (PurpleLogLogger *logger);
    537 
    538 /**
    539  *
    540  * Returns the current logger
    541  *
    542  * @return logger      The current logger
    543  */
    544 PurpleLogLogger *purple_log_logger_get (void);
    545 
    546 /**
    547  * Returns a GList containing the IDs and names of the registered
    548  * loggers.
    549  *
    550  * @return The list of IDs and names.
    551  */
    552 GList *purple_log_logger_get_options(void);
    553 
    554 /**************************************************************************/
    555 /** @name Log Subsystem                                                   */
    556 /**************************************************************************/
    557 /*@{*/
    558 
    559 /**
    560  * Initializes the log subsystem.
    561  */
    562 void purple_log_init(void);
    563 
    564 /**
    565  * Returns the log subsystem handle.
    566  *
    567  * @return The log subsystem handle.
    568  */
    569 void *purple_log_get_handle(void);
    570 
    571 /**
    572  * Uninitializes the log subsystem.
    573  */
    574 void purple_log_uninit(void);
    575 
    576 /*@}*/
    577 
    578 
    579 #ifdef __cplusplus
    580 }
    581 #endif
     4#define purple_log_init()
     5#define purple_log_uninit()
     6#define PurpleLog void
    5827
    5838#endif /* _PURPLE_LOG_H_ */
  • libpurple/network.c

    Only in libpurple: Makefile.in
    Only in extract/pidgin-2.10.9/libpurple: marshallers.c
    Only in extract/pidgin-2.10.9/libpurple: marshallers.h
    Only in extract/pidgin-2.10.9/libpurple: marshallers.list
    Only in extract/pidgin-2.10.9/libpurple: media
    Only in extract/pidgin-2.10.9/libpurple: media.c
    Only in extract/pidgin-2.10.9/libpurple: media-gst.h
    Only in extract/pidgin-2.10.9/libpurple: media.h
    Only in extract/pidgin-2.10.9/libpurple: mediamanager.c
    Only in extract/pidgin-2.10.9/libpurple: mediamanager.h
    Only in libpurple: moz.build
    diff -ru extract/pidgin-2.10.9/libpurple/network.c libpurple/network.c
    old new  
    2424 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
    2525 */
    2626
     27#ifdef _WIN32
     28#undef _WIN32_WINNT
     29#define _WIN32_WINNT 0x0501
     30#define INCL_WINSOCK_API_TYPEDEFS 1
     31#endif
     32
    2733#include "internal.h"
    2834
    2935#ifndef _WIN32
     
    3541#ifdef HAVE_GETIFADDRS
    3642#include <ifaddrs.h>
    3743#endif
    38 #else
     44#elif 0
    3945#include <nspapi.h>
    4046#endif
    4147
     
    8187static NMState nm_state = NM_STATE_UNKNOWN;
    8288static gboolean have_nm_state = FALSE;
    8389
    84 #elif defined _WIN32
     90#elif 0
    8591static int current_network_count;
    8692
    8793/* Mutex for the other global vars */
    8894static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
    8995static gboolean network_initialized = FALSE;
    9096static HANDLE network_change_handle = NULL;
    91 static int (WSAAPI *MyWSANSPIoctl) (
    92                 HANDLE hLookup, DWORD dwControlCode, LPVOID lpvInBuffer,
    93                 DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer,
    94                 LPDWORD lpcbBytesReturned, LPWSACOMPLETION lpCompletion) = NULL;
     97static LPFN_WSANSPIOCTL MyWSANSPIoctl = NULL;
     98#else
     99static network_available_callback available_callback = NULL;
    95100#endif
    96101
    97102struct _PurpleNetworkListenData {
     
    611616        return ntohs(addr.sin_port);
    612617}
    613618
    614 #ifdef _WIN32
     619#if 0
    615620#ifndef NS_NLA
    616621#define NS_NLA 15
    617622#endif
     
    850855
    851856        return FALSE;
    852857
    853 #elif defined _WIN32
     858#elif 0
    854859        return (current_network_count > 0 || force_online);
    855860#else
     861        if (available_callback)
     862                return (available_callback());
     863
    856864        return TRUE;
    857865#endif
    858866}
     
    11401148#ifdef HAVE_NETWORKMANAGER
    11411149        GError *error = NULL;
    11421150#endif
    1143 #ifdef _WIN32
     1151#if 0
    11441152        GError *err = NULL;
    11451153        gint cnt = wpurple_get_connected_network_count();
    11461154
     
    11611169        purple_prefs_add_string("/purple/network/stun_server", "");
    11621170        purple_prefs_add_string("/purple/network/turn_server", "");
    11631171        purple_prefs_add_int   ("/purple/network/turn_port", 3478);
    1164         purple_prefs_add_int     ("/purple/network/turn_port_tcp", 3478);
    11651172        purple_prefs_add_string("/purple/network/turn_username", "");
    11661173        purple_prefs_add_string("/purple/network/turn_password", "");
    11671174        purple_prefs_add_bool  ("/purple/network/auto_ip", TRUE);
     
    12361243                dbus_g_connection_unref(nm_conn);
    12371244#endif
    12381245
    1239 #ifdef _WIN32
     1246#if 0
    12401247        g_static_mutex_lock(&mutex);
    12411248        network_initialized = FALSE;
    12421249        if (network_change_handle != NULL) {
     
    12691276        /* TODO: clean up remaining port mappings, note calling
    12701277         purple_upnp_remove_port_mapping from here doesn't quite work... */
    12711278}
     1279
     1280void
     1281purple_network_configuration_changed(void)
     1282{
     1283        purple_signal_emit(purple_network_get_handle(), "network-configuration-changed", NULL);
     1284}
     1285
     1286void
     1287purple_network_set_available_callback(network_available_callback cb)
     1288{
     1289        available_callback = cb;
     1290}
  • libpurple/network.h

    diff -ru extract/pidgin-2.10.9/libpurple/network.h libpurple/network.h
    old new  
    350350 */
    351351void purple_network_uninit(void);
    352352
     353/**
     354 * Emits the network-configuration-changed signal
     355 */
     356void
     357purple_network_configuration_changed(void);
     358
     359/**
     360 * Function pointer to a function indicating if network is available
     361 */
     362typedef gboolean (*network_available_callback)(void);
     363
     364/**
     365 * Sets the callback function to be used to query the UI about the
     366 * availability of the network.
     367 */
     368void
     369purple_network_set_available_callback(network_available_callback cb);
     370
    353371/*@}*/
    354372
    355373#ifdef __cplusplus
  • libpurple/notify.c

    diff -ru extract/pidgin-2.10.9/libpurple/notify.c libpurple/notify.c
    old new  
    2828#include "internal.h"
    2929#include "dbus-maybe.h"
    3030#include "notify.h"
     31#include "debug.h"
    3132
    3233static PurpleNotifyUiOps *notify_ui_ops = NULL;
    3334static GList *handles = NULL;
     
    8586                }
    8687
    8788        }
     89        else {
     90                int level;
     91                if (type == PURPLE_NOTIFY_MSG_ERROR)
     92                        level = PURPLE_DEBUG_ERROR;
     93                else if (type == PURPLE_NOTIFY_MSG_WARNING)
     94                        level = PURPLE_DEBUG_WARNING;
     95                else
     96                        level = PURPLE_DEBUG_INFO;
     97                purple_debug(level, "notify", "Notification: %s (%s)",
     98                             title ? title : "(null)",
     99                             primary ? primary : "(null)");
     100        }
    88101
    89102        if (cb != NULL)
    90103                cb(user_data);
  • libpurple/plugin.c

    diff -ru extract/pidgin-2.10.9/libpurple/plugin.c libpurple/plugin.c
    old new  
    3333#include "request.h"
    3434#include "signals.h"
    3535#include "util.h"
    36 #include "valgrind.h"
    3736#include "version.h"
    3837
    3938typedef struct
     
    7372
    7473#ifdef PURPLE_PLUGINS
    7574
     75#define RUNNING_ON_VALGRIND 0
     76
    7677static gboolean
    7778has_file_extension(const char *filename, const char *ext)
    7879{
     
    283284                                purple_debug_error("plugins", "%s is not loadable: %s\n",
    284285                                                 plugin->path, plugin->error);
    285286                        }
     287#if 0
    286288                        plugin->handle = g_module_open(filename, G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
    287 
     289#endif
    288290                        if (plugin->handle == NULL)
    289291                        {
    290292#ifdef _WIN32
     
    788790void
    789791purple_plugin_destroy(PurplePlugin *plugin)
    790792{
    791 #ifdef PURPLE_PLUGINS
    792793        g_return_if_fail(plugin != NULL);
    793794
     795#ifdef PURPLE_PLUGINS
    794796        if (purple_plugin_is_loaded(plugin))
    795797                purple_plugin_unload(plugin);
    796798
     
    886888                                loader_info->destroy(plugin);
    887889                }
    888890        }
     891#else
     892        if (plugin->info != NULL) {
     893                if (PURPLE_IS_PROTOCOL_PLUGIN(plugin))
     894                        protocol_plugins = g_list_remove(protocol_plugins, plugin);
     895
     896                if (plugin->info->unload)
     897                        plugin->info->unload(plugin);
     898        }
     899
     900        plugins = g_list_remove(plugins, plugin);
     901#endif /* !PURPLE_PLUGINS */
    889902
    890903        g_free(plugin->path);
    891904        g_free(plugin->error);
     
    893906        PURPLE_DBUS_UNREGISTER_POINTER(plugin);
    894907
    895908        g_free(plugin);
    896 #endif /* !PURPLE_PLUGINS */
    897909}
    898910
    899911gboolean
     
    11791191purple_plugins_init(void) {
    11801192        void *handle = purple_plugins_get_handle();
    11811193
     1194#ifdef LIBDIR
    11821195        purple_plugins_add_search_path(LIBDIR);
     1196#endif
    11831197
    11841198        purple_signal_register(handle, "plugin-load",
    11851199                                                 purple_marshal_VOID__POINTER,
     
    12561270void
    12571271purple_plugins_destroy_all(void)
    12581272{
    1259 #ifdef PURPLE_PLUGINS
    1260 
    12611273        while (plugins != NULL)
    12621274                purple_plugin_destroy(plugins->data);
    1263 
    1264 #endif /* PURPLE_PLUGINS */
    12651275}
    12661276
     1277#if 0
    12671278void
    12681279purple_plugins_save_loaded(const char *key)
    12691280{
     
    13451356        g_list_free(files);
    13461357#endif /* PURPLE_PLUGINS */
    13471358}
     1359#endif
    13481360
    13491361
    13501362void
  • libpurple/plugin.h

    diff -ru extract/pidgin-2.10.9/libpurple/plugin.h libpurple/plugin.h
    old new  
    3030#define _PURPLE_PLUGIN_H_
    3131
    3232#include <glib.h>
    33 #include <gmodule.h>
     33#ifdef PURPLE_PLUGINS
     34# include <gmodule.h>
     35#endif
    3436#include "signals.h"
    3537#include "value.h"
    3638
     
    217219/**
    218220 * Handles the initialization of modules.
    219221 */
     222#if 0
    220223#if !defined(PURPLE_PLUGINS) || defined(PURPLE_STATIC_PRPL)
    221224# define _FUNC_NAME(x) purple_init_##x##_plugin
    222225# define PURPLE_INIT_PLUGIN(pluginname, initfunc, plugininfo) \
     
    237240                return purple_plugin_register(plugin); \
    238241        }
    239242#endif
     243#endif
    240244
     245#ifdef PURPLE_STATIC_PRPL
     246# define _FUNC_NAME(x) purple_init_##x##_plugin
     247#else
     248# define _FUNC_NAME(x) purple_plugin_register_self
     249#endif
     250
     251#define PURPLE_INIT_PLUGIN(pluginname, initfunc, plugininfo) \
     252        gboolean _FUNC_NAME(pluginname)(void) { \
     253                PurplePlugin *plugin = purple_plugin_new(TRUE, NULL); \
     254                plugin->info = &(plugininfo); \
     255                initfunc((plugin)); \
     256                return purple_plugin_register(plugin); \
     257        }
    241258
    242259#ifdef __cplusplus
    243260extern "C" {
     
    536553void purple_plugins_destroy_all(void);
    537554
    538555/**
    539  * Saves the list of loaded plugins to the specified preference key
    540  *
    541  * @param key The preference key to save the list of plugins to.
    542  */
    543 void purple_plugins_save_loaded(const char *key);
    544 
    545 /**
    546  * Attempts to load all the plugins in the specified preference key
    547  * that were loaded when purple last quit.
    548  *
    549  * @param key The preference key containing the list of plugins.
    550  */
    551 void purple_plugins_load_saved(const char *key);
    552 
    553 /**
    554556 * Probes for plugins in the registered module paths.
    555557 *
    556558 * @param ext The extension type to probe for, or @c NULL for all.
  • libpurple/prefs.c

    Only in extract/pidgin-2.10.9/libpurple: plugins
    Only in extract/pidgin-2.10.9/libpurple: pounce.c
    Only in extract/pidgin-2.10.9/libpurple: pounce.h
    diff -ru extract/pidgin-2.10.9/libpurple/prefs.c libpurple/prefs.c
    old new  
    4040#include "win32dep.h"
    4141#endif
    4242
     43static PurplePrefsUiOps *prefs_ui_ops = NULL;
     44
    4345struct pref_cb {
    4446        PurplePrefCallback func;
    4547        gpointer data;
    4648        guint id;
    4749        void *handle;
    48 };
    49 
    50 /* TODO: This should use PurpleValues? */
    51 struct purple_pref {
    52         PurplePrefType type;
     50        void *observer;
    5351        char *name;
    54         union {
    55                 gpointer generic;
    56                 gboolean boolean;
    57                 int integer;
    58                 char *string;
    59                 GList *stringlist;
    60         } value;
    61         GSList *callbacks;
    62         struct purple_pref *parent;
    63         struct purple_pref *sibling;
    64         struct purple_pref *first_child;
    65 };
    66 
    67 
    68 static struct purple_pref prefs = {
    69         PURPLE_PREF_NONE,
    70         NULL,
    71         { NULL },
    72         NULL,
    73         NULL,
    74         NULL,
    75         NULL
    7652};
    7753
    78 static GHashTable *prefs_hash = NULL;
    7954static guint       save_timer = 0;
    8055static gboolean    prefs_loaded = FALSE;
    81 
    82 
    83 /*********************************************************************
    84  * Private utility functions                                         *
    85  *********************************************************************/
    86 
    87 static struct
    88 purple_pref *find_pref(const char *name)
    89 {
    90         g_return_val_if_fail(name != NULL && name[0] == '/', NULL);
    91 
    92         if (name[1] == '\0')
    93                 return &prefs;
    94         else
    95         {
    96                 /* When we're initializing, the debug system is
    97                  * initialized before the prefs system, but debug
    98                  * calls will end up calling prefs functions, so we
    99                  * need to deal cleanly here. */
    100                 if (prefs_hash)
    101                         return g_hash_table_lookup(prefs_hash, name);
    102                 else
    103                         return NULL;
    104         }
    105 }
    106 
    107 
    108 /*********************************************************************
    109  * Writing to disk                                                   *
    110  *********************************************************************/
    111 
    112 /*
    113  * This function recursively creates the xmlnode tree from the prefs
    114  * tree structure.  Yay recursion!
    115  */
    116 static void
    117 pref_to_xmlnode(xmlnode *parent, struct purple_pref *pref)
    118 {
    119         xmlnode *node, *childnode;
    120         struct purple_pref *child;
    121         char buf[21];
    122         GList *cur;
    123 
    124         /* Create a new node */
    125         node = xmlnode_new_child(parent, "pref");
    126         xmlnode_set_attrib(node, "name", pref->name);
    127 
    128         /* Set the type of this node (if type == PURPLE_PREF_NONE then do nothing) */
    129         if (pref->type == PURPLE_PREF_INT) {
    130                 xmlnode_set_attrib(node, "type", "int");
    131                 g_snprintf(buf, sizeof(buf), "%d", pref->value.integer);
    132                 xmlnode_set_attrib(node, "value", buf);
    133         }
    134         else if (pref->type == PURPLE_PREF_STRING) {
    135                 xmlnode_set_attrib(node, "type", "string");
    136                 xmlnode_set_attrib(node, "value", pref->value.string ? pref->value.string : "");
    137         }
    138         else if (pref->type == PURPLE_PREF_STRING_LIST) {
    139                 xmlnode_set_attrib(node, "type", "stringlist");
    140                 for (cur = pref->value.stringlist; cur != NULL; cur = cur->next)
    141                 {
    142                         childnode = xmlnode_new_child(node, "item");
    143                         xmlnode_set_attrib(childnode, "value", cur->data ? cur->data : "");
    144                 }
    145         }
    146         else if (pref->type == PURPLE_PREF_PATH) {
    147                 char *encoded = g_filename_to_utf8(pref->value.string ? pref->value.string : "", -1, NULL, NULL, NULL);
    148                 xmlnode_set_attrib(node, "type", "path");
    149                 xmlnode_set_attrib(node, "value", encoded);
    150                 g_free(encoded);
    151         }
    152         else if (pref->type == PURPLE_PREF_PATH_LIST) {
    153                 xmlnode_set_attrib(node, "type", "pathlist");
    154                 for (cur = pref->value.stringlist; cur != NULL; cur = cur->next)
    155                 {
    156                         char *encoded = g_filename_to_utf8(cur->data ? cur->data : "", -1, NULL, NULL, NULL);
    157                         childnode = xmlnode_new_child(node, "item");
    158                         xmlnode_set_attrib(childnode, "value", encoded);
    159                         g_free(encoded);
    160                 }
    161         }
    162         else if (pref->type == PURPLE_PREF_BOOLEAN) {
    163                 xmlnode_set_attrib(node, "type", "bool");
    164                 g_snprintf(buf, sizeof(buf), "%d", pref->value.boolean);
    165                 xmlnode_set_attrib(node, "value", buf);
    166         }
    167 
    168         /* All My Children */
    169         for (child = pref->first_child; child != NULL; child = child->sibling)
    170                 pref_to_xmlnode(node, child);
    171 }
    172 
    173 static xmlnode *
    174 prefs_to_xmlnode(void)
    175 {
    176         xmlnode *node;
    177         struct purple_pref *pref, *child;
    178 
    179         pref = &prefs;
    180 
    181         /* Create the root preference node */
    182         node = xmlnode_new("pref");
    183         xmlnode_set_attrib(node, "version", "1");
    184         xmlnode_set_attrib(node, "name", "/");
    185 
    186         /* All My Children */
    187         for (child = pref->first_child; child != NULL; child = child->sibling)
    188                 pref_to_xmlnode(node, child);
    189 
    190         return node;
    191 }
    192 
    193 static void
    194 sync_prefs(void)
    195 {
    196         xmlnode *node;
    197         char *data;
    198 
    199         if (!prefs_loaded)
    200         {
    201                 /*
    202                  * TODO: Call schedule_prefs_save()?  Ideally we wouldn't need to.
    203                  * (prefs.xml should be loaded when purple_prefs_init is called)
    204                  */
    205                 purple_debug_error("prefs", "Attempted to save prefs before "
    206                                                  "they were read!\n");
    207                 return;
    208         }
    209 
    210         node = prefs_to_xmlnode();
    211         data = xmlnode_to_formatted_str(node, NULL);
    212         purple_util_write_data_to_file("prefs.xml", data, -1);
    213         g_free(data);
    214         xmlnode_free(node);
    215 }
     56static GSList     *callbacks = NULL;
    21657
    21758static gboolean
    21859save_cb(gpointer data)
    21960{
    220         sync_prefs();
     61        PurplePrefsUiOps *uiop = purple_prefs_get_ui_ops();
     62        g_return_val_if_fail(uiop, FALSE);
     63        uiop->save();
     64
    22165        save_timer = 0;
    22266        return FALSE;
    22367}
    22468
    225 static void
    226 schedule_prefs_save(void)
    227 {
    228         if (save_timer == 0)
    229                 save_timer = purple_timeout_add_seconds(5, save_cb, NULL);
    230 }
    231 
    232 
    23369/*********************************************************************
    23470 * Reading from disk                                                 *
    23571 *********************************************************************/
    23672
    237 static GList *prefs_stack = NULL;
    238 
    239 static void
    240 prefs_start_element_handler (GMarkupParseContext *context,
    241                 const gchar *element_name,
    242                 const gchar **attribute_names,
    243                 const gchar **attribute_values,
    244                 gpointer user_data,
    245                 GError **error)
    246 {
    247         PurplePrefType pref_type = PURPLE_PREF_NONE;
    248         int i;
    249         const char *pref_name = NULL, *pref_value = NULL;
    250         GString *pref_name_full;
    251         GList *tmp;
    252 
    253         if(!purple_strequal(element_name, "pref") &&
    254            !purple_strequal(element_name, "item"))
    255                 return;
    256 
    257         for(i = 0; attribute_names[i]; i++) {
    258                 if(purple_strequal(attribute_names[i], "name")) {
    259                         pref_name = attribute_values[i];
    260                 } else if(purple_strequal(attribute_names[i], "type")) {
    261                         if(purple_strequal(attribute_values[i], "bool"))
    262                                 pref_type = PURPLE_PREF_BOOLEAN;
    263                         else if(purple_strequal(attribute_values[i], "int"))
    264                                 pref_type = PURPLE_PREF_INT;
    265                         else if(purple_strequal(attribute_values[i], "string"))
    266                                 pref_type = PURPLE_PREF_STRING;
    267                         else if(purple_strequal(attribute_values[i], "stringlist"))
    268                                 pref_type = PURPLE_PREF_STRING_LIST;
    269                         else if(purple_strequal(attribute_values[i], "path"))
    270                                 pref_type = PURPLE_PREF_PATH;
    271                         else if(purple_strequal(attribute_values[i], "pathlist"))
    272                                 pref_type = PURPLE_PREF_PATH_LIST;
    273                         else
    274                                 return;
    275                 } else if(purple_strequal(attribute_names[i], "value")) {
    276                         pref_value = attribute_values[i];
    277                 }
    278         }
    279 
    280         if ((pref_type == PURPLE_PREF_BOOLEAN || pref_type == PURPLE_PREF_INT) &&
    281                         pref_value == NULL) {
    282                 /* Missing a value attribute */
    283                 return;
    284         }
    285 
    286         if(purple_strequal(element_name, "item")) {
    287                 struct purple_pref *pref;
    288 
    289                 pref_name_full = g_string_new("");
    290 
    291                 for(tmp = prefs_stack; tmp; tmp = tmp->next) {
    292                         pref_name_full = g_string_prepend(pref_name_full, tmp->data);
    293                         pref_name_full = g_string_prepend_c(pref_name_full, '/');
    294                 }
    295 
    296                 pref = find_pref(pref_name_full->str);
    297 
    298                 if(pref) {
    299                         if(pref->type == PURPLE_PREF_STRING_LIST) {
    300                                 pref->value.stringlist = g_list_append(pref->value.stringlist,
    301                                                 g_strdup(pref_value));
    302                         } else if(pref->type == PURPLE_PREF_PATH_LIST) {
    303                                 pref->value.stringlist = g_list_append(pref->value.stringlist,
    304                                                 g_filename_from_utf8(pref_value, -1, NULL, NULL, NULL));
    305                         }
    306                 }
    307                 g_string_free(pref_name_full, TRUE);
    308         } else {
    309                 char *decoded;
    310 
    311                 if(!pref_name || purple_strequal(pref_name, "/"))
    312                         return;
    313 
    314                 pref_name_full = g_string_new(pref_name);
    315 
    316                 for(tmp = prefs_stack; tmp; tmp = tmp->next) {
    317                         pref_name_full = g_string_prepend_c(pref_name_full, '/');
    318                         pref_name_full = g_string_prepend(pref_name_full, tmp->data);
    319                 }
    320 
    321                 pref_name_full = g_string_prepend_c(pref_name_full, '/');
    322 
    323                 switch(pref_type) {
    324                         case PURPLE_PREF_NONE:
    325                                 purple_prefs_add_none(pref_name_full->str);
    326                                 break;
    327                         case PURPLE_PREF_BOOLEAN:
    328                                 purple_prefs_set_bool(pref_name_full->str, atoi(pref_value));
    329                                 break;
    330                         case PURPLE_PREF_INT:
    331                                 purple_prefs_set_int(pref_name_full->str, atoi(pref_value));
    332                                 break;
    333                         case PURPLE_PREF_STRING:
    334                                 purple_prefs_set_string(pref_name_full->str, pref_value);
    335                                 break;
    336                         case PURPLE_PREF_STRING_LIST:
    337                                 purple_prefs_set_string_list(pref_name_full->str, NULL);
    338                                 break;
    339                         case PURPLE_PREF_PATH:
    340                                 if (pref_value) {
    341                                         decoded = g_filename_from_utf8(pref_value, -1, NULL, NULL, NULL);
    342                                         purple_prefs_set_path(pref_name_full->str, decoded);
    343                                         g_free(decoded);
    344                                 } else {
    345                                         purple_prefs_set_path(pref_name_full->str, NULL);
    346                                 }
    347                                 break;
    348                         case PURPLE_PREF_PATH_LIST:
    349                                 purple_prefs_set_path_list(pref_name_full->str, NULL);
    350                                 break;
    351                 }
    352                 prefs_stack = g_list_prepend(prefs_stack, g_strdup(pref_name));
    353                 g_string_free(pref_name_full, TRUE);
    354         }
    355 }
    356 
    357 static void
    358 prefs_end_element_handler(GMarkupParseContext *context,
    359                                                   const gchar *element_name,
    360                                                   gpointer user_data, GError **error)
    361 {
    362         if(prefs_stack && purple_strequal(element_name, "pref")) {
    363                 g_free(prefs_stack->data);
    364                 prefs_stack = g_list_delete_link(prefs_stack, prefs_stack);
    365         }
    366 }
    367 
    368 static GMarkupParser prefs_parser = {
    369         prefs_start_element_handler,
    370         prefs_end_element_handler,
    371         NULL,
    372         NULL,
    373         NULL
    374 };
    375 
    37673gboolean
    37774purple_prefs_load()
    37875{
    379         gchar *filename = g_build_filename(purple_user_dir(), "prefs.xml", NULL);
    380         gchar *contents = NULL;
    381         gsize length;
    382         GMarkupParseContext *context;
    383         GError *error = NULL;
    384 
    385         if (!filename) {
    386                 prefs_loaded = TRUE;
    387                 return FALSE;
    388         }
    389 
    390         purple_debug_info("prefs", "Reading %s\n", filename);
    391 
    392         if(!g_file_get_contents(filename, &contents, &length, &error)) {
    393 #ifdef _WIN32
    394                 gchar *common_appdata = wpurple_get_special_folder(CSIDL_COMMON_APPDATA);
    395 #endif
    396                 g_free(filename);
    397                 g_error_free(error);
    398 
    399                 error = NULL;
    400 
    401 #ifdef _WIN32
    402                 filename = g_build_filename(common_appdata ? common_appdata : "", "purple", "prefs.xml", NULL);
    403                 g_free(common_appdata);
    404 #else
    405                 filename = g_build_filename(SYSCONFDIR, "purple", "prefs.xml", NULL);
    406 #endif
    407 
    408                 purple_debug_info("prefs", "Reading %s\n", filename);
    409 
    410                 if (!g_file_get_contents(filename, &contents, &length, &error)) {
    411                         purple_debug_error("prefs", "Error reading prefs: %s\n",
    412                                         error->message);
    413                         g_error_free(error);
    414                         g_free(filename);
    415                         prefs_loaded = TRUE;
    416 
    417                         return FALSE;
    418                 }
    419         }
    420 
    421         context = g_markup_parse_context_new(&prefs_parser, 0, NULL, NULL);
    422 
    423         if(!g_markup_parse_context_parse(context, contents, length, NULL)) {
    424                 g_markup_parse_context_free(context);
    425                 g_free(contents);
    426                 g_free(filename);
    427                 prefs_loaded = TRUE;
    428 
    429                 return FALSE;
    430         }
    431 
    432         if(!g_markup_parse_context_end_parse(context, NULL)) {
    433                 purple_debug_error("prefs", "Error parsing %s\n", filename);
    434                 g_markup_parse_context_free(context);
    435                 g_free(contents);
    436                 g_free(filename);
    437                 prefs_loaded = TRUE;
    438 
    439                 return FALSE;
    440         }
    441 
    442         purple_debug_info("prefs", "Finished reading %s\n", filename);
    443         g_markup_parse_context_free(context);
    444         g_free(contents);
    445         g_free(filename);
    44676        prefs_loaded = TRUE;
    44777
    44878        return TRUE;
    44979}
    45080
    451 
    452 
    45381static void
    45482prefs_save_cb(const char *name, PurplePrefType type, gconstpointer val,
    45583                          gpointer user_data)
    45684{
    457 
    458         if(!prefs_loaded)
     85        if (!prefs_loaded)
    45986                return;
    46087
    46188        purple_debug_misc("prefs", "%s changed, scheduling save.\n", name);
    46289
    463         schedule_prefs_save();
    464 }
    465 
    466 static char *
    467 get_path_dirname(const char *name)
    468 {
    469         char *c, *str;
    470 
    471         str = g_strdup(name);
    472 
    473         if ((c = strrchr(str, '/')) != NULL) {
    474                 *c = '\0';
    475 
    476                 if (*str == '\0') {
    477                         g_free(str);
    478 
    479                         str = g_strdup("/");
    480                 }
    481         }
    482         else {
    483                 g_free(str);
    484 
    485                 str = g_strdup(".");
    486         }
    487 
    488         return str;
    489 }
    490 
    491 static char *
    492 get_path_basename(const char *name)
    493 {
    494         const char *c;
    495 
    496         if ((c = strrchr(name, '/')) != NULL)
    497                 return g_strdup(c + 1);
    498 
    499         return g_strdup(name);
    500 }
    501 
    502 static char *
    503 pref_full_name(struct purple_pref *pref)
    504 {
    505         GString *name;
    506         struct purple_pref *parent;
    507 
    508         if(!pref)
    509                 return NULL;
    510 
    511         if(pref == &prefs)
    512                 return g_strdup("/");
    513 
    514         name = g_string_new(pref->name);
    515 
    516         for(parent = pref->parent; parent && parent->name; parent = parent->parent) {
    517                 name = g_string_prepend_c(name, '/');
    518                 name = g_string_prepend(name, parent->name);
    519         }
    520         name = g_string_prepend_c(name, '/');
    521         return g_string_free(name, FALSE);
    522 }
    523 
    524 static struct purple_pref *
    525 find_pref_parent(const char *name)
    526 {
    527         char *parent_name = get_path_dirname(name);
    528         struct purple_pref *ret = &prefs;
    529 
    530         if(!purple_strequal(parent_name, "/")) {
    531                 ret = find_pref(parent_name);
    532         }
    533 
    534         g_free(parent_name);
    535         return ret;
    536 }
    537 
    538 static void
    539 free_pref_value(struct purple_pref *pref)
    540 {
    541         switch(pref->type) {
    542                 case PURPLE_PREF_BOOLEAN:
    543                         pref->value.boolean = FALSE;
    544                         break;
    545                 case PURPLE_PREF_INT:
    546                         pref->value.integer = 0;
    547                         break;
    548                 case PURPLE_PREF_STRING:
    549                 case PURPLE_PREF_PATH:
    550                         g_free(pref->value.string);
    551                         pref->value.string = NULL;
    552                         break;
    553                 case PURPLE_PREF_STRING_LIST:
    554                 case PURPLE_PREF_PATH_LIST:
    555                         {
    556                                 g_list_foreach(pref->value.stringlist, (GFunc)g_free, NULL);
    557                                 g_list_free(pref->value.stringlist);
    558                         } break;
    559                 case PURPLE_PREF_NONE:
    560                         break;
    561         }
     90        if (save_timer == 0)
     91                save_timer = purple_timeout_add_seconds(6, save_cb, NULL);
    56292}
    56393
    564 static struct purple_pref *
    565 add_pref(PurplePrefType type, const char *name)
    566 {
    567         struct purple_pref *parent;
    568         struct purple_pref *me;
    569         struct purple_pref *sibling;
    570         char *my_name;
    571 
    572         parent = find_pref_parent(name);
    573 
    574         if(!parent)
    575                 return NULL;
    576 
    577         my_name = get_path_basename(name);
    578 
    579         for(sibling = parent->first_child; sibling; sibling = sibling->sibling) {
    580                 if(purple_strequal(sibling->name, my_name)) {
    581                         g_free(my_name);
    582                         return NULL;
    583                 }
    584         }
    585 
    586         me = g_new0(struct purple_pref, 1);
    587         me->type = type;
    588         me->name = my_name;
    589 
    590         me->parent = parent;
    591         if(parent->first_child) {
    592                 /* blatant abuse of a for loop */
    593                 for(sibling = parent->first_child; sibling->sibling;
    594                                 sibling = sibling->sibling);
    595                 sibling->sibling = me;
    596         } else {
    597                 parent->first_child = me;
     94#define UIOP(aCall)                                                 \
     95        {                                                           \
     96                PurplePrefsUiOps *uiop = purple_prefs_get_ui_ops(); \
     97                g_return_if_fail(uiop);                             \
     98                                                                    \
     99                uiop->aCall;                                        \
     100        }
     101
     102#define UIOP_return(aCall, aDefault)                                \
     103        {                                                           \
     104                PurplePrefsUiOps *uiop = purple_prefs_get_ui_ops(); \
     105                g_return_val_if_fail(uiop, aDefault);               \
     106                                                                    \
     107                return uiop->aCall;                                 \
    598108        }
    599109
    600         g_hash_table_insert(prefs_hash, g_strdup(name), (gpointer)me);
    601 
    602         return me;
    603 }
    604 
    605110void
    606111purple_prefs_add_none(const char *name)
    607 {
    608         add_pref(PURPLE_PREF_NONE, name);
    609 }
     112        UIOP(add_none(name))
    610113
    611114void
    612115purple_prefs_add_bool(const char *name, gboolean value)
    613 {
    614         struct purple_pref *pref = add_pref(PURPLE_PREF_BOOLEAN, name);
    615 
    616         if(!pref)
    617                 return;
    618 
    619         pref->value.boolean = value;
    620 }
     116        UIOP(add_bool(name, value))
    621117
    622118void
    623119purple_prefs_add_int(const char *name, int value)
    624 {
    625         struct purple_pref *pref = add_pref(PURPLE_PREF_INT, name);
    626 
    627         if(!pref)
    628                 return;
    629 
    630         pref->value.integer = value;
    631 }
     120        UIOP(add_int(name, value))
    632121
    633122void
    634123purple_prefs_add_string(const char *name, const char *value)
    635 {
    636         struct purple_pref *pref;
    637 
    638         if(value != NULL && !g_utf8_validate(value, -1, NULL)) {
    639                 purple_debug_error("prefs", "purple_prefs_add_string: Cannot store invalid UTF8 for string pref %s\n", name);
    640                 return;
    641         }
    642 
    643         pref = add_pref(PURPLE_PREF_STRING, name);
    644 
    645         if(!pref)
    646                 return;
    647 
    648         pref->value.string = g_strdup(value);
    649 }
    650 
    651 void
    652 purple_prefs_add_string_list(const char *name, GList *value)
    653 {
    654         struct purple_pref *pref = add_pref(PURPLE_PREF_STRING_LIST, name);
    655         GList *tmp;
    656 
    657         if(!pref)
    658                 return;
    659 
    660         for(tmp = value; tmp; tmp = tmp->next) {
    661                 if(tmp->data != NULL && !g_utf8_validate(tmp->data, -1, NULL)) {
    662                         purple_debug_error("prefs", "purple_prefs_add_string_list: Skipping invalid UTF8 for string list pref %s\n", name);
    663                         continue;
    664                 }
    665                 pref->value.stringlist = g_list_append(pref->value.stringlist,
    666                                 g_strdup(tmp->data));
    667         }
    668 }
    669 
    670 void
    671 purple_prefs_add_path(const char *name, const char *value)
    672 {
    673         struct purple_pref *pref = add_pref(PURPLE_PREF_PATH, name);
    674 
    675         if(!pref)
    676                 return;
    677 
    678         pref->value.string = g_strdup(value);
    679 }
    680 
    681 void
    682 purple_prefs_add_path_list(const char *name, GList *value)
    683 {
    684         struct purple_pref *pref = add_pref(PURPLE_PREF_PATH_LIST, name);
    685         GList *tmp;
    686 
    687         if(!pref)
    688                 return;
    689 
    690         for(tmp = value; tmp; tmp = tmp->next)
    691                 pref->value.stringlist = g_list_append(pref->value.stringlist,
    692                                 g_strdup(tmp->data));
    693 }
    694 
    695 
    696 static void
    697 remove_pref(struct purple_pref *pref)
    698 {
    699         char *name;
    700         GSList *l;
    701 
    702         if(!pref)
    703                 return;
    704 
    705         while(pref->first_child)
    706                 remove_pref(pref->first_child);
    707 
    708         if(pref == &prefs)
    709                 return;
    710 
    711         if(pref->parent->first_child == pref) {
    712                 pref->parent->first_child = pref->sibling;
    713         } else {
    714                 struct purple_pref *sib = pref->parent->first_child;
    715                 while(sib && sib->sibling != pref)
    716                         sib = sib->sibling;
    717                 if(sib)
    718                         sib->sibling = pref->sibling;
    719         }
    720 
    721         name = pref_full_name(pref);
    722 
    723         if (prefs_loaded)
    724                 purple_debug_info("prefs", "removing pref %s\n", name);
    725 
    726         g_hash_table_remove(prefs_hash, name);
    727         g_free(name);
    728 
    729         free_pref_value(pref);
    730 
    731         while((l = pref->callbacks) != NULL) {
    732                 pref->callbacks = pref->callbacks->next;
    733                 g_free(l->data);
    734                 g_slist_free_1(l);
    735         }
    736         g_free(pref->name);
    737         g_free(pref);
    738 }
     124        UIOP(add_string(name, value))
    739125
    740126void
    741127purple_prefs_remove(const char *name)
    742 {
    743         struct purple_pref *pref = find_pref(name);
    744 
    745         if(!pref)
    746                 return;
    747 
    748         remove_pref(pref);
    749 }
    750 
    751 void
    752 purple_prefs_destroy()
    753 {
    754         purple_prefs_remove("/");
    755 }
    756 
    757 static void
    758 do_callbacks(const char* name, struct purple_pref *pref)
    759 {
    760         GSList *cbs;
    761         struct purple_pref *cb_pref;
    762         for(cb_pref = pref; cb_pref; cb_pref = cb_pref->parent) {
    763                 for(cbs = cb_pref->callbacks; cbs; cbs = cbs->next) {
    764                         struct pref_cb *cb = cbs->data;
    765                         cb->func(name, pref->type, pref->value.generic, cb->data);
    766                 }
    767         }
    768 }
     128        UIOP(remove(name))
    769129
    770130void
    771131purple_prefs_trigger_callback(const char *name)
    772132{
    773         struct purple_pref *pref = find_pref(name);
    774 
    775         if(!pref) {
    776                 purple_debug_error("prefs",
    777                                 "purple_prefs_trigger_callback: Unknown pref %s\n", name);
    778                 return;
    779         }
    780 
    781         do_callbacks(name, pref);
    782 }
     133        GSList *cbs;
    783134
    784 void
    785 purple_prefs_set_generic(const char *name, gpointer value)
    786 {
    787         struct purple_pref *pref = find_pref(name);
     135        purple_debug_misc("prefs", "trigger callback %s\n", name);
    788136
    789         if(!pref) {
    790                 purple_debug_error("prefs",
    791                                 "purple_prefs_set_generic: Unknown pref %s\n", name);
    792                 return;
     137        for (cbs = callbacks; cbs; cbs = cbs->next) {
     138                const char *cb_name = ((struct pref_cb *)cbs->data)->name;
     139                size_t len = strlen(cb_name);
     140                if (!strncmp(cb_name, name, len) &&
     141                    (name[len] == 0 || name[len] == '/' ||
     142                     (len && name[len - 1] == '/'))) {
     143                        /* This test should behave like this:
     144                         * name    = /toto/tata
     145                         * cb_name = /toto/tata --> true
     146                         * cb_name = /toto/tatatiti --> false
     147                         * cb_name = / --> true
     148                         * cb_name = /toto --> true
     149                         * cb_name = /toto/ --> true
     150                         */
     151                        purple_prefs_observe(cbs->data);
     152                }
    793153        }
    794 
    795         pref->value.generic = value;
    796         do_callbacks(name, pref);
    797154}
    798155
    799156void
    800157purple_prefs_set_bool(const char *name, gboolean value)
    801 {
    802         struct purple_pref *pref = find_pref(name);
    803 
    804         if(pref) {
    805                 if(pref->type != PURPLE_PREF_BOOLEAN) {
    806                         purple_debug_error("prefs",
    807                                         "purple_prefs_set_bool: %s not a boolean pref\n", name);
    808                         return;
    809                 }
    810 
    811                 if(pref->value.boolean != value) {
    812                         pref->value.boolean = value;
    813                         do_callbacks(name, pref);
    814                 }
    815         } else {
    816                 purple_prefs_add_bool(name, value);
    817         }
    818 }
     158        UIOP(set_bool(name, value))
    819159
    820160void
    821161purple_prefs_set_int(const char *name, int value)
    822 {
    823         struct purple_pref *pref = find_pref(name);
    824 
    825         if(pref) {
    826                 if(pref->type != PURPLE_PREF_INT) {
    827                         purple_debug_error("prefs",
    828                                         "purple_prefs_set_int: %s not an integer pref\n", name);
    829                         return;
    830                 }
    831 
    832                 if(pref->value.integer != value) {
    833                         pref->value.integer = value;
    834                         do_callbacks(name, pref);
    835                 }
    836         } else {
    837                 purple_prefs_add_int(name, value);
    838         }
    839 }
     162        UIOP(set_int(name, value))
    840163
    841164void
    842165purple_prefs_set_string(const char *name, const char *value)
    843 {
    844         struct purple_pref *pref = find_pref(name);
    845 
    846         if(value != NULL && !g_utf8_validate(value, -1, NULL)) {
    847                 purple_debug_error("prefs", "purple_prefs_set_string: Cannot store invalid UTF8 for string pref %s\n", name);
    848                 return;
    849         }
    850 
    851         if(pref) {
    852                 if(pref->type != PURPLE_PREF_STRING && pref->type != PURPLE_PREF_PATH) {
    853                         purple_debug_error("prefs",
    854                                         "purple_prefs_set_string: %s not a string pref\n", name);
    855                         return;
    856                 }
    857 
    858                 if (!purple_strequal(pref->value.string, value)) {
    859                         g_free(pref->value.string);
    860                         pref->value.string = g_strdup(value);
    861                         do_callbacks(name, pref);
    862                 }
    863         } else {
    864                 purple_prefs_add_string(name, value);
    865         }
    866 }
    867 
    868 void
    869 purple_prefs_set_string_list(const char *name, GList *value)
    870 {
    871         struct purple_pref *pref = find_pref(name);
    872         if(pref) {
    873                 GList *tmp;
    874 
    875                 if(pref->type != PURPLE_PREF_STRING_LIST) {
    876                         purple_debug_error("prefs",
    877                                         "purple_prefs_set_string_list: %s not a string list pref\n",
    878                                         name);
    879                         return;
    880                 }
    881 
    882                 g_list_foreach(pref->value.stringlist, (GFunc)g_free, NULL);
    883                 g_list_free(pref->value.stringlist);
    884                 pref->value.stringlist = NULL;
    885 
    886                 for(tmp = value; tmp; tmp = tmp->next) {
    887                         if(tmp->data != NULL && !g_utf8_validate(tmp->data, -1, NULL)) {
    888                                 purple_debug_error("prefs", "purple_prefs_set_string_list: Skipping invalid UTF8 for string list pref %s\n", name);
    889                                 continue;
    890                         }
    891                         pref->value.stringlist = g_list_prepend(pref->value.stringlist,
    892                                         g_strdup(tmp->data));
    893                 }
    894                 pref->value.stringlist = g_list_reverse(pref->value.stringlist);
    895 
    896                 do_callbacks(name, pref);
    897 
    898         } else {
    899                 purple_prefs_add_string_list(name, value);
    900         }
    901 }
    902 
    903 void
    904 purple_prefs_set_path(const char *name, const char *value)
    905 {
    906         struct purple_pref *pref = find_pref(name);
    907 
    908         if(pref) {
    909                 if(pref->type != PURPLE_PREF_PATH) {
    910                         purple_debug_error("prefs",
    911                                         "purple_prefs_set_path: %s not a path pref\n", name);
    912                         return;
    913                 }
    914 
    915                 if (!purple_strequal(pref->value.string, value)) {
    916                         g_free(pref->value.string);
    917                         pref->value.string = g_strdup(value);
    918                         do_callbacks(name, pref);
    919                 }
    920         } else {
    921                 purple_prefs_add_path(name, value);
    922         }
    923 }
    924 
    925 void
    926 purple_prefs_set_path_list(const char *name, GList *value)
    927 {
    928         struct purple_pref *pref = find_pref(name);
    929         if(pref) {
    930                 GList *tmp;
    931 
    932                 if(pref->type != PURPLE_PREF_PATH_LIST) {
    933                         purple_debug_error("prefs",
    934                                         "purple_prefs_set_path_list: %s not a path list pref\n",
    935                                         name);
    936                         return;
    937                 }
    938 
    939                 g_list_foreach(pref->value.stringlist, (GFunc)g_free, NULL);
    940                 g_list_free(pref->value.stringlist);
    941                 pref->value.stringlist = NULL;
    942 
    943                 for(tmp = value; tmp; tmp = tmp->next)
    944                         pref->value.stringlist = g_list_prepend(pref->value.stringlist,
    945                                         g_strdup(tmp->data));
    946                 pref->value.stringlist = g_list_reverse(pref->value.stringlist);
    947 
    948                 do_callbacks(name, pref);
    949 
    950         } else {
    951                 purple_prefs_add_path_list(name, value);
    952         }
    953 }
    954 
     166        UIOP(set_string(name, value))
    955167
    956168gboolean
    957169purple_prefs_exists(const char *name)
    958 {
    959         struct purple_pref *pref = find_pref(name);
    960 
    961         if (pref != NULL)
    962                 return TRUE;
    963 
    964         return FALSE;
    965 }
     170        UIOP_return(exists(name), FALSE)
    966171
    967172PurplePrefType
    968173purple_prefs_get_type(const char *name)
    969 {
    970         struct purple_pref *pref = find_pref(name);
    971 
    972         if (pref == NULL)
    973                 return PURPLE_PREF_NONE;
    974 
    975         return (pref->type);
    976 }
     174        UIOP_return(get_type(name), PURPLE_PREF_NONE)
    977175
    978176gboolean
    979177purple_prefs_get_bool(const char *name)
    980 {
    981         struct purple_pref *pref = find_pref(name);
    982 
    983         if(!pref) {
    984                 purple_debug_error("prefs",
    985                                 "purple_prefs_get_bool: Unknown pref %s\n", name);
    986                 return FALSE;
    987         } else if(pref->type != PURPLE_PREF_BOOLEAN) {
    988                 purple_debug_error("prefs",
    989                                 "purple_prefs_get_bool: %s not a boolean pref\n", name);
    990                 return FALSE;
    991         }
    992 
    993         return pref->value.boolean;
    994 }
     178        UIOP_return(get_bool(name), FALSE)
    995179
    996180int
    997181purple_prefs_get_int(const char *name)
    998 {
    999         struct purple_pref *pref = find_pref(name);
    1000 
    1001         if(!pref) {
    1002                 purple_debug_error("prefs",
    1003                                 "purple_prefs_get_int: Unknown pref %s\n", name);
    1004                 return 0;
    1005         } else if(pref->type != PURPLE_PREF_INT) {
    1006                 purple_debug_error("prefs",
    1007                                 "purple_prefs_get_int: %s not an integer pref\n", name);
    1008                 return 0;
    1009         }
    1010 
    1011         return pref->value.integer;
    1012 }
     182        UIOP_return(get_int(name), 0)
    1013183
    1014184const char *
    1015185purple_prefs_get_string(const char *name)
    1016 {
    1017         struct purple_pref *pref = find_pref(name);
    1018 
    1019         if(!pref) {
    1020                 purple_debug_error("prefs",
    1021                                 "purple_prefs_get_string: Unknown pref %s\n", name);
    1022                 return NULL;
    1023         } else if(pref->type != PURPLE_PREF_STRING) {
    1024                 purple_debug_error("prefs",
    1025                                 "purple_prefs_get_string: %s not a string pref\n", name);
    1026                 return NULL;
    1027         }
     186        UIOP_return(get_string(name), NULL)
    1028187
    1029         return pref->value.string;
    1030 }
    1031 
    1032 GList *
    1033 purple_prefs_get_string_list(const char *name)
     188guint
     189purple_prefs_connect_callback(void *handle, const char *name, PurplePrefCallback func, gpointer data)
    1034190{
    1035         struct purple_pref *pref = find_pref(name);
    1036         GList *ret = NULL, *tmp;
    1037 
    1038         if(!pref) {
    1039                 purple_debug_error("prefs",
    1040                                 "purple_prefs_get_string_list: Unknown pref %s\n", name);
    1041                 return NULL;
    1042         } else if(pref->type != PURPLE_PREF_STRING_LIST) {
    1043                 purple_debug_error("prefs",
    1044                                 "purple_prefs_get_string_list: %s not a string list pref\n", name);
    1045                 return NULL;
    1046         }
    1047 
    1048         for(tmp = pref->value.stringlist; tmp; tmp = tmp->next)
    1049                 ret = g_list_prepend(ret, g_strdup(tmp->data));
    1050         ret = g_list_reverse(ret);
     191        struct pref_cb *cb;
     192        static guint cb_id = 0;
     193        PurplePrefsUiOps *uiop = NULL;
    1051194
    1052         return ret;
    1053 }
     195        g_return_val_if_fail(name != NULL, 0);
     196        g_return_val_if_fail(func != NULL, 0);
    1054197
    1055 const char *
    1056 purple_prefs_get_path(const char *name)
    1057 {
    1058         struct purple_pref *pref = find_pref(name);
     198        uiop = purple_prefs_get_ui_ops();
     199        g_return_val_if_fail(uiop, 0);
    1059200
    1060         if(!pref) {
    1061                 purple_debug_error("prefs",
    1062                                 "purple_prefs_get_path: Unknown pref %s\n", name);
    1063                 return NULL;
    1064         } else if(pref->type != PURPLE_PREF_PATH) {
    1065                 purple_debug_error("prefs",
    1066                                 "purple_prefs_get_path: %s not a path pref\n", name);
    1067                 return NULL;
    1068         }
     201        cb = g_new0(struct pref_cb, 1);
    1069202
    1070         return pref->value.string;
    1071 }
     203        cb->func = func;
     204        cb->data = data;
     205        cb->id = ++cb_id;
     206        cb->handle = handle;
     207        cb->name = g_strdup(name);
    1072208
    1073 GList *
    1074 purple_prefs_get_path_list(const char *name)
    1075 {
    1076         struct purple_pref *pref = find_pref(name);
    1077         GList *ret = NULL, *tmp;
     209        cb->observer = uiop->add_observer(name, cb);
    1078210
    1079         if(!pref) {
    1080                 purple_debug_error("prefs",
    1081                                 "purple_prefs_get_path_list: Unknown pref %s\n", name);
    1082                 return NULL;
    1083         } else if(pref->type != PURPLE_PREF_PATH_LIST) {
    1084                 purple_debug_error("prefs",
    1085                                 "purple_prefs_get_path_list: %s not a path list pref\n", name);
    1086                 return NULL;
     211        if (cb->observer == NULL) {
     212                purple_debug_error("prefs", "purple_prefs_connect_callback: add observer failed for %s\n", name);
     213                g_free(cb->name);
     214                g_free(cb);
     215                return 0;
    1087216        }
    1088217
    1089         for(tmp = pref->value.stringlist; tmp; tmp = tmp->next)
    1090                 ret = g_list_prepend(ret, g_strdup(tmp->data));
    1091         ret = g_list_reverse(ret);
    1092 
    1093         return ret;
     218        callbacks = g_slist_append(callbacks, cb);
     219        return cb->id;
    1094220}
    1095221
    1096 static void
    1097 purple_prefs_rename_node(struct purple_pref *oldpref, struct purple_pref *newpref)
     222void purple_prefs_observe(gpointer data)
    1098223{
    1099         struct purple_pref *child, *next;
    1100         char *oldname, *newname;
     224        struct pref_cb *cb = data;
     225        PurplePrefsUiOps *uiop = purple_prefs_get_ui_ops();
     226        gconstpointer value = NULL;
     227        PurplePrefType type = PURPLE_PREF_NONE;
     228        type = uiop->get_type(cb->name);
    1101229
    1102         /* if we're a parent, rename the kids first */
    1103         for(child = oldpref->first_child; child != NULL; child = next)
    1104         {
    1105                 struct purple_pref *newchild;
    1106                 next = child->sibling;
    1107                 for(newchild = newpref->first_child; newchild != NULL; newchild = newchild->sibling)
    1108                 {
    1109                         if(purple_strequal(child->name, newchild->name))
    1110                         {
    1111                                 purple_prefs_rename_node(child, newchild);
    1112                                 break;
    1113                         }
    1114                 }
    1115                 if(newchild == NULL) {
    1116                         /* no rename happened, we weren't able to find the new pref */
    1117                         char *tmpname = pref_full_name(child);
    1118                         purple_debug_error("prefs", "Unable to find rename pref for %s\n", tmpname);
    1119                         g_free(tmpname);
    1120                 }
    1121         }
    1122 
    1123         oldname = pref_full_name(oldpref);
    1124         newname = pref_full_name(newpref);
    1125 
    1126         if (oldpref->type != newpref->type)
    1127         {
    1128                 purple_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname);
    1129                 g_free(oldname);
    1130                 g_free(newname);
    1131                 return;
    1132         }
     230        purple_debug_misc("prefs", "observe name = %s\n", cb->name);
    1133231
    1134         purple_debug_info("prefs", "Renaming %s to %s\n", oldname, newname);
    1135         g_free(oldname);
    1136 
    1137         switch(oldpref->type) {
    1138                 case PURPLE_PREF_NONE:
     232        switch (type) {
     233                case PURPLE_PREF_INT:
     234                        value = GINT_TO_POINTER(uiop->get_int(cb->name));
    1139235                        break;
    1140236                case PURPLE_PREF_BOOLEAN:
    1141                         purple_prefs_set_bool(newname, oldpref->value.boolean);
    1142                         break;
    1143                 case PURPLE_PREF_INT:
    1144                         purple_prefs_set_int(newname, oldpref->value.integer);
     237                        value = GINT_TO_POINTER(uiop->get_bool(cb->name));
    1145238                        break;
    1146239                case PURPLE_PREF_STRING:
    1147                         purple_prefs_set_string(newname, oldpref->value.string);
    1148                         break;
    1149                 case PURPLE_PREF_STRING_LIST:
    1150                         purple_prefs_set_string_list(newname, oldpref->value.stringlist);
     240                        value = uiop->get_string(cb->name);
    1151241                        break;
    1152                 case PURPLE_PREF_PATH:
    1153                         purple_prefs_set_path(newname, oldpref->value.string);
    1154                         break;
    1155                 case PURPLE_PREF_PATH_LIST:
    1156                         purple_prefs_set_path_list(newname, oldpref->value.stringlist);
     242                case PURPLE_PREF_NONE:
    1157243                        break;
     244                default:
     245                        purple_debug_error("prefs", "Unexpected type = %i\n", type);
    1158246        }
    1159         g_free(newname);
    1160 
    1161         remove_pref(oldpref);
     247        cb->func(cb->name, type, value, cb->data);
    1162248}
    1163249
    1164250void
    1165 purple_prefs_rename(const char *oldname, const char *newname)
    1166 {
    1167         struct purple_pref *oldpref, *newpref;
    1168 
    1169         oldpref = find_pref(oldname);
    1170 
    1171         /* it's already been renamed, call off the dogs */
    1172         if(!oldpref)
    1173                 return;
    1174 
    1175         newpref = find_pref(newname);
    1176 
    1177         if (newpref == NULL)
    1178         {
    1179                 purple_debug_error("prefs", "Unable to rename %s to %s: new pref not created\n", oldname, newname);
    1180                 return;
    1181         }
    1182 
    1183         purple_prefs_rename_node(oldpref, newpref);
    1184 }
    1185 
    1186 void
    1187 purple_prefs_rename_boolean_toggle(const char *oldname, const char *newname)
    1188 {
    1189                 struct purple_pref *oldpref, *newpref;
    1190 
    1191                 oldpref = find_pref(oldname);
    1192 
    1193                 /* it's already been renamed, call off the cats */
    1194                 if(!oldpref)
    1195                         return;
    1196 
    1197                 if (oldpref->type != PURPLE_PREF_BOOLEAN)
    1198                 {
    1199                         purple_debug_error("prefs", "Unable to rename %s to %s: old pref not a boolean\n", oldname, newname);
    1200                         return;
    1201                 }
    1202 
    1203                 if (oldpref->first_child != NULL) /* can't rename parents */
    1204                 {
    1205                         purple_debug_error("prefs", "Unable to rename %s to %s: can't rename parents\n", oldname, newname);
    1206                         return;
    1207                 }
    1208 
    1209 
    1210                 newpref = find_pref(newname);
    1211 
    1212                 if (newpref == NULL)
    1213                 {
    1214                         purple_debug_error("prefs", "Unable to rename %s to %s: new pref not created\n", oldname, newname);
    1215                         return;
    1216                 }
    1217 
    1218                 if (oldpref->type != newpref->type)
    1219                 {
    1220                         purple_debug_error("prefs", "Unable to rename %s to %s: differing types\n", oldname, newname);
    1221                         return;
    1222                 }
    1223 
    1224                 purple_debug_info("prefs", "Renaming and toggling %s to %s\n", oldname, newname);
    1225                 purple_prefs_set_bool(newname, !(oldpref->value.boolean));
    1226 
    1227                 remove_pref(oldpref);
    1228 }
    1229 
    1230 guint
    1231 purple_prefs_connect_callback(void *handle, const char *name, PurplePrefCallback func, gpointer data)
    1232 {
    1233         struct purple_pref *pref;
    1234         struct pref_cb *cb;
    1235         static guint cb_id = 0;
    1236 
    1237         g_return_val_if_fail(name != NULL, 0);
    1238         g_return_val_if_fail(func != NULL, 0);
    1239 
    1240         pref = find_pref(name);
    1241         if (pref == NULL) {
    1242                 purple_debug_error("prefs", "purple_prefs_connect_callback: Unknown pref %s\n", name);
    1243                 return 0;
    1244         }
    1245 
    1246         cb = g_new0(struct pref_cb, 1);
    1247 
    1248         cb->func = func;
    1249         cb->data = data;
    1250         cb->id = ++cb_id;
    1251         cb->handle = handle;
    1252 
    1253         pref->callbacks = g_slist_append(pref->callbacks, cb);
    1254 
    1255         return cb->id;
    1256 }
    1257 
    1258 static gboolean
    1259 disco_callback_helper(struct purple_pref *pref, guint callback_id)
     251purple_prefs_disconnect_callback(guint callback_id)
    1260252{
    1261253        GSList *cbs;
    1262         struct purple_pref *child;
    1263 
    1264         if(!pref)
    1265                 return FALSE;
    1266254
    1267         for(cbs = pref->callbacks; cbs; cbs = cbs->next) {
     255        for (cbs = callbacks; cbs; cbs = cbs->next) {
    1268256                struct pref_cb *cb = cbs->data;
    1269                 if(cb->id == callback_id) {
    1270                         pref->callbacks = g_slist_delete_link(pref->callbacks, cbs);
     257                if (cb->id == callback_id) {
     258                        PurplePrefsUiOps *uiop = purple_prefs_get_ui_ops();
     259                        uiop->remove_observer(cb->name, cb->observer);
     260
     261                        callbacks = g_slist_delete_link(callbacks, cbs);
     262                        g_free(cb->name);
    1271263                        g_free(cb);
    1272                         return TRUE;
     264                        return;
    1273265                }
    1274266        }
    1275 
    1276         for(child = pref->first_child; child; child = child->sibling) {
    1277                 if(disco_callback_helper(child, callback_id))
    1278                         return TRUE;
    1279         }
    1280 
    1281         return FALSE;
    1282267}
    1283268
    1284269void
    1285 purple_prefs_disconnect_callback(guint callback_id)
    1286 {
    1287         disco_callback_helper(&prefs, callback_id);
    1288 }
    1289 
    1290 static void
    1291 disco_callback_helper_handle(struct purple_pref *pref, void *handle)
     270purple_prefs_disconnect_by_handle(void *handle)
    1292271{
    1293272        GSList *cbs;
    1294         struct purple_pref *child;
    1295273
    1296         if(!pref)
    1297                 return;
     274        g_return_if_fail(handle != NULL);
    1298275
    1299         cbs = pref->callbacks;
     276        cbs = callbacks;
    1300277        while (cbs != NULL) {
     278                PurplePrefsUiOps *uiop;
    1301279                struct pref_cb *cb = cbs->data;
    1302                 if(cb->handle == handle) {
    1303                         pref->callbacks = g_slist_delete_link(pref->callbacks, cbs);
    1304                         g_free(cb);
    1305                         cbs = pref->callbacks;
    1306                 } else
     280                if (cb->handle != handle) {
    1307281                        cbs = cbs->next;
    1308         }
    1309 
    1310         for(child = pref->first_child; child; child = child->sibling)
    1311                 disco_callback_helper_handle(child, handle);
    1312 }
     282                        continue;
     283                }
    1313284
    1314 void
    1315 purple_prefs_disconnect_by_handle(void *handle)
    1316 {
    1317         g_return_if_fail(handle != NULL);
     285                uiop = purple_prefs_get_ui_ops();
     286                uiop->remove_observer(cb->name, cb->observer);
    1318287
    1319         disco_callback_helper_handle(&prefs, handle);
     288                callbacks = g_slist_delete_link(callbacks, cbs);
     289                g_free(cb->name);
     290                g_free(cb);
     291                cbs = callbacks;
     292        }
    1320293}
    1321294
    1322295GList *
    1323296purple_prefs_get_children_names(const char *name)
    1324 {
    1325         GList * list = NULL;
    1326         struct purple_pref *pref = find_pref(name), *child;
    1327         char sep[2] = "\0\0";;
    1328 
    1329         if (pref == NULL)
    1330                 return NULL;
    1331 
    1332         if (name[strlen(name) - 1] != '/')
    1333                 sep[0] = '/';
    1334         for (child = pref->first_child; child; child = child->sibling) {
    1335                 list = g_list_append(list, g_strdup_printf("%s%s%s", name, sep, child->name));
    1336         }
    1337         return list;
    1338 }
    1339 
    1340 void
    1341 purple_prefs_update_old()
    1342 {
    1343         purple_prefs_rename("/core", "/purple");
    1344 
    1345         /* Remove some no-longer-used prefs */
    1346         purple_prefs_remove("/purple/away/auto_response/enabled");
    1347         purple_prefs_remove("/purple/away/auto_response/idle_only");
    1348         purple_prefs_remove("/purple/away/auto_response/in_active_conv");
    1349         purple_prefs_remove("/purple/away/auto_response/sec_before_resend");
    1350         purple_prefs_remove("/purple/away/auto_response");
    1351         purple_prefs_remove("/purple/away/default_message");
    1352         purple_prefs_remove("/purple/buddies/use_server_alias");
    1353         purple_prefs_remove("/purple/conversations/away_back_on_send");
    1354         purple_prefs_remove("/purple/conversations/send_urls_as_links");
    1355         purple_prefs_remove("/purple/conversations/im/show_login");
    1356         purple_prefs_remove("/purple/conversations/chat/show_join");
    1357         purple_prefs_remove("/purple/conversations/chat/show_leave");
    1358         purple_prefs_remove("/purple/conversations/combine_chat_im");
    1359         purple_prefs_remove("/purple/conversations/use_alias_for_title");
    1360         purple_prefs_remove("/purple/logging/log_signon_signoff");
    1361         purple_prefs_remove("/purple/logging/log_idle_state");
    1362         purple_prefs_remove("/purple/logging/log_away_state");
    1363         purple_prefs_remove("/purple/logging/log_own_states");
    1364         purple_prefs_remove("/purple/status/scores/hidden");
    1365         purple_prefs_remove("/plugins/core/autorecon/hide_connected_error");
    1366         purple_prefs_remove("/plugins/core/autorecon/hide_connecting_error");
    1367         purple_prefs_remove("/plugins/core/autorecon/hide_reconnecting_dialog");
    1368         purple_prefs_remove("/plugins/core/autorecon/restore_state");
    1369         purple_prefs_remove("/plugins/core/autorecon");
    1370 
    1371         /* Convert old sounds while_away pref to new 3-way pref. */
    1372         if (purple_prefs_exists("/purple/sound/while_away") &&
    1373             purple_prefs_get_bool("/purple/sound/while_away"))
    1374         {
    1375                 purple_prefs_set_int("/purple/sound/while_status", 3);
    1376         }
    1377         purple_prefs_remove("/purple/sound/while_away");
    1378 }
     297        UIOP_return(get_children_names(name), NULL)
    1379298
    1380299void *
    1381300purple_prefs_get_handle(void)
     
    1390309{
    1391310        void *handle = purple_prefs_get_handle();
    1392311
    1393         prefs_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
    1394 
    1395312        purple_prefs_connect_callback(handle, "/", prefs_save_cb, NULL);
    1396313
    1397314        purple_prefs_add_none("/purple");
     
    1402319
    1403320        /* Away */
    1404321        purple_prefs_add_none("/purple/away");
    1405         purple_prefs_add_string("/purple/away/idle_reporting", "system");
    1406         purple_prefs_add_bool("/purple/away/away_when_idle", TRUE);
    1407         purple_prefs_add_int("/purple/away/mins_before_away", 5);
    1408 
    1409         /* Away -> Auto-Reply */
    1410         if (!purple_prefs_exists("/purple/away/auto_response/enabled") ||
    1411             !purple_prefs_exists("/purple/away/auto_response/idle_only"))
    1412         {
    1413                 purple_prefs_add_string("/purple/away/auto_reply", "awayidle");
    1414         }
    1415         else
    1416         {
    1417                 if (!purple_prefs_get_bool("/purple/away/auto_response/enabled"))
    1418                 {
    1419                         purple_prefs_add_string("/purple/away/auto_reply", "never");
    1420                 }
    1421                 else
    1422                 {
    1423                         if (purple_prefs_get_bool("/purple/away/auto_response/idle_only"))
    1424                         {
    1425                                 purple_prefs_add_string("/purple/away/auto_reply", "awayidle");
    1426                         }
    1427                         else
    1428                         {
    1429                                 purple_prefs_add_string("/purple/away/auto_reply", "away");
    1430                         }
    1431                 }
    1432         }
     322        purple_prefs_add_string("/purple/away/auto_reply", "awayidle");
    1433323
    1434324        /* Buddies */
    1435325        purple_prefs_add_none("/purple/buddies");
     
    1442332        purple_prefs_remove("/purple/contact/idle_score");
    1443333
    1444334        purple_prefs_load();
    1445         purple_prefs_update_old();
    1446335}
    1447336
    1448337void
     
    1451340        if (save_timer != 0)
    1452341        {
    1453342                purple_timeout_remove(save_timer);
    1454                 save_timer = 0;
    1455                 sync_prefs();
     343                save_cb(NULL);
    1456344        }
    1457345
    1458346        purple_prefs_disconnect_by_handle(purple_prefs_get_handle());
    1459347
    1460348        prefs_loaded = FALSE;
    1461         purple_prefs_destroy();
    1462         g_hash_table_destroy(prefs_hash);
    1463         prefs_hash = NULL;
     349}
    1464350
     351void
     352purple_prefs_set_ui_ops(PurplePrefsUiOps *ops)
     353{
     354        prefs_ui_ops = ops;
     355}
     356
     357PurplePrefsUiOps *
     358purple_prefs_get_ui_ops(void)
     359{
     360        return prefs_ui_ops;
    1465361}
  • libpurple/prefs.h

    diff -ru extract/pidgin-2.10.9/libpurple/prefs.h libpurple/prefs.h
    old new  
    3838        PURPLE_PREF_BOOLEAN,     /**< Boolean.         */
    3939        PURPLE_PREF_INT,         /**< Integer.         */
    4040        PURPLE_PREF_STRING,      /**< String.          */
     41        /* The 3 following types are unused in libpurple,
     42           and not implemented in Instantbird */
    4143        PURPLE_PREF_STRING_LIST, /**< List of strings. */
    4244        PURPLE_PREF_PATH,        /**< Path.            */
    4345        PURPLE_PREF_PATH_LIST    /**< List of paths.   */
     
    6264typedef void (*PurplePrefCallback) (const char *name, PurplePrefType type,
    6365                gconstpointer val, gpointer data);
    6466
     67
     68/** @copydoc _PurplePrefsUiOps */
     69typedef struct _PurplePrefsUiOps PurplePrefsUiOps;
     70
     71
     72/**  Prefs UI operations
     73 */
     74struct _PurplePrefsUiOps
     75{
     76        void (*add_none)(const char *name);
     77        void (*add_bool)(const char *name, gboolean value);
     78        void (*add_int)(const char *name, int value);
     79        void (*add_string)(const char *name, const char *value);
     80
     81        void (*set_bool)(const char *name, gboolean value);
     82        void (*set_int)(const char *name, int value);
     83        void (*set_string)(const char *name, const char *value);
     84
     85        gboolean (*get_bool)(const char *name);
     86        int (*get_int)(const char *name);
     87        const char *(*get_string)(const char *name);
     88
     89        PurplePrefType (*get_type)(const char *name);
     90        GList *(*get_children_names)(const char *name);
     91
     92        gboolean (*exists)(const char *name);
     93        void (*remove)(const char *name);
     94
     95        void (*save)(void);
     96
     97        void *(*add_observer)(const char *name, gpointer data);
     98        void (*remove_observer)(const char *name, void *observer);
     99
     100        void (*_purple_reserved1)(void);
     101        void (*_purple_reserved2)(void);
     102        void (*_purple_reserved3)(void);
     103        void (*_purple_reserved4)(void);
     104};
     105
     106
    65107#ifdef __cplusplus
    66108extern "C" {
    67109#endif
    68110
    69111/**************************************************************************/
     112/** @name UI Registration Functions                                       */
     113/**************************************************************************/
     114/*@{*/
     115/**
     116 * Sets the UI operations structure to be used for preferences.
     117 *
     118 * @param ops The UI operations structure.
     119 */
     120void purple_prefs_set_ui_ops(PurplePrefsUiOps *ops);
     121
     122/**
     123 * Returns the UI operations structure used for preferences.
     124 *
     125 * @return The UI operations structure in use.
     126 */
     127PurplePrefsUiOps *purple_prefs_get_ui_ops(void);
     128
     129/*@}*/
     130
     131/**************************************************************************/
    70132/** @name Prefs API
    71133    Preferences are named according to a directory-like structure.
    72134    Example: "/plugins/core/potato/is_from_idaho" (probably a boolean)    */
     
    122184void purple_prefs_add_string(const char *name, const char *value);
    123185
    124186/**
    125  * Add a new string list pref.
    126  *
    127  * @param name  The name of the pref
    128  * @param value The initial value to set
    129  * @note This function takes a copy of the strings in the value list. The list
    130  *       itself and original copies of the strings are up to the caller to
    131  *       free.
    132  */
    133 void purple_prefs_add_string_list(const char *name, GList *value);
    134 
    135 /**
    136  * Add a new path pref.
    137  *
    138  * @param name  The name of the pref
    139  * @param value The initial value to set
    140  */
    141 void purple_prefs_add_path(const char *name, const char *value);
    142 
    143 /**
    144  * Add a new path list pref.
    145  *
    146  * @param name  The name of the pref
    147  * @param value The initial value to set
    148  * @note This function takes a copy of the strings in the value list. The list
    149  *       itself and original copies of the strings are up to the caller to
    150  *       free.
    151  */
    152 void purple_prefs_add_path_list(const char *name, GList *value);
    153 
    154 
    155 /**
    156187 * Remove a pref.
    157188 *
    158189 * @param name The name of the pref
     
    160191void purple_prefs_remove(const char *name);
    161192
    162193/**
    163  * Rename a pref
    164  *
    165  * @param oldname The old name of the pref
    166  * @param newname The new name for the pref
    167  */
    168 void purple_prefs_rename(const char *oldname, const char *newname);
    169 
    170 /**
    171  * Rename a boolean pref, toggling it's value
    172  *
    173  * @param oldname The old name of the pref
    174  * @param newname The new name for the pref
    175  */
    176 void purple_prefs_rename_boolean_toggle(const char *oldname, const char *newname);
    177 
    178 /**
    179  * Remove all prefs.
    180  */
    181 void purple_prefs_destroy(void);
    182 
    183 /**
    184  * Set raw pref value
    185  *
    186  * @param name  The name of the pref
    187  * @param value The value to set
    188  *
    189  * @deprecated We're not really sure what purpose this function serves, so it
    190  *             will be removed in 3.0.0.  Preferences values set using this
    191  *             function aren't serialized to prefs.xml, which could be
    192  *             misleading.  There is also no purple_prefs_get_generic, which
    193  *             means that if you can't really get the value (other in a
    194  *             connected callback).  If you think you have a use for this then
    195  *             please let us know.
    196  */
    197 /* TODO: When this is removed, also remove struct purple_pref->value.generic */
    198 void purple_prefs_set_generic(const char *name, gpointer value);
    199 
    200 /**
    201194 * Set boolean pref value
    202195 *
    203196 * @param name  The name of the pref
     
    221214 */
    222215void purple_prefs_set_string(const char *name, const char *value);
    223216
    224 /**
    225  * Set string list pref value
    226  *
    227  * @param name  The name of the pref
    228  * @param value The value to set
    229  */
    230 void purple_prefs_set_string_list(const char *name, GList *value);
    231 
    232 /**
    233  * Set path pref value
    234  *
    235  * @param name  The name of the pref
    236  * @param value The value to set
    237  */
    238 void purple_prefs_set_path(const char *name, const char *value);
    239 
    240 /**
    241  * Set path list pref value
    242  *
    243  * @param name  The name of the pref
    244  * @param value The value to set
    245  */
    246 void purple_prefs_set_path_list(const char *name, GList *value);
    247 
    248217
    249218/**
    250219 * Check if a pref exists
     
    287256const char *purple_prefs_get_string(const char *name);
    288257
    289258/**
    290  * Get string list pref value
    291  *
    292  * @param name The name of the pref
    293  * @return The value of the pref
    294  */
    295 GList *purple_prefs_get_string_list(const char *name);
    296 
    297 /**
    298  * Get path pref value
    299  *
    300  * @param name The name of the pref
    301  * @return The value of the pref
    302  */
    303 const char *purple_prefs_get_path(const char *name);
    304 
    305 /**
    306  * Get path list pref value
    307  *
    308  * @param name The name of the pref
    309  * @return The value of the pref
    310  */
    311 GList *purple_prefs_get_path_list(const char *name);
    312 
    313 /**
    314259 * Returns a list of children for a pref
    315260 *
    316261 * @param name The parent pref
     
    338283                gpointer data);
    339284
    340285/**
     286 * Call the callback of the observer
     287 */
     288void purple_prefs_observe(gpointer data);
     289
     290/**
    341291 * Remove a callback to a pref
    342292 */
    343293void purple_prefs_disconnect_callback(guint callback_id);
     
    357307 */
    358308gboolean purple_prefs_load(void);
    359309
    360 /**
    361  * Rename legacy prefs and delete some that no longer exist.
    362  */
    363 void purple_prefs_update_old(void);
    364 
    365310/*@}*/
    366311
    367312#ifdef __cplusplus
  • libpurple/protocols/gg/lib/common.c

    Only in libpurple/protocols/bonjour: Makefile.in
    Only in libpurple/protocols/bonjour: moz.build
    Only in libpurple/protocols/bonjour: win32
    Only in libpurple/protocols: create-cid.sh
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/common.c libpurple/protocols/gg/lib/common.c
    old new  
    4444#include <stdio.h>
    4545#include <stdlib.h>
    4646#include <string.h>
    47 #include <unistd.h>
     47#ifndef _MSC_VER
     48#  include <unistd.h>
     49#endif
    4850
    4951#include "libgadu.h"
    5052
  • libpurple/protocols/gg/lib/dcc7.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/dcc7.c libpurple/protocols/gg/lib/dcc7.c
    old new  
    4949#include <string.h>
    5050#include <stdio.h>
    5151#include <stdlib.h>
    52 #include <unistd.h>
     52#ifndef _MSC_VER
     53#  include <unistd.h>
     54#endif
    5355
    5456#include "compat.h"
    5557#include "libgadu.h"
     
    5860#include "libgadu-internal.h"
    5961#include "libgadu-debug.h"
    6062
    61 #define gg_debug_dcc(dcc, level, fmt...) \
    62         gg_debug_session(((dcc) != NULL) ? (dcc)->sess : NULL, level, fmt)
     63#define gg_debug_dcc(dcc, level, ...) \
     64        gg_debug_session(((dcc) != NULL) ? (dcc)->sess : NULL, level, __VA_ARGS__)
    6365
    6466#define gg_debug_dump_dcc(dcc, level, buf, len) \
    6567        gg_debug_dump(((dcc) != NULL) ? (dcc)->sess : NULL, level, buf, len)
  • libpurple/protocols/gg/lib/events.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/events.c libpurple/protocols/gg/lib/events.c
    old new  
    5050#include <string.h>
    5151#include <stdlib.h>
    5252#include <time.h>
    53 #include <unistd.h>
     53#ifndef _MSC_VER
     54#  include <unistd.h>
     55#endif
    5456#include <ctype.h>
    5557#ifdef GG_CONFIG_HAVE_GNUTLS
    5658#  include <gnutls/gnutls.h>
  • libpurple/protocols/gg/lib/handlers.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/handlers.c libpurple/protocols/gg/lib/handlers.c
    old new  
    5959#include <stdlib.h>
    6060#include <string.h>
    6161#include <signal.h>
    62 #include <unistd.h>
     62#ifndef _MSC_VER
     63#  include <unistd.h>
     64#endif
    6365#include <time.h>
    6466#ifdef GG_CONFIG_HAVE_OPENSSL
    6567#  include <openssl/err.h>
  • libpurple/protocols/gg/lib/http.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/http.c libpurple/protocols/gg/lib/http.c
    old new  
    4545#include <stdio.h>
    4646#include <stdlib.h>
    4747#include <string.h>
    48 #include <unistd.h>
     48#ifndef _MSC_VER
     49#  include <unistd.h>
     50#endif
    4951
    5052#define GG_HTTP_MAX_LENGTH 1000000000
    5153
  • libpurple/protocols/gg/lib/libgadu.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/libgadu.c libpurple/protocols/gg/lib/libgadu.c
    old new  
    6565#include <string.h>
    6666#include <signal.h>
    6767#include <time.h>
    68 #include <unistd.h>
     68#ifndef _MSC_VER
     69#  include <unistd.h>
     70#endif
    6971#ifdef GG_CONFIG_HAVE_GNUTLS
    7072#  include <gnutls/gnutls.h>
    7173#endif
  • libpurple/protocols/gg/lib/libgadu-config.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/libgadu-config.h libpurple/protocols/gg/lib/libgadu-config.h
    old new  
    11/* Local libgadu configuration. */
    22
    3 #include "config.h"
     3/*#include "config.h" */
    44
    55#ifndef __GG_LIBGADU_CONFIG_H
    66#define __GG_LIBGADU_CONFIG_H
     
    1111#define __GG_LIBGADU_BIGENDIAN
    1212#endif /* WORDS_BIGENDIAN */
    1313
     14#ifndef _WIN32
    1415/* Defined if this machine has va_copy(). */
    1516#define __GG_LIBGADU_HAVE_VA_COPY
    1617
    1718/* Defined if this machine has __va_copy(). */
    1819#define __GG_LIBGADU_HAVE___VA_COPY
     20#endif
    1921
    2022/* Defined if this machine supports long long. */
    2123#undef __GG_LIBGADU_HAVE_LONG_LONG
     
    5658#define random (long) rand
    5759#endif
    5860
     61#ifdef _MSC_VER
     62typedef unsigned __int32 uint32_t;
     63typedef unsigned __int16 uint16_t;
     64typedef unsigned __int8  uint8_t;
     65#define snprintf _snprintf
     66#include <win32dep.h>
     67#define EINPROGRESS WSAEINPROGRESS
     68#define ECONNRESET WSAECONNRESET
     69#define ENOTCONN WSAENOTCONN
     70#define strncasecmp strnicmp
     71#define strcasecmp stricmp
     72#define ssize_t SSIZE_T
     73#endif
     74
    5975#endif /* __GG_LIBGADU_CONFIG_H */
  • libpurple/protocols/gg/lib/libgadu.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/libgadu.h libpurple/protocols/gg/lib/libgadu.h
    old new  
    4141extern "C" {
    4242#endif
    4343
     44#include "libgadu-config.h"
     45
    4446#include <sys/types.h>
    4547#include <stdio.h>
    4648#include <stdarg.h>
     
    22882290
    22892291#define GG_DCC7_DUNNO1 0x24
    22902292
     2293#if 0
    22912294struct gg_dcc7_dunno1 {
    22922295        // XXX
    22932296} GG_PACKED;
     2297#endif
    22942298
    22952299#define GG_DCC7_TIMEOUT_CONNECT 10      /* 10 sekund */
    22962300#define GG_DCC7_TIMEOUT_SEND 1800       /* 30 minut */
  • libpurple/protocols/gg/lib/message.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/message.h libpurple/protocols/gg/lib/message.h
    old new  
    2020#define LIBGADU_MESSAGE_H
    2121
    2222#include <sys/types.h>
    23 #include <inttypes.h>
    2423#include "libgadu.h"
    2524
    2625#if 0
  • libpurple/protocols/gg/lib/pubdir.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/pubdir.c libpurple/protocols/gg/lib/pubdir.c
    old new  
    3232#include <stdio.h>
    3333#include <stdlib.h>
    3434#include <string.h>
     35#ifndef _MSC_VER
    3536#include <unistd.h>
     37#endif
    3638
    3739#include "libgadu.h"
    3840#include "libgadu-config.h"
  • libpurple/protocols/gg/lib/resolver.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/resolver.c libpurple/protocols/gg/lib/resolver.c
    old new  
    3333#include <errno.h>
    3434#include <stdlib.h>
    3535#include <string.h>
    36 #include <unistd.h>
     36#ifndef _MSC_VER
     37#  include <unistd.h>
     38#endif
    3739#ifndef _WIN32
    3840#  include <signal.h>
    3941#  include <netinet/in.h>
  • libpurple/protocols/gg/lib/sha1.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/gg/lib/sha1.c libpurple/protocols/gg/lib/sha1.c
    old new  
    2828
    2929#include <string.h>
    3030#include <sys/types.h>
     31#ifndef _MSC_VER
    3132#include <unistd.h>
     33#endif
    3234
    3335#include "libgadu.h"
    3436
  • libpurple/protocols/jabber/buddy.c

    Only in libpurple/protocols/gg: Makefile.in
    Only in libpurple/protocols/gg: moz.build
    Only in extract/pidgin-2.10.9/libpurple/protocols: irc
    Only in extract/pidgin-2.10.9/libpurple/protocols/jabber: auth_cyrus.c
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/jabber/buddy.c libpurple/protocols/jabber/buddy.c
    old new  
    131131        const JabberBuddyResource *jbrb = b;
    132132        JabberBuddyState state_a, state_b;
    133133
    134         if (jbra->priority != jbrb->priority)
    135                 return jbra->priority > jbrb->priority ? -1 : 1;
    136 
    137134        /* Fold the states for easier comparison */
    138135        /* TODO: Differentiate online/chat and away/dnd? */
    139136        switch (jbra->state) {
     
    177174        }
    178175
    179176        if (state_a == state_b) {
     177                if (jbra->priority != jbrb->priority)
     178                        return jbra->priority > jbrb->priority ? -1 : 1;
     179
    180180                if (jbra->idle == jbrb->idle)
    181181                        return 0;
    182182                else if ((jbra->idle && !jbrb->idle) ||
  • libpurple/protocols/jabber/disco.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/jabber/disco.c libpurple/protocols/jabber/disco.c
    old new  
    3535#include "google/jingleinfo.h"
    3636#include "iq.h"
    3737#include "jabber.h"
     38#ifdef USE_JINGLE
    3839#include "jingle/jingle.h"
     40#endif
    3941#include "pep.h"
    4042#include "presence.h"
    4143#include "roster.h"
  • libpurple/protocols/jabber/google/google_session.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/jabber/google/google_session.c libpurple/protocols/jabber/google/google_session.c
    old new  
    2323#include "google_session.h"
    2424#include "relay.h"
    2525
    26 #include "jingle/jingle.h"
    27 
    2826#ifdef USE_VV
    2927
     28#include "jingle/jingle.h"
     29
    3030typedef struct {
    3131        PurpleMedia *media;
    3232        gboolean video;
  • libpurple/protocols/jabber/iq.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/jabber/iq.c libpurple/protocols/jabber/iq.c
    old new  
    3333#include "google/jingleinfo.h"
    3434#include "google/google_session.h"
    3535#include "iq.h"
     36#ifdef USE_JINGLE
    3637#include "jingle/jingle.h"
     38#endif
    3739#include "oob.h"
    3840#include "roster.h"
    3941#include "si.h"
     
    4345#include "ibb.h"
    4446
    4547#ifdef _WIN32
    46 #include "utsname.h"
     48#include "win32/utsname.h"
    4749#endif
    4850
    4951static GHashTable *iq_handlers = NULL;
     
    552554        iq_handlers = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
    553555        signal_iq_handlers = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
    554556
     557#ifdef USE_JINGLE
    555558        jabber_iq_register_handler("jingle", JINGLE, jingle_parse);
     559#endif
    556560        jabber_iq_register_handler("mailbox", NS_GOOGLE_MAIL_NOTIFY,
    557561                        jabber_gmail_poke);
    558562        jabber_iq_register_handler("new-mail", NS_GOOGLE_MAIL_NOTIFY,
  • libpurple/protocols/jabber/jabber.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/jabber/jabber.c libpurple/protocols/jabber/jabber.c
    old new  
    6969#include "pep.h"
    7070#include "adhoccommands.h"
    7171
     72#ifdef USE_JINGLE
    7273#include "jingle/jingle.h"
    7374#include "jingle/rtp.h"
     75#endif
    7476
    7577#define PING_TIMEOUT 60
    7678/* Send a whitespace keepalive to the server if we haven't sent
     
    15891591{
    15901592        JabberStream *js = purple_connection_get_protocol_data(gc);
    15911593
     1594#ifdef USE_JINGLE
    15921595        /* Close all of the open Jingle sessions on this stream */
    15931596        jingle_terminate_sessions(js);
     1597#endif
    15941598
    15951599        if (js->bosh)
    15961600                jabber_bosh_connection_close(js->bosh);
     
    38663870        /* Bits Of Binary */
    38673871        jabber_add_feature(NS_BOB, 0);
    38683872
     3873#ifdef USE_JINGLE
    38693874        /* Jingle features! */
    38703875        jabber_add_feature(JINGLE, 0);
     3876#endif
    38713877
    38723878#ifdef USE_VV
    38733879        jabber_add_feature(NS_GOOGLE_PROTOCOL_SESSION, jabber_audio_enabled);
  • libpurple/protocols/jabber/jabber.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/jabber/jabber.h libpurple/protocols/jabber/jabber.h
    old new  
    6060#include "connection.h"
    6161#include "dnsquery.h"
    6262#include "dnssrv.h"
     63#ifdef USE_VV
    6364#include "media.h"
    6465#include "mediamanager.h"
     66#endif
    6567#include "roomlist.h"
    6668#include "sslconn.h"
    6769
  • libpurple/protocols/jabber/libxmpp.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/jabber/libxmpp.c libpurple/protocols/jabber/libxmpp.c
    old new  
    258258        GList *encryption_values = NULL;
    259259
    260260        /* Translators: 'domain' is used here in the context of Internet domains, e.g. pidgin.im */
    261         split = purple_account_user_split_new(_("Domain"), NULL, '@');
     261        split = purple_account_user_split_new(_("Domain"), "jabber.org", '@');
    262262        purple_account_user_split_set_reverse(split, FALSE);
    263263        prpl_info.user_splits = g_list_append(prpl_info.user_splits, split);
    264264
    265         split = purple_account_user_split_new(_("Resource"), "", '/');
     265        split = purple_account_user_split_new(_("Resource"), "Instantbird", '/');
    266266        purple_account_user_split_set_reverse(split, FALSE);
    267267        prpl_info.user_splits = g_list_append(prpl_info.user_splits, split);
    268268
     
    315315        prpl_info.protocol_options = g_list_append(prpl_info.protocol_options,
    316316                                                  option);
    317317
    318         /* this should probably be part of global smiley theme settings later on,
    319           shared with MSN */
    320         option = purple_account_option_bool_new(_("Show Custom Smileys"),
    321                 "custom_smileys", TRUE);
    322         prpl_info.protocol_options = g_list_append(prpl_info.protocol_options,
    323                 option);
    324 
    325318        my_protocol = plugin;
    326319
    327320        purple_prefs_remove("/plugins/prpl/jabber");
  • libpurple/protocols/jabber/message.c

    Only in libpurple/protocols/jabber: Makefile.in
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/jabber/message.c libpurple/protocols/jabber/message.c
    old new  
    106106                                         * this should be able to be implemented by removing the
    107107                                         * user from the conversation like we do with chats now. */
    108108                                        purple_conversation_write(conv, "", buf,
    109                                                                 PURPLE_MESSAGE_SYSTEM, time(NULL));
     109                                                                  PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LINKIFY,
     110                                                                  time(NULL));
    110111                                }
    111112                        }
    112113                        serv_got_typing_stopped(gc, jm->from);
     
    602603                                GList *smiley_refs = NULL;
    603604                                gchar *reformatted_xhtml;
    604605
    605                                 if (purple_account_get_bool(account, "custom_smileys", TRUE)) {
     606                                if (purple_account_get_bool(account, "custom_smileys", FALSE)) {
    606607                                        /* find a list of smileys ("cid" and "alt" text pairs)
    607608                                          occuring in the message */
    608609                                        smiley_refs = jabber_message_get_refs_from_xmlnode(child);
     
    13031304        const PurpleConnection *gc = js->gc;
    13041305        PurpleAccount *account = purple_connection_get_account(gc);
    13051306
    1306         return purple_account_get_bool(account, "custom_smileys", TRUE);
     1307        return purple_account_get_bool(account, "custom_smileys", FALSE);
    13071308}
  • libpurple/protocols/msn/cmdproc.c

    Only in libpurple/protocols/jabber: moz.build
    Only in libpurple/protocols: module.ver.in
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/cmdproc.c libpurple/protocols/msn/cmdproc.c
    old new  
    109109        g_free(show);
    110110}
    111111
    112 gboolean
     112void
    113113msn_cmdproc_send_trans(MsnCmdProc *cmdproc, MsnTransaction *trans)
    114114{
    115115        MsnServConn *servconn;
    116116        char *data;
    117117        size_t len;
    118         gboolean ret;
    119118
    120         g_return_val_if_fail(cmdproc != NULL, TRUE);
    121         g_return_val_if_fail(trans != NULL, TRUE);
     119        g_return_if_fail(cmdproc != NULL);
     120        g_return_if_fail(trans != NULL);
    122121
    123122        servconn = cmdproc->servconn;
    124123
    125124        if (!servconn->connected) {
    126125                msn_transaction_destroy(trans);
    127                 return FALSE;
     126                return;
    128127        }
    129128
    130129        if (trans->saveable)
     
    155154                trans->payload_len = 0;
    156155        }
    157156
    158         ret = msn_servconn_write(servconn, data, len) != -1;
     157        msn_servconn_write(servconn, data, len);
    159158
    160159        if (!trans->saveable)
    161160                msn_transaction_destroy(trans);
    162161        g_free(data);
    163         return ret;
    164162}
    165163
    166164void
  • libpurple/protocols/msn/cmdproc.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/cmdproc.h libpurple/protocols/msn/cmdproc.h
    old new  
    7979 * @param cmdproc       The MsnCmdProc to be used.
    8080 * @param trans         The MsnTransaction to be sent.
    8181 */
    82 gboolean msn_cmdproc_send_trans(MsnCmdProc *cmdproc, MsnTransaction *trans);
     82void msn_cmdproc_send_trans(MsnCmdProc *cmdproc, MsnTransaction *trans);
    8383
    8484/**
    8585 * Add a transaction to the queue to be processed latter.
  • libpurple/protocols/msn/contact.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/contact.c libpurple/protocols/msn/contact.c
    old new  
    474474}
    475475
    476476/*parse contact list*/
    477 static gboolean
     477static void
    478478msn_parse_contact_list(MsnSession *session, xmlnode *node)
    479479{
    480480        xmlnode *fault, *faultnode;
     
    499499                        if (g_str_equal(errorcode, "ABDoesNotExist")) {
    500500                                msn_create_address_book(session);
    501501                                g_free(errorcode);
    502                                 return FALSE;
     502                                return;
    503503                        }
    504504
    505505                        g_free(errorcode);
    506506                }
    507507
    508508                msn_get_contact_list(session, MSN_PS_INITIAL, NULL);
    509                 return FALSE;
    510509        } else {
    511510                xmlnode *service;
    512511
     
    515514                         service; service = xmlnode_get_next_twin(service)) {
    516515                        msn_parse_each_service(session, service);
    517516                }
    518                 return TRUE;
    519517        }
    520518}
    521519
     
    536534
    537535                purple_debug_misc("msn", "Got the contact list!\n");
    538536
    539                 if (msn_parse_contact_list(session, resp->xml)) {
     537                msn_parse_contact_list(session, resp->xml);
    540538#ifdef MSN_PARTIAL_LISTS
    541                         abLastChange = purple_account_get_string(session->account,
    542                                 "ablastChange", NULL);
    543                         dynamicItemLastChange = purple_account_get_string(session->account,
    544                                 "DynamicItemLastChanged", NULL);
     539                abLastChange = purple_account_get_string(session->account,
     540                        "ablastChange", NULL);
     541                dynamicItemLastChange = purple_account_get_string(session->account,
     542                        "DynamicItemLastChanged", NULL);
    545543#endif
    546544
    547                         if (state->partner_scenario == MSN_PS_INITIAL) {
     545                if (state->partner_scenario == MSN_PS_INITIAL) {
    548546#ifdef MSN_PARTIAL_LISTS
    549                                 /* XXX: this should be enabled when we can correctly do partial
    550                                    syncs with the server. Currently we need to retrieve the whole
    551                                    list to detect sync issues */
    552                                 msn_get_address_book(session, MSN_PS_INITIAL, abLastChange, dynamicItemLastChange);
     547                        /* XXX: this should be enabled when we can correctly do partial
     548                           syncs with the server. Currently we need to retrieve the whole
     549                           list to detect sync issues */
     550                        msn_get_address_book(session, MSN_PS_INITIAL, abLastChange, dynamicItemLastChange);
    553551#else
    554                                 msn_get_address_book(session, MSN_PS_INITIAL, NULL, NULL);
     552                        msn_get_address_book(session, MSN_PS_INITIAL, NULL, NULL);
    555553#endif
    556                         }
    557554                }
    558555        }
    559556}
  • libpurple/protocols/msn/directconn.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/directconn.c libpurple/protocols/msn/directconn.c
    old new  
    5151                purple_cipher_context_destroy(context);
    5252        } else if (type == DC_NONCE_PLAIN) {
    5353                memcpy(digest, nonce, nonce_len);
    54         } else {
    55                 nonce_hash[0] = '\0';
    56                 g_return_if_reached();
    5754        }
    5855
    5956        g_sprintf(nonce_hash,
     
    596593
    597594        case DC_STATE_ESTABLISHED:
    598595                if (packet_length) {
    599                         MsnP2PVersion p2p;
    600                         p2p = msn_slplink_get_p2p_version(dc->slplink);
    601                         part = msn_slpmsgpart_new_from_data(p2p, dc->in_buffer + 4, packet_length);
     596                        part = msn_slpmsgpart_new_from_data(dc->in_buffer + 4, packet_length);
    602597                        if (part) {
    603598                                msn_slplink_process_msg(dc->slplink, part);
    604599                                msn_slpmsgpart_unref(part);
  • libpurple/protocols/msn/httpconn.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/httpconn.c libpurple/protocols/msn/httpconn.c
    old new  
    111111                        return TRUE;
    112112                }
    113113
    114                 size -= (s - buf);
    115114                buf = s;
     115                size -= (s - buf);
    116116        }
    117117
    118118        if ((s = strstr(buf, "\r\n\r\n")) == NULL)
  • libpurple/protocols/msn/msg.c

    Only in libpurple/protocols/msn: Makefile.in
    Only in libpurple/protocols/msn: moz.build
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/msg.c libpurple/protocols/msn/msg.c
    old new  
    135135
    136136        msn_message_set_header(msg, "User-Agent", NULL);
    137137
     138        msg->msnslp_message = TRUE;
     139
    138140        msn_message_set_flag(msg, 'D');
    139141        msn_message_set_content_type(msg, "application/x-msnmsgrp2p");
    140142
     
    250252        /* Now we *should* be at the body. */
    251253        content_type = msn_message_get_content_type(msg);
    252254
     255        if (content_type != NULL &&
     256                !strcmp(content_type, "application/x-msnmsgrp2p")) {
     257                msg->msnslp_message = TRUE;
     258                msg->part = msn_slpmsgpart_new_from_data(tmp, payload_len - (tmp - tmp_base));
     259        }
     260
    253261        if (payload_len - (tmp - tmp_base) > 0) {
    254262                msg->body_len = payload_len - (tmp - tmp_base);
    255263                g_free(msg->body);
     
    371379
    372380        body = msn_message_get_bin_data(msg, &body_len);
    373381
    374         if (body != NULL && (end - n) > body_len)
     382        if (msg->msnslp_message)
    375383        {
    376                 memcpy(n, body, body_len);
    377                 n += body_len;
    378                 *n = '\0';
    379         }
     384                size_t siz;
     385                char *body;
    380386
    381         if (ret_size != NULL)
    382         {
    383                 *ret_size = n - base;
     387                body = msn_slpmsgpart_serialize(msg->part, &siz);
    384388
    385                 if (*ret_size > 1664)
    386                         *ret_size = 1664;
     389                memcpy(n, body, siz);
     390                n += siz;
     391
     392                g_free(body);
     393        }
     394        else
     395        {
     396                if (body != NULL)
     397                {
     398                        memcpy(n, body, body_len);
     399                        n += body_len;
     400                        *n = '\0';
     401                }
    387402        }
    388403
    389404        return base;
     
    624639
    625640        body = msn_message_get_bin_data(msg, &body_len);
    626641
    627         if (body != NULL)
     642        if (msg->msnslp_message)
    628643        {
    629                 if (msg->type == MSN_MSG_TEXT)
    630                 {
    631                         g_string_append_len(str, body, body_len);
    632                         g_string_append(str, "\r\n");
    633                 }
    634                 else
     644                msn_slpmsgpart_to_string(msg->part, str);
     645
     646                if (purple_debug_is_verbose() && body != NULL)
    635647                {
    636                         size_t i;
    637                         for (i = 0; i < body_len; i++, body++)
     648                        if (text_body)
     649                        {
     650                                g_string_append_len(str, body, body_len);
     651                                if (body[body_len - 1] == '\0')
     652                                {
     653                                        str->len--;
     654                                        g_string_append(str, " 0x00");
     655                                }
     656                                g_string_append(str, "\r\n");
     657                        }
     658                        else
    638659                        {
    639                                 g_string_append_printf(str, "%02x ", (unsigned char)*body);
    640                                 if (i % 16 == 0 && i != 0)
    641                                         g_string_append_c(str, '\n');
     660                                int i;
     661
     662                                for (i = 0; i < body_len; i++)
     663                                {
     664                                        g_string_append_printf(str, "%.2hhX ", body[i]);
     665                                        if ((i % 16) == 15)
     666                                                g_string_append(str, "\r\n");
     667                                }
     668
     669                                g_string_append(str, "\r\n");
    642670                        }
    643                         g_string_append_c(str, '\n');
     671                }
     672        }
     673        else
     674        {
     675                if (body != NULL)
     676                {
     677                        g_string_append_len(str, body, body_len);
     678                        g_string_append(str, "\r\n");
    644679                }
    645680        }
    646681
     
    819854
    820855}
    821856
     857#define purple_mkstemp(a, b) NULL
     858
    822859/* TODO: Make these not be such duplicates of each other */
    823860static void
    824861got_wink_cb(MsnSlpCall *slpcall, const guchar *data, gsize size)
     
    877914{
    878915        MsnSession *session;
    879916        MsnSlpLink *slplink;
    880         MsnP2PVersion p2p;
    881917
    882918        session = cmdproc->servconn->session;
    883919        slplink = msn_session_get_slplink(session, msg->remote_user);
     
    900936                }
    901937        }
    902938
    903         p2p = msn_slplink_get_p2p_version(slplink);
    904         msg->part = msn_slpmsgpart_new_from_data(p2p, msg->body, msg->body_len);
    905 
    906         if (msg->part)
     939        if (msg->part) {
    907940                msn_slplink_process_msg(slplink, msg->part);
    908         else
    909                 purple_debug_warning("msn", "P2P message failed to parse.\n");
     941        }
     942        else /* This should never happen. */
     943                purple_debug_fatal("msn", "P2P message without a Part.\n");
    910944}
    911945
    912946static void
     
    947981
    948982        session = cmdproc->servconn->session;
    949983
    950         if (!purple_account_get_bool(session->account, "custom_smileys", TRUE))
     984        if (!purple_account_get_bool(session->account, "custom_smileys", FALSE))
    951985                return;
    952986
    953987        swboard = cmdproc->data;
  • libpurple/protocols/msn/msg.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/msg.h libpurple/protocols/msn/msg.h
    old new  
    7878
    7979        MsnMsgType type;
    8080
     81        gboolean msnslp_message;
    8182        MsnSlpMessagePart *part;
    8283
    8384        char *remote_user;
     
    136137MsnMessage *msn_message_new_plain(const char *message);
    137138
    138139/**
     140 * Creates a MSNSLP ack message.
     141 *
     142 * @param acked_msg The message to acknowledge.
     143 *
     144 * @return A new MSNSLP ack message.
     145 */
     146MsnMessage *msn_message_new_msnslp_ack(MsnMessage *acked_msg);
     147
     148/**
    139149 * Creates a new message based off a command.
    140150 *
    141151 * @param session The MSN session.
  • libpurple/protocols/msn/msn.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/msn.c libpurple/protocols/msn/msn.c
    old new  
    539539        for (l = session->user->endpoints; l; l = l->next) {
    540540                MsnUserEndpoint *ep = l->data;
    541541
    542                 if (ep->id[0] != '\0' && strncasecmp(ep->id + 1, session->guid, 36) == 0)
     542                if (ep->id[0] != '\0' && g_ascii_strncasecmp(ep->id + 1, session->guid, 36) == 0)
    543543                        /* Don't add myself to the list */
    544544                        continue;
    545545
     
    608608                MsnUserEndpoint *ep = l->data;
    609609                char *user;
    610610
    611                 if (ep->id[0] != '\0' && strncasecmp(ep->id + 1, session->guid, 36) == 0)
     611                if (ep->id[0] != '\0' && g_ascii_strncasecmp(ep->id + 1, session->guid, 36) == 0)
    612612                        /* Don't kick myself */
    613613                        continue;
    614614
     
    30413041        prpl_info.protocol_options = g_list_append(prpl_info.protocol_options,
    30423042                                                                                           option);
    30433043
    3044         option = purple_account_option_bool_new(_("Show custom smileys"),
    3045                                                                                   "custom_smileys", TRUE);
    3046         prpl_info.protocol_options = g_list_append(prpl_info.protocol_options,
    3047                                                                                            option);
    3048 
    30493044        option = purple_account_option_bool_new(_("Allow direct connections"),
    30503045                                                                                  "direct_connect", TRUE);
    30513046        prpl_info.protocol_options = g_list_append(prpl_info.protocol_options,
  • libpurple/protocols/msn/msnutils.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/msnutils.c libpurple/protocols/msn/msnutils.c
    old new  
    265265                                msg[retcount++] = '\n';
    266266                                c += 4;
    267267                        }
     268                        else if (!g_ascii_strncasecmp(c + 1, "br/>", 4))
     269                        {
     270                                msg[retcount++] = '\r';
     271                                msg[retcount++] = '\n';
     272                                c += 5;
     273                        }
    268274                        else if (!g_ascii_strncasecmp(c + 1, "i>", 2))
    269275                        {
    270276                                if (!has_italic)
  • libpurple/protocols/msn/nexus.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/nexus.c libpurple/protocols/msn/nexus.c
    old new  
    2626#include "cipher.h"
    2727#include "debug.h"
    2828
    29 #include "msnutils.h"
    3029#include "soap.h"
    3130#include "nexus.h"
    3231#include "notification.h"
     
    165164        return out;
    166165}
    167166
    168 #define MSN_USER_KEY_SIZE (7*4 + 8 + 20 + 72)
    169167#define CRYPT_MODE_CBC 1
    170168#define CIPHER_TRIPLE_DES 0x6603
    171169#define HASH_SHA1 0x8004
    172170static char *
    173171msn_rps_encrypt(MsnNexus *nexus)
    174172{
    175         char usr_key_base[MSN_USER_KEY_SIZE], *usr_key;
     173        MsnUsrKey *usr_key;
    176174        const char magic1[] = "SESSION KEY HASH";
    177175        const char magic2[] = "SESSION KEY ENCRYPTION";
    178176        PurpleCipherContext *hmac;
    179177        size_t len;
    180         guchar *hash;
     178        guchar hash[20];
    181179        char *key1, *key2, *key3;
    182180        gsize key1_len;
    183         const char *iv;
     181        int *iv;
    184182        char *nonce_fixed;
    185183        char *cipher;
    186184        char *response;
    187185
    188         usr_key = &usr_key_base[0];
    189         /* Header */
    190         msn_push32le(usr_key, 28);                  /* Header size */
    191         msn_push32le(usr_key, CRYPT_MODE_CBC);      /* Crypt mode */
    192         msn_push32le(usr_key, CIPHER_TRIPLE_DES);   /* Cipher type */
    193         msn_push32le(usr_key, HASH_SHA1);           /* Hash type */
    194         msn_push32le(usr_key, 8);                   /* IV size */
    195         msn_push32le(usr_key, 20);                  /* Hash size */
    196         msn_push32le(usr_key, 72);                  /* Cipher size */
    197         /* Data */
    198         iv = usr_key;
    199         msn_push32le(usr_key, rand());
    200         msn_push32le(usr_key, rand());
    201         hash = (guchar *)usr_key;
    202         usr_key += 20;  /* Remaining is cipher data */
     186        usr_key = g_malloc(sizeof(MsnUsrKey));
     187        usr_key->size = GUINT32_TO_LE(28);
     188        usr_key->crypt_mode = GUINT32_TO_LE(CRYPT_MODE_CBC);
     189        usr_key->cipher_type = GUINT32_TO_LE(CIPHER_TRIPLE_DES);
     190        usr_key->hash_type = GUINT32_TO_LE(HASH_SHA1);
     191        usr_key->iv_len = GUINT32_TO_LE(8);
     192        usr_key->hash_len = GUINT32_TO_LE(20);
     193        usr_key->cipher_len = GUINT32_TO_LE(72);
    203194
    204195        key1 = (char *)purple_base64_decode((const char *)nexus->tokens[MSN_AUTH_MESSENGER].secret, &key1_len);
    205196        key2 = rps_create_key(key1, key1_len, magic1, sizeof(magic1) - 1);
    206197        key3 = rps_create_key(key1, key1_len, magic2, sizeof(magic2) - 1);
    207198
     199        iv = (int *)usr_key->iv;
     200        iv[0] = rand();
     201        iv[1] = rand();
     202
    208203        len = strlen(nexus->nonce);
    209204        hmac = purple_cipher_context_new_by_name("hmac", NULL);
    210205        purple_cipher_context_set_option(hmac, "hash", "sha1");
     
    217212        nonce_fixed = g_malloc(len + 8);
    218213        memcpy(nonce_fixed, nexus->nonce, len);
    219214        memset(nonce_fixed + len, 0x08, 8);
    220         cipher = des3_cbc(key3, iv, nonce_fixed, len + 8, FALSE);
     215        cipher = des3_cbc(key3, usr_key->iv, nonce_fixed, len + 8, FALSE);
    221216        g_free(nonce_fixed);
    222217
    223         memcpy(usr_key, cipher, 72);
     218        memcpy(usr_key->hash, hash, 20);
     219        memcpy(usr_key->cipher, cipher, 72);
    224220
    225221        g_free(key1);
    226222        g_free(key2);
    227223        g_free(key3);
    228224        g_free(cipher);
    229225
    230         response = purple_base64_encode((guchar *)usr_key_base, MSN_USER_KEY_SIZE);
     226        response = purple_base64_encode((guchar *)usr_key, sizeof(MsnUsrKey));
     227
     228        g_free(usr_key);
    231229
    232230        return response;
    233231}
  • libpurple/protocols/msn/nexus.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/nexus.h libpurple/protocols/msn/nexus.h
    old new  
    2828
    2929typedef struct _MsnNexus MsnNexus;
    3030typedef struct _MsnTicketToken MsnTicketToken;
     31typedef struct _MsnUsrKey MsnUsrKey;
    3132
    3233/* Index into ticket_tokens in nexus.c Keep updated! */
    3334typedef enum
     
    187188        "</Body>"\
    188189"</Envelope>"
    189190
     191struct _MsnUsrKey
     192{
     193        int size; /* 28. Does not count data */
     194        int crypt_mode; /* CRYPT_MODE_CBC (1) */
     195        int cipher_type; /* TripleDES (0x6603) */
     196        int hash_type; /* SHA1 (0x8004) */
     197        int iv_len;    /* 8 */
     198        int hash_len;  /* 20 */
     199        int cipher_len; /* 72 */
     200        /* Data */
     201        char iv[8];
     202        char hash[20];
     203        char cipher[72];
     204};
     205
    190206struct _MsnTicketToken {
    191207        GHashTable *token;
    192208        char *secret;
  • libpurple/protocols/msn/notification.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/notification.c libpurple/protocols/msn/notification.c
    old new  
    195195        {
    196196                /* RPS authentication */
    197197
    198                 if (session->nexus)
    199                         msn_nexus_destroy(session->nexus);
    200 
    201198                session->nexus = msn_nexus_new(session);
    202199
    203200                session->nexus->policy = g_strdup(cmd->params[3]);
     
    575572                payload = xmlnode_to_str(adl_node, &payload_len);
    576573                msn_notification_post_adl(session->notification->cmdproc, payload, payload_len);
    577574                g_free(payload);
    578                 xmlnode_free(adl_node);
    579575        } else {
    580576                purple_debug_error("msn",
    581577                                   "Got FQY update for unknown user %s on network %d.\n",
     
    15921588                /* Disconnect others, if MPOP is disabled */
    15931589                if (is_me
    15941590                 && !session->enable_mpop
    1595                  && strncasecmp(id + 1, session->guid, 36) != 0) {
     1591                 && g_ascii_strncasecmp(id + 1, session->guid, 36) != 0) {
    15961592                        purple_debug_info("msn", "Disconnecting Endpoint %s\n", id);
    15971593
    15981594                        tmp = g_strdup_printf("%s;%s", user->passport, id);
  • libpurple/protocols/msn/p2p.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/p2p.c libpurple/protocols/msn/p2p.c
    old new  
    204204
    205205                case MSN_P2P_VERSION_TWO: {
    206206                        MsnP2Pv2Header *header = &info->header.v2;
    207                         char *header_wire = NULL;
    208                         char *data_header_wire = NULL;
    209207
    210208                        if (header->header_tlv != NULL)
    211                                 header_wire = msn_tlvlist_write(header->header_tlv, (size_t *)&header->header_len);
     209                                header->header_len = msn_tlvlist_size(header->header_tlv) + 8;
    212210                        else
    213                                 header->header_len = 0;
     211                                header->header_len = 8;
    214212
    215213                        if (header->data_tlv != NULL)
    216                                 data_header_wire = msn_tlvlist_write(header->data_tlv, (size_t *)&header->data_header_len);
     214                                header->data_header_len = msn_tlvlist_size(header->data_tlv) + 8;
    217215                        else
    218                                 header->data_header_len = 0;
     216                                header->data_header_len = 8;
    219217
    220                         tmp = wire = g_new(char, 16 + header->header_len + header->data_header_len);
     218                        tmp = wire = g_new(char, header->header_len + header->data_header_len);
    221219
    222                         msn_push8(tmp, header->header_len + 8);
     220                        msn_push8(tmp, header->header_len);
    223221                        msn_push8(tmp, header->opcode);
    224                         msn_push16be(tmp, header->data_header_len + 8 + header->message_len);
     222                        msn_push16be(tmp, header->data_header_len + header->message_len);
    225223                        msn_push32be(tmp, header->base_id);
    226224
    227                         if (header_wire != NULL) {
    228                                 memcpy(tmp, header_wire, header->header_len);
    229                                 tmp += header->header_len;
     225                        if (header->header_tlv != NULL) {
     226                                msn_tlvlist_write(tmp, header->header_len - 8, header->header_tlv);
     227                                tmp += header->header_len - 8;
    230228                        }
    231229
    232                         msn_push8(tmp, header->data_header_len + 8);
     230                        msn_push8(tmp, header->data_header_len);
    233231                        msn_push8(tmp, header->data_tf);
    234232                        msn_push16be(tmp, header->package_number);
    235233                        msn_push32be(tmp, header->session_id);
    236234
    237                         if (data_header_wire != NULL) {
    238                                 memcpy(tmp, data_header_wire, header->data_header_len);
    239                                 tmp += header->data_header_len;
     235                        if (header->data_tlv != NULL) {
     236                                msn_tlvlist_write(tmp, header->data_header_len - 8, header->data_tlv);
     237                                tmp += header->data_header_len - 8;
    240238                        }
    241239
    242240                        if (len)
    243                                 *len = header->header_len + header->data_header_len + 16;
     241                                *len = header->header_len + header->data_header_len;
    244242
    245243                        break;
    246244                }
     
    250248        }
    251249
    252250        return wire;
     251
    253252}
    254253
    255254size_t
     
    313312}
    314313
    315314gboolean
    316 msn_p2p_msg_is_data(const MsnP2PInfo *info)
     315msn_p2p_msg_is_data(const MsnP2PHeaderFlag flags)
    317316{
    318         gboolean data = FALSE;
    319 
    320         switch (info->version) {
    321                 case MSN_P2P_VERSION_ONE: {
    322                         guint32 flags = info->header.v1.flags;
    323                         data = (flags == P2P_MSN_OBJ_DATA ||
    324                                 flags == (P2P_WLM2009_COMP | P2P_MSN_OBJ_DATA) ||
    325                                 flags == P2P_FILE_DATA);
    326                         break;
    327                 }
    328 
    329                 case MSN_P2P_VERSION_TWO:
    330                         data = info->header.v2.message_len > 0;
    331                         break;
    332 
    333                 default:
    334                         purple_debug_error("msn", "Invalid P2P Info version: %d\n", info->version);
    335         }
    336 
    337         return data;
     317        return (flags == P2P_MSN_OBJ_DATA ||
     318                flags == (P2P_WLM2009_COMP | P2P_MSN_OBJ_DATA) ||
     319                flags == P2P_FILE_DATA);
    338320}
    339321
    340322gboolean
     
    349331
    350332                case MSN_P2P_VERSION_TWO:
    351333                        /* Nothing to do! */
    352                         valid = TRUE;
    353334                        break;
    354335
    355336                default:
     
    360341}
    361342
    362343gboolean
    363 msn_p2p_info_is_first(MsnP2PInfo *info)
    364 {
    365         gboolean first = FALSE;
    366 
    367         switch (info->version) {
    368                 case MSN_P2P_VERSION_ONE:
    369                         first = info->header.v1.offset == 0;
    370                         break;
    371 
    372                 case MSN_P2P_VERSION_TWO:
    373                         /* Nothing to do! */
    374                         first = info->header.v2.data_tf & TF_FIRST;
    375                         break;
    376 
    377                 default:
    378                         purple_debug_error("msn", "Invalid P2P Info version: %d\n", info->version);
    379         }
    380 
    381         return first;
    382 }
    383 
    384 gboolean
    385344msn_p2p_info_is_final(MsnP2PInfo *info)
    386345{
    387346        gboolean final = FALSE;
     
    392351                        break;
    393352
    394353                case MSN_P2P_VERSION_TWO:
    395                         final = msn_tlv_gettlv(info->header.v2.data_tlv, P2P_DATA_TLV_REMAINING, 1) == NULL;
     354                        /* Nothing to do! */
    396355                        break;
    397356
    398357                default:
     
    402361        return final;
    403362}
    404363
    405 void
    406 msn_p2p_info_create_ack(MsnP2PInfo *old_info, MsnP2PInfo *new_info)
    407 {
    408         switch (old_info->version) {
    409                 case MSN_P2P_VERSION_ONE: {
    410                         MsnP2PHeader *old = &old_info->header.v1;
    411                         MsnP2PHeader *new = &new_info->header.v1;
    412 
    413                         new->session_id = old->session_id;
    414                         new->flags = P2P_ACK;
    415                         new->ack_id = old->id;
    416                         new->ack_sub_id = old->ack_id;
    417                         new->ack_size = old->total_size;
    418                         break;
    419                 }
    420 
    421                 case MSN_P2P_VERSION_TWO: {
    422                         MsnP2Pv2Header *old = &old_info->header.v2;
    423                         MsnP2Pv2Header *new = &new_info->header.v2;
    424 
    425                         msn_tlvlist_add_32(&new->header_tlv, P2P_HEADER_TLV_TYPE_ACK, old->base_id + old->message_len);
    426                         new->opcode = P2P_OPCODE_NONE;
    427 
    428                         if (old->message_len > 0) {
    429                                 if (!msn_tlv_gettlv(old->header_tlv, P2P_HEADER_TLV_TYPE_ACK, 1)) {
    430                                         if (old->opcode & P2P_OPCODE_SYN) {
    431                                                 msn_tlv_t *ack_tlv;
    432                                                 new->opcode |= P2P_OPCODE_RAK;
    433                                                
    434                                                 ack_tlv = msn_tlv_gettlv(old->header_tlv, P2P_HEADER_TLV_TYPE_PEER_INFO, 1);
    435                                                 if (ack_tlv) {
    436                                                         msn_tlvlist_add_tlv(&new->header_tlv, ack_tlv);
    437                                                         new->opcode |= P2P_OPCODE_SYN;
    438                                                 }
    439                                         }
    440                                 }
    441                         }
    442                         break;
    443                 }
    444 
    445                 default:
    446                         purple_debug_error("msn", "Invalid P2P Info version: %d\n", old_info->version);
    447         }
    448 }
    449 
    450 gboolean
    451 msn_p2p_info_require_ack(MsnP2PInfo *info)
    452 {
    453         gboolean ret = FALSE;
    454 
    455         switch (info->version) {
    456                 case MSN_P2P_VERSION_ONE: {
    457                         guint32 flags = msn_p2p_info_get_flags(info);
    458 
    459                         ret = flags == P2P_NO_FLAG || flags == P2P_WLM2009_COMP ||
    460                               msn_p2p_msg_is_data(info);
    461                         break;
    462                 }
    463 
    464                 case MSN_P2P_VERSION_TWO:
    465                         ret = (info->header.v2.opcode & P2P_OPCODE_RAK) > 0;
    466                         break;
    467 
    468                 default:
    469                         purple_debug_error("msn", "Invalid P2P Info version: %d\n", info->version);
    470         }
    471 
    472         return ret;
    473 }
    474 
    475 gboolean
    476 msn_p2p_info_is_ack(MsnP2PInfo *info)
    477 {
    478         gboolean ret = FALSE;
    479 
    480         switch (info->version) {
    481                 case MSN_P2P_VERSION_ONE: {
    482                         ret = msn_p2p_info_get_flags(info) == P2P_ACK;
    483                         break;
    484                 }
    485 
    486                 case MSN_P2P_VERSION_TWO:
    487                         ret = msn_tlv_gettlv(info->header.v2.header_tlv, P2P_HEADER_TLV_TYPE_ACK, 1) != NULL;
    488                         break;
    489 
    490                 default:
    491                         purple_debug_error("msn", "Invalid P2P Info version: %d\n", info->version);
    492         }
    493 
    494         return ret;
    495 }
    496 
    497 void
    498 msn_p2p_info_init_first(MsnP2PInfo *info, MsnP2PInfo *old_info)
    499 {
    500         switch (info->version) {
    501                 case MSN_P2P_VERSION_ONE:
    502                         info->header.v1.session_id = old_info->header.v1.session_id;
    503                         info->header.v1.flags = old_info->header.v1.flags;
    504                         break;
    505 
    506                 case MSN_P2P_VERSION_TWO:
    507                         info->header.v2.data_tf = TF_FIRST;
    508                         break;
    509 
    510                 default:
    511                         purple_debug_error("msn", "Invalid P2P Info version: %d\n", info->version);
    512         }
    513 }
    514 
    515364guint32
    516365msn_p2p_info_get_session_id(MsnP2PInfo *info)
    517366{
     
    523372                        break;
    524373
    525374                case MSN_P2P_VERSION_TWO:
    526                         session_id = info->header.v2.session_id;
     375                        /* Nothing to do! */
    527376                        break;
    528377
    529378                default:
     
    544393                        break;
    545394
    546395                case MSN_P2P_VERSION_TWO:
    547                         id = info->header.v2.base_id;
     396                        /* Nothing to do! */
    548397                        break;
    549398
    550399                default:
     
    628477                        break;
    629478
    630479                case MSN_P2P_VERSION_TWO:
    631                         flags = info->header.v2.data_tf;
     480                        /* Nothing to do! */
    632481                        break;
    633482
    634483                default:
     
    716565                        break;
    717566
    718567                case MSN_P2P_VERSION_TWO:
    719                         info->header.v2.session_id = session_id;
     568                        /* Nothing to do! */
    720569                        break;
    721570
    722571                default:
     
    734583                        break;
    735584
    736585                case MSN_P2P_VERSION_TWO:
    737                         info->header.v2.base_id = id;
     586                        /* Nothing to do! */
    738587                        break;
    739588
    740589                default:
     
    803652                        break;
    804653
    805654                case MSN_P2P_VERSION_TWO:
    806                         info->header.v2.data_tf = flags;
     655                        /* Nothing to do! */
    807656                        break;
    808657
    809658                default:
  • libpurple/protocols/msn/p2p.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/p2p.h libpurple/protocols/msn/p2p.h
    old new  
    5959/*      guint8  body[1]; */
    6060} MsnP2Pv2Header;
    6161
    62 typedef struct {
    63         guint16 protocol_version;
    64         guint16 implementation_id;
    65         guint16 version;
    66         guint16 reserved;
    67         guint32 caps;
    68 } P2PPeerInfo;
    69 
    70 typedef enum
    71 {
    72         TF_FIRST    = 0x01,     /**< The first package. */
    73         TF_MSNOBJ   = 0x04,     /**< Payload contains binary data for MsnObject. */
    74         TF_FILE     = 0x06      /**< Payload contains binary data. */
    75 } TF;
    76 
    77 typedef enum
    78 {
    79         P2P_HEADER_TLV_TYPE_PEER_INFO  = 0x01, /**< Client peer info */
    80         P2P_HEADER_TLV_TYPE_ACK        = 0x02, /**< ACK */
    81         P2P_HEADER_TLV_TYPE_NAK        = 0x03  /**< NAK */
    82 } P2PHeaderTLVType;
    83 
    84 typedef enum
    85 {
    86         P2P_DATA_TLV_REMAINING  = 0x01, /**< Indicates the remaining data to transfer.*/
    87 } P2PDataTLVType;
    88 
    89 typedef enum
    90 {
    91         P2P_PI_PVER     = 0x0200,
    92         P2P_PI_IMP_ID   = 0,
    93         P2P_PI_VER      = 0x0e00,
    94         P2P_PI_RES      = 0,
    95         P2P_PI_CAPS     = 0x0000010f
    96 } P2PPeerInfoVal;
    97 
    9862typedef struct
    9963{
    10064        guint32 value;
     
    178142msn_p2p_info_to_string(MsnP2PInfo *info, GString *str);
    179143
    180144gboolean
    181 msn_p2p_msg_is_data(const MsnP2PInfo *info);
     145msn_p2p_msg_is_data(const MsnP2PHeaderFlag flags);
    182146
    183147gboolean
    184148msn_p2p_info_is_valid(MsnP2PInfo *info);
    185149
    186150gboolean
    187 msn_p2p_info_is_first(MsnP2PInfo *info);
    188 
    189 gboolean
    190151msn_p2p_info_is_final(MsnP2PInfo *info);
    191152
    192 void
    193 msn_p2p_info_create_ack(MsnP2PInfo *old_info, MsnP2PInfo *new_info);
    194 
    195 gboolean
    196 msn_p2p_info_require_ack(MsnP2PInfo *info);
    197 
    198 gboolean
    199 msn_p2p_info_is_ack(MsnP2PInfo *info);
    200 
    201 void
    202 msn_p2p_info_init_first(MsnP2PInfo *new_info, MsnP2PInfo *old_info);
    203 
    204153guint32
    205154msn_p2p_info_get_session_id(MsnP2PInfo *info);
    206155
     
    262211msn_p2p_info_set_app_id(MsnP2PInfo *info, guint32 app_id);
    263212
    264213#endif /* MSN_P2P_H */
     214
  • libpurple/protocols/msn/session.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/session.c libpurple/protocols/msn/session.c
    old new  
    263263        {
    264264                swboard = msn_switchboard_new(session);
    265265                swboard->im_user = g_strdup(username);
    266                 if (msn_switchboard_request(swboard))
    267                         msn_switchboard_request_add_user(swboard, username);
    268                 else
    269                         return NULL;
     266                msn_switchboard_request(swboard);
     267                msn_switchboard_request_add_user(swboard, username);
    270268        }
    271269
    272270        swboard->flag |= flag;
     
    290288msn_session_activate_login_timeout(MsnSession *session)
    291289{
    292290        if (!session->logged_in && session->connected) {
    293                 if (session->login_timeout)
    294                         purple_timeout_remove(session->login_timeout);
    295291                session->login_timeout =
    296292                        purple_timeout_add_seconds(MSN_LOGIN_FQY_TIMEOUT,
    297293                                                   msn_login_timeout_cb, session);
  • libpurple/protocols/msn/slp.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/slp.c libpurple/protocols/msn/slp.c
    old new  
    284284        purple_xfer_unref(xfer);
    285285
    286286        slpmsg = msn_slpmsg_file_new(slpcall, purple_xfer_get_size(xfer));
     287        msn_slpmsg_set_slplink(slpmsg, slpcall->slplink);
    287288
    288289        msn_slplink_send_slpmsg(slpcall->slplink, slpmsg);
    289290}
  • libpurple/protocols/msn/slpcall.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/slpcall.c libpurple/protocols/msn/slpcall.c
    old new  
    237237{
    238238        GList *smileys;
    239239
    240         if (!purple_account_get_bool(account, "custom_smileys", TRUE))
     240        if (!purple_account_get_bool(account, "custom_smileys", FALSE))
    241241                return NULL;
    242242
    243243        smileys = purple_smileys_get_all();
     
    328328                        dc->remote_nonce[36] = '\0';
    329329                }
    330330
    331                 if (!strcasecmp(listening, "false")) {
     331                if (!g_ascii_strcasecmp(listening, "false")) {
    332332                        if (dc->listen_data != NULL) {
    333333                                /*
    334334                                 * We'll listen for incoming connections but
     
    490490                if (img != NULL) {
    491491                        /* DATA PREP */
    492492                        slpmsg = msn_slpmsg_dataprep_new(slpcall);
     493                        msn_slpmsg_set_slplink(slpmsg, slplink);
    493494                        msn_slplink_queue_slpmsg(slplink, slpmsg);
    494495
    495496                        /* DATA */
    496497                        slpmsg = msn_slpmsg_obj_new(slpcall, img);
     498                        msn_slpmsg_set_slplink(slpmsg, slplink);
    497499                        msn_slplink_queue_slpmsg(slplink, slpmsg);
    498500                        purple_imgstore_unref(img);
    499501
     
    11281130                }
    11291131                g_free(body_str);
    11301132        }
    1131          else if (msn_p2p_msg_is_data(slpmsg->p2p_info))
     1133         else if (msn_p2p_msg_is_data(flags))
    11321134        {
    11331135                slpcall = msn_slplink_find_slp_call_with_session_id(slplink, session_id);
    11341136
     
    11451147                        slpcall->wasted = TRUE;
    11461148                }
    11471149        }
    1148         else if (msn_p2p_info_is_ack(slpmsg->p2p_info))
     1150        else if (flags == P2P_ACK)
    11491151        {
    11501152                /* Acknowledgement of previous message. Don't do anything currently. */
    11511153        }
  • libpurple/protocols/msn/slpcall.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/slpcall.h libpurple/protocols/msn/slpcall.h
    old new  
    6565        gboolean wait_for_socket;
    6666
    6767        void (*progress_cb)(MsnSlpCall *slpcall,
    68                                                 gsize total_length, gsize len);
     68                                                gsize total_length, gsize len, gsize offset);
    6969        void (*session_init_cb)(MsnSlpCall *slpcall);
    7070
    7171        /* Can be checksum, or smile */
  • libpurple/protocols/msn/slplink.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/slplink.c libpurple/protocols/msn/slplink.c
    old new  
    7979        slplink->slp_seq_id = rand() % 0xFFFFFF00 + 4;
    8080
    8181        slplink->remote_user = g_strdup(username);
    82         slplink->p2p_version = MSN_P2P_VERSION_ONE;
    8382
    8483        slplink->slp_msg_queue = g_queue_new();
    8584
     
    265264        return NULL;
    266265}
    267266
    268 MsnP2PVersion
    269 msn_slplink_get_p2p_version(MsnSlpLink *slplink)
    270 {
    271         return slplink->p2p_version;
    272 }
    273 
    274267static void
    275268msn_slplink_send_part(MsnSlpLink *slplink, MsnSlpMessagePart *part)
    276269{
     
    299292        part = msn_slpmsgpart_new(msn_p2p_info_dup(info));
    300293        part->ack_data = slpmsg;
    301294
    302         real_size = msn_p2p_info_is_ack(info) ? 0 : slpmsg->size;
     295        real_size = (msn_p2p_info_get_flags(info) == P2P_ACK) ? 0 : slpmsg->size;
    303296
    304297        offset = msn_p2p_info_get_offset(info);
    305298        if (offset < real_size)
     
    337330        msn_slplink_send_part(slplink, part);
    338331
    339332
    340         if (msn_p2p_msg_is_data(info) && slpmsg->slpcall != NULL)
     333        if (msn_p2p_msg_is_data(msn_p2p_info_get_flags(info)) &&
     334                (slpmsg->slpcall != NULL))
    341335        {
    342336                slpmsg->slpcall->progress = TRUE;
    343337
    344338                if (slpmsg->slpcall->progress_cb != NULL)
    345339                {
    346340                        slpmsg->slpcall->progress_cb(slpmsg->slpcall, slpmsg->size,
    347                                                                                  len);
     341                                                                                 len, offset);
    348342                }
    349343        }
    350344
     
    364358        {
    365359                msn_p2p_info_set_ack_id(info, rand() % 0xFFFFFF00);
    366360        }
    367         else if (msn_p2p_msg_is_data(info))
     361        else if (msn_p2p_msg_is_data(flags))
    368362        {
    369363                MsnSlpCall *slpcall;
    370364                slpcall = slpmsg->slpcall;
     
    412406        }
    413407}
    414408
     409static MsnSlpMessage *
     410msn_slplink_create_ack(MsnSlpLink *slplink, MsnP2PInfo *info)
     411{
     412        MsnSlpMessage *slpmsg;
     413
     414        slpmsg = msn_slpmsg_ack_new(info);
     415        msn_slpmsg_set_slplink(slpmsg, slplink);
     416
     417        return slpmsg;
     418}
     419
    415420static void
    416421msn_slplink_send_ack(MsnSlpLink *slplink, MsnP2PInfo *info)
    417422{
    418         MsnSlpMessage *slpmsg = msn_slpmsg_ack_new(slplink, info);
     423        MsnSlpMessage *slpmsg = msn_slplink_create_ack(slplink, info);
    419424
    420425        msn_slplink_send_slpmsg(slplink, slpmsg);
    421426        msn_slpmsg_destroy(slpmsg);
     
    442447{
    443448        MsnSlpMessage *slpmsg;
    444449        guint32 session_id;
     450        guint32 flags;
    445451
    446         slpmsg = msn_slpmsg_new(slplink, NULL);
     452        slpmsg = msn_slpmsg_new(slplink);
    447453        slpmsg->id = msn_p2p_info_get_id(info);
    448454        session_id = msn_p2p_info_get_session_id(info);
     455        msn_p2p_info_set_session_id(slpmsg->p2p_info, session_id);
    449456        slpmsg->size = msn_p2p_info_get_total_size(info);
    450         msn_p2p_info_init_first(slpmsg->p2p_info, info);
     457        flags = msn_p2p_info_get_flags(info);
     458        msn_p2p_info_set_flags(slpmsg->p2p_info, flags);
    451459
    452460        if (session_id)
    453461        {
    454462                slpmsg->slpcall = msn_slplink_find_slp_call_with_session_id(slplink, session_id);
    455463                if (slpmsg->slpcall != NULL)
    456464                {
    457                         if (msn_p2p_msg_is_data(info))
     465                        if (msn_p2p_msg_is_data(flags))
    458466                        {
    459467                                PurpleXfer *xfer = slpmsg->slpcall->xfer;
    460468                                if (xfer != NULL)
     
    494502process_complete_msg(MsnSlpLink *slplink, MsnSlpMessage *slpmsg, MsnP2PInfo *info)
    495503{
    496504        MsnSlpCall *slpcall;
     505        guint32 flags;
    497506
    498507        slpcall = msn_slp_process_msg(slplink, slpmsg);
    499508
     
    504513
    505514        purple_debug_info("msn", "msn_slplink_process_msg: slpmsg complete\n");
    506515
    507         if (msn_p2p_info_require_ack(slpmsg->p2p_info))
     516        flags = msn_p2p_info_get_flags(slpmsg->p2p_info);
     517
     518        if (flags == P2P_NO_FLAG || flags == P2P_WLM2009_COMP ||
     519            msn_p2p_msg_is_data(flags))
    508520        {
    509521                /* Release all the messages and send the ACK */
    510522
     
    517529                         */
    518530                        purple_debug_info("msn", "msn_slplink_process_msg: save ACK\n");
    519531
    520                         slpcall->slplink->dc->prev_ack = msn_slpmsg_ack_new(slplink, info);
     532                        slpcall->slplink->dc->prev_ack = msn_slplink_create_ack(slplink, info);
    521533                } else if (!slpcall->wasted) {
    522534                        purple_debug_info("msn", "msn_slplink_process_msg: send ACK\n");
    523535
     
    561573{
    562574        MsnSlpMessage *slpmsg;
    563575        MsnP2PInfo *info;
     576        guint64 offset;
    564577
    565578        info = part->info;
    566579
     
    573586                return;
    574587        }
    575588
    576         if (msn_p2p_info_is_first(info))
     589        offset = msn_p2p_info_get_offset(info);
     590
     591        if (offset == 0)
    577592                slpmsg = init_first_msg(slplink, info);
    578593        else {
    579594                guint32 session_id, id;
     
    590605
    591606        slpmsg_add_part(slpmsg, part);
    592607
    593         if (msn_p2p_msg_is_data(slpmsg->p2p_info) && slpmsg->slpcall != NULL)
     608        if (msn_p2p_msg_is_data(msn_p2p_info_get_flags(slpmsg->p2p_info)) &&
     609                (slpmsg->slpcall != NULL))
    594610        {
    595611                slpmsg->slpcall->progress = TRUE;
    596612
    597613                if (slpmsg->slpcall->progress_cb != NULL)
    598614                {
    599615                        slpmsg->slpcall->progress_cb(slpmsg->slpcall, slpmsg->size,
    600                                                                                  part->size);
     616                                                                                 part->size, offset);
    601617                }
    602618        }
    603619
  • libpurple/protocols/msn/slplink.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/slplink.h libpurple/protocols/msn/slplink.h
    old new  
    4545        guint refs;
    4646
    4747        char *remote_user;
    48         MsnP2PVersion p2p_version;
    4948
    5049        int slp_seq_id;
    5150
     
    7675MsnSlpCall *msn_slplink_find_slp_call(MsnSlpLink *slplink,
    7776                                                                          const char *id);
    7877MsnSlpCall *msn_slplink_find_slp_call_with_session_id(MsnSlpLink *slplink, long id);
    79 MsnP2PVersion msn_slplink_get_p2p_version(MsnSlpLink *slplink);
    80 
    8178void msn_slplink_queue_slpmsg(MsnSlpLink *slplink, MsnSlpMessage *slpmsg);
    8279void msn_slplink_send_slpmsg(MsnSlpLink *slplink,
    8380                                                         MsnSlpMessage *slpmsg);
  • libpurple/protocols/msn/slpmsg.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/slpmsg.c libpurple/protocols/msn/slpmsg.c
    old new  
    3434 **************************************************************************/
    3535
    3636MsnSlpMessage *
    37 msn_slpmsg_new(MsnSlpLink *slplink, MsnSlpCall *slpcall)
     37msn_slpmsg_new(MsnSlpLink *slplink)
    3838{
    3939        MsnSlpMessage *slpmsg;
    40         MsnP2PVersion p2p;
    41 
    42         g_return_val_if_fail(slplink != NULL, NULL);
    4340
    4441        slpmsg = g_new0(MsnSlpMessage, 1);
    4542
    4643        if (purple_debug_is_verbose())
    4744                purple_debug_info("msn", "slpmsg new (%p)\n", slpmsg);
    4845
    49         msn_slpmsg_set_slplink(slpmsg, slplink);
    50         slpmsg->slpcall = slpcall;
     46        if (slplink)
     47                msn_slpmsg_set_slplink(slpmsg, slplink);
     48        else
     49                slpmsg->slplink = NULL;
    5150
    52         p2p = msn_slplink_get_p2p_version(slplink);
    53         slpmsg->p2p_info = msn_p2p_info_new(p2p);
     51        slpmsg->p2p_info = msn_p2p_info_new(MSN_P2P_VERSION_ONE);
    5452
    5553        return slpmsg;
    5654}
     
    105103
    106104        slplink->slp_msgs =
    107105                g_list_append(slplink->slp_msgs, slpmsg);
     106
    108107}
    109108
    110109void
     
    189188                g_strlcat(body, content, body_len);
    190189        }
    191190
    192         slpmsg = msn_slpmsg_new(slplink, slpcall);
     191        slpmsg = msn_slpmsg_new(slplink);
    193192        msn_slpmsg_set_body(slpmsg, body, body_len);
    194193
     194        slpmsg->slpcall = slpcall;
     195
    195196        g_free(body);
    196197
    197198        return slpmsg;
    198199}
    199200
    200 MsnSlpMessage *msn_slpmsg_ack_new(MsnSlpLink *slplink, MsnP2PInfo *ack_info)
     201MsnSlpMessage *msn_slpmsg_ack_new(MsnP2PInfo *ack_info)
    201202{
    202203        MsnSlpMessage *slpmsg;
    203204        MsnP2PInfo *new_info;
    204205
    205         slpmsg = msn_slpmsg_new(slplink, NULL);
     206        slpmsg = msn_slpmsg_new(NULL);
    206207
    207208        new_info = slpmsg->p2p_info;
    208         msn_p2p_info_create_ack(ack_info, new_info);
     209        msn_p2p_info_set_session_id(new_info, msn_p2p_info_get_session_id(ack_info));
    209210        slpmsg->size = msn_p2p_info_get_total_size(ack_info);
     211        msn_p2p_info_set_flags(new_info, P2P_ACK);
     212        msn_p2p_info_set_ack_id(new_info, msn_p2p_info_get_id(ack_info));
     213        msn_p2p_info_set_ack_sub_id(new_info, msn_p2p_info_get_ack_id(ack_info));
     214        msn_p2p_info_set_ack_size(new_info, msn_p2p_info_get_total_size(ack_info));
    210215        slpmsg->info = "SLP ACK";
    211216
    212217        return slpmsg;
     
    216221{
    217222        MsnSlpMessage *slpmsg;
    218223
    219         slpmsg = msn_slpmsg_new(slpcall->slplink, slpcall);
     224        slpmsg = msn_slpmsg_new(NULL);
     225        slpmsg->slpcall = slpcall;
    220226        msn_p2p_info_set_flags(slpmsg->p2p_info, P2P_MSN_OBJ_DATA);
    221227        slpmsg->info = "SLP DATA";
    222228
     
    229235{
    230236        MsnSlpMessage *slpmsg;
    231237
    232         slpmsg = msn_slpmsg_new(slpcall->slplink, slpcall);
     238        slpmsg = msn_slpmsg_new(NULL);
    233239
     240        slpmsg->slpcall = slpcall;
    234241        msn_p2p_info_set_session_id(slpmsg->p2p_info, slpcall->session_id);
    235242        msn_slpmsg_set_body(slpmsg, NULL, 4);
    236243        slpmsg->info = "SLP DATA PREP";
     
    243250{
    244251        MsnSlpMessage *slpmsg;
    245252
    246         slpmsg = msn_slpmsg_new(slpcall->slplink, slpcall);
     253        slpmsg = msn_slpmsg_new(NULL);
    247254
     255        slpmsg->slpcall = slpcall;
    248256        msn_p2p_info_set_flags(slpmsg->p2p_info, P2P_FILE_DATA);
    249257        slpmsg->info = "SLP FILE";
    250258        slpmsg->size = size;
  • libpurple/protocols/msn/slpmsg.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/slpmsg.h libpurple/protocols/msn/slpmsg.h
    old new  
    7272 * If it's set to NULL, it is a temporary SlpMessage.
    7373 * @return The created slp message.
    7474 */
    75 MsnSlpMessage *msn_slpmsg_new(MsnSlpLink *slplink, MsnSlpCall *slpcall);
     75MsnSlpMessage *msn_slpmsg_new(MsnSlpLink *slplink);
    7676
    7777/**
    7878 * Destroys a slp message
     
    104104 *
    105105 * @return A new SlpMessage with ACK headers
    106106 */
    107 MsnSlpMessage *msn_slpmsg_ack_new(MsnSlpLink *slplink, MsnP2PInfo *info);
     107MsnSlpMessage *msn_slpmsg_ack_new(MsnP2PInfo *info);
    108108
    109109/**
    110110 * Create a new SLP message for MsnObject data.
  • libpurple/protocols/msn/slpmsg_part.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/slpmsg_part.c libpurple/protocols/msn/slpmsg_part.c
    old new  
    4242        return msn_slpmsgpart_ref(part);
    4343}
    4444
    45 MsnSlpMessagePart *
    46 msn_slpmsgpart_new_from_data(MsnP2PVersion p2p, const char *data, size_t data_len)
     45MsnSlpMessagePart *msn_slpmsgpart_new_from_data(const char *data, size_t data_len)
    4746{
    4847        MsnSlpMessagePart *part;
    4948        MsnP2PInfo *info;
    5049        size_t len;
    5150        int body_len;
    5251
    53         info = msn_p2p_info_new(p2p);
     52        info = msn_p2p_info_new(MSN_P2P_VERSION_ONE);
    5453
    5554        /* Extract the binary SLP header */
    5655        len = msn_p2p_header_from_wire(info, data, data_len);
     
    176175
    177176        slpmsg = data;
    178177
    179         real_size = msn_p2p_info_is_ack(slpmsg->p2p_info) ? 0 : slpmsg->size;
     178        real_size = (msn_p2p_info_get_flags(slpmsg->p2p_info) == P2P_ACK) ? 0 : slpmsg->size;
    180179
    181180        offset = msn_p2p_info_get_offset(slpmsg->p2p_info);
    182181        offset += msn_p2p_info_get_length(part->info);
     
    198197        else
    199198        {
    200199                /* The whole message has been sent */
    201                 if (msn_p2p_msg_is_data(slpmsg->p2p_info))
     200                if (msn_p2p_msg_is_data(msn_p2p_info_get_flags(slpmsg->p2p_info)))
    202201                {
    203202                        if (slpmsg->slpcall != NULL)
    204203                        {
  • libpurple/protocols/msn/slpmsg_part.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/slpmsg_part.h libpurple/protocols/msn/slpmsg_part.h
    old new  
    4646
    4747MsnSlpMessagePart *msn_slpmsgpart_new(MsnP2PInfo *info);
    4848
    49 MsnSlpMessagePart *msn_slpmsgpart_new_from_data(MsnP2PVersion p2p, const char *data, size_t data_len);
     49MsnSlpMessagePart *msn_slpmsgpart_new_from_data(const char *data, size_t data_len);
    5050
    5151MsnSlpMessagePart *msn_slpmsgpart_ref(MsnSlpMessagePart *part);
    5252
  • libpurple/protocols/msn/switchboard.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/switchboard.c libpurple/protocols/msn/switchboard.c
    old new  
    421421
    422422        purple_debug_info("msn", "unqueuing unsent message to %s\n", swboard->im_user);
    423423
    424         if (msn_switchboard_request(swboard)) {
    425                 msn_switchboard_request_add_user(swboard, swboard->im_user);
    426                 swboard->reconn_timeout_h = 0;
    427         }
     424        msn_switchboard_request(swboard);
     425        msn_switchboard_request_add_user(swboard, swboard->im_user);
     426        swboard->reconn_timeout_h = 0;
    428427        return FALSE;
    429428}
    430429
     
    10731072        swboard_error_helper(swboard, reason, swboard->im_user);
    10741073}
    10751074
    1076 gboolean
     1075void
    10771076msn_switchboard_request(MsnSwitchBoard *swboard)
    10781077{
    10791078        MsnCmdProc *cmdproc;
    10801079        MsnTransaction *trans;
    10811080
    1082         g_return_val_if_fail(swboard != NULL, FALSE);
     1081        g_return_if_fail(swboard != NULL);
    10831082
    10841083        cmdproc = swboard->session->notification->cmdproc;
    10851084
     
    10891088        msn_transaction_set_data(trans, swboard);
    10901089        msn_transaction_set_error_cb(trans, xfr_error);
    10911090
    1092         return msn_cmdproc_send_trans(cmdproc, trans);
     1091        msn_cmdproc_send_trans(cmdproc, trans);
    10931092}
    10941093
    10951094void
  • libpurple/protocols/msn/switchboard.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/switchboard.h libpurple/protocols/msn/switchboard.h
    old new  
    250250gboolean msn_switchboard_chat_leave(MsnSwitchBoard *swboard);
    251251gboolean msn_switchboard_chat_invite(MsnSwitchBoard *swboard, const char *who);
    252252
    253 gboolean msn_switchboard_request(MsnSwitchBoard *swboard);
     253void msn_switchboard_request(MsnSwitchBoard *swboard);
    254254void msn_switchboard_request_add_user(MsnSwitchBoard *swboard, const char *user);
    255255
    256256/**
  • libpurple/protocols/msn/tlv.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/tlv.c libpurple/protocols/msn/tlv.c
    old new  
    4545        g_free(oldtlv);
    4646}
    4747
    48 GSList *
    49 msn_tlvlist_read(const char *bs, size_t bs_len)
     48static GSList *
     49msn_tlv_read(GSList *list, const char *bs, size_t *bs_len)
    5050{
    51         GSList *list = NULL;
     51        guint8 type, length;
     52        msn_tlv_t *tlv;
    5253
    53         while (bs_len > 0) {
    54                 guint8 type, length;
    55                 msn_tlv_t *tlv;
     54        type = msn_read8(bs);
     55        length = msn_read8(bs);
     56        *bs_len -= 2;
    5657
    57                 if (bs_len == 3 && *bs == 0) {
    58                         /* Padding to multiple of 4 */
    59                         break;
    60                 } else if (bs_len == 2 && *bs == 0) {
    61                         /* Padding to multiple of 4 */
    62                         break;
    63                 } else if (bs_len == 1) {
    64                         if (*bs == 0) {
    65                                 /* Padding to multiple of 4 */
    66                                 break;
    67                         } else {
    68                                 /* TLV is not small enough to fit here */
    69                                 msn_tlvlist_free(list);
    70                                 return NULL;
    71                         }
    72                 }
    73 
    74                 type = msn_pop8(bs);
    75                 length = msn_pop8(bs);
    76                 bs_len -= 2;
     58        if (length > *bs_len) {
     59                msn_tlvlist_free(list);
     60                return NULL;
     61        }
    7762
    78                 if (length > bs_len) {
     63        tlv = createtlv(type, length, NULL);
     64        if (length > 0) {
     65                tlv->value = g_memdup(bs, length);
     66                if (!tlv->value) {
     67                        freetlv(tlv);
    7968                        msn_tlvlist_free(list);
    8069                        return NULL;
    8170                }
     71        }
    8272
    83                 tlv = createtlv(type, length, NULL);
    84                 if (length > 0) {
    85                         tlv->value = g_memdup(bs, length);
    86                         if (!tlv->value) {
    87                                 freetlv(tlv);
    88                                 msn_tlvlist_free(list);
    89                                 return NULL;
    90                         }
    91                 }
     73        *bs_len -= length;
     74
     75        return g_slist_prepend(list, tlv);
     76}
    9277
    93                 bs_len -= length;
    94                 bs += length;
     78GSList *
     79msn_tlvlist_read(const char *bs, size_t bs_len)
     80{
     81        GSList *list = NULL;
    9582
    96                 list = g_slist_prepend(list, tlv);
     83        while (bs_len > 0) {
     84                list = msn_tlv_read(list, bs, &bs_len);
     85                if (list == NULL)
     86                        return NULL;
    9787        }
    9888
    9989        return g_slist_reverse(list);
    10090}
    10191
    102 GSList *
    103 msn_tlvlist_copy(GSList *orig)
     92GSList *msn_tlvlist_copy(GSList *orig)
    10493{
    10594        GSList *new = NULL;
    10695        msn_tlv_t *tlv;
     
    169158}
    170159
    171160int
    172 msn_tlvlist_add_raw(GSList **list, const guint8 type, const guint8 length, const char *value)
     161msn_tlvlist_add_raw(GSList **list, const guint16 type, const guint16 length, const char *value)
    173162{
    174163        msn_tlv_t *tlv;
    175164
     
    186175}
    187176
    188177int
    189 msn_tlvlist_add_8(GSList **list, const guint8 type, const guint8 value)
     178msn_tlvlist_add_8(GSList **list, const guint16 type, const guint8 value)
    190179{
    191180        char v8[1];
    192181
     
    196185}
    197186
    198187int
    199 msn_tlvlist_add_16(GSList **list, const guint8 type, const guint16 value)
     188msn_tlvlist_add_16(GSList **list, const guint16 type, const guint16 value)
    200189{
    201190        char v16[2];
    202191
     
    206195}
    207196
    208197int
    209 msn_tlvlist_add_32(GSList **list, const guint8 type, const guint32 value)
     198msn_tlvlist_add_32(GSList **list, const guint16 type, const guint32 value)
    210199{
    211200        char v32[4];
    212201
     
    216205}
    217206
    218207int
    219 msn_tlvlist_add_str(GSList **list, const guint8 type, const char *value)
     208msn_tlvlist_add_str(GSList **list, const guint16 type, const char *value)
    220209{
    221210        return msn_tlvlist_add_raw(list, type, strlen(value), value);
    222211}
    223212
    224213int
    225 msn_tlvlist_add_empty(GSList **list, const guint8 type)
     214msn_tlvlist_add_empty(GSList **list, const guint16 type)
    226215{
    227216        return msn_tlvlist_add_raw(list, type, 0, NULL);
    228217}
    229218
    230219int
    231 msn_tlvlist_add_tlv(GSList **list, const msn_tlv_t *tlv)
    232 {
    233         return msn_tlvlist_add_raw(list, tlv->type, tlv->length, (const char *)tlv->value);
    234 }
    235 
    236 int
    237 msn_tlvlist_replace_raw(GSList **list, const guint8 type, const guint8 length, const char *value)
     220msn_tlvlist_replace_raw(GSList **list, const guint16 type, const guint16 length, const char *value)
    238221{
    239222        GSList *cur;
    240223        msn_tlv_t *tlv;
     
    263246}
    264247
    265248int
    266 msn_tlvlist_replace_str(GSList **list, const guint8 type, const char *str)
     249msn_tlvlist_replace_str(GSList **list, const guint16 type, const char *str)
    267250{
    268251        return msn_tlvlist_replace_raw(list, type, strlen(str), str);
    269252}
    270253
    271254int
    272 msn_tlvlist_replace_empty(GSList **list, const guint8 type)
     255msn_tlvlist_replace_empty(GSList **list, const guint16 type)
    273256{
    274257        return msn_tlvlist_replace_raw(list, type, 0, NULL);
    275258}
    276259
    277260int
    278 msn_tlvlist_replace_8(GSList **list, const guint8 type, const guint8 value)
     261msn_tlvlist_replace_8(GSList **list, const guint16 type, const guint8 value)
    279262{
    280263        char v8[1];
    281264
     
    285268}
    286269
    287270int
    288 msn_tlvlist_replace_32(GSList **list, const guint8 type, const guint32 value)
     271msn_tlvlist_replace_32(GSList **list, const guint16 type, const guint32 value)
    289272{
    290273        char v32[4];
    291274
     
    294277        return msn_tlvlist_replace_raw(list, type, 4, v32);
    295278}
    296279
    297 int
    298 msn_tlvlist_replace_tlv(GSList **list, const msn_tlv_t *tlv)
    299 {
    300         return msn_tlvlist_replace_raw(list, tlv->type, tlv->length, (const char *)tlv->value);
    301 }
    302 
    303280void
    304 msn_tlvlist_remove(GSList **list, const guint8 type)
     281msn_tlvlist_remove(GSList **list, const guint16 type)
    305282{
    306283        GSList *cur, *next;
    307284        msn_tlv_t *tlv;
     
    325302        }
    326303}
    327304
    328 char *
    329 msn_tlvlist_write(GSList *list, size_t *out_len)
     305int
     306msn_tlvlist_write(char *bs, size_t bs_len, GSList *list)
    330307{
    331         char *buf;
    332         char *tmp;
    333         size_t bytes_left;
    334         size_t total_len;
    335 
    336         tmp = buf = g_malloc(256);
    337         bytes_left = total_len = 256;
    338 
    339         for (; list; list = g_slist_next(list)) {
    340                 msn_tlv_t *tlv = (msn_tlv_t *)list->data;
    341 
    342                 if (G_UNLIKELY(tlv->length + 2 > bytes_left)) {
    343                         buf = g_realloc(buf, total_len + 256);
    344                         bytes_left += 256;
    345                         total_len += 256;
    346                         tmp = buf + (total_len - bytes_left);
    347                 }
    348 
    349                 msn_push8(tmp, tlv->type);
    350                 msn_push8(tmp, tlv->length);
    351                 memcpy(tmp, tlv->value, tlv->length);
    352                 tmp += tlv->length;
     308#if 0
     309        int goodbuflen;
     310        GSList *cur;
     311        msn_tlv_t *tlv;
    353312
    354                 bytes_left -= (tlv->length + 2);
    355         }
     313        /* do an initial run to test total length */
     314        goodbuflen = msn_tlvlist_size(*list);
    356315
    357         /* Align length to multiple of 4 */
    358         total_len = total_len - bytes_left;
    359         bytes_left = 4 - total_len % 4;
    360         if (bytes_left != 4)
    361                 memset(tmp, 0, bytes_left);
    362         else
    363                 bytes_left = 0;
     316        if (goodbuflen > byte_stream_bytes_left(bs))
     317                return 0; /* not enough buffer */
    364318
    365         *out_len = total_len + bytes_left;
     319        /* do the real write-out */
     320        for (cur = *list; cur; cur = cur->next) {
     321                tlv = cur->data;
     322                byte_stream_put16(bs, tlv->type);
     323                byte_stream_put16(bs, tlv->length);
     324                if (tlv->length > 0)
     325                        byte_stream_putraw(bs, tlv->value, tlv->length);
     326        }
    366327
    367         return buf;
     328#endif
     329        return 0; /* TODO: This is a nonsensical return */
    368330}
    369331
    370332msn_tlv_t *
    371 msn_tlv_gettlv(GSList *list, const guint8 type, const int nth)
     333msn_tlv_gettlv(GSList *list, const guint16 type, const int nth)
    372334{
    373335        msn_tlv_t *tlv;
    374336        int i;
     
    385347}
    386348
    387349int
    388 msn_tlv_getlength(GSList *list, const guint8 type, const int nth)
     350msn_tlv_getlength(GSList *list, const guint16 type, const int nth)
    389351{
    390352        msn_tlv_t *tlv;
    391353
     
    409371}
    410372
    411373char *
    412 msn_tlv_getstr(GSList *list, const guint8 type, const int nth)
     374msn_tlv_getstr(GSList *list, const guint16 type, const int nth)
    413375{
    414376        msn_tlv_t *tlv;
    415377
     
    421383}
    422384
    423385guint8
    424 msn_tlv_get8(GSList *list, const guint8 type, const int nth)
     386msn_tlv_get8(GSList *list, const guint16 type, const int nth)
    425387{
    426388        msn_tlv_t *tlv;
    427389
     
    433395}
    434396
    435397guint16
    436 msn_tlv_get16(GSList *list, const guint8 type, const int nth)
     398msn_tlv_get16(GSList *list, const guint16 type, const int nth)
    437399{
    438400        msn_tlv_t *tlv;
    439401
     
    445407}
    446408
    447409guint32
    448 msn_tlv_get32(GSList *list, const guint8 type, const int nth)
     410msn_tlv_get32(GSList *list, const guint16 type, const int nth)
    449411{
    450412        msn_tlv_t *tlv;
    451413
  • libpurple/protocols/msn/tlv.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/msn/tlv.h libpurple/protocols/msn/tlv.h
    old new  
    3838/* TLV handling functions */
    3939char *msn_tlv_getvalue_as_string(msn_tlv_t *tlv);
    4040
    41 msn_tlv_t *msn_tlv_gettlv(GSList *list, const guint8 type, const int nth);
    42 int msn_tlv_getlength(GSList *list, const guint8 type, const int nth);
    43 char *msn_tlv_getstr(GSList *list, const guint8 type, const int nth);
    44 guint8 msn_tlv_get8(GSList *list, const guint8 type, const int nth);
    45 guint16 msn_tlv_get16(GSList *list, const guint8 type, const int nth);
    46 guint32 msn_tlv_get32(GSList *list, const guint8 type, const int nth);
     41msn_tlv_t *msn_tlv_gettlv(GSList *list, const guint16 type, const int nth);
     42int msn_tlv_getlength(GSList *list, const guint16 type, const int nth);
     43char *msn_tlv_getstr(GSList *list, const guint16 type, const int nth);
     44guint8 msn_tlv_get8(GSList *list, const guint16 type, const int nth);
     45guint16 msn_tlv_get16(GSList *list, const guint16 type, const int nth);
     46guint32 msn_tlv_get32(GSList *list, const guint16 type, const int nth);
    4747
    4848/* TLV list handling functions */
    4949GSList *msn_tlvlist_read(const char *bs, size_t bs_len);
     
    5252int msn_tlvlist_count(GSList *list);
    5353size_t msn_tlvlist_size(GSList *list);
    5454gboolean msn_tlvlist_equal(GSList *one, GSList *two);
    55 char *msn_tlvlist_write(GSList *list, size_t *out_len);
     55int msn_tlvlist_write(char *bs, size_t bs_len, GSList *list);
    5656void msn_tlvlist_free(GSList *list);
    5757
    58 int msn_tlvlist_add_raw(GSList **list, const guint8 type, const guint8 length, const char *value);
    59 int msn_tlvlist_add_empty(GSList **list, const guint8 type);
    60 int msn_tlvlist_add_8(GSList **list, const guint8 type, const guint8 value);
    61 int msn_tlvlist_add_16(GSList **list, const guint8 type, const guint16 value);
    62 int msn_tlvlist_add_32(GSList **list, const guint8 type, const guint32 value);
    63 int msn_tlvlist_add_str(GSList **list, const guint8 type, const char *value);
    64 int msn_tlvlist_add_tlv(GSList **list, const msn_tlv_t *tlv);
    65 
    66 int msn_tlvlist_replace_raw(GSList **list, const guint8 type, const guint8 lenth, const char *value);
    67 int msn_tlvlist_replace_str(GSList **list, const guint8 type, const char *str);
    68 int msn_tlvlist_replace_empty(GSList **list, const guint8 type);
    69 int msn_tlvlist_replace_8(GSList **list, const guint8 type, const guint8 value);
    70 int msn_tlvlist_replace_16(GSList **list, const guint8 type, const guint16 value);
    71 int msn_tlvlist_replace_32(GSList **list, const guint8 type, const guint32 value);
    72 int msn_tlvlist_replace_tlv(GSList **list, const msn_tlv_t *tlv);
     58int msn_tlvlist_add_raw(GSList **list, const guint16 type, const guint16 length, const char *value);
     59int msn_tlvlist_add_empty(GSList **list, const guint16 type);
     60int msn_tlvlist_add_8(GSList **list, const guint16 type, const guint8 value);
     61int msn_tlvlist_add_16(GSList **list, const guint16 type, const guint16 value);
     62int msn_tlvlist_add_32(GSList **list, const guint16 type, const guint32 value);
     63int msn_tlvlist_add_str(GSList **list, const guint16 type, const char *value);
     64
     65int msn_tlvlist_replace_raw(GSList **list, const guint16 type, const guint16 lenth, const char *value);
     66int msn_tlvlist_replace_str(GSList **list, const guint16 type, const char *str);
     67int msn_tlvlist_replace_empty(GSList **list, const guint16 type);
     68int msn_tlvlist_replace_8(GSList **list, const guint16 type, const guint8 value);
     69int msn_tlvlist_replace_16(GSList **list, const guint16 type, const guint16 value);
     70int msn_tlvlist_replace_32(GSList **list, const guint16 type, const guint32 value);
    7371
    74 void msn_tlvlist_remove(GSList **list, const guint8 type);
     72void msn_tlvlist_remove(GSList **list, const guint16 type);
    7573
    7674#endif /* MSN_TLV_H */
    7775
  • libpurple/protocols/novell/nmconn.c

    Only in extract/pidgin-2.10.9/libpurple/protocols: mxit
    Only in libpurple/protocols/myspace: Makefile.in
    Only in libpurple/protocols/myspace: moz.build
    Only in libpurple/protocols: netsoul
    Only in libpurple/protocols/novell: Makefile.in
    Only in libpurple/protocols/novell: moz.build
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/novell/nmconn.c libpurple/protocols/novell/nmconn.c
    old new  
    1919 */
    2020
    2121#include <glib.h>
     22#ifndef _MSC_VER
    2223#include <unistd.h>
     24#endif
    2325#include <errno.h>
    2426#include <string.h>
    2527#include <ctype.h>
  • libpurple/protocols/null/nullprpl.c

    Only in libpurple/protocols/null: Makefile.in
    Only in libpurple/protocols/null: moz.build
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/null/nullprpl.c libpurple/protocols/null/nullprpl.c
    old new  
    6767#include "util.h"
    6868#include "version.h"
    6969
     70/* Disable gettext for the null-prpl, it will never be translated... */
     71#undef _
     72#define _(String) (String)
    7073
    7174#define NULLPRPL_ID "prpl-null"
    7275static PurplePlugin *_null_protocol = NULL;
     
    172175        !strcmp(status_id, NULL_STATUS_AWAY) ||
    173176        !strcmp(status_id, NULL_STATUS_OFFLINE)) {
    174177      purple_debug_info("nullprpl", "%s sees that %s is %s: %s\n",
    175                         from_username, to_username, status_id, message);
     178                        from_username, to_username, status_id,
     179                        message ? message : "");
    176180      purple_prpl_got_user_status(from->account, to_username, status_id,
    177181                                  (message) ? "message" : NULL, message, NULL);
    178182    } else {
     
    364368
    365369  purple_debug_info("nullprpl", "logging in %s\n", acct->username);
    366370
     371  if (!strcmp(acct->username, "crash@test"))
     372    *((int *) NULL) = 42;
     373
    367374  purple_connection_update_progress(gc, _("Connecting"),
    368375                                    0,   /* which connection step this is */
    369376                                    2);  /* total number of steps */
     
    522529
    523530static void nullprpl_set_status(PurpleAccount *acct, PurpleStatus *status) {
    524531  const char *msg = purple_status_get_attr_string(status, "message");
    525   purple_debug_info("nullprpl", "setting %s's status to %s: %s\n",
    526                     acct->username, purple_status_get_name(status), msg);
     532  if (msg)
     533    purple_debug_info("nullprpl", "setting %s's status to %s: %s\n",
     534                      acct->username, purple_status_get_name(status), msg);
     535  else
     536    purple_debug_info("nullprpl", "setting %s's status to %s\n",
     537                      acct->username, purple_status_get_name(status));
    527538
    528539  foreach_nullprpl_gc(report_status_change, get_nullprpl_gc(acct->username),
    529540                      NULL);
  • libpurple/protocols/oscar/authorization.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/oscar/authorization.c libpurple/protocols/oscar/authorization.c
    old new  
    9393oscar_auth_dontgrant_msgprompt(gpointer cbdata)
    9494{
    9595        struct name_data *data = cbdata;
     96#if 0
    9697        purple_request_input(data->gc, NULL, _("Authorization Denied Message:"),
    9798                                           NULL, _("No reason given."), TRUE, FALSE, NULL,
    9899                                           _("_OK"), G_CALLBACK(oscar_auth_dontgrant),
    99100                                           _("_Cancel"), G_CALLBACK(oscar_free_name_data),
    100101                                           purple_connection_get_account(data->gc), data->name, NULL,
    101102                                           data);
     103#else
     104        oscar_auth_dontgrant(data, NULL);
     105#endif
    102106}
    103107
    104108void
  • libpurple/protocols/oscar/family_locate.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/oscar/family_locate.c libpurple/protocols/oscar/family_locate.c
    old new  
    567567aim_userinfo_t *aim_locate_finduserinfo(OscarData *od, const char *bn) {
    568568        aim_userinfo_t *cur = NULL;
    569569
    570         if (bn == NULL)
     570        if (bn == NULL || od == NULL)
    571571                return NULL;
    572572
    573573        cur = od->locate.userinfo;
  • libpurple/protocols/oscar/libaim.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/oscar/libaim.c libpurple/protocols/oscar/libaim.c
    old new  
    142142        NULL
    143143};
    144144
     145gboolean purple_init_icq_plugin(void);
     146
    145147static void
    146148init_plugin(PurplePlugin *plugin)
    147149{
    148150        oscar_init(plugin, FALSE);
     151        purple_init_icq_plugin();
    149152}
    150153
    151 PURPLE_INIT_PLUGIN(aim, init_plugin, info);
     154PURPLE_INIT_PLUGIN(oscar, init_plugin, info)
  • libpurple/protocols/oscar/libicq.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/oscar/libicq.c libpurple/protocols/oscar/libicq.c
    old new  
    2424 * which contains all the shared implementation code with libaim
    2525 */
    2626
    27 
     27#ifndef PURPLE_STATIC_PRPL
     28#define PURPLE_STATIC_PRPL
     29#endif
    2830#include "oscarcommon.h"
    2931
    3032static GHashTable *
  • libpurple/protocols/oscar/oscar.c

    Only in libpurple/protocols/oscar: Makefile.in
    Only in libpurple/protocols/oscar: moz.build
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/oscar/oscar.c libpurple/protocols/oscar/oscar.c
    old new  
    350350                flap_connection_send_version(od, conn);
    351351        else
    352352        {
    353                 if (purple_account_get_bool(account, "use_clientlogin", OSCAR_DEFAULT_USE_CLIENTLOGIN))
     353                if (purple_account_get_bool(account, "use_clientlogin", od->icq ? ICQ_DEFAULT_USE_CLIENTLOGIN : AIM_DEFAULT_USE_CLIENTLOGIN))
    354354                {
    355355                        ClientInfo aiminfo = CLIENTINFO_PURPLE_AIM;
    356356                        ClientInfo icqinfo = CLIENTINFO_PURPLE_ICQ;
     
    577577
    578578        gc = data;
    579579        od = purple_connection_get_protocol_data(gc);
    580         report_idle = strcmp((const char *)value, "none") != 0;
     580        report_idle = GPOINTER_TO_INT(value);
    581581        presence = aim_ssi_getpresence(od->ssi.local);
    582582
    583583        if (report_idle)
     
    765765        od->use_ssl = purple_ssl_is_supported() && strcmp(encryption_type, OSCAR_NO_ENCRYPTION) != 0;
    766766
    767767        /* Connect to core Purple signals */
    768         purple_prefs_connect_callback(gc, "/purple/away/idle_reporting", idle_reporting_pref_cb, gc);
     768        purple_prefs_connect_callback(gc, "/messenger/status/reportIdle", idle_reporting_pref_cb, gc);
    769769        purple_prefs_connect_callback(gc, "/plugins/prpl/oscar/recent_buddies", recent_buddies_pref_cb, gc);
    770770
    771771        /*
     
    778778         * This authentication method is used for both ICQ and AIM when
    779779         * clientLogin is not enabled.
    780780         */
    781         if (purple_account_get_bool(account, "use_clientlogin", OSCAR_DEFAULT_USE_CLIENTLOGIN)) {
     781        if (purple_account_get_bool(account, "use_clientlogin", od->icq ? ICQ_DEFAULT_USE_CLIENTLOGIN : AIM_DEFAULT_USE_CLIENTLOGIN)) {
    782782                send_client_login(od, purple_account_get_username(account));
    783783        } else {
    784784                FlapConnection *newconn;
     
    39823982                const char *idle_reporting_pref;
    39833983                gboolean report_idle;
    39843984
    3985                 idle_reporting_pref = purple_prefs_get_string("/purple/away/idle_reporting");
    3986                 report_idle = strcmp(idle_reporting_pref, "none") != 0;
     3985                report_idle = purple_prefs_get_bool("/messenger/status/reportIdle");
    39873986
    39883987                if (report_idle)
    39893988                        aim_ssi_setpresence(od, tmp | AIM_SSI_PRESENCE_FLAG_SHOWIDLE);
     
    40254024                                        b = purple_find_buddy_in_group(account, curitem->name, g);
    40264025                                        if (b) {
    40274026                                                /* Get server stored alias */
    4028                                                 purple_blist_alias_buddy(b, alias_utf8);
     4027                                                if (!purple_strequal(curitem->name, alias_utf8))
     4028                                                        purple_blist_alias_buddy(b, alias_utf8);
    40294029                                        } else {
    40304030                                                b = purple_buddy_new(account, curitem->name, alias_utf8);
    40314031
     
    57675767        prpl_info->protocol_options = g_list_append(prpl_info->protocol_options, option);
    57685768
    57695769        option = purple_account_option_bool_new(_("Use clientLogin"), "use_clientlogin",
    5770                         OSCAR_DEFAULT_USE_CLIENTLOGIN);
     5770                        is_icq ? ICQ_DEFAULT_USE_CLIENTLOGIN : AIM_DEFAULT_USE_CLIENTLOGIN);
    57715771        prpl_info->protocol_options = g_list_append(prpl_info->protocol_options, option);
    57725772
    57735773        option = purple_account_option_bool_new(
  • libpurple/protocols/oscar/oscarcommon.h

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/oscar/oscarcommon.h libpurple/protocols/oscar/oscarcommon.h
    old new  
    5454#define OSCAR_DEFAULT_WEB_AWARE FALSE
    5555#define OSCAR_DEFAULT_ALWAYS_USE_RV_PROXY FALSE
    5656#define OSCAR_DEFAULT_ALLOW_MULTIPLE_LOGINS TRUE
    57 #define OSCAR_DEFAULT_USE_CLIENTLOGIN TRUE
     57#define AIM_DEFAULT_USE_CLIENTLOGIN FALSE
     58#define ICQ_DEFAULT_USE_CLIENTLOGIN TRUE
    5859#define OSCAR_DEFAULT_ENCRYPTION OSCAR_OPPORTUNISTIC_ENCRYPTION
    5960
    6061#ifdef _WIN32
  • libpurple/protocols/sametime/sametime.c

    Only in libpurple/protocols: prpl.mk
    Only in libpurple/protocols: prpl.py
    Only in libpurple/protocols: prpl-rules.mk
    Only in libpurple/protocols/sametime: Makefile.in
    Only in libpurple/protocols/sametime: meanwhile
    Only in libpurple/protocols/sametime: moz.build
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/sametime/sametime.c libpurple/protocols/sametime/sametime.c
    old new  
    927927    return NULL;
    928928  }
    929929
    930   if (!name) {
    931     DEBUG_WARN("Can't ensure a null group\n");
    932     return NULL;
    933   }
    934 
    935930  DEBUG_INFO("attempting to ensure group %s, called %s\n",
    936931             NSTR(name), NSTR(alias));
    937932
  • libpurple/protocols/yahoo/libyahoo.c

    Only in extract/pidgin-2.10.9/libpurple/protocols: silc
    Only in extract/pidgin-2.10.9/libpurple/protocols: silc10
    Only in libpurple/protocols/simple: Makefile.in
    Only in libpurple/protocols/simple: moz.build
    Only in libpurple/protocols: sipe
    Only in libpurple/protocols: xpcomModule.cpp.in
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/yahoo/libyahoo.c libpurple/protocols/yahoo/libyahoo.c
    old new  
    306306        NULL
    307307};
    308308
     309gboolean purple_init_yahoojp_plugin(void);
     310
    309311static void
    310312init_plugin(PurplePlugin *plugin)
    311313{
     
    343345
    344346        purple_signal_connect(purple_get_core(), "uri-handler", plugin,
    345347                PURPLE_CALLBACK(yahoo_uri_handler), NULL);
     348        purple_init_yahoojp_plugin();
    346349}
    347350
    348351PURPLE_INIT_PLUGIN(yahoo, init_plugin, info);
  • libpurple/protocols/yahoo/libyahoojp.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/yahoo/libyahoojp.c libpurple/protocols/yahoo/libyahoojp.c
    old new  
    2121 *
    2222 */
    2323
     24#ifndef PURPLE_STATIC_PRPL
     25#define PURPLE_STATIC_PRPL
     26#endif
    2427#include "internal.h"
    2528
    2629#include <account.h>
  • libpurple/protocols/yahoo/libymsg.c

    diff -ru extract/pidgin-2.10.9/libpurple/protocols/yahoo/libymsg.c libpurple/protocols/yahoo/libymsg.c
    old new  
    13631363static void
    13641364yahoo_buddy_add_deny_reason_cb(gpointer data) {
    13651365        struct yahoo_add_request *add_req = data;
     1366        yahoo_buddy_add_deny_cb(add_req, NULL);
     1367        /*
    13661368        purple_request_input(add_req->gc, NULL, _("Authorization denied message:"),
    13671369                        NULL, _("No reason given."), TRUE, FALSE, NULL,
    13681370                        _("OK"), G_CALLBACK(yahoo_buddy_add_deny_cb),
    13691371                        _("Cancel"), G_CALLBACK(yahoo_buddy_add_deny_noreason_cb),
    13701372                        purple_connection_get_account(add_req->gc), add_req->who, NULL,
    13711373                        add_req);
     1374        */
    13721375}
    13731376
    13741377static void yahoo_buddy_denied_our_add(PurpleConnection *gc, const char *who, const char *reason)
  • libpurple/protocols/yahoo/util.c

    Only in libpurple/protocols/yahoo: Makefile.in
    Only in libpurple/protocols/yahoo: moz.build
    diff -ru extract/pidgin-2.10.9/libpurple/protocols/yahoo/util.c libpurple/protocols/yahoo/util.c
    old new  
    498498                         */
    499499                        int size, htmlsize;
    500500                        gchar tmp[11];
     501                        gchar *tmp2 = g_strdup_printf("font-size: %spt", fontsize);
    501502                        size = strtol(fontsize, NULL, 10);
    502503                        htmlsize = point_to_html(size);
    503504                        sprintf(tmp, "%u", htmlsize);
    504505                        xmlnode_set_attrib(*cur, "size", tmp);
    505                         xmlnode_set_attrib(*cur, "absz", fontsize);
     506                        xmlnode_set_attrib(*cur, "style", tmp2);
     507                        g_free(tmp2);
    506508#endif /* !USE_CSS_FORMATTING */
    507509                        g_free(fontsize);
    508510                }
  • libpurple/proxy.c

    Only in extract/pidgin-2.10.9/libpurple/protocols: zephyr
    diff -ru extract/pidgin-2.10.9/libpurple/proxy.c libpurple/proxy.c
    old new  
    285285        return param;
    286286}
    287287
     288#if 0
    288289static PurpleProxyInfo *
    289290purple_gnome_proxy_get_info(void)
    290291{
     
    415416
    416417        return &info;
    417418}
     419#endif
    418420
    419421#ifdef _WIN32
    420422
     
    22652267                        gpi = NULL;
    22662268        }
    22672269        if (gpi == NULL) {
     2270#if 0
    22682271                if (purple_running_gnome())
    22692272                        gpi = purple_gnome_proxy_get_info();
    22702273                else
     2274#endif
    22712275                        gpi = purple_global_proxy_get_info();
    22722276        }
    22732277
     
    25892593        }
    25902594}
    25912595
     2596#if 0
    25922597static void
    25932598proxy_pref_cb(const char *name, PurplePrefType type,
    25942599                          gconstpointer value, gpointer data)
     
    26242629        else if (purple_strequal(name, "/purple/proxy/password"))
    26252630                purple_proxy_info_set_password(info, value);
    26262631}
     2632#endif
    26272633
    26282634void *
    26292635purple_proxy_get_handle()
     
    26432649
    26442650        /* Proxy */
    26452651        purple_prefs_add_none("/purple/proxy");
     2652#if 0
    26462653        purple_prefs_add_string("/purple/proxy/type", "none");
    26472654        purple_prefs_add_string("/purple/proxy/host", "");
    26482655        purple_prefs_add_int("/purple/proxy/port", 0);
    26492656        purple_prefs_add_string("/purple/proxy/username", "");
    26502657        purple_prefs_add_string("/purple/proxy/password", "");
     2658#endif
    26512659        purple_prefs_add_bool("/purple/proxy/socks4_remotedns", FALSE);
    26522660
     2661#if 0
    26532662        /* Setup callbacks for the preferences. */
    26542663        handle = purple_proxy_get_handle();
    26552664        purple_prefs_connect_callback(handle, "/purple/proxy/type", proxy_pref_cb,
     
    26692678        purple_prefs_trigger_callback("/purple/proxy/port");
    26702679        purple_prefs_trigger_callback("/purple/proxy/username");
    26712680        purple_prefs_trigger_callback("/purple/proxy/password");
     2681#endif
    26722682}
    26732683
    26742684void
  • libpurple/proxy.h

    diff -ru extract/pidgin-2.10.9/libpurple/proxy.h libpurple/proxy.h
    old new  
    195195 */
    196196void purple_global_proxy_set_info(PurpleProxyInfo *info);
    197197
     198/**
     199 * Set purple's global proxy information.
     200 *
     201 * @param info     The proxy information.
     202 */
     203void purple_global_proxy_set_info(PurpleProxyInfo *info);
     204
    198205/*@}*/
    199206
    200207/**************************************************************************/
  • libpurple/prpl.c

    diff -ru extract/pidgin-2.10.9/libpurple/prpl.c libpurple/prpl.c
    old new  
    382382        g_return_if_fail(new_status != NULL);
    383383        g_return_if_fail(!purple_status_is_exclusive(new_status) || old_status != NULL);
    384384
     385        purple_signal_emit(purple_accounts_get_handle(), "account-status-changing",
     386                                        account, old_status, new_status);
     387
    385388        do_prpl_change_account_status(account, old_status, new_status);
    386389
    387390        purple_signal_emit(purple_accounts_get_handle(), "account-status-changed",
  • libpurple/prpl.h

    diff -ru extract/pidgin-2.10.9/libpurple/prpl.h libpurple/prpl.h
    old new  
    7272#include "conversation.h"
    7373#include "ft.h"
    7474#include "imgstore.h"
    75 #include "media.h"
    7675#include "notify.h"
    7776#include "proxy.h"
    7877#include "plugin.h"
     
    8079#include "status.h"
    8180#include "whiteboard.h"
    8281
    83 
    8482/** @copydoc PurpleBuddyIconSpec */
    8583struct _PurpleBuddyIconSpec {
    8684        /** This is a comma-delimited list of image formats or @c NULL if icons
  • libpurple/request.c

    Only in extract/pidgin-2.10.9/libpurple: purple.h
    Only in extract/pidgin-2.10.9/libpurple: purple.h.in
    Only in extract/pidgin-2.10.9/libpurple: purple.pc.in
    Only in libpurple: purple-prefs.js
    diff -ru extract/pidgin-2.10.9/libpurple/request.c libpurple/request.c
    old new  
    11961196
    11971197/* -- */
    11981198
     1199#define PURPLE_REQUEST_NO_OPS(type, title, description)             \
     1200        purple_debug_error("request", "Requesting "type": %s (%s)", \
     1201                           title ? title : "(null)",                \
     1202                           description ? description : "(null)")
     1203
    11991204void *
    12001205purple_request_input(void *handle, const char *title, const char *primary,
    12011206                                   const char *secondary, const char *default_value,
     
    12301235
    12311236                return info->ui_handle;
    12321237        }
     1238        else
     1239                PURPLE_REQUEST_NO_OPS("input", title, primary);
    12331240
    12341241        return NULL;
    12351242}
     
    12921299
    12931300                return info->ui_handle;
    12941301        }
     1302        else
     1303                PURPLE_REQUEST_NO_OPS("choice", title, primary);
    12951304
    12961305        return NULL;
    12971306}
     
    13661375
    13671376                return info->ui_handle;
    13681377        }
     1378        else
     1379                PURPLE_REQUEST_NO_OPS("action", title, primary);
    13691380
    13701381        return NULL;
    13711382}
     
    14701481                handles = g_list_append(handles, info);
    14711482                return info->ui_handle;
    14721483        }
     1484        else
     1485                PURPLE_REQUEST_NO_OPS("file", title, filename);
    14731486
    14741487        return NULL;
    14751488}
     
    14971510                handles = g_list_append(handles, info);
    14981511                return info->ui_handle;
    14991512        }
     1513        else
     1514                PURPLE_REQUEST_NO_OPS("folder", title, dirname);
    15001515
    15011516        return NULL;
    15021517}
  • libpurple/server.c

    Only in extract/pidgin-2.10.9/libpurple: savedstatuses.c
    Only in extract/pidgin-2.10.9/libpurple: savedstatuses.h
    diff -ru extract/pidgin-2.10.9/libpurple/server.c libpurple/server.c
    old new  
    126126        PurplePlugin *prpl = NULL;
    127127        PurplePluginProtocolInfo *prpl_info = NULL;
    128128        int val = -EINVAL;
    129         const gchar *auto_reply_pref = NULL;
    130129
    131130        g_return_val_if_fail(gc != NULL, val);
    132131
     
    148147         * XXX - If "only auto-reply when away & idle" is set, then shouldn't
    149148         * this only reset lar->sent if we're away AND idle?
    150149         */
    151         auto_reply_pref = purple_prefs_get_string("/purple/away/auto_reply");
    152150        if((gc->flags & PURPLE_CONNECTION_AUTO_RESP) &&
    153151                        !purple_presence_is_available(presence) &&
    154                         !purple_strequal(auto_reply_pref, "never")) {
     152                        !purple_strequal(purple_prefs_get_string("/purple/away/auto_reply"), "never")) {
    155153
    156154                struct last_auto_response *lar;
    157155                lar = get_last_auto_response(gc, name);
     
    645643                const char *away_msg = NULL;
    646644                gboolean mobile = FALSE;
    647645
    648                 auto_reply_pref = purple_prefs_get_string("/purple/away/auto_reply");
    649 
    650646                presence = purple_account_get_presence(account);
    651647                status = purple_presence_get_active_status(presence);
    652648                status_type = purple_status_get_type(status);
     
    655651                if ((primitive == PURPLE_STATUS_AVAILABLE) ||
    656652                        (primitive == PURPLE_STATUS_INVISIBLE) ||
    657653                        mobile ||
    658                     purple_strequal(auto_reply_pref, "never") ||
     654                    purple_strequal((auto_reply_pref = purple_prefs_get_string("/purple/away/auto_reply")), "never") ||
    659655                    (!purple_presence_is_idle(presence) && purple_strequal(auto_reply_pref, "awayidle")))
    660656                {
    661657                        g_free(name);
  • libpurple/smiley.c

    diff -ru extract/pidgin-2.10.9/libpurple/smiley.c libpurple/smiley.c
    old new  
    6060static char *smileys_dir = NULL;
    6161
    6262#define SMILEYS_DEFAULT_FOLDER                  "custom_smiley"
    63 #define SMILEYS_LOG_ID                          "smileys"
     63#define SMILEYS_LOG_ID                          N_("smileys")
    6464
    6565#define XML_FILE_NAME                           "smileys.xml"
    6666
  • libpurple/sslconn.c

    Only in extract/pidgin-2.10.9/libpurple: sound.c
    Only in extract/pidgin-2.10.9/libpurple: sound.h
    Only in extract/pidgin-2.10.9/libpurple: sound-theme.c
    Only in extract/pidgin-2.10.9/libpurple: sound-theme.h
    Only in extract/pidgin-2.10.9/libpurple: sound-theme-loader.c
    Only in extract/pidgin-2.10.9/libpurple: sound-theme-loader.h
    diff -ru extract/pidgin-2.10.9/libpurple/sslconn.c libpurple/sslconn.c
    old new  
    2727
    2828#include "internal.h"
    2929
    30 #include "certificate.h"
    3130#include "debug.h"
    3231#include "request.h"
    3332#include "sslconn.h"
    3433
     34extern void purple_nss_init(void);
     35
    3536static gboolean _ssl_initialized = FALSE;
    3637static PurpleSslOps *_ssl_ops = NULL;
    3738
     
    4344
    4445        if (_ssl_initialized)
    4546                return FALSE;
     47#if 0
    4648
    4749        plugin = purple_plugins_find_with_id("core-ssl");
    4850
    4951        if (plugin != NULL && !purple_plugin_is_loaded(plugin))
    5052                purple_plugin_load(plugin);
     53#endif
     54        purple_nss_init();
    5155
    5256        ops = purple_ssl_get_ops();
    5357        if ((ops == NULL) || (ops->init == NULL) || (ops->uninit == NULL) ||
     
    6367gboolean
    6468purple_ssl_is_supported(void)
    6569{
    66 #ifdef HAVE_SSL
    6770        ssl_init();
    6871        return (purple_ssl_get_ops() != NULL);
    69 #else
    70         return FALSE;
    71 #endif
    7272}
    7373
    7474static void
     
    131131        gsc->connect_cb      = func;
    132132        gsc->error_cb        = error_func;
    133133
     134#if 0
    134135        /* TODO: Move this elsewhere */
    135136        gsc->verifier = purple_certificate_find_verifier("x509","tls_cached");
     137#endif
    136138
    137139        gsc->connect_data = purple_proxy_connect(NULL, account, host, port, purple_ssl_connect_cb, gsc);
    138140
     
    222224    if(host)
    223225        gsc->host            = g_strdup(host);
    224226
     227#if 0
    225228        /* TODO: Move this elsewhere */
    226229        gsc->verifier = purple_certificate_find_verifier("x509","tls_cached");
     230#endif
    227231
    228232
    229233        ops = purple_ssl_get_ops();
  • libpurple/sslconn.h

    diff -ru extract/pidgin-2.10.9/libpurple/sslconn.h libpurple/sslconn.h
    old new  
    3434        PURPLE_SSL_CERTIFICATE_INVALID = 3
    3535} PurpleSslErrorType;
    3636
    37 #include "certificate.h"
    3837#include "proxy.h"
    3938
    4039#define PURPLE_SSL_DEFAULT_PORT 443
    4140
    4241/** @copydoc _PurpleSslConnection */
    4342typedef struct _PurpleSslConnection PurpleSslConnection;
     43typedef struct _PurpleCertificateVerifier PurpleCertificateVerifier;
    4444
    4545typedef void (*PurpleSslInputFunction)(gpointer, PurpleSslConnection *,
    4646                                                                         PurpleInputCondition);
  • libpurple/ssl-nss.c

    diff -ru extract/pidgin-2.10.9/libpurple/ssl-nss.c libpurple/ssl-nss.c
    old new  
    2121 */
    2222#include "internal.h"
    2323#include "debug.h"
    24 #include "certificate.h"
    2524#include "plugin.h"
    2625#include "sslconn.h"
    2726#include "util.h"
     
    6463
    6564#define PURPLE_SSL_NSS_DATA(gsc) ((PurpleSslNssData *)gsc->private_data)
    6665
    67 static const PRIOMethods *_nss_methods = NULL;
    68 static PRDescIdentity _identity;
    69 static PurpleCertificateScheme x509_nss;
     66/* static const PRIOMethods *_nss_methods = NULL; */
     67/* static PRDescIdentity _identity; */
     68/* static PurpleCertificateScheme x509_nss; */
    7069
    7170/* Thank you, Evolution */
    7271static void
     
    133132static void
    134133ssl_nss_init_nss(void)
    135134{
     135#if 0
    136136        PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
    137137        NSS_NoDB_Init(".");
    138138        NSS_SetDomesticPolicy();
     
    152152
    153153        _identity = PR_GetUniqueIdentity("Purple");
    154154        _nss_methods = PR_GetDefaultIOMethods();
     155#endif
    155156}
    156157
    157158static SECStatus
     
    183184static void
    184185ssl_nss_uninit(void)
    185186{
     187#if 0
    186188        NSS_Shutdown();
    187189        PR_Cleanup();
    188190
    189191        _nss_methods = NULL;
     192#endif
    190193}
    191194
     195#if 0
    192196static void
    193197ssl_nss_verified_cb(PurpleCertificateVerificationStatus st,
    194198                       gpointer userdata)
     
    265269
    266270        return peer_certs;
    267271}
     272#endif
    268273
    269274static void
    270275ssl_nss_handshake_cb(gpointer data, int fd, PurpleInputCondition cond)
     
    296301        purple_input_remove(nss_data->handshake_handler);
    297302        nss_data->handshake_handler = 0;
    298303
     304        gsc->connect_cb(gsc->connect_cb_data, gsc, cond);
     305
     306#if 0
    299307        /* If a Verifier was given, hand control over to it */
    300308        if (gsc->verifier) {
    301309                GList *peers;
     
    318326                 */
    319327                gsc->connect_cb(gsc->connect_cb_data, gsc, cond);
    320328        }
     329#endif
    321330}
    322331
    323332static gboolean
     
    379388
    380389        SSL_OptionSet(nss_data->in, SSL_SECURITY,            PR_TRUE);
    381390        SSL_OptionSet(nss_data->in, SSL_HANDSHAKE_AS_CLIENT, PR_TRUE);
     391        SSL_OptionSet(nss_data->in, SSL_ENABLE_SESSION_TICKETS, PR_FALSE);
    382392
    383393        /* If we have our internal verifier set up, use it. Otherwise,
    384394         * use default. */
    385         if (gsc->verifier != NULL)
     395        if (gsc->verifier != NULL && !purple_prefs_get_bool("/purple/ssl/check_certificates"))
    386396                SSL_AuthCertificateHook(nss_data->in, ssl_auth_cert, NULL);
    387397
    388398        if(gsc->host)
     
    434444        PRInt32 ret;
    435445        PurpleSslNssData *nss_data = PURPLE_SSL_NSS_DATA(gsc);
    436446
     447        if (nss_data->handshake_handler != 0) {
     448                purple_debug_error("nss", "attempting to read from an ssl socket before the end of the handshake\n");
     449                return -1;
     450        }
     451
    437452        ret = PR_Read(nss_data->in, data, len);
    438453
    439454        if (ret == -1)
     
    451466        if(!nss_data)
    452467                return 0;
    453468
     469        if (nss_data->handshake_handler != 0) {
     470                purple_debug_error("nss", "attempting to write to an ssl socket before the end of the handshake\n");
     471                return -1;
     472        }
     473
    454474        ret = PR_Write(nss_data->in, data, len);
    455475
    456476        if (ret == -1)
     
    483503        return NULL;
    484504}
    485505
     506#if 0
     507/* No purple_certificate_* stuff for Instantbird */
     508
    486509/************************************************************************/
    487510/* X.509 functionality                                                  */
    488511/************************************************************************/
     
    936959        NULL,
    937960        NULL
    938961};
     962#endif
    939963
    940964static PurpleSslOps ssl_ops =
    941965{
     
    954978};
    955979
    956980
     981void purple_nss_init(void)
     982{
     983        purple_ssl_set_ops(&ssl_ops);
     984}
     985
     986#if 0
     987/* Instantbird does not need the plugin stuff for NSS */
    957988static gboolean
    958989plugin_load(PurplePlugin *plugin)
    959990{
     
    10261057}
    10271058
    10281059PURPLE_INIT_PLUGIN(ssl_nss, init_plugin, info)
     1060#endif
  • libpurple/status.c

    diff -ru extract/pidgin-2.10.9/libpurple/status.c libpurple/status.c
    old new  
    607607notify_buddy_status_update(PurpleBuddy *buddy, PurplePresence *presence,
    608608                PurpleStatus *old_status, PurpleStatus *new_status)
    609609{
     610#if 0
    610611        if (purple_prefs_get_bool("/purple/logging/log_system"))
    611612        {
    612613                time_t current_time = time(NULL);
     
    652653                g_free(tmp);
    653654                g_free(logtmp);
    654655        }
     656#endif
    655657}
    656658
    657659static void
     
    12531255        PurpleBlistUiOps *ops = purple_blist_get_ui_ops();
    12541256        PurpleAccount *account = purple_buddy_get_account(buddy);
    12551257
     1258#if 0
    12561259        if (!old_idle && idle)
    12571260        {
    12581261                if (purple_prefs_get_bool("/purple/logging/log_system"))
     
    12931296                        }
    12941297                }
    12951298        }
     1299#endif
    12961300
    12971301        if (old_idle != idle)
    12981302                purple_signal_emit(purple_blist_get_handle(), "buddy-idle-changed", buddy,
     
    13391343
    13401344                account = purple_presence_get_account(presence);
    13411345
     1346#if 0
    13421347                if (purple_prefs_get_bool("/purple/logging/log_system"))
    13431348                {
    13441349                        PurpleLog *log = purple_account_get_log(account, FALSE);
     
    13601365                                g_free(msg);
    13611366                        }
    13621367                }
     1368#endif
    13631369
    13641370                gc = purple_account_get_connection(account);
    13651371
  • libpurple/upnp.h

    Only in extract/pidgin-2.10.9/libpurple: tests
    Only in extract/pidgin-2.10.9/libpurple: theme.c
    Only in extract/pidgin-2.10.9/libpurple: theme.h
    Only in extract/pidgin-2.10.9/libpurple: theme-loader.c
    Only in extract/pidgin-2.10.9/libpurple: theme-loader.h
    Only in extract/pidgin-2.10.9/libpurple: theme-manager.c
    Only in extract/pidgin-2.10.9/libpurple: theme-manager.h
    diff -ru extract/pidgin-2.10.9/libpurple/upnp.h libpurple/upnp.h
    old new  
    6161 */
    6262void purple_upnp_discover(PurpleUPnPCallback cb, gpointer cb_data);
    6363
    64 #if 0
    65 /**
    66  * Retrieve the current UPnP control info, if there is any available.
    67  * This will only be filled in if purple_upnp_discover() had been called,
    68  * and finished discovering.
    69  *
    70  * @return The control URL for the IGD we'll use to use the IGD services
    71  */
    72 const PurpleUPnPControlInfo* purple_upnp_get_control_info(void);
    73 #endif
    74 
    7564/**
    7665 * Gets the IP address from a UPnP enabled IGD that sits on the local
    7766 * network, so when getting the network IP, instead of returning the
  • libpurple/util.c

    diff -ru extract/pidgin-2.10.9/libpurple/util.c libpurple/util.c
    old new  
    24952495/**************************************************************************
    24962496 * Path/Filename Functions
    24972497 **************************************************************************/
     2498#ifdef PURPLE_PLUGINS
    24982499const char *
    24992500purple_home_dir(void)
    25002501{
     
    25042505        return wpurple_data_dir();
    25052506#endif
    25062507}
     2508#endif
    25072509
    25082510/* Returns the argument passed to -c IFF it was present, or ~/.purple. */
    25092511const char *
    25102512purple_user_dir(void)
    25112513{
    2512         if (custom_user_dir != NULL)
    2513                 return custom_user_dir;
    2514         else if (!user_dir)
    2515                 user_dir = g_build_filename(purple_home_dir(), ".purple", NULL);
    2516 
    2517         return user_dir;
     2514        g_return_val_if_fail(custom_user_dir != NULL, NULL);
     2515        return custom_user_dir;
    25182516}
    25192517
    25202518void purple_util_set_user_dir(const char *dir)
     
    27152713        return xmlnode_from_file(purple_user_dir(), filename, description, "util");
    27162714}
    27172715
     2716#if 0
    27182717/*
    27192718 * Like mkstemp() but returns a file pointer, uses a pre-set template,
    27202719 * uses the semantics of tempnam() for the directory to use and allocates
     
    27632762
    27642763        return fp;
    27652764}
     2765#endif
    27662766
    27672767const char *
    27682768purple_util_get_image_extension(gconstpointer data, size_t len)
     
    28302830        return filename;
    28312831}
    28322832
     2833#if 0
    28332834gboolean
    28342835purple_program_is_valid(const char *program)
    28352836{
     
    28652866
    28662867        return is_valid;
    28672868}
    2868 
     2869#endif
    28692870
    28702871gboolean
    28712872purple_running_gnome(void)
    28722873{
    2873 #ifndef _WIN32
     2874#if !defined(_WIN32) && !defined(__APPLE__)
    28742875        gchar *tmp = g_find_program_in_path("gnome-open");
    28752876
    28762877        if (tmp == NULL)
     
    28882889gboolean
    28892890purple_running_kde(void)
    28902891{
    2891 #ifndef _WIN32
     2892#if !defined(_WIN32) && !defined(__APPLE__)
    28922893        gchar *tmp = g_find_program_in_path("kfmclient");
    28932894        const char *session;
    28942895
  • libpurple/util.h

    diff -ru extract/pidgin-2.10.9/libpurple/util.h libpurple/util.h
    old new  
    644644 *
    645645 * @see purple_user_dir()
    646646 */
    647 const gchar *purple_home_dir(void);
     647/* const gchar *purple_home_dir(void); */
    648648
    649649/**
    650650 * Returns the purple settings directory in the user's home directory.
     
    745745 *
    746746 * @return A file pointer to the temporary file, or @c NULL on failure.
    747747 */
    748 FILE *purple_mkstemp(char **path, gboolean binary);
     748/* FILE *purple_mkstemp(char **path, gboolean binary); */
    749749
    750750/**
    751751 * Returns an extension corresponding to the image data's file type.
     
    787787 *
    788788 * @return TRUE if the program is runable.
    789789 */
    790 gboolean purple_program_is_valid(const char *program);
     790/* gboolean purple_program_is_valid(const char *program); */
    791791
    792792/**
    793793 * Check if running GNOME.
  • libpurple/win32/libc_interface.h

    Only in extract/pidgin-2.10.9/libpurple: valgrind.h
    Only in extract/pidgin-2.10.9/libpurple/win32: giowin32.c
    Only in extract/pidgin-2.10.9/libpurple/win32: global.mak
    diff -ru extract/pidgin-2.10.9/libpurple/win32/libc_interface.h libpurple/win32/libc_interface.h
    old new  
    134134/* stdio.h */
    135135#undef snprintf
    136136#define snprintf _snprintf
    137 #undef vsnprintf
    138 #define vsnprintf _vsnprintf
    139137
    140138#define rename( oldname, newname ) \
    141139wpurple_rename( oldname, newname )
  • libpurple/win32/win32dep.c

    Only in extract/pidgin-2.10.9/libpurple/win32: libpurplerc.rc.in
    Only in extract/pidgin-2.10.9/libpurple/win32: rules.mak
    Only in extract/pidgin-2.10.9/libpurple/win32: targets.mak
    diff -ru extract/pidgin-2.10.9/libpurple/win32/win32dep.c libpurple/win32/win32dep.c
    old new  
    2222 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
    2323 *
    2424 */
     25#ifndef _WIN32_IE
    2526#define _WIN32_IE 0x501
     27#endif
     28
    2629#include "internal.h"
    2730#include <winuser.h>
    2831
     
    112115
    113116/* Determine Purple Paths during Runtime */
    114117
     118#if 0
    115119/* Get paths to special Windows folders. */
    116120gchar *wpurple_get_special_folder(int folder_type) {
    117121        gchar *retval = NULL;
     
    327331
    328332        return result;
    329333}
     334#endif
    330335
    331336void wpurple_init(void) {
    332337        WORD wVersionRequested;
     
    336341                g_thread_init(NULL);
    337342
    338343        purple_debug_info("wpurple", "wpurple_init start\n");
    339         purple_debug_info("wpurple", "libpurple version: " DISPLAY_VERSION "\n");
     344        //      purple_debug_info("wpurple", "libpurple version: " DISPLAY_VERSION "\n");
    340345
    341346        purple_debug_info("wpurple", "Glib:%u.%u.%u\n",
    342347                glib_major_version, glib_minor_version, glib_micro_version);
  • libpurple/win32/win32dep.h

    diff -ru extract/pidgin-2.10.9/libpurple/win32/win32dep.h libpurple/win32/win32dep.h
    old new  
    5454 **/
    5555/* Windows helper functions */
    5656FARPROC wpurple_find_and_loadproc(const char *dllname, const char *procedure);
    57 gboolean wpurple_read_reg_dword(HKEY rootkey, const char *subkey, const char *valname, LPDWORD result);
    58 char *wpurple_read_reg_string(HKEY rootkey, const char *subkey, const char *valname); /* needs to be g_free'd */
    59 gboolean wpurple_write_reg_string(HKEY rootkey, const char *subkey, const char *valname, const char *value);
     57/* gboolean wpurple_read_reg_dword(HKEY rootkey, const char *subkey, const char *valname, LPDWORD result); */
     58/* char *wpurple_read_reg_string(HKEY rootkey, const char *subkey, const char *valname); / * needs to be g_free'd */
     59/* gboolean wpurple_write_reg_string(HKEY rootkey, const char *subkey, const char *valname, const char *value); */
    6060char *wpurple_escape_dirsep(const char *filename); /* needs to be g_free'd */
    61 GIOChannel *wpurple_g_io_channel_win32_new_socket(int socket); /* Until we get the post-2.8 glib win32 giochannel implementation working, use the thread-based one */
    6261
    6362/* Determine Purple paths */
    64 gchar *wpurple_get_special_folder(int folder_type); /* needs to be g_free'd */
    65 const char *wpurple_install_dir(void);
    66 const char *wpurple_lib_dir(void);
    67 const char *wpurple_locale_dir(void);
    68 const char *wpurple_data_dir(void);
     63/* gchar *wpurple_get_special_folder(int folder_type); /* needs to be g_free'd */
     64/* const char *wpurple_install_dir(void); */
     65/* const char *wpurple_lib_dir(void); */
     66/* const char *wpurple_locale_dir(void); */
     67/* const char *wpurple_data_dir(void); */
    6968
    7069/* init / cleanup */
    7170void wpurple_init(void);
     
    8079/*
    8180 *  Purple specific
    8281 */
    83 #define DATADIR wpurple_install_dir()
    84 #define LIBDIR wpurple_lib_dir()
    85 #define LOCALEDIR wpurple_locale_dir()
     82/* #define DATADIR wpurple_install_dir() */
     83/* #define LIBDIR wpurple_lib_dir() */
     84/* #define LOCALEDIR wpurple_locale_dir() */
    8685
    8786#ifdef __cplusplus
    8887}
  • libpurple/win32/wpurpleerror.h

    diff -ru extract/pidgin-2.10.9/libpurple/win32/wpurpleerror.h libpurple/win32/wpurpleerror.h
    old new  
    2525#ifndef _WPURPLEERROR_H
    2626#define _WPURPLEERROR_H
    2727
     28#if defined(_MSC_VER) && _MSC_VER >= 1600
     29/* libpurple expects errno to contain winsocks error codes rather than
     30   the real errno values (which are defined in MSVC10). */
     31
     32/* Include the Microsoft errno.h before undefining the error codes, so
     33   that it doesn't do anything if it is included later (avoid macro
     34   redefinition warnings). */
     35#include <errno.h>
     36
     37#undef ENETDOWN
     38#undef EAFNOSUPPORT
     39#undef EINPROGRESS
     40#undef ENOBUFS
     41#undef EPROTONOSUPPORT
     42#undef EPROTOTYPE
     43#undef ESOCKTNOSUPPORT
     44
     45#undef EADDRINUSE
     46#undef EALREADY
     47#undef EADDRNOTAVAIL
     48#undef ECONNREFUSED
     49#undef EISCONN
     50#undef ENETUNREACH
     51#undef ENOTSOCK
     52#undef ETIMEDOUT
     53#undef EWOULDBLOCK
     54
     55#undef ENOTCONN
     56#undef ENETRESET
     57#undef EOPNOTSUPP
     58#undef EMSGSIZE
     59#undef ECONNABORTED
     60#undef ECONNRESET
     61#undef EHOSTUNREACH
     62#endif
     63
    2864/* Here we define unix socket errors as windows socket errors */
    2965
    3066#define ENETDOWN WSAENETDOWN
     
    3672#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
    3773
    3874#define EADDRINUSE WSAEADDRINUSE
    39 #define EINPROGRESS WSAEINPROGRESS
    4075#define EALREADY WSAEALREADY
    4176#define EADDRNOTAVAIL WSAEADDRNOTAVAIL
    4277#define ECONNREFUSED WSAECONNREFUSED
All information, including names and email addresses, entered onto this website or sent to mailing lists affiliated with this website will be public. Do not post confidential information, especially passwords!