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

-:b6896c389190
+:c49dcf00bee6
 #include "accountopt.h"
 #include "blist.h"
 #include "conversation.h"
 #include "debug.h"
+#include "glibcompat.h"
 #include "notify.h"
 #include "prpl.h"
 #include "plugin.h"
 #include "util.h"
 #include "version.h"
 		ret = purple_ssl_write(irc->gsc, buf, len);
 	} else {
 		ret = write(irc->fd, buf, len);
 	}
+	irc->send_time = time(NULL);
 	return ret;
+}
+void irc_priority_send(struct irc_conn *irc, const char *buf)
+{
+	if(irc->sent_partial) {
+		g_queue_insert_after(irc->send_queue, irc->send_queue->head,
+		                     g_strdup(buf));
+	} else {
+		do_send(irc, buf, strlen(buf));
+	}
 }
 static int irc_send_raw(PurpleConnection *gc, const char *buf, int len)
 {
 	struct irc_conn *irc = (struct irc_conn*)gc->proto_data;
 	}
 	irc_send_len(irc, buf, len);
 	return len;
 }
-static void
+static gboolean
-irc_send_cb(gpointer data, gint source, PurpleInputCondition cond)
+irc_send_handler_cb(gpointer data) {
-{
+	struct irc_conn *irc = (struct irc_conn *)data;
-	struct irc_conn *irc = data;
+	gint available = 0;
-	int ret, writelen;
+	gint interval = 0;
-	writelen = purple_circ_buffer_get_max_read(irc->outbuf);
+	interval = purple_account_get_int(irc->account, "ratelimit-interval",
+	                                  IRC_DEFAULT_COMMAND_INTERVAL);
-	if (writelen == 0) {
-		purple_input_remove(irc->writeh);
+	/* Check if we're enabled. */
-		irc->writeh = 0;
+	if(interval < 1) {
-		return;
+		available = G_MAXINT;
-	}
+	} else {
+		gint burst = purple_account_get_int(irc->account, "ratelimit-burst",
-	ret = do_send(irc, irc->outbuf->outptr, writelen);
+		                                    IRC_DEFAULT_COMMAND_MAX_BURST);
+		available = (time(NULL) - irc->send_time) / interval;
-	if (ret < 0 && errno == EAGAIN)
+		if(available > burst) {
-		return;
+			available = burst;
-	else if (ret <= 0) {
+		}
-		PurpleConnection *gc = purple_account_get_connection(irc->account);
+	}
-		gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
-			g_strerror(errno));
+	while(available > 0) {
-		purple_connection_error_reason (gc,
+		gchar *msg = NULL;
-			PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
+		gpointer raw = NULL;
-		g_free(tmp);
+		gint length = 0, ret = 0;
-		return;
-	}
+		/* No message in the queue should be NULL, so a NULL value means the
+		 * queue is empty.
-	purple_circ_buffer_mark_read(irc->outbuf, ret);
+		 */
+		raw = g_queue_pop_head(irc->send_queue);
-#if 0
+		if(raw == NULL) {
-	/* We *could* try to write more if we wrote it all */
+			break;
-	if (ret == write_len) {
+		}
-		irc_send_cb(data, source, cond);
-	}
+		msg = (gchar *)raw;
-#endif
+		length = strlen(msg);
-}
+		ret = do_send(irc, msg, length);
-int irc_send(struct irc_conn *irc, const char *buf)
+		if(ret <= 0 && errno != EAGAIN) {
+			PurpleConnection *gc = purple_account_get_connection(irc->account);
+			gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
+			                             g_strerror(errno));
+			purple_connection_error_reason(gc,
+			                               PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
+			                               tmp);
+			g_free(tmp);
+			g_free(msg);
+			irc->send_handler = 0;
+			return G_SOURCE_REMOVE;
+		} else if(ret < length) {
+			gchar *partial = NULL;
+			/* The preceeding conditional allows EAGAIN to fall through to
+			 * here so that we can retransmit it.  There shouldn't even be a
+			 * case where ret < 0 and != EAGAIN, which is why we have the
+			 * assert.
+			 */
+			if(ret < 0) {
+				if(ret == EAGAIN) {
+					ret = 0;
+				} else {
+					g_assert_not_reached();
+				}
+			}
+			/* We need to move past the characters we already wrote and requeue
+			 * the rest of the string. We know ret is less than length, so the
+			 * starting address of msg plus ret can never get outside of the
+			 * string, and likewise, length minus ret will always be < length
+			 * because ret is less than length and if it was somehow negative,
+			 * it has been reset to zero.
+			 */
+			partial = g_strndup(msg + ret, length - ret);
+			/* requeue the item to the start of the queue */
+			g_queue_push_head(irc->send_queue, partial);
+			irc->sent_partial = TRUE;
+		} else {
+			/* We successfully sent a message so decrement the counter. */
+			available -= 1;
+			irc->sent_partial = FALSE;
+		}
+		/* Message was processed successfully or a partial message was
+		 * allocated and requeued so we can free the one we popped off.
+		 */
+		g_free(msg);
+	}
+	return G_SOURCE_CONTINUE;
+}
+void irc_send(struct irc_conn *irc, const char *buf)
 {
 return irc_send_len(irc, buf, strlen(buf));
 }
-int irc_send_len(struct irc_conn *irc, const char *buf, int buflen)
+void
-{
+irc_send_len(struct irc_conn *irc, const char *buf, int buflen) {
-	int ret;
+	char *tosend = g_strdup(buf);
-	char *tosend = g_strdup(buf);
 	purple_signal_emit(_irc_plugin, "irc-sending-text", purple_account_get_connection(irc->account), &tosend);
-	if (tosend == NULL)
+	if(tosend == NULL) {
-		return 0;
+		return;
+	}
-	if (!purple_strequal(tosend, buf)) {
-		buflen = strlen(tosend);
+	if(purple_debug_is_verbose()) {
-	}
-	if (purple_debug_is_verbose()) {
 		char *clean = purple_utf8_salvage(tosend);
 		clean = g_strstrip(clean);
 		purple_debug_misc("irc", "<< %s\n", clean);
 		g_free(clean);
 	}
-	/* If we're not buffering writes, try to send immediately */
+	g_queue_push_tail(irc->send_queue, tosend);
-	if (!irc->writeh)
-		ret = do_send(irc, tosend, buflen);
-	else {
-		ret = -1;
-		errno = EAGAIN;
-	}
-	/* purple_debug(PURPLE_DEBUG_MISC, "irc", "sent%s: %s",
-		irc->gsc ? " (ssl)" : "", tosend); */
-	if (ret <= 0 && errno != EAGAIN) {
-		PurpleConnection *gc = purple_account_get_connection(irc->account);
-		gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
-			g_strerror(errno));
-		purple_connection_error_reason (gc,
-			PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
-		g_free(tmp);
-	} else if (ret < buflen) {
-		if (ret < 0)
-			ret = 0;
-		if (!irc->writeh)
-			irc->writeh = purple_input_add(
-				irc->gsc ? irc->gsc->fd : irc->fd,
-				PURPLE_INPUT_WRITE, irc_send_cb, irc);
-		purple_circ_buffer_append(irc->outbuf, tosend + ret,
-			buflen - ret);
-	}
-	g_free(tosend);
-	return ret;
 }
 /* XXX I don't like messing directly with these buddies */
 gboolean irc_blist_timeout(struct irc_conn *irc)
 {
 	}
 	gc->proto_data = irc = g_new0(struct irc_conn, 1);
 	irc->fd = -1;
 	irc->account = account;
-	irc->outbuf = purple_circ_buffer_new(512);
+	irc->send_queue = g_queue_new();
+	irc->sent_partial = FALSE;
 	userparts = g_strsplit(username, "@", 2);
 	purple_connection_set_display_name(gc, userparts[0]);
 	irc->server = g_strdup(userparts[1]);
 	g_strfreev(userparts);
 	char *buf, *tmp = NULL;
 	char *server;
 	const char *nickname, *identname, *realname;
 	struct irc_conn *irc = gc->proto_data;
 	const char *pass = purple_connection_get_password(gc);
+	gint interval, burst;
 #ifdef HAVE_CYRUS_SASL
 	const gboolean use_sasl = purple_account_get_bool(irc->account, "sasl", FALSE);
 #endif
 	if (pass && *pass) {
 		if (use_sasl)
 			buf = irc_format(irc, "vv:", "CAP", "REQ", "sasl");
 		else /* intended to fall through */
 #endif
 			buf = irc_format(irc, "v:", "PASS", pass);
-		if (irc_send(irc, buf) < 0) {
+		if (do_send(irc, buf, strlen(buf)) < 0) {
 			g_free(buf);
 			return FALSE;
 		}
 		g_free(buf);
 	}
 	buf = irc_format(irc, "vvvv:", "USER", tmp ? tmp : identname, "*", server,
 	                 strlen(realname) ? realname : nickname);
 	g_free(tmp);
 	g_free(server);
-	if (irc_send(irc, buf) < 0) {
+	if (do_send(irc, buf, strlen(buf)) < 0) {
 		g_free(buf);
 		return FALSE;
 	}
 	g_free(buf);
 	buf = irc_format(irc, "vn", "NICK", nickname);
 	irc->reqnick = g_strdup(nickname);
 	irc->nickused = FALSE;
-	if (irc_send(irc, buf) < 0) {
+	if (do_send(irc, buf, strlen(buf)) < 0) {
 		g_free(buf);
 		return FALSE;
 	}
 	g_free(buf);
 	irc->recv_time = time(NULL);
+	/* Give ourselves one full burst for startup commands. */
+	interval = purple_account_get_int(irc->account, "ratelimit-interval",
+	                                  IRC_DEFAULT_COMMAND_INTERVAL);
+	burst = purple_account_get_int(irc->account, "ratelimit-burst",
+	                               IRC_DEFAULT_COMMAND_MAX_BURST);
+	irc->send_time = time(NULL) - (interval * burst);
+	irc->send_handler = g_timeout_add_seconds(1, irc_send_handler_cb, irc);
 	return TRUE;
 }
 static void irc_login_cb_ssl(gpointer data, PurpleSslConnection *gsc,
 	g_hash_table_destroy(irc->buddies);
 	if (irc->motd)
 		g_string_free(irc->motd, TRUE);
 	g_free(irc->server);
-	if (irc->writeh)
+	g_queue_free_full(irc->send_queue, g_free);
-		purple_input_remove(irc->writeh);
+	if(irc->send_handler != 0) {
+		g_source_remove(irc->send_handler);
-	purple_circ_buffer_destroy(irc->outbuf);
+	}
 	g_free(irc->mode_chars);
 	g_free(irc->reqnick);
 #ifdef HAVE_CYRUS_SASL
 						_("Allow plaintext SASL auth over unencrypted connection"),
 						"auth_plain_in_clear", FALSE);
 	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
 #endif
+	option = purple_account_option_int_new(_("Seconds between sending messages"),
+	                                       "ratelimit-interval",
+	                                       IRC_DEFAULT_COMMAND_INTERVAL);
+	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
+	option = purple_account_option_int_new(_("Maximum messages to send at once"),
+	                                       "ratelimit-burst",
+	                                       IRC_DEFAULT_COMMAND_MAX_BURST);
+	prpl_info.protocol_options = g_list_append(prpl_info.protocol_options, option);
 	_irc_plugin = plugin;
 	purple_prefs_remove("/plugins/prpl/irc/quitmsg");
 	purple_prefs_remove("/plugins/prpl/irc");

Mercurial > pidgin3 / file comparison

comparison: libpurple/protocols/irc/irc.c

libpurple/protocols/irc/irc.c