events_node = purple_xmlnode_get_child_with_namespace(message_node, "x", "jabber:x:event");

if (events_node != NULL) {

if (purple_xmlnode_get_child(events_node, "id") != NULL) {

/* The user is just typing */

/* TODO: Deal with typing notification */

if(bconv->pb != NULL)

bb = purple_buddy_get_protocol_data(bconv->pb);

/* Close the socket, clear the watcher and free memory */

bonjour_jabber_close_conversation(bconv);

if(bb)

return -1;

}

return ret_port;

}

ggp_account_token *token, gpointer _register_data);

static void ggp_account_register_dialog_ok(

ggp_account_register_data *register_data, PurpleRequestFields *fields);

static void ggp_account_register_dialog_cancel(

ggp_account_register_data *register_data, PurpleRequestFields *fields);

static void ggp_account_register_response(struct gg_http *h, gboolean success,

ggp_account_register_response, register_data, TRUE);

}

static void ggp_account_register_response(struct gg_http *h, gboolean success,

gboolean cancelled, gpointer _register_data)

{

#include "utils.h"

gboolean ggp_validator_password(PurpleRequestField *field, gchar **errmsg,

void *user_data)

{

#include <internal.h>

#include <request.h>

gboolean ggp_validator_password(PurpleRequestField *field, gchar **errmsg,

void *user_data);

purple_debug(PURPLE_DEBUG_ERROR, "irc", "chat send on nonexistent chat\n");

return -EINVAL;

}

purple_markup_html_to_xhtml(purple_message_get_contents(msg), NULL, &tmp);

args[0] = purple_conversation_get_name(convo);

args[1] = tmp;

g_return_val_if_reached(NULL);

}

guchar *jabber_scram_hi(const JabberScramHash *hash, const GString *str,

GString *salt, guint iterations)

{

g_free(usi);

}

static void user_search_fields_result_cb(JabberStream *js, const char *from,

JabberIqType type, const char *id,

PurpleXmlNode *packet, gpointer data)

PurpleXmlNode *packet, gpointer data)

{

JabberChat *chat;

int chat_id = GPOINTER_TO_INT(data);

if(!(chat = jabber_chat_find_by_id(js, chat_id)))

/* defaults, in case the conference server doesn't

* support this request */

chat->xhtml = TRUE;

}

void jabber_chat_disco_traffic(JabberChat *chat)

ADD_VALUE(encryption_values, _("Require encryption"), "require_tls");

ADD_VALUE(encryption_values, _("Use encryption if available"), "opportunistic_tls");

ADD_VALUE(encryption_values, _("Use old-style SSL"), "old_ssl");

encryption_values = g_list_reverse(encryption_values);

#undef ADD_VALUE

static gboolean

jabber_process_starttls(JabberStream *js, PurpleXmlNode *packet)

{

jabber_send_raw(js,

"<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>", -1);

return TRUE;

}

void jabber_stream_features_parse(JabberStream *js, PurpleXmlNode *packet)

PurpleXmlNode *t = purple_xmlnode_get_child_with_namespace(error, "text", NS_XMPP_STANZAS);

if (t)

cdata = purple_xmlnode_get_data(t);

code = purple_xmlnode_get_attrib(error, "code");

/* Stanza errors */

g_hash_table_remove(jabber_cmds, protocol);

}

static PurpleAccount *find_acct(const char *protocol, const char *acct_id)

{

PurpleAccount *acct = NULL;

jabber_register_commands(protocol);

purple_signal_register(protocol, "jabber-register-namespace-watcher",

purple_marshal_VOID__POINTER_POINTER,

G_TYPE_NONE, 2,

g_return_if_fail(plugin_ref > 0);

purple_signals_unregister_by_instance(protocol);

jabber_unregister_commands(protocol);

--plugin_ref;

return JINGLE_TYPE_RAWUDP;

else if (purple_strequal(type, JINGLE_TRANSPORT_ICEUDP))

return JINGLE_TYPE_ICEUDP;

#ifdef USE_VV

else if (purple_strequal(type, JINGLE_APP_RTP))

return JINGLE_TYPE_RTP;

else if (!strcmp(type, NS_GOOGLE_TRANSPORT_P2P))

return JINGLE_TYPE_GOOGLE_P2P;

#endif

else

return G_TYPE_NONE;

}

static PurpleMedia *jingle_rtp_get_media(JingleSession *session);

enum {

PROP_0,

PROP_MEDIA_TYPE,

const char *slash = NULL;

const char *c;

gboolean needs_validation = FALSE;

#ifndef USE_IDN

char *node = NULL;

char *domain;

/* We're good */

break;

/*

* Hmm, this character is a bit more exotic. Better fall

* back to using the more expensive UTF-8 compliant

}

}

if (!needs_validation) {

/* JID is made of only ASCII characters--just lowercase and return */

jid = g_new0(JabberID, 1);

}

if (js->stream_id == NULL) {

/* Instead, let's make up a placeholder stream ID, which we need

* to do because we flag on it being NULL as a special case

* in this parsing code.

purple_debug_info("jabber", "Server failed to specify a stream "

"ID (underspecified in rfc3920, but intended "

"to be a MUST; digest legacy auth may fail.\n");

}

} else {

jbr->commands_fetched = TRUE;

}

out:

g_free(userdata->from);

g_free(userdata);

JabberIqType type, const char *id, PurpleXmlNode *query)

{

PurpleXmlNode *item, *group;

if (!jabber_is_own_account(js, from)) {

purple_debug_warning("jabber", "Received bogon roster push from %s\n",

}

}

if (type == JABBER_IQ_SET) {

JabberIq *ack = jabber_iq_new(js, JABBER_IQ_RESULT);

jabber_iq_set_id(ack, id);

assert_pbkdf2_equal("password", "salt", 1, "\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9\xb5\x24\xaf\x60\x12\x06\x2f\xe0\x37\xa6");

assert_pbkdf2_equal("password", "salt", 2, "\xea\x6c\x01\x4d\xc7\x2d\x6f\x8c\xcd\x1e\xd9\x2a\xce\x1d\x41\xf0\xd8\xde\x89\x57");

assert_pbkdf2_equal("password", "salt", 4096, "\x4b\x00\x79\x01\xb7\x65\x48\x9a\xbe\xad\x49\xd9\x26\xf7\x21\xd0\x65\xa4\x29\xc1");

assert_pbkdf2_equal("password", "salt", 16777216, "\xee\xfe\x3d\x61\xcd\x4d\xa4\xe4\xe9\x94\x5b\x3d\x6b\xa2\x15\x8c\x26\x34\xe9\x84");

}

static void

static void

remove_avatar_0_12_nodes(JabberStream *js)

{

/*

* This causes ejabberd 2.0.0 to kill the connection unceremoniously.

* See https://support.process-one.net/browse/EJAB-623. When adiumx.com

ADD_VALUE(encryption_values, _("Require encryption"), "require_tls");

ADD_VALUE(encryption_values, _("Use encryption if available"), "opportunistic_tls");

ADD_VALUE(encryption_values, _("Use old-style SSL"), "old_ssl");

encryption_values = g_list_reverse(encryption_values);

#undef ADD_VALUE

purple_notify_user_info_add_pair_html(user_info, tag, value);

}

tag = _("Full name");

value = nm_user_record_get_full_name(user_record);

if (value) {

tmp);

g_free(tmp);

return -1;

}

/* better make sure we're connected */

if(! purple_account_is_connected(acct)) return;

/* check if it's a NAB group for this account */

owner = purple_blist_node_get_string(node, GROUP_KEY_OWNER);

if(owner && purple_strequal(owner, purple_account_get_username(acct))) {

}

}

mwConversation_removeClientData(conv);

}

}

static GList *mw_protocol_blist_node_menu(PurpleBlistNode *node) {

GList *l = NULL;

PurpleMenuAction *act;

PURPLE_CALLBACK(blist_menu_conf), NULL, NULL);

l = g_list_append(l, act);

/** note: this never gets called for a PurpleGroup, have to use the

blist-node-extended-menu signal for that. The function

blist_node_menu_cb is assigned to this signal in the function

return;

}

}

}

}

static void st_import_action_cb(PurpleConnection *gc, char *filename) {

struct mwSametimeList *l;

}

/************************* Channel Authentication ****************************/

typedef struct {

NULL, NULL);

m = g_list_append(m, act);

if (chu) {

act = purple_menu_action_new(_("Add Private Group"),

PURPLE_CALLBACK(silcpurple_chat_prv),

}

}

/* Command reply handler. Delivers a reply to command that was sent

earlier. The `conn' is the associated client connection. The `command'

}

}

purple_notify_userinfo(gc, client_entry->nickname, user_info, NULL, NULL);

purple_notify_user_info_destroy(user_info);

}

purple_request_fields_add_group(fields, g);

g = purple_request_field_group_new(NULL);

#ifdef HAVE_SYS_UTSNAME_H

f = purple_request_field_bool_new("device",

_("Let others see what computer you are using"),

"prpl-silc", silcpurple_cmd_generic,

_("ping: Send PING to the connected server"), NULL);

cmds = g_slist_prepend(cmds, GUINT_TO_POINTER(id));

}

static void

NULL

};

static void

silcpurple_protocol_init(PurpleProtocol *protocol)

silc_log_set_callback(SILC_LOG_ERROR, silcpurple_log_error, NULL);

silcpurple_register_commands();

return TRUE;

}

guint32 flags; /* 0x00008201 */

/* guint32 flags2; */ /* unknown, used in windows messenger */

/* guint32 flags3; */

};

guint8 *

static KTEXT_ST last_authent;

#endif

Code_t ZMakeAuthentication(notice, buffer, buffer_len, len)

register ZNotice_t *notice;

char *buffer;

return(Z_RetSubs(&notice, nsubs, ZAUTH));

}

static Code_t Z_RetSubs(notice, nsubs, auth_routine)

register ZNotice_t *notice;

int *nsubs;

'ZFmtNotice.c',

'ZFmtRaw.c',

'ZFmtRawLst.c',

'ZFmtSmRaw.c',

'ZFreeNot.c',

'ZGetLocs.c',

'ZNewLocU.c',

'ZOpenPort.c',

'ZParseNot.c',

'ZPeekNot.c',

'ZPeekPkt.c',

'ZPending.c',

'ZSendList.c',

'ZSendNot.c',

'ZSendPkt.c',

'ZSetDest.c',

'ZSetFD.c',

'ZSetSrv.c',