示例#1
0
std::string markup_unescape(std::string const &markup) {
    gchar *unescaped = purple_unescape_html(markup.c_str());
    std::string result(unescaped);
    g_free(unescaped);

    return result;
}
示例#2
0
static int tgprpl_send_im (PurpleConnection * gc, const char *who, const char *message, PurpleMessageFlags flags) {
  debug ("tgprpl_send_im()\n");
  
  telegram_conn *conn = purple_connection_get_protocol_data(gc);
  PurpleAccount *pa = conn->pa;
 
  // this is part of a workaround to support clients without
  // the request API (request.h), see telegram-base.c:request_code()
  if (conn->in_fallback_chat) {
    request_code_entered (conn->TLS, message);
    conn->in_fallback_chat = 0;
    return 1;
  }
  
  PurpleBuddy *b = purple_find_buddy (pa, who);
  if (!b) {
    warning ("Buddy %s not found, cannot send IM\n", who);
    return -1;
  }
  
  tgl_peer_t *peer = tgl_peer_get(conn->TLS, TGL_MK_USER(atoi (who)));
  if (!peer) {
    warning ("Protocol data tgl_peer_t for %s not found, cannot send IM\n", who);
    return -1;
  }
  gchar *raw = purple_unescape_html(message);
  tgl_do_send_message (conn->TLS, peer->id, raw, (int)strlen (raw), 0, 0);
  g_free(raw);
  return 1;
}
示例#3
0
static void find_feed_url_cb(FacebookAccount *fba, gchar *data, gsize data_len, gpointer userdata)
{
	const gchar *search_string = "/feeds/notifications.php";
	gchar *feed_url;
	gchar *stripped;

	purple_debug_info("facebook", "find_feed_url_cb\n");

	if (!data)
		data = "(null)";

	feed_url = g_strstr_len(data, data_len, search_string);
	if (!feed_url)
	{
		purple_debug_error("facebook", "received data, but could not find url on page\n");
		return;
	}

	feed_url = g_strndup(feed_url, strchr(feed_url, '"') - feed_url);

	/* convert & to & */
	stripped = purple_unescape_html(feed_url);
	g_free(feed_url);
	feed_url = stripped;
	
	purple_debug_info("facebook", "parsed feed url %s\n", feed_url);

	if (feed_url && *feed_url)
	{
		purple_account_set_string(fba->account, "notifications_feed_url", feed_url);
		fb_get_notifications_feed(fba);
	}
}
void purpleTooltipInfo::Init(PurpleNotifyUserInfoEntry *aEntry)
{
  mType = purple_notify_user_info_entry_get_type(aEntry);
  mLabel = purple_notify_user_info_entry_get_label(aEntry);
  char *value =
    purple_unescape_html(purple_notify_user_info_entry_get_value(aEntry));
  mValue = value;
  g_free(value);
}
示例#5
0
文件: xmlnode.c 项目: bf4/pidgin-mac
char *
xmlnode_get_data_unescaped(xmlnode *node)
{
	char *escaped = xmlnode_get_data(node);

	char *unescaped = escaped ? purple_unescape_html(escaped) : NULL;

	g_free(escaped);

	return unescaped;
}
示例#6
0
文件: xmlnode.c 项目: bf4/pidgin-mac
static void
xmlnode_parser_element_start_libxml(void *user_data,
				   const xmlChar *element_name, const xmlChar *prefix, const xmlChar *xmlns,
				   int nb_namespaces, const xmlChar **namespaces,
				   int nb_attributes, int nb_defaulted, const xmlChar **attributes)
{
	struct _xmlnode_parser_data *xpd = user_data;
	xmlnode *node;
	int i, j;

	if(!element_name || xpd->error) {
		return;
	} else {
		if(xpd->current)
			node = xmlnode_new_child(xpd->current, (const char*) element_name);
		else
			node = xmlnode_new((const char *) element_name);

		xmlnode_set_namespace(node, (const char *) xmlns);
		xmlnode_set_prefix(node, (const char *)prefix);

		if (nb_namespaces != 0) {
			node->namespace_map = g_hash_table_new_full(
				g_str_hash, g_str_equal, g_free, g_free);

			for (i = 0, j = 0; i < nb_namespaces; i++, j += 2) {
				const char *key = (const char *)namespaces[j];
				const char *val = (const char *)namespaces[j + 1];
				g_hash_table_insert(node->namespace_map,
					g_strdup(key ? key : ""), g_strdup(val ? val : ""));
			}
		}

		for(i=0; i < nb_attributes * 5; i+=5) {
			const char *prefix = (const char *)attributes[i + 1];
			char *txt;
			int attrib_len = attributes[i+4] - attributes[i+3];
			char *attrib = g_malloc(attrib_len + 1);
			memcpy(attrib, attributes[i+3], attrib_len);
			attrib[attrib_len] = '\0';
			txt = attrib;
			attrib = purple_unescape_html(txt);
			g_free(txt);
			if (prefix && *prefix) {
				xmlnode_set_attrib_with_prefix(node, (const char*) attributes[i], prefix, attrib);
			} else {
				xmlnode_set_attrib(node, (const char*) attributes[i], attrib);
			}
			g_free(attrib);
		}

		xpd->current = node;
	}
}
示例#7
0
char *
purple_xmlnode_get_data_unescaped(const PurpleXmlNode *node)
{
    char *escaped = purple_xmlnode_get_data(node);

    char *unescaped = escaped ? purple_unescape_html(escaped) : NULL;

    g_free(escaped);

    return unescaped;
}
示例#8
0
static int tgprpl_send_chat (PurpleConnection * gc, int id, const char *message, PurpleMessageFlags flags) {
  debug ("tgprpl_send_chat()\n");
  telegram_conn *conn = purple_connection_get_protocol_data (gc);
  
  gchar *raw = purple_unescape_html(message);
  tgl_do_send_message (conn->TLS, TGL_MK_CHAT(id), raw, (int)strlen (raw), 0, 0);
  g_free (raw);
  
  p2tgl_got_chat_in(conn->TLS, TGL_MK_CHAT(id), TGL_MK_USER(conn->TLS->our_id), message,
                    PURPLE_MESSAGE_RECV, time(NULL));
  return 1;
}
示例#9
0
文件: fetion.c 项目: Gankraft/fetion
static int
fetion_im_send(PurpleConnection * gc, const char *who, const char *what,
	       PurpleMessageFlags flags)
{
	struct fetion_account_data *sip = gc->proto_data;
	char *to = g_strdup(who);
	char *text = purple_unescape_html(what);
	fetion_send_message(sip, to, text, NULL, FALSE);
	g_free(to);
	g_free(text);
	return 1;
}
示例#10
0
/*
 * Initialize from an incoming libPurple callback parameters
 *
 * payload form: (Sprint)
 * { "serviceName": "gmail", "username": "******", "usernameFrom": "*****@*****.**", "messageText": "<body>test reply to phone<\/body>" }
 * { "serviceName": "aol", "username": "******", "usernameFrom": "palm", "messageText": "test incoming message" }
 *
 *
 */
MojErr IMMessage::initFromCallback(const char* serviceName, const char* username, const char* usernameFrom, const char* message) {

	MojErr err;

	// unescape, strip html
	//    #/tmp/testsanitize "<a>foo</a>"
	//    sanitized: &lt;a&gt;foo&lt;/a&gt;
	//    unsanitized: <a>foo</a>
	//    removed: foo

    char* unescapedMessage = purple_unescape_html(message);
    char* sanitizedMessage = purple_markup_strip_html(unescapedMessage);
    g_free(unescapedMessage);

    msgText.assign("");

    // Inefficient but working solution.
    // TODO: Implement proper sanitization (that just keeps br, u, l and i)
    for (char* ptr = sanitizedMessage; *ptr; ++ptr)
        if (*ptr == '\n')
            msgText.append("<br>");
        else
            msgText.append(*ptr);

    err = msgText.assign(sanitizedMessage);
    g_free(sanitizedMessage);
	MojErrCheck(err);

	// remove blanks and convert to lowercase
	// for AOL, this is screen name with no "@aol.com"...
	MojString formattedUserName;
	err = formattedUserName.assign(usernameFrom);
	MojErrCheck(err);
	err = unformatFromAddress(formattedUserName, fromAddress);
	MojErrCheck(err);

	err = toAddress.assign(username);
	MojErrCheck(err);
	err = msgType.assign(serviceName);
	MojErrCheck(err);

	// set time stamp to current time - seconds since 1/1/1970
	// for some reason multiplying a time_t by 1000 doesn't work - you have to convert to a long first...
	//deviceTimestamp = time (NULL) * 1000;
	MojInt64 sec = time (NULL);
	deviceTimestamp = sec * 1000;
	// server timestamp is new Date().getTime()
	serverTimestamp = sec * 1000;

	return MojErrNone;
}
示例#11
0
/* Frees 'urls' */
static void
process_urls(PurpleConversation *conv, GList *urls)
{
	GList *iter;
	int c;
	FinchConv *fconv = FINCH_CONV(conv);
	GntTextView *tv = GNT_TEXT_VIEW(fconv->tv);

	for (iter = urls, c = 1; iter; iter = iter->next, c++) {
		int i;
		CbInfo *cbdata;
		gchar *url, *str;
		gchar *original_url;
		const gchar *tiny_url;

		i = gnt_text_view_get_lines_below(tv);

		original_url = purple_unescape_html((char *)iter->data);
		tiny_url = g_hash_table_lookup(tinyurl_cache, original_url);
		if (tiny_url) {
			gchar *str = g_strdup_printf("\n[%d] %s", c, tiny_url);

			g_free(original_url);
			gnt_text_view_append_text_with_flags(tv, str, GNT_TEXT_FLAG_DIM);
			if (i == 0)
				gnt_text_view_scroll(tv, 0);
			g_free(str);
			continue;
		}
		cbdata = g_new(CbInfo, 1);
		cbdata->num = c;
		cbdata->original_url = original_url;
		cbdata->tag = g_strdup_printf("%s%d", "tiny_", tag_num++);
		cbdata->conv = conv;
		if (g_ascii_strncasecmp(original_url, "http://", 7) && g_ascii_strncasecmp(original_url, "https://", 8)) {
			url = g_strdup_printf("%shttp%%3A%%2F%%2F%s", purple_prefs_get_string(PREF_URL), purple_url_encode(original_url));
		} else {
			url = g_strdup_printf("%s%s", purple_prefs_get_string(PREF_URL), purple_url_encode(original_url));
		}
		purple_http_get(NULL, url_fetched, cbdata, url);
		str = g_strdup_printf(_("\nFetching TinyURL..."));
		gnt_text_view_append_text_with_tag((tv), str, GNT_TEXT_FLAG_DIM, cbdata->tag);
		g_free(str);
		if (i == 0)
			gnt_text_view_scroll(tv, 0);
		g_free(iter->data);
		g_free(url);
	}
	g_list_free(urls);
}
示例#12
0
/* 205 - MSG_CLIENT_PRIVMSG */
static int
nap_send_im(PurpleConnection *gc, const char *who, const char *message,
            PurpleMessageFlags flags)
{
    char *tmp = purple_unescape_html(message);

    if ((strlen(tmp) < 2) || (tmp[0] != '/' ) || (tmp[1] == '/')) {
        /* Actually send a chat message */
        nap_write_packet(gc, 205, "%s %s", who, tmp);
    } else {
        /* user typed an IRC-style command */
        nap_do_irc_style(gc, tmp, who);
    }

    g_free(tmp);

    return 1;
}
示例#13
0
static void on_write_im(PurpleConversation *conv,
                        const char *name,
                        const char *message,
                        PurpleMessageFlags flags,
                        time_t mtime)
{
    g_assert(conversations_uiops_lua);
    LuaState *L    = ms_lua_var_get(conversations_uiops_lua, "conversation_write_im");
    char *message2 = purple_unescape_html(message);
    lua_pushlightuserdata(L, conv);
    lua_gettable(L, LUA_REGISTRYINDEX);
    g_assert(!lua_isnil(L, -1));
    lua_pushstring(L, name);
    lua_pushstring(L, message2);
    lua_pushinteger(L, flags);
    lua_pushinteger(L, mtime);
    ms_lua_call(L, 5, 0, "purple.conversations in uiops.conversation_write_im");
    g_free(message2);
}
示例#14
0
static gchar *format_channel_real(ParserVars *vars, const gchar *name, const gchar *title) {
    PurpleAccount *pa;
    gchar *unescaped, *ret;
    GString *gs;
    if(!vars->fla) return g_strdup(name);
    unescaped = purple_unescape_html(name);

    gs = g_string_new(NULL);
    pa = vars->fla->pa;
    g_string_append(gs, "<a href=\"flistc://");
    g_string_append(gs, purple_url_encode(flist_serialize_account(pa)));
    g_string_append_c(gs, '/');
    g_string_append(gs, purple_url_encode(unescaped));
    g_string_append(gs, "\">(Channel) ");
    g_string_append(gs, title);
    g_string_append(gs, "</a>");
    ret = g_string_free(gs, FALSE);

    g_free(unescaped);
    return ret;
}
示例#15
0
/* 402 - MSG_CLIENT_PUBLIC */
static int
nap_chat_send(PurpleConnection *gc, int id, const char *message,
              PurpleMessageFlags flags)
{
    PurpleConversation *c = purple_find_chat(gc, id);
    char *tmp = purple_unescape_html(message);

    if (!c)
        return -EINVAL;

    if ((strlen(tmp) < 2) || (tmp[0] != '/' ) || (tmp[1] == '/')) {
        /* Actually send a chat message */
        nap_write_packet(gc, 402, "%s %s", c->name, tmp);
    } else {
        /* user typed an IRC-style command */
        nap_do_irc_style(gc, tmp, c->name);
    }

    g_free(tmp);

    return 0;
}
示例#16
0
文件: util.c 项目: Draghtnod/pidgin
SilcDList silcpurple_image_message(const char *msg, SilcMessageFlags *mflags)
{
	SilcMime mime = NULL, p;
	SilcDList list, parts = NULL;
	const char *start, *end, *last;
	GData *attribs;
	char *type;
	gboolean images = FALSE;

	last = msg;
	while (last && *last && purple_markup_find_tag("img", last, &start,
						     &end, &attribs)) {
		PurpleStoredImage *image = NULL;
		const char *id;

		/* Check if there is text before image */
		if (start - last) {
			char *text, *tmp;
			p = silc_mime_alloc();

			/* Add content type */
			silc_mime_add_field(p, "Content-Type",
					    "text/plain; charset=utf-8");

			tmp = g_strndup(last, start - last);
			text = purple_unescape_html(tmp);
			g_free(tmp);

			/* Add text */
			silc_mime_add_data(p, (const unsigned char *)text, strlen(text));
			g_free(text);

			if (!parts)
				parts = silc_dlist_init();
			silc_dlist_add(parts, p);
		}

		id = g_datalist_get_data(&attribs, "id");
		if (id && (image = purple_imgstore_find_by_id(atoi(id)))) {
			unsigned long imglen = purple_imgstore_get_size(image);
			gconstpointer img = purple_imgstore_get_data(image);

			p = silc_mime_alloc();

			/* Add content type */
			type = silcpurple_file2mime(purple_imgstore_get_filename(image));
			if (!type) {
				g_datalist_clear(&attribs);
				last = end + 1;
				continue;
			}
			silc_mime_add_field(p, "Content-Type", type);
			g_free(type);

			/* Add content transfer encoding */
			silc_mime_add_field(p, "Content-Transfer-Encoding", "binary");

			/* Add image data */
			silc_mime_add_data(p, img, imglen);

			if (!parts)
				parts = silc_dlist_init();
			silc_dlist_add(parts, p);
			images = TRUE;
		}

		g_datalist_clear(&attribs);

		/* Continue after tag */
		last = end + 1;
	}

	/* Check for text after the image(s) */
	if (images && last && *last) {
		char *tmp = purple_unescape_html(last);
		p = silc_mime_alloc();

		/* Add content type */
		silc_mime_add_field(p, "Content-Type",
				    "text/plain; charset=utf-8");

		/* Add text */
		silc_mime_add_data(p, (const unsigned char *)tmp, strlen(tmp));
		g_free(tmp);

		if (!parts)
			parts = silc_dlist_init();
		silc_dlist_add(parts, p);
	}

	/* If there weren't any images, don't return anything. */
	if (!images) {
		if (parts)
			silc_dlist_uninit(parts);
		return NULL;
	}

	if (silc_dlist_count(parts) > 1) {
		/* Multipart MIME message */
		char b[32];
		mime = silc_mime_alloc();
		silc_mime_add_field(mime, "MIME-Version", "1.0");
		g_snprintf(b, sizeof(b), "b%4X%4X",
			   (unsigned int)time(NULL),
			   silc_dlist_count(parts));
		silc_mime_set_multipart(mime, "mixed", b);
		silc_dlist_start(parts);
		while ((p = silc_dlist_get(parts)) != SILC_LIST_END)
			silc_mime_add_multipart(mime, p);
	} else {
		/* Simple MIME message */
		silc_dlist_start(parts);
		mime = silc_dlist_get(parts);
		silc_mime_add_field(mime, "MIME-Version", "1.0");
	}

	*mflags &= ~SILC_MESSAGE_FLAG_UTF8;
	*mflags |= SILC_MESSAGE_FLAG_DATA;

	/* Encode message. Fragment if it is too large */
	list = silc_mime_encode_partial(mime, 0xfc00);

	silc_dlist_uninit(parts);

	/* Added multiparts gets freed here */
	silc_mime_free(mime);

	return list;
}
示例#17
0
static void fb_login_cb(FacebookAccount *fba, gchar *response, gsize len,
		gpointer userdata)
{
	gchar *user_cookie;
	const gchar *persist_data_start;
	gchar *persist_data;
	const gchar *session_start;
	gchar *session;
	gchar *captcha_url;
	const gchar *extra_challenge_params;
	gchar *extra_challenge;
	if (len && g_strstr_len(response, len, "captcha"))
	{
		purple_debug_info("facebook", "captcha page: %s\n", response);

		purple_connection_update_progress(fba->pc, _("Handling Captcha"), 2, 4);
		
		persist_data_start = "<input type=\"hidden\" id=\"captcha_persist_data\" name=\"captcha_persist_data\" value=\"";
		persist_data = g_strstr_len(response, len, persist_data_start);
		if (persist_data)
		{
			persist_data += strlen(persist_data_start);
			fba->persist_data = g_strndup(persist_data, strchr(persist_data, '"') - persist_data);
		}
		
		session_start = "<input type=\"hidden\" id=\"captcha_session\" name=\"captcha_session\" value=\"";
		session = g_strstr_len(response, len, session_start);
		if (session)
		{
			session += strlen(session_start);
			fba->captcha_session = g_strndup(session, strchr(session, '"') - session);
		}
		
		
		extra_challenge_params = "<input type=\"hidden\" id=\"extra_challenge_params\" name=\"extra_challenge_params\" value=\"";
		extra_challenge = g_strstr_len(response, len, extra_challenge_params);
		if (extra_challenge)
		{
			extra_challenge += strlen(extra_challenge_params);
			fba->extra_challenge = g_strndup(extra_challenge, strchr(extra_challenge, '"') - extra_challenge);
			extra_challenge = purple_unescape_html(fba->extra_challenge);
			g_free(fba->extra_challenge);
			fba->extra_challenge = extra_challenge;
		}
		
		if (!fba->extra_challenge || !fba->persist_data || !fba->captcha_session)
		{
			purple_debug_info("facebook", "captcha response: %s\n", response);
			g_free(fba->extra_challenge);
			g_free(fba->persist_data);
			g_free(fba->captcha_session);
			fba->extra_challenge = NULL;
			fba->persist_data = NULL;
			fba->captcha_session = NULL;
			purple_connection_error_reason(fba->pc, PURPLE_CONNECTION_ERROR_OTHER_ERROR,
				"Could not authenticate captcha.  Logging into the Facebook website may fix this.");
			return;
		}
		
		captcha_url = g_strdup_printf("/challenge?k=" FACEBOOK_CAPTCHA_SITE "&%s",
				fba->extra_challenge?fba->extra_challenge:"");
		
		fb_post_or_get(fba, FB_METHOD_GET | FB_METHOD_SSL, "api-secure.recaptcha.net",
			captcha_url, NULL, fb_login_captcha_cb, NULL, FALSE);
		
		g_free(captcha_url);
		
		return;
	}

	purple_connection_update_progress(fba->pc, _("Authenticating"), 2, 3);

	/* Look for our uid */
	user_cookie = g_hash_table_lookup(fba->cookie_table, "c_user");
	if (user_cookie == NULL) {
		/*
		 * Server didn't set the c_user cookie, so we must have given
		 * them a bad username or password
		 */
		purple_connection_error_reason(fba->pc,
				PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
				_("Incorrect username or password."));
		return;
	}
	fba->uid = atoll(user_cookie);
	purple_debug_info("facebook", "uid %" G_GINT64_FORMAT "\n", fba->uid);

	/* ok, we're logged in now! */
	purple_connection_set_state(fba->pc, PURPLE_CONNECTED);

	/* This will kick off our long-poll message retrieval loop */
	fb_get_post_form_id(fba);
	fb_check_friend_requests(fba);

	/* periodically check for people adding you to their facebook friend list */
	fba->friend_request_timer = purple_timeout_add_seconds(60 * 5,
			fb_check_friend_requests, fba);

	/* periodically check for new notifications */
	fba->notifications_timer = purple_timeout_add_seconds(60,
			(GSourceFunc)fb_get_notifications_feed, fba);

	/* Periodically check for new messages.  NOTE: This MUST exist,
	 * regardless of other other mechanisms for checking messages.  This
	 * is because the code needs a failsafe checker in case other one of
	 * the other retrieval mechanisms dies due to a bad request, etc.
	 * Without such a failsafe, a user will receive no messages, which is
	 * one of hardest bugs to debug and get reports about.  Hence, the
	 * importance of this loop.
	 * That said, there is room for tweaking this loop and possibly even
	 * setting it such that it is the primary or only message checker.
	 * The key is that the method must NEVER die until logout.
	 */
	fba->perpetual_messages_timer = purple_timeout_add_seconds(15,
			(GSourceFunc)fb_get_messages_failsafe, fba);

	/* init blist subsystem */
	fb_blist_init(fba);

	/* init conversation subsystem */
	fb_conversation_init(fba);
}