option = purple_account_option_bool_new(_("Use SSL"), "ssl", FALSE);

opts = g_list_append(opts, option);

option = purple_account_option_bool_new(_("Authenticate with SASL"),

"sasl", FALSE);

opts = g_list_append(opts, option);

"unencrypted connection"),

"auth_plain_in_clear", FALSE);

opts = g_list_append(opts, option);

return opts;

}

const char *nickname, *identname, *realname;

struct irc_conn *irc = purple_connection_get_protocol_data(gc);

const char *pass = purple_connection_get_password(gc);

const gboolean use_sasl = purple_account_get_bool(irc->account, "sasl", FALSE);

if (pass && *pass) {

if (use_sasl)

buf = irc_format(irc, "vv:", "CAP", "REQ", "sasl");

buf = irc_format(irc, "v:", "PASS", pass);

if (irc_send(irc, buf) < 0) {

g_free(buf);

g_free(irc->mode_chars);

g_free(irc->reqnick);

if (irc->sasl_conn) {

sasl_dispose(&irc->sasl_conn);

irc->sasl_conn = NULL;

g_free(irc->sasl_cb);

if(irc->sasl_mechs)

g_string_free(irc->sasl_mechs, TRUE);

g_free(irc);

#include <config.h>

#include <sasl/sasl.h>

#include <purple.h>

char *mode_chars;

char *reqnick;

gboolean nickused;

sasl_conn_t *sasl_conn;

const char *current_mech;

GString *sasl_mechs;

gboolean mech_works;

sasl_callback_t *sasl_cb;

};

struct irc_buddy {

void irc_msg_wallops(struct irc_conn *irc, const char *name, const char *from, char **args);

void irc_msg_whois(struct irc_conn *irc, const char *name, const char *from, char **args);

void irc_msg_who(struct irc_conn *irc, const char *name, const char *from, char **args);

void irc_msg_cap(struct irc_conn *irc, const char *name, const char *from, char **args);

void irc_msg_auth(struct irc_conn *irc, char *arg);

void irc_msg_authenticate(struct irc_conn *irc, const char *name, const char *from, char **args);

void irc_msg_authok(struct irc_conn *irc, const char *name, const char *from, char **args);

void irc_msg_authtryagain(struct irc_conn *irc, const char *name, const char *from, char **args);

void irc_msg_authfail(struct irc_conn *irc, const char *name, const char *from, char **args);

void irc_cmd_table_build(struct irc_conn *irc);

#include <stdio.h>

#include <stdlib.h>

#include <sasl/sasl.h>

static char *irc_mask_nick(const char *mask);

static char *irc_mask_userhost(const char *mask);

const char *from, const char *to,

const char *rawmsg, gboolean notice);

static void irc_sasl_finish(struct irc_conn *irc);

static char *irc_mask_nick(const char *mask)

{

g_free(msg);

}

static int

irc_sasl_cb_secret(sasl_conn_t *conn, void *ctx, int id, sasl_secret_t **secret)

{

irc_send(irc, buf);

g_free(buf);

}

{ "501", "n:", 2, irc_msg_badmode }, /* Unknown mode flag */

{ "506", "nc:", 3, irc_msg_nosend }, /* Must identify to send */

{ "515", "nc:", 3, irc_msg_regonly }, /* Registration required */

{ "903", "*", 0, irc_msg_authok}, /* SASL auth successful */

{ "904", "*", 0, irc_msg_authtryagain }, /* SASL auth failed, can recover*/

{ "905", "*", 0, irc_msg_authfail }, /* SASL auth failed */

{ "907", "*", 0, irc_msg_authfail }, /* SASL auth failed */

{ "cap", "vv:", 3, irc_msg_cap }, /* SASL capable */

{ "authenticate", ":", 1, irc_msg_authenticate }, /* SASL authenticate */

{ "invite", "n:", 2, irc_msg_invite }, /* Invited */

{ "join", ":", 1, irc_msg_join }, /* Joined a channel */

{ "kick", "cn:", 3, irc_msg_kick }, /* KICK */

}

purple_connection_take_error(gc, error);

return;

} else if (!strncmp(input, "AUTHENTICATE ", 13)) {

irc_msg_auth(irc, input + 13);

return;

}

if (input[0] != ':' || (cur = strchr(input, ' ')) == NULL) {

_("Server requires plaintext authentication over an unencrypted stream"));

}

static void

auth_old_pass_cb(PurpleConnection *gc, PurpleRequestFields *fields)

{

/* Disable the account as the user has cancelled connecting */

purple_account_set_enabled(purple_connection_get_account(gc), FALSE);

}

void

jabber_auth_start(JabberStream *js, PurpleXmlNode *packet)

js->user->resource = g_strdup("Home");

}

*/

if (!purple_connection_get_password(js->gc)) {

purple_account_request_password(account, G_CALLBACK(auth_old_pass_cb), G_CALLBACK(auth_no_pass_cb), js->gc);

return;

}

iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:auth");

query = purple_xmlnode_get_child(iq->node, "query");

jabber_auth_add_mech(jabber_auth_get_plain_mech());

jabber_auth_add_mech(jabber_auth_get_digest_md5_mech());

jabber_auth_add_mech(jabber_auth_get_cyrus_mech());

#ifdef HAVE_WEBEX_TOKEN

jabber_auth_add_mech(jabber_auth_get_webex_token_mech());

#endif

JabberSaslMech *jabber_auth_get_plain_mech(void);

JabberSaslMech *jabber_auth_get_digest_md5_mech(void);

JabberSaslMech **jabber_auth_get_scram_mechs(gint *count);

JabberSaslMech *jabber_auth_get_cyrus_mech(void);

JabberSaslMech *jabber_auth_get_webex_token_mech(void);

void jabber_auth_add_mech(JabberSaslMech *);

/* If we've got a security layer, we need to encode the data,

* splitting it on the maximum buffer length negotiated */

if (js->sasl_maxbuf>0) {

int pos = 0;

}

return;

}

if (js->bosh)

jabber_bosh_connection_send(js->bosh, data);

}

purple_connection_update_last_received(gc);

if (js->sasl_maxbuf > 0) {

const char *out;

unsigned int olen;

}

return G_SOURCE_CONTINUE;

}

buf[len] = '\0';

purple_debug_misc("jabber", "Recv (%" G_GSSIZE_FORMAT "): %s", len,

buf);

if (js->auth_mech && js->auth_mech->dispose)

js->auth_mech->dispose(js);

if(js->sasl)

sasl_dispose(&js->sasl);

if(js->sasl_mechs)

/* Note: _not_ g_free. See auth_cyrus.c:jabber_sasl_cb_secret */

free(js->sasl_secret);

g_free(js->sasl_password);

g_free(js->serverFQDN);

g_list_free_full(js->commands, (GDestroyNotify)jabber_adhoc_commands_free);

g_free(js->server_name);

const gchar *type = "pc"; /* default client type, if unknown or

unspecified */

const gchar *ui_name = NULL;

/* We really really only want to do this once per process */

static gboolean sasl_initialized = FALSE;

#ifdef _WIN32

gchar *sasldir;

#endif

int ret;

/* XXX - If any other plugin wants SASL this won't be good ... */

if (!sasl_initialized) {

sasl_initialized = TRUE;

#ifdef _WIN32

SetErrorMode(old_error_mode);

#endif

}

jabber_cmds = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, cmds_free_func);

#include "buddy.h"

#include "bosh.h"

#include <sasl/sasl.h>

#define CAPS0115_NODE "https://pidgin.im/"

char *serverFQDN;

sasl_conn_t *sasl;

sasl_callback_t *sasl_cb;

sasl_secret_t *sasl_secret;

GString *sasl_mechs;

gchar *sasl_password;

gboolean unregistration;

PurpleAccountUnregistrationCb unregistration_cb;

PurpleProtocolOptions options;

options = OPT_PROTO_CHAT_TOPIC | OPT_PROTO_UNIQUE_CHATNAME |

return PURPLE_PROTOCOL(g_object_new(

XMPP_TYPE_PROTOCOL,

conf.set('HAVE_' + func.to_upper(),

compiler.has_function(func))

endforeach

#######################################################################

# Check for external libzephyr

option('avahi', type : 'feature',

description : 'compile with avahi (required for Bonjour support)')

option('dynamic-prpls', type : 'string', value: 'all',

description : 'specify which protocols to build dynamically')