PurpleUtilFetchUrlData * http_get_friend_list(NPSession *session,PurpleUtilFetchUrlCallback callback) { PurpleUtilFetchUrlData *url_data; PurpleAccount *account; gchar *cookies; account = session->account; cookies = np_session_get_encoded_cookie(session); const char *http_server = purple_account_get_string(session->account, "http_method_server", NP_HTTPCONN_SERVER); const char *_ua = purple_account_get_string(session->account, "np_user_agent", NP_USER_AGENT); char *friend_list_url = g_strdup_printf("%s/%s",http_server,NP_FRIEND_LIST_PATH); purple_debug_info("np", "friendListURL: %s",friend_list_url); gchar *content = g_strdup_printf("_ua=%s",_ua,NULL); url_data = np_util_post_url2(friend_list_url, content,cookies, FALSE , callback, session); g_free(content); return url_data; }
const gchar *twitter_option_search_api_subdir(PurpleAccount * account) { if (!strcmp(purple_account_get_protocol_id(account), TWITTER_PROTOCOL_ID)) { return twitter_get_subdir_from_base(purple_account_get_string(account, TWITTER_PREF_SEARCH_API_BASE, TWITTER_PREF_SEARCH_API_BASE_DEFAULT)); } else { return twitter_get_subdir_from_base(purple_account_get_string(account, TWITTER_PREF_SEARCH_API_BASE, STATUSNET_PREF_API_BASE_DEFAULT)); } }
gboolean fb_data_load(FbData *fata) { const gchar *str; FbDataPrivate *priv; FbId id; gboolean ret = TRUE; guint i; guint64 uint; GValue val = G_VALUE_INIT; PurpleAccount *acct; g_return_val_if_fail(FB_IS_DATA(fata), FALSE); priv = fata->priv; acct = purple_connection_get_account(priv->gc); for (i = 0; i < G_N_ELEMENTS(fb_props_strs); i++) { str = purple_account_get_string(acct, fb_props_strs[i], NULL); if (str == NULL) { ret = FALSE; } g_value_init(&val, G_TYPE_STRING); g_value_set_string(&val, str); g_object_set_property(G_OBJECT(priv->api), fb_props_strs[i], &val); g_value_unset(&val); } str = purple_account_get_string(acct, "mid", NULL); if (str != NULL) { uint = g_ascii_strtoull(str, NULL, 10); g_value_init(&val, G_TYPE_UINT64); g_value_set_uint64(&val, uint); g_object_set_property(G_OBJECT(priv->api), "mid", &val); g_value_unset(&val); } else { ret = FALSE; } str = purple_account_get_string(acct, "uid", NULL); if (str != NULL) { id = FB_ID_FROM_STR(str); g_value_init(&val, FB_TYPE_ID); g_value_set_int64(&val, id); g_object_set_property(G_OBJECT(priv->api), "uid", &val); g_value_unset(&val); } else { ret = FALSE; } fb_api_rehash(priv->api); return ret; }
void IdenticaProtocol::onDestroy(User *user) { PurpleAccount *account = user->account(); if (account == NULL) return; user->updateSetting<std::string>("twitter_oauth_secret", purple_account_get_string(account, "twitter_oauth_secret", "")); user->updateSetting<std::string>("twitter_oauth_token", purple_account_get_string(account, "twitter_oauth_token", "")); user->updateSetting<std::string>("twitter_sent_msg_ids", purple_account_get_string(account, "twitter_sent_msg_ids", "")); user->updateSetting<std::string>("twitter_last_msg_id", purple_account_get_string(account, "twitter_last_msg_id", "")); }
void flist_update_server_status(FListAccount *fla) { JsonObject *json = json_object_new(); const gchar *status = purple_account_get_string(fla->pa, "_status", "online"); const gchar *status_message = purple_account_get_string(fla->pa, "_status_message", ""); json_object_set_string_member(json, "status", status); json_object_set_string_member(json, "statusmsg", status_message); flist_request(fla->pc, FLIST_SET_STATUS, json); json_object_unref(json); }
static gboolean do_login(PurpleConnection *gc) { char *buf, *tmp = NULL; char hostname[256]; const char *username, *realname; struct irc_conn *irc = gc->proto_data; const char *pass = purple_connection_get_password(gc); if (pass && *pass) { buf = irc_format(irc, "vv", "PASS", pass); if (irc_send(irc, buf) < 0) { /* purple_connection_error(gc, "Error sending password"); */ g_free(buf); return FALSE; } g_free(buf); } gethostname(hostname, sizeof(hostname)); hostname[sizeof(hostname) - 1] = '\0'; realname = purple_account_get_string(irc->account, "realname", ""); username = purple_account_get_string(irc->account, "username", ""); if (username == NULL || *username == '\0') { username = g_get_user_name(); } if (username != NULL && strchr(username, ' ') != NULL) { tmp = g_strdup(username); while ((buf = strchr(tmp, ' ')) != NULL) { *buf = '_'; } } buf = irc_format(irc, "vvvv:", "USER", tmp ? tmp : username, hostname, irc->server, strlen(realname) ? realname : IRC_DEFAULT_ALIAS); g_free(tmp); if (irc_send(irc, buf) < 0) { /* purple_connection_error(gc, "Error registering with server");*/ g_free(buf); return FALSE; } g_free(buf); buf = irc_format(irc, "vn", "NICK", purple_connection_get_display_name(gc)); if (irc_send(irc, buf) < 0) { /* purple_connection_error(gc, "Error sending nickname");*/ g_free(buf); return FALSE; } g_free(buf); irc->recv_time = time(NULL); return TRUE; }
static GString *purple_fbapi_construct_request_vargs(PurpleAccount *account, const char *method, va_list args) { GTree *params; const char *api_key, *api_secret; const char *key, *value; char call_id[21]; char *signature; GString *body; /* Read all paramters into a sorted tree */ params = g_tree_new((GCompareFunc)strcmp); while ((key = va_arg(args, const char *)) != NULL) { value = va_arg(args, const char *); g_tree_insert(params, (char *)key, (char *)value); /* If we have a session_key then we need a call_id */ if (g_str_equal(key, "session_key")) { struct timeval tv; if (gettimeofday(&tv, NULL) != 0) { time_t now; purple_debug_error("fbapi", "Error calling gettimeofday(): %s\n", g_strerror(errno)); now = time(NULL); strftime(call_id, sizeof(call_id), "%s000000", localtime(&now)); } else { char tmp[22]; strftime(tmp, sizeof(tmp), "%s", localtime(&tv.tv_sec)); sprintf(call_id, "%s%06lu", tmp, (long unsigned int)tv.tv_usec); } g_tree_insert(params, "call_id", call_id); } } api_key = purple_account_get_string(account, "fb_api_key", PURPLE_FBAPI_KEY); api_secret = purple_account_get_string(account, "fb_api_secret", API_SECRET); /* Add the method and api_key parameters to the list */ g_tree_insert(params, "method", (char *)method); g_tree_insert(params, "api_key", (char *)api_key); /* Add the signature parameter to the list */ signature = generate_signature((char *)api_secret, params); g_tree_insert(params, "sig", signature); /* Construct the body of the HTTP POST request */ body = g_string_new(NULL); g_tree_foreach(params, append_params_to_body, body); g_tree_destroy(params); g_free(signature); return body; }
static void waprpl_login(PurpleAccount * acct) { PurpleConnection *gc = purple_account_get_connection(acct); purple_debug_info(WHATSAPP_ID, "logging in %s\n", purple_account_get_username(acct)); purple_connection_update_progress(gc, "Connecting", 0, 4); whatsapp_connection *wconn = g_new0(whatsapp_connection, 1); wconn->fd = -1; wconn->sslfd = -1; wconn->account = acct; wconn->rh = 0; wconn->wh = 0; wconn->timer = 0; wconn->connected = 0; wconn->conv_id = 1; wconn->gsc = 0; wconn->sslrh = 0; wconn->sslwh = 0; const char *username = purple_account_get_username(acct); const char *password = purple_account_get_password(acct); const char *nickname = purple_account_get_string(acct, "nick", ""); wconn->waAPI = waAPI_create(username, password, nickname); purple_connection_set_protocol_data(gc, wconn); const char *hostname = purple_account_get_string(acct, "server", ""); int port = purple_account_get_int(acct, "port", WHATSAPP_DEFAULT_PORT); char hn[256]; if (strlen(hostname) == 0) { sprintf(hn, "e%d.whatsapp.net", rand() % 9 + 1); hostname = hn; } if (purple_proxy_connect(gc, acct, hostname, port, waprpl_connect_cb, gc) == NULL) { purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, "Unable to connect"); } static int sig_con = 0; if (!sig_con) { sig_con = 1; purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", _whatsapp_protocol, PURPLE_CALLBACK(waprpl_blist_node_removed), NULL); purple_signal_connect(purple_blist_get_handle(), "blist-node-added", _whatsapp_protocol, PURPLE_CALLBACK(waprpl_blist_node_added), NULL); } }
PurpleStoredImage * purple_buddy_icons_set_account_icon(PurpleAccount *account, guchar *icon_data, size_t icon_len) { PurpleStoredImage *old_img; PurpleStoredImage *img = NULL; char *old_icon; if (icon_data != NULL && icon_len > 0) { img = purple_buddy_icon_data_new(icon_data, icon_len, NULL); } old_icon = g_strdup(purple_account_get_string(account, "buddy_icon", NULL)); if (img && purple_buddy_icons_is_caching()) { const char *filename = purple_imgstore_get_filename(img); purple_account_set_string(account, "buddy_icon", filename); purple_account_set_int(account, "buddy_icon_timestamp", time(NULL)); ref_filename(filename); } else { purple_account_set_string(account, "buddy_icon", NULL); purple_account_set_int(account, "buddy_icon_timestamp", 0); } unref_filename(old_icon); old_img = g_hash_table_lookup(pointer_icon_cache, account); if (img) g_hash_table_insert(pointer_icon_cache, account, img); else g_hash_table_remove(pointer_icon_cache, account); if (purple_account_is_connected(account)) { PurpleConnection *gc; PurplePluginProtocolInfo *prpl_info; gc = purple_account_get_connection(account); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(purple_connection_get_prpl(gc)); if (prpl_info && prpl_info->set_buddy_icon) prpl_info->set_buddy_icon(gc, img); } if (old_img) purple_imgstore_unref(old_img); else if (old_icon) { /* The old icon may not have been loaded into memory. In that * case, we'll need to uncache the filename. The filenames * are ref-counted, so this is safe. */ purple_buddy_icon_data_uncache_file(old_icon); } g_free(old_icon); return img; }
PurpleStoredImage * purple_buddy_icons_find_account_icon(PurpleAccount *account) { PurpleStoredImage *img; const char *account_icon_file; const char *dirname; char *path; guchar *data; size_t len; g_return_val_if_fail(account != NULL, NULL); if ((img = g_hash_table_lookup(pointer_icon_cache, account))) { return purple_imgstore_ref(img); } account_icon_file = purple_account_get_string(account, "buddy_icon", NULL); if (account_icon_file == NULL) return NULL; dirname = purple_buddy_icons_get_cache_dir(); path = g_build_filename(dirname, account_icon_file, NULL); if (read_icon_file(path, &data, &len)) { g_free(path); img = purple_buddy_icons_set_account_icon(account, data, len); return purple_imgstore_ref(img); } g_free(path); return NULL; }
void silcpurple_idle_set(PurpleConnection *gc, int idle) { SilcPurple sg; SilcClient client; SilcClientConnection conn; SilcAttributeObjService service; const char *server; int port; sg = gc->proto_data; if (sg == NULL) return; client = sg->client; if (client == NULL) return; conn = sg->conn; if (conn == NULL) return; server = purple_account_get_string(sg->account, "server", "silc.silcnet.org"); port = purple_account_get_int(sg->account, "port", 706), memset(&service, 0, sizeof(service)); silc_client_attribute_del(client, conn, SILC_ATTRIBUTE_SERVICE, NULL); service.port = port; g_snprintf(service.address, sizeof(service.address), "%s", server); service.idle = idle; silc_client_attribute_add(client, conn, SILC_ATTRIBUTE_SERVICE, &service, sizeof(service)); }
static int waprpl_send_chat(PurpleConnection * gc, int id, const char *message, PurpleMessageFlags flags) { whatsapp_connection *wconn = purple_connection_get_protocol_data(gc); PurpleAccount *account = purple_connection_get_account(gc); PurpleConversation *convo = purple_find_chat(gc, id); PurpleChat *ch = blist_find_chat_by_convo(gc, id); GHashTable *hasht = purple_chat_get_components(ch); char *chat_id = g_hash_table_lookup(hasht, "id"); char *plain; purple_markup_html_to_xhtml(message, NULL, &plain); char msgid[128]; waAPI_getmsgid(wconn->waAPI, msgid); purple_signal_emit(purple_connection_get_prpl(gc), "whatsapp-sending-message", gc, msgid, chat_id, message); waAPI_sendchat(wconn->waAPI, msgid, chat_id, plain); g_free(plain); waprpl_check_output(gc); const char *me = purple_account_get_string(account, "nick", ""); purple_conv_chat_write(PURPLE_CONV_CHAT(convo), me, message, PURPLE_MESSAGE_SEND, time(NULL)); return 1; }
AccountWindow::StringListOption::StringListOption(PurpleAccount *account_, PurpleAccountOption *option_) : account(account_), option(option_) { g_assert(account); g_assert(option); setText(purple_account_option_get_text(option)); const char *def = purple_account_get_string(account, purple_account_option_get_setting(option), purple_account_option_get_default_list_value(option)); for (GList *l = purple_account_option_get_list(option); l; l = l->next) if (l->data) { PurpleKeyValuePair *kvp = reinterpret_cast<PurpleKeyValuePair*>( l->data); addOptionPtr(kvp->key, kvp->value); if (kvp->value && def && !strcmp(def, reinterpret_cast<const char*>(kvp->value))) setSelectedByDataPtr(kvp->value); } signal_selection_changed.connect(sigc::mem_fun(this, &StringListOption::onSelectionChanged)); }
static char *gaym_send_convert(struct gaym_conn *gaym, const char *string) { char *utf8; GError *err = NULL; const gchar *charset; charset = purple_account_get_string(gaym->account, "encoding", IRC_DEFAULT_CHARSET); if (!strcasecmp("UTF-8", charset)) return g_strdup(string); utf8 = g_convert(string, strlen(string), charset, "UTF-8", NULL, NULL, &err); if (err) { purple_debug(PURPLE_DEBUG_ERROR, "gaym", "Send conversion error: %s\n", err->message); purple_debug(PURPLE_DEBUG_ERROR, "gaym", "Sending as UTF-8 instead of %s\n", charset); utf8 = g_strdup(string); g_error_free(err); } return utf8; }
static VALUE get_string_setting(VALUE self, VALUE name, VALUE default_value) { PurpleAccount *account; Data_Get_Struct(self, PurpleAccount, account); const char* value = purple_account_get_string(account, RSTRING_PTR(name), RSTRING_PTR(default_value)); return (NULL == value) ? Qnil : rb_str_new2(value); }
static char *irc_send_convert(struct irc_conn *irc, const char *string) { char *utf8; GError *err = NULL; gchar **encodings; const gchar *enclist; enclist = purple_account_get_string(irc->account, "encoding", IRC_DEFAULT_CHARSET); encodings = g_strsplit(enclist, ",", 2); if (encodings[0] == NULL || !g_ascii_strcasecmp("UTF-8", encodings[0])) { g_strfreev(encodings); return NULL; } utf8 = g_convert(string, strlen(string), encodings[0], "UTF-8", NULL, NULL, &err); if (err) { purple_debug(PURPLE_DEBUG_ERROR, "irc", "Send conversion error: %s\n", err->message); purple_debug(PURPLE_DEBUG_ERROR, "irc", "Sending as UTF-8 instead of %s\n", encodings[0]); utf8 = g_strdup(string); g_error_free(err); } g_strfreev(encodings); return utf8; }
static char *gaym_recv_convert(struct gaym_conn *gaym, const char *string) { char *utf8 = NULL; GError *err = NULL; const gchar *charset; charset = purple_account_get_string(gaym->account, "encoding", IRC_DEFAULT_CHARSET); if (!strcasecmp("UTF-8", charset)) { if (g_utf8_validate(string, strlen(string), NULL)) utf8 = g_strdup(string); } else { utf8 = g_convert(string, strlen(string), "UTF-8", charset, NULL, NULL, &err); } if (err) { purple_debug(PURPLE_DEBUG_ERROR, "gaym", "recv conversion error: %s\n", err->message); g_error_free(err); } if (utf8 == NULL) utf8 = g_strdup(_ ("(There was an error converting this message. Check the 'Encoding' option in the Account Editor)")); return utf8; }
static void server_list_create(PurpleAccount *account) { PurpleConnection *gc; qq_data *qd; const gchar *custom_server; gc = purple_account_get_connection(account); g_return_if_fail(gc != NULL && gc->proto_data != NULL); qd = gc->proto_data; qd->use_tcp = purple_account_get_bool(account, "use_tcp", TRUE); custom_server = purple_account_get_string(account, "server", NULL); if (custom_server != NULL) { purple_debug_info("QQ", "Select server '%s'\n", custom_server); if (*custom_server != '\0' && g_ascii_strcasecmp(custom_server, "auto") != 0) { qd->servers = g_list_append(qd->servers, g_strdup(custom_server)); return; } } if (qd->use_tcp) { qd->servers = server_list_build('T'); return; } qd->servers = server_list_build('U'); }
static void yahoo_xfer_init(PurpleXfer *xfer) { struct yahoo_xfer_data *xfer_data; PurpleConnection *gc; PurpleAccount *account; struct yahoo_data *yd; xfer_data = xfer->data; gc = xfer_data->gc; yd = gc->proto_data; account = purple_connection_get_account(gc); if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) { if (yd->jp) { if (purple_proxy_connect(NULL, account, purple_account_get_string(account, "xferjp_host", YAHOOJP_XFER_HOST), purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT), yahoo_sendfile_connected, xfer) == NULL) { purple_notify_error(gc, NULL, _("File Transfer Failed"), _("Unable to establish file descriptor.")); purple_xfer_cancel_remote(xfer); } } else { if (purple_proxy_connect(NULL, account, purple_account_get_string(account, "xfer_host", YAHOO_XFER_HOST), purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT), yahoo_sendfile_connected, xfer) == NULL) { purple_notify_error(gc, NULL, _("File Transfer Failed"), _("Unable to establish file descriptor.")); purple_xfer_cancel_remote(xfer); } } } else { /* TODO: Using xfer->fd like this is probably a bad thing... */ if (purple_proxy_connect(NULL, account, xfer_data->host, xfer_data->port, yahoo_receivefile_connected, xfer) == NULL) xfer->fd = -1; else xfer->fd = 0; if (xfer->fd == -1) { purple_notify_error(gc, NULL, _("File Transfer Failed"), _("Unable to establish file descriptor.")); purple_xfer_cancel_remote(xfer); } } }
void jabber_auth_start_old(JabberStream *js) { PurpleAccount *account; JabberIq *iq; PurpleXmlNode *query, *username; account = purple_connection_get_account(js->gc); /* * We can end up here without encryption if the server doesn't support * <stream:features/> and we're not using old-style SSL. If the user * is requiring SSL/TLS, we need to enforce it. */ if (!jabber_stream_is_ssl(js) && g_str_equal("require_tls", purple_account_get_string(account, "connection_security", JABBER_DEFAULT_REQUIRE_TLS))) { purple_connection_error(js->gc, PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR, _("You require encryption, but it is not available on this server.")); return; } if (js->registration) { jabber_register_start(js); return; } /* * IQ Auth doesn't have support for resource binding, so we need to pick a * default resource so it will work properly. jabberd14 throws an error and * iChat server just fails silently. */ if (!js->user->resource || *js->user->resource == '\0') { g_free(js->user->resource); js->user->resource = g_strdup("Home"); } #ifdef HAVE_CYRUS_SASL /* If we have Cyrus SASL, then passwords will have been set * to OPTIONAL for this protocol. So, we need to do our own * password prompting here */ 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; } #endif iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:auth"); query = purple_xmlnode_get_child(iq->node, "query"); username = purple_xmlnode_new_child(query, "username"); purple_xmlnode_insert_data(username, js->user->node, -1); jabber_iq_set_callback(iq, auth_old_cb, NULL); jabber_iq_send(iq); }
/*------------------------------------------------------------------------ * Create a new mxit session object * * @return The MXit session object */ static struct MXitSession* mxit_create_object( PurpleAccount* account ) { PurpleConnection* con = purple_account_get_connection( account ); struct MXitSession* session = NULL; /* currently the wapsite does not handle a '+' in front of the username (mxitid) so we just strip it */ { const char* username = purple_account_get_username( account ); if ( username[0] == '+' ) { char* fixed = g_strdup( &username[1] ); purple_account_set_username( account, fixed ); g_free( fixed ); } } session = g_new0( struct MXitSession, 1 ); session->con = con; session->acc = account; /* configure the connection (reference: "libpurple/connection.h") */ purple_connection_set_protocol_data( con, session ); purple_connection_set_flags( con, PURPLE_CONNECTION_FLAG_NO_BGCOLOR | PURPLE_CONNECTION_FLAG_NO_URLDESC | PURPLE_CONNECTION_FLAG_HTML | PURPLE_CONNECTION_FLAG_SUPPORT_MOODS ); /* configure the session (reference: "libpurple/account.h") */ g_strlcpy( session->server, purple_account_get_string( account, MXIT_CONFIG_SERVER_ADDR, DEFAULT_SERVER ), sizeof( session->server ) ); g_strlcpy( session->http_server, purple_account_get_string( account, MXIT_CONFIG_HTTPSERVER, DEFAULT_HTTP_SERVER ), sizeof( session->http_server ) ); session->port = purple_account_get_int( account, MXIT_CONFIG_SERVER_PORT, DEFAULT_PORT ); g_strlcpy( session->distcode, purple_account_get_string( account, MXIT_CONFIG_DISTCODE, "" ), sizeof( session->distcode ) ); g_strlcpy( session->clientkey, purple_account_get_string( account, MXIT_CONFIG_CLIENTKEY, "" ), sizeof( session->clientkey ) ); g_strlcpy( session->dialcode, purple_account_get_string( account, MXIT_CONFIG_DIALCODE, "" ), sizeof( session->dialcode ) ); session->http = purple_account_get_bool( account, MXIT_CONFIG_USE_HTTP, FALSE ); session->iimages = g_hash_table_new( g_str_hash, g_str_equal ); session->rx_state = RX_STATE_RLEN; session->http_interval = MXIT_HTTP_POLL_MIN; session->http_last_poll = mxit_now_milli(); session->async_http_reqs = purple_http_connection_set_new(); return session; }
static void np_login(PurpleAccount *account) { PurpleConnection *gc; NPSession *session; PurplePresence *presence; const char *host; gboolean http_method = FALSE; int port; purple_debug_warning("np","\n===> %p ",account); purple_debug_warning("np","account->alias = %s\n",account->alias); purple_debug_warning("np","account->username = %s\n",account->username); purple_debug_warning("np","account->password = %s\n",account->password); purple_debug_warning("np","account->user_info = %s\n",account->user_info); g_return_if_fail(account != NULL); session = np_session_new(account); gc = purple_account_get_connection(account); g_return_if_fail(gc != NULL); const char *http_server = purple_account_get_string(session->account, "http_method_server", NP_HTTPCONN_SERVER); purple_debug_info("np", "http_server: %s",http_server); purple_connection_set_state(gc, PURPLE_CONNECTING); purple_connection_update_progress(gc, _("Connecting"), 1, 3); np_http_login0(session, np_http_login0_cb); return; /* host = purple_account_get_string(account, "server", NP_IM_SERVER); port = purple_account_get_int(account, "port", NP_IM_PORT); session = np_session_new(account); purple_debug_warning("np","=====> session : %p ",session); gc = purple_account_get_connection(account); g_return_if_fail(gc != NULL); gc->proto_data = session; gc->flags |= PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_NO_BGCOLOR | PURPLE_CONNECTION_AUTO_RESP; np_session_set_login_step(session, NP_LOGIN_STEP_START); presence = purple_account_get_presence(account); if (!np_session_connect(session, host, port, http_method)) purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _("Unable to connect")); */ }
static void prp_cmd (MsnCmdProc *cmdproc, MsnCommand *cmd) { MsnSession *session = cmdproc->session; const gchar *type, *value; struct pn_contact *user; type = cmd->params[0]; value = cmd->params[1]; user = msn_session_get_contact (session); if (cmd->param_count == 2) { gchar *tmp; tmp = pn_url_decode (value); if (strcmp (type, "PHH") == 0) pn_contact_set_home_phone (user, tmp); else if (strcmp (type, "PHW") == 0) pn_contact_set_work_phone (user, tmp); else if (strcmp (type, "PHM") == 0) pn_contact_set_mobile_phone (user, tmp); else if (strcmp (type, "MFN") == 0) { PurpleAccount *account; PurpleConnection *connection; const gchar* friendly_name; account = msn_session_get_user_data (session); connection = purple_account_get_connection (account); friendly_name = purple_account_get_string (account, "friendly_name", NULL); /* * The server doesn't seem to store the friendly name anymore, * store it in account opts. */ if (friendly_name) msn_session_set_public_alias (session, friendly_name); else purple_account_set_string (account, "friendly_name", tmp); purple_connection_set_display_name (connection, friendly_name); } g_free (tmp); } else { if (strcmp (type, "PHH") == 0) pn_contact_set_home_phone (user, NULL); else if (strcmp (type, "PHW") == 0) pn_contact_set_work_phone (user, NULL); else if (strcmp (type, "PHM") == 0) pn_contact_set_mobile_phone (user, NULL); } }
PurpleUtilFetchUrlData * np_http_login0(NPSession *session,PurpleUtilFetchUrlCallback callback) { PurpleUtilFetchUrlData *url_data; PurpleAccount *account; account = session->account; const char *username = account->username; const char *pwd_md5 = g_compute_checksum_for_string(G_CHECKSUM_MD5,account->password,strlen(account->password)); const char *http_server = purple_account_get_string(session->account, "http_method_server", NP_HTTPCONN_SERVER); const char *_ua = purple_account_get_string(session->account, "np_user_agent", NP_USER_AGENT); char *login_url = g_strdup_printf("%s/%s",http_server,NP_LOGIN_0_PATH); purple_debug_info("np", "login_url: %s",login_url); const char *login_from = "niupai"; const char *login_device_id = purple_account_get_string(session->account, "device_id", "FAKE_DEVICE_ID_FROM_PURPLE"); char *plain_login_key = g_strdup_printf("%s%s",login_device_id,"nPiGa:#)"); char *login_key = g_compute_checksum_for_string(G_CHECKSUM_MD5,plain_login_key,strlen(plain_login_key)); purple_debug_info("np", "login_device_id: %s",login_device_id); gchar *content = g_strdup_printf("account=%s&password=%s&login_from=%s&login_device_id=%s&login_key=%s&_ua=%s", username, pwd_md5, login_from, login_device_id, login_key, _ua, NULL ); url_data = np_util_post_url(login_url, content,TRUE, callback, session); g_free(plain_login_key); g_free(login_key); g_free(login_url); g_free(content); return url_data; }
static void pb_login(PurpleAccount *account) { PushBulletAccount *pba; PurpleConnection *pc; const gchar *password; pc = purple_account_get_connection(account); pba = g_new0(PushBulletAccount, 1); pba->account = account; pba->pc = pc; pba->sent_messages_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); pc->proto_data = pba; password = purple_account_get_password(account); if (password && *password) { pba->access_token = g_strdup(password); } else { pb_oauth_request_access_token(account); purple_connection_error_reason(pc, PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED, _("Access Token required")); return; } if(pba->access_token) { purple_connection_set_state(pc, PURPLE_CONNECTED); pb_start_socket(pba); if (purple_account_get_string(account, "main_sms_device", NULL) != NULL) { pba->main_sms_device = g_strdup(purple_account_get_string(account, "main_sms_device", NULL)); pb_get_phonebook(pba, pba->main_sms_device); } pb_get_everything(pba); return; } }
/*------------------------------------------------------------------------ * Return the ID of the current splash-screen. * * @param session The MXit session object * @return The ID of the splash-screen (or NULL if no splash-screen) */ const char* splash_current(struct MXitSession* session) { const char* splashId = purple_account_get_string(session->acc, MXIT_CONFIG_SPLASHID, NULL); if ((splashId != NULL) && (*splashId != '\0')) { purple_debug_info(MXIT_PLUGIN_ID, "Current splashId: '%s'\n", splashId); return splashId; } else return NULL; }
void AccountWindow::StringOption::updateValue() { if (type == TYPE_PASSWORD) { setMasked(true); setValue(purple_account_get_password(account)); } else if (type == TYPE_ALIAS) setValue(purple_account_get_alias(account)); else setValue(purple_account_get_string(account, purple_account_option_get_setting(option), purple_account_option_get_default_string(option))); }
static gboolean exec_skype() { if (!connected && !in_progress) { in_progress = TRUE; PurpleAccount *acct = skype_get_account(NULL); purple_proxy_connect(acct->gc, acct, purple_account_get_string(acct, "host", "skype.robbmob.com"), purple_account_get_int(acct, "port", 5000), connect_function, acct); g_thread_create((GThreadFunc)skype_read_thread, acct, FALSE, NULL); purple_timeout_add_seconds(10, connection_timeout, acct); } return TRUE; }
static void nap_login(PurpleAccount *account) { PurpleConnection *gc = purple_account_get_connection(account); purple_connection_update_progress(gc, _("Connecting"), 0, NAPSTER_CONNECT_STEPS); gc->proto_data = g_new0(struct nap_data, 1); if (purple_proxy_connect(gc, account, purple_account_get_string(account, "server", NAP_SERVER), purple_account_get_int(account, "port", NAP_PORT), nap_login_connect, gc) != 0) { purple_connection_error(gc, _("Unable to connect.")); } }
PurpleUtilFetchUrlData * http_main_start(NPSession *session,PurpleUtilFetchUrlCallback callback) { PurpleUtilFetchUrlData *url_data; PurpleAccount *account; account = session->account; const char *http_server = purple_account_get_string(session->account, "http_method_server", NP_HTTPCONN_SERVER); const char *_ua = purple_account_get_string(session->account, "np_user_agent", NP_USER_AGENT); char *start_url = g_strdup_printf("%s/%s",http_server,NP_MAIN_START_PATH); purple_debug_info("np", "main/start: %s",start_url); gchar *content = g_strdup_printf("_ua=%s",_ua,NULL); url_data = np_util_post_url(start_url, content, FALSE , callback, session); g_free(content); return url_data; }