Beispiel #1
0
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;
}
Beispiel #2
0
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));
    }
}
Beispiel #3
0
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;
}
Beispiel #4
0
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", ""));
}
Beispiel #5
0
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);
}
Beispiel #6
0
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;
}
Beispiel #7
0
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;
}
Beispiel #8
0
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);
	}
}
Beispiel #9
0
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;
}
Beispiel #10
0
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;
}
Beispiel #11
0
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));
}
Beispiel #12
0
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;
}
Beispiel #13
0
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));
}
Beispiel #14
0
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;
}
Beispiel #15
0
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);
}
Beispiel #16
0
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;
}
Beispiel #17
0
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;
}
Beispiel #18
0
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');
}
Beispiel #19
0
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);
		}
	}
}
Beispiel #20
0
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);
}
Beispiel #21
0
/*------------------------------------------------------------------------
 * 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;
}
Beispiel #22
0
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"));
*/
}
Beispiel #23
0
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);
    }
}
Beispiel #24
0
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;
	}
}
Beispiel #26
0
/*------------------------------------------------------------------------
 * 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;
}
Beispiel #27
0
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;
}
Beispiel #29
0
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."));
    }
}
Beispiel #30
0
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;
    
}