static VALUE set_bool_setting(VALUE self, VALUE name, VALUE value)
{
PurpleAccount *account;
Data_Get_Struct(self, PurpleAccount, account);
purple_account_set_bool(account, StringValueCStr(name), RTEST(value) ? TRUE : FALSE);
return value;
}
void QuetzalAccount::load(Config cfg)
{
cfg.beginGroup(QLatin1String("general"));
QByteArray password = cfg.value(QLatin1String("passwd"), QString(), Config::Crypted).toUtf8();
if (!password.isEmpty()) {
purple_account_set_password(m_account, password.constData());
purple_account_set_remember_password(m_account, true);
}
purple_account_set_alias(m_account, cfg.value(QLatin1String("alias"),
QString()).toUtf8().constData());
purple_account_set_user_info(m_account, cfg.value(QLatin1String("userInfo"),
QString()).toUtf8().constData());
QMapIterator<QString, QVariant> it(cfg.value(QLatin1String("quetzal_settings")).toMap());
while (it.hasNext()) {
it.next();
QByteArray key = it.key().toUtf8();
QVariant::Type type = it.value().type();
if (type == QVariant::Bool) {
purple_account_set_bool(m_account, key.constData(), it.value().toBool());
} else if (type == QVariant::Int || type == QVariant::UInt
|| type == QVariant::LongLong || type == QVariant::ULongLong) {
purple_account_set_int(m_account, key.constData(), it.value().toInt());
} else {
purple_account_set_string(m_account, key.constData(), it.value().toString().toUtf8());
}
}
cfg.endGroup();
RosterStorage::instance()->load(this);
int size = cfg.beginArray(QLatin1String("chats"));
QString name = QLatin1String("name");
QString recent = QLatin1String("recent");
QString data = QLatin1String("data");
for (int i = 0; i < size; i++) {
cfg.setArrayIndex(i);
QByteArray alias = cfg.value(name, QString()).toUtf8();
PurpleGroup *group = NULL;
if (cfg.value(recent, false)) {
group = purple_find_group("Recent");
if (!group) {
group = purple_group_new("Recent");
purple_blist_add_group(group, NULL);
}
}
GHashTable *comps = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
QMapIterator<QString, QVariant> it(cfg.value(data).toMap());
while (it.hasNext()) {
it.next();
QByteArray key = it.key().toUtf8();
QByteArray value = it.value().toString().toUtf8();
g_hash_table_insert(comps, g_strdup(key.constData()), g_strdup(value.constData()));
}
PurpleChat *pc = purple_chat_new(m_account, alias.constData(), comps);
purple_blist_add_chat(pc, NULL, NULL);
}
_purple_buddy_icons_blist_loaded_cb();
}
PurpleAccount* createPurpleAccount(MojString username, MojString prpl, MojObject prefs)
{
PurplePluginProtocolInfo* info = getProtocolInfo(prpl.data());
// TODO: Strip off possible junk here!
// The Username Split API might be useful, as soon as I have
// understood it ...
PurpleAccount* account = purple_account_new(username.data(), prpl.data());
for(GList* l = info->protocol_options; l != NULL; l = l->next)
{
PurpleAccountOption* option = (PurpleAccountOption*)l->data;
const char* name = purple_account_option_get_setting(option);
if (!prefs.contains(name))
continue;
switch(purple_account_option_get_type(option))
{
case PURPLE_PREF_BOOLEAN:
{
bool value;
prefs.get(name, value);
purple_account_set_bool(account, name, value);
}
break;
case PURPLE_PREF_INT:
{
bool found;
int value;
prefs.get(name, value, found);
purple_account_set_int(account, name, value);
}
break;
case PURPLE_PREF_STRING:
case PURPLE_PREF_STRING_LIST:
{
bool found;
MojString value;
prefs.get(name, value, found);
purple_account_set_string(account, name, value.data());
}
break;
default:
continue;
}
}
return account;
}
void AccountWindow::BoolOption::onToggle(CheckBox& /*activator*/,
bool new_state)
{
if (type == TYPE_REMEMBER_PASSWORD)
purple_account_set_remember_password(account, new_state);
else if (type == TYPE_ENABLE_ACCOUNT)
purple_account_set_enabled(account, PACKAGE_NAME, new_state);
else
purple_account_set_bool(account,
purple_account_option_get_setting(option), new_state);
}
static void allow_cyrus_plaintext_auth(PurpleAccount *account)
{
PurpleConnection *gc;
JabberStream *js;
gc = purple_account_get_connection(account);
js = purple_connection_get_protocol_data(gc);
purple_account_set_bool(account, "auth_plain_in_clear", TRUE);
start_cyrus_wrapper(js);
}
/* This code should never be reinstated in it's current form. Period. See
* issue 185 for why */
static void fb_remove_buddy(PurpleConnection *pc, PurpleBuddy *buddy, PurpleGroup *group)
{
gchar *postdata;
FacebookAccount *fba = pc->proto_data;
if (atoi(buddy->name) == fba->uid)
{
purple_account_set_bool(fba->account, "facebook_hide_self", TRUE);
return;
}
postdata = g_strdup_printf("uid=%s&post_form_id=%s", buddy->name, fba->post_form_id);
fb_post_or_get(fba, FB_METHOD_POST, NULL, "/ajax/removefriend.php", postdata, NULL, NULL, FALSE);
g_free(postdata);
}
/** we fold the following methods into one set() method:
* account_set_bool
* account_set_int
* account_set_string */
static int account_set(LuaState *L)/*{{{*/
{
PurpleAccount **account = ms_lua_checkclass(L, "purple.account", 1);
const char *key = luaL_checkstring(L, 2);
switch (lua_type(L, 3)) {
case LUA_TNUMBER:
purple_account_set_int(*account, key, lua_tonumber(L, 3));
break;
case LUA_TBOOLEAN:
purple_account_set_bool(*account, key, lua_toboolean(L, 3));
case LUA_TSTRING:
purple_account_set_string(*account, key, lua_tostring(L, 3));
default:
luaL_error(L, "unsupported type for set()");
break;
}
return 0;
}/*}}}*/
/*------------------------------------------------------------------------
* Remove the stored splash-screen (if it exists).
*
* @param session The MXit session object
*/
void splash_remove(struct MXitSession* session)
{
const char* splashId = NULL;
char* filename;
/* Get current splash ID */
splashId = splash_current(session);
if (splashId != NULL) {
purple_debug_info(MXIT_PLUGIN_ID, "Removing splashId: '%s'\n", splashId);
/* Delete stored splash image */
filename = g_strdup_printf("%s" G_DIR_SEPARATOR_S "mxit" G_DIR_SEPARATOR_S "%s.png", purple_user_dir(), purple_escape_filename(splashId));
g_unlink(filename);
g_free(filename);
/* Clear current splash ID from settings */
purple_account_set_string(session->acc, MXIT_CONFIG_SPLASHID, "");
purple_account_set_bool(session->acc, MXIT_CONFIG_SPLASHCLICK, FALSE);
}
}
static void purple_sync_settings( account_t *acc, PurpleAccount *pa )
{
PurplePlugin *prpl = purple_plugins_find_with_id( pa->protocol_id );
PurplePluginProtocolInfo *pi = prpl->info->extra_info;
GList *i;
for( i = pi->protocol_options; i; i = i->next )
{
PurpleAccountOption *o = i->data;
const char *name;
set_t *s;
name = purple_account_option_get_setting( o );
s = set_find( &acc->set, name );
if( s->value == NULL )
continue;
switch( purple_account_option_get_type( o ) )
{
case PURPLE_PREF_STRING:
case PURPLE_PREF_STRING_LIST:
purple_account_set_string( pa, name, set_getstr( &acc->set, name ) );
break;
case PURPLE_PREF_INT:
purple_account_set_int( pa, name, set_getint( &acc->set, name ) );
break;
case PURPLE_PREF_BOOLEAN:
purple_account_set_bool( pa, name, set_getbool( &acc->set, name ) );
break;
default:
break;
}
}
if( pi->options & OPT_PROTO_MAIL_CHECK )
purple_account_set_check_mail( pa, set_getbool( &acc->set, "mail_notifications" ) );
}
/*------------------------------------------------------------------------
* Save a new splash-screen for later display.
*
* @param session The MXit session object
* @param splashID The ID of the splash-screen
* @param data Splash-screen image data (PNG format)
* @param datalen Splash-screen image data size
*/
void splash_update(struct MXitSession* session, const char* splashId, const char* data, unsigned int datalen, gboolean clickable)
{
char* dir;
char* filename;
/* Remove the current splash-screen */
splash_remove(session);
/* Save the new splash image */
dir = g_strdup_printf("%s" G_DIR_SEPARATOR_S "mxit", purple_user_dir());
purple_build_dir(dir, S_IRUSR | S_IWUSR | S_IXUSR); /* ensure directory exists */
filename = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s.png", dir, purple_escape_filename(splashId));
if (purple_util_write_data_to_file_absolute(filename, data, datalen)) {
/* Store new splash-screen ID to settings */
purple_account_set_string(session->acc, MXIT_CONFIG_SPLASHID, splashId);
purple_account_set_bool(session->acc, MXIT_CONFIG_SPLASHCLICK, clickable );
}
g_free(dir);
g_free(filename);
}
void fb_add_buddy(PurpleConnection *pc, PurpleBuddy *buddy, PurpleGroup *group)
{
gchar *postdata;
FacebookAccount *fba = pc->proto_data;
gchar *buddy_tmp;
if (!purple_account_get_bool(
fba->account, "facebook_manage_friends", FALSE)) {
/*
* We used to pop up dialogs here but if a user renamed a group,
* this would spawn message for each person in the buddy list. Bad!
purple_notify_info(fba->pc, _("Friend not added"),
_("Adding Facebook friends via Pidgin is disabled"),
_("Either add a friend via Facebook.com or edit your account preferences"));
*/
purple_debug_warning("facebook", "attempted to add %s but was blocked\n", buddy->name);
return;
}
if (atoll(buddy->name) == fba->uid)
{
purple_account_set_bool(fba->account,
"facebook_hide_self", FALSE);
return;
}
buddy_tmp = g_strdup(purple_url_encode(buddy->name));
postdata = g_strdup_printf(
"user=%" G_GINT64_FORMAT "&profile_id=%s&message=&"
"source=&submit=1&post_form_id=%s&fb_dtsg=%s&"
"post_form_id_source=AsyncRequest&__a=1",
fba->uid, buddy_tmp, fba->post_form_id, fba->dtsg);
g_free(buddy_tmp);
fb_post_or_get(fba, FB_METHOD_POST, NULL, "/ajax/profile/connect.php",
postdata, NULL, NULL, FALSE);
g_free(postdata);
}
void fb_add_buddy(PurpleConnection *pc, PurpleBuddy *buddy, PurpleGroup *group)
{
gchar *postdata;
gchar *url;
FacebookAccount *fba = pc->proto_data;
gchar *buddy_tmp;
if (!purple_account_get_bool(
fba->account, "facebook_manage_friends", FALSE)) {
purple_notify_info(fba->pc, _("Friend not added"),
_("Adding Facebook friends via Pidgin is disabled"),
_("Either add a friend via Facebook.com or edit your account preferences"));
// TODO: Message here
return;
}
if (atoi(buddy->name) == fba->uid)
{
purple_account_set_bool(fba->account,
"facebook_hide_self", FALSE);
return;
}
buddy_tmp = g_strdup(purple_url_encode(buddy->name));
postdata = g_strdup_printf(
"confirmed=1&add=Add+Friend&action=follow_up&uid=%s&flids=&flid_name=&source=search&is_from_whitelist=0&message=&failed_captcha=0&post_form_id=%s",
buddy_tmp, fba->post_form_id);
url = g_strdup_printf("/ajax/addfriend.php?id=%s", buddy_tmp);
g_free(buddy_tmp);
fb_post_or_get(fba, FB_METHOD_POST, NULL, url, postdata,
NULL, NULL, FALSE);
g_free(postdata);
g_free(url);
}
/*
* ssl_cdsa_handshake_cb
*/
static void
ssl_cdsa_handshake_cb(gpointer data, gint source, PurpleInputCondition cond)
{
PurpleSslConnection *gsc = (PurpleSslConnection *)data;
PurpleAccount *account = gsc->account;
PurpleSslCDSAData *cdsa_data = PURPLE_SSL_CDSA_DATA(gsc);
OSStatus err;
purple_debug_info("cdsa", "Connecting\n");
/*
* do the negotiation that sets up the SSL connection between
* here and there.
*/
err = SSLHandshake(cdsa_data->ssl_ctx);
if (err == errSSLPeerBadRecordMac
&& !purple_account_get_bool(account, PURPLE_SSL_CDSA_BUGGY_TLS_WORKAROUND, false)
&& !strcmp(purple_account_get_protocol_id(account),"prpl-jabber")) {
/*
* Set a flag so we know to explicitly disable TLS 1.1 and 1.2 on our next (immediate) connection attempt for this account.
* Some XMPP servers use buggy TLS stacks that incorrectly report their capabilities, which breaks things with 10.8's new support
* for TLS 1.1 and 1.2.
*/
purple_debug_info("cdsa", "SSLHandshake reported that the server rejected our MAC, which most likely means it lied about the TLS versions it supports.");
purple_debug_info("cdsa", "Setting a flag in this account to only use TLS 1.0 and below on the next connection attempt.");
purple_account_set_bool(account, PURPLE_SSL_CDSA_BUGGY_TLS_WORKAROUND, true);
if (gsc->error_cb != NULL)
gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED, gsc->connect_cb_data);
purple_ssl_close(gsc);
return;
} else if (err != noErr) {
if(err == errSSLWouldBlock)
return;
fprintf(stderr,"cdsa: SSLHandshake failed with error %d\n",(int)err);
purple_debug_error("cdsa", "SSLHandshake failed with error %d\n",(int)err);
if (gsc->error_cb != NULL)
gsc->error_cb(gsc, PURPLE_SSL_HANDSHAKE_FAILED,
gsc->connect_cb_data);
purple_ssl_close(gsc);
return;
}
SSLCipherSuite cipher;
SSLProtocol protocol;
err = SSLGetNegotiatedCipher(cdsa_data->ssl_ctx, &cipher);
if (err == noErr) {
err = SSLGetNegotiatedProtocolVersion(cdsa_data->ssl_ctx, &protocol);
purple_debug_info("cdsa", "Your connection is using %s with %s encryption, using %s for message authentication and %s key exchange (%X).\n",
SSLVersionToString(protocol),
SSLCipherName(cipher),
SSLMACName(cipher),
SSLKeyExchangeName(cipher),
cipher);
}
purple_input_remove(cdsa_data->handshake_handler);
cdsa_data->handshake_handler = 0;
purple_debug_info("cdsa", "SSL_connect: verifying certificate\n");
if(certificate_ui_cb) { // does the application want to verify the certificate?
struct query_cert_userdata *userdata = (struct query_cert_userdata*)malloc(sizeof(struct query_cert_userdata));
size_t hostnamelen = 0;
SSLGetPeerDomainNameLength(cdsa_data->ssl_ctx, &hostnamelen);
userdata->hostname = (char*)malloc(hostnamelen+1);
SSLGetPeerDomainName(cdsa_data->ssl_ctx, userdata->hostname, &hostnamelen);
userdata->hostname[hostnamelen] = '\0'; // just make sure it's zero-terminated
userdata->cond = cond;
userdata->gsc = gsc;
SSLCopyPeerCertificates(cdsa_data->ssl_ctx, &userdata->certs);
certificate_ui_cb(gsc, userdata->hostname, userdata->certs, query_cert_result, userdata);
} else {
purple_debug_info("cdsa", "SSL_connect complete (did not verify certificate)\n");
/* SSL connected now */
gsc->connect_cb(gsc->connect_cb_data, gsc, cond);
}
SSLCipherSuite suite;
SSLGetNegotiatedCipher(cdsa_data->ssl_ctx, &suite);
purple_debug_info("cdsa", "Using cipher %x.\n", suite);
}
