pidgin3: comparison libpurple/protocols/jabber/jabber.c

-:f84f2b4ef0e5
+:53a26c29d26c
 						  "xmlns:stream='" NS_XMPP_STREAMS "' "
 						  "version='1.0'>",
 						  js->user->domain);
 	/* setup the parser fresh for each stream */
 	jabber_parser_setup(js);
-	jabber_send_raw(js, open_stream, -1);
+	jabber_send_raw(NULL, js, open_stream, -1);
 	js->reinit = FALSE;
 	g_free(open_stream);
 }
 static void
 	/* Otherwise, it's a standard XMPP connection, or a HTTP (insecure) BOSH connection.
 	 * We request STARTTLS for standard XMPP connections, but we do nothing for insecure
 	 * BOSH connections, per XEP-0206. */
 	if(!js->bosh) {
-		jabber_send_raw(js,
+		jabber_send_raw(NULL, js,
 				"<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>", -1);
 		return TRUE;
 	}
 	/* It's an insecure standard XMPP connection, or an insecure BOSH connection, let's
 	g_bytes_unref(output);
 	return success;
 }
-void jabber_send_raw(JabberStream *js, const char *data, int len)
+void
+jabber_send_raw(PurpleProtocolServer *protocol_server, JabberStream *js,
+const gchar *data, gint len)
 {
 	PurpleConnection *gc;
 	PurpleAccount *account;
 	gc = js->gc;
 		jabber_bosh_connection_send(js->bosh, data);
 	else
 		do_jabber_send_raw(js, data, len);
 }
-int jabber_protocol_send_raw(PurpleConnection *gc, const char *buf, int len)
+gint
+jabber_protocol_send_raw(PurpleProtocolServer *protocol_server,
+PurpleConnection *gc, const gchar *buf, gint len)
 {
 	JabberStream *js = purple_connection_get_protocol_data(gc);
 	g_return_val_if_fail(js != NULL, -1);
 	/* TODO: It's probably worthwhile to restrict this to when the account
 	 * state is CONNECTED, but I can /almost/ envision reasons for wanting
 	 * to do things during the connection process.
 	 */
-	jabber_send_raw(js, buf, len);
+	jabber_send_raw(NULL, js, buf, len);
 	return (len < 0 ? (int)strlen(buf) : len);
 }
 void jabber_send_signal_cb(PurpleConnection *pc, PurpleXmlNode **packet,
 gpointer unused)
 		if (purple_strequal((*packet)->name, "message") ||
 				purple_strequal((*packet)->name, "iq") ||
 				purple_strequal((*packet)->name, "presence"))
 			purple_xmlnode_set_namespace(*packet, NS_XMPP_CLIENT);
 	txt = purple_xmlnode_to_str(*packet, &len);
-	jabber_send_raw(js, txt, len);
+	jabber_send_raw(NULL, js, txt, len);
 	g_free(txt);
 }
 void jabber_send(JabberStream *js, PurpleXmlNode *packet)
 {
 					_("Ping timed out"));
 	js->keepalive_timeout = 0;
 	return FALSE;
 }
-void jabber_keepalive(PurpleConnection *gc)
+void
-{
+jabber_keepalive(PurpleProtocolServer *protocol_server, PurpleConnection *gc) {
 	JabberStream *js = purple_connection_get_protocol_data(gc);
 	if (js->keepalive_timeout == 0) {
 		jabber_keepalive_ping(js);
 		js->keepalive_timeout = g_timeout_add_seconds(120,
 				(GSourceFunc)(jabber_keepalive_timeout), gc);
 	}
 }
-static int jabber_get_keepalive_interval(void)
+static int
-{
+jabber_get_keepalive_interval(PurpleProtocolServer *protocol_server) {
 	return PING_TIMEOUT;
 }
 static gboolean
 jabber_recv_cb(GObject *stream, gpointer data)
 	js->input = g_io_stream_get_input_stream(js->stream);
 	js->output = purple_queued_output_stream_new(
 	        g_io_stream_get_output_stream(js->stream));
 	if (js->state == JABBER_STREAM_CONNECTING) {
-		jabber_send_raw(js, "<?xml version='1.0' ?>", -1);
+		jabber_send_raw(NULL, js, "<?xml version='1.0' ?>", -1);
 	}
 	jabber_stream_set_state(js, JABBER_STREAM_INITIALIZING);
 	source = g_pollable_input_stream_create_source(
 	        G_POLLABLE_INPUT_STREAM(js->input), js->cancellable);
 	iq = jabber_iq_new_query(js, JABBER_IQ_GET, "jabber:iq:register");
 	purple_xmlnode_set_attrib(iq->node, "to", gateway);
 	jabber_iq_send(iq);
 }
-void jabber_register_account(PurpleAccount *account)
+void
+jabber_register_account(PurpleProtocolServer *protocol_server,
+PurpleAccount *account)
 {
 	JabberStream *js;
 	js = jabber_stream_new(account);
 	if (js == NULL)
 	jabber_iq_set_callback(iq, jabber_unregister_account_iq_cb, NULL);
 	jabber_iq_send(iq);
 }
-void jabber_unregister_account(PurpleAccount *account, PurpleAccountUnregistrationCb cb, void *user_data) {
+void
+jabber_unregister_account(PurpleProtocolServer *protocol_server,
+PurpleAccount *account,
+PurpleAccountUnregistrationCb cb, gpointer user_data)
+{
 	PurpleConnection *gc = purple_account_get_connection(account);
 	JabberStream *js;
 	if (purple_connection_get_state(gc) != PURPLE_CONNECTION_CONNECTED) {
 		if (purple_connection_get_state(gc) != PURPLE_CONNECTION_CONNECTING)
 {
 	return g_strdup_printf("purple%x", js->next_id++);
 }
-void jabber_idle_set(PurpleConnection *gc, int idle)
+void
+jabber_idle_set(PurpleProtocolServer *protocol_server, PurpleConnection *gc,
+gint idle)
 {
 	JabberStream *js = purple_connection_get_protocol_data(gc);
 	js->idle = idle ? time(NULL) - idle : idle;
 	/* We want whatever is sent to set this.  It's okay because
 	 * the eventloop unsets it via the return FALSE.
 	 */
 	js->inactivity_timer = 0;
-	if (js->bosh)
+	if (js->bosh) {
 		jabber_bosh_connection_send_keepalive(js->bosh);
-	else
+	} else {
-		jabber_send_raw(js, "\t", 1);
+		jabber_send_raw(NULL, js, "\t", 1);
+	}
 	return FALSE;
 }
 void jabber_stream_restart_inactivity_timer(JabberStream *js)

Mercurial > pidgin3 / file comparison

comparison: libpurple/protocols/jabber/jabber.c

libpurple/protocols/jabber/jabber.c