comparison libgaim/protocols/oscar/flap_connection.c @ 15106:b2b0839f57d0

[gaim-migrate @ 17891] Outgoing message throttling. If we're sending messages too quickly, and Gaim thinks that sending another message will make AIM give us a warning, then delay sending the message a little bit. Currently only activated for IMs. Let me know if you see any problems. committer: Tailor Script <[e-mail]>

15105:cb7eef7bf550

	aim_tlvlist_free(&tl);

	flap_connection_send(conn, frame);
}

static void
update_rate_class(FlapConnection *conn, guint16 family, guint16 subtype)
{
	GSList *tmp1, *tmp2;

	for (tmp1 = conn->rateclasses; tmp1 != NULL; tmp1 = tmp1->next)
	{

		{
			struct snacpair *snacpair;
			snacpair = tmp2->data;
			if ((snacpair->group == family) && (snacpair->subtype == subtype))
			{
				/*
				 * We've found the rateclass for this SNAC family
				 * and subtype!  Update our "current" average by
				 * calculating a rolling average.  This is pretty
				 * shoddy.  We should really keep track of the times
				 * when the last windowsize messages that were sent
				 * and just calculate the REAL average.
				 */
				struct timeval now;
				struct timezone tz;
				unsigned long timediff; /* In milliseconds */

				gettimeofday(&now, &tz);
				timediff = MIN((now.tv_sec - rateclass->last.tv_sec) * 1000 + (now.tv_usec - rateclass->last.tv_usec) / 1000, rateclass->max);

				/* This formula is taken from the joscar API docs. */
				rateclass->current = MIN(((rateclass->current * (rateclass->windowsize - 1)) + timediff) / rateclass->windowsize, rateclass->max);
				rateclass->last.tv_sec = now.tv_sec;
				rateclass->last.tv_usec = now.tv_usec;

				return;
			}
		}
	}
}


/**
 * This sends a channel 2 FLAP containing a SNAC.  The SNAC family and
 * subtype are looked up in the rate info for this connection, and if
 * sending this SNAC will induce rate limiting then we delay sending
 * of the SNAC by putting it into an outgoing holding queue.
 */
void
flap_connection_send_snac(OscarData *od, FlapConnection *conn, guint16 family, guint16 subtype, guint16 flags, aim_snacid_t snacid, ByteStream *data)
{
	FlapFrame *frame;
	guint32 length;

	length = data != NULL ? data->offset : 0;

	frame = flap_frame_new(od, 0x02, 10 + length);
	aim_putsnac(&frame->data, family, subtype, flags, snacid);

	{
		byte_stream_rewind(data);
		byte_stream_putbs(&frame->data, data, length);
	}

	/* TODO: Outgoing message throttling */
	update_rate_class(conn, family, subtype);

	flap_connection_send(conn, frame);
}

/**

		g_free(rateclass->members->data);
		rateclass->members = g_slist_delete_link(rateclass->members, rateclass->members);
	}

	free(rateclass);
}

static gboolean
flap_connection_destroy_cb(gpointer data)
{

	{
		flap_connection_destroy_rateclass(conn->rateclasses->data);
		conn->rateclasses = g_slist_delete_link(conn->rateclasses, conn->rateclasses);
	}

	g_free(conn);

	return FALSE;
}

	if (datalen > 0)
		byte_stream_new(&frame->data, datalen);

	return frame;
}

/**
 * Free a FlapFrame
 *
 * @param frame The frame to free.
 * @return -1 on error; 0 on success.
 */
static void
flap_frame_destroy(FlapFrame *frame)
{
	free(frame->data.data);
	free(frame);

	return;
}

static void
parse_snac(OscarData *od, FlapConnection *conn, FlapFrame *frame)
{

15106:b2b0839f57d0

	aim_tlvlist_free(&tl);

	flap_connection_send(conn, frame);
}

static struct rateclass *
flap_connection_get_rateclass(FlapConnection *conn, guint16 family, guint16 subtype)
{
	GSList *tmp1, *tmp2;

	for (tmp1 = conn->rateclasses; tmp1 != NULL; tmp1 = tmp1->next)
	{

		{
			struct snacpair *snacpair;
			snacpair = tmp2->data;
			if ((snacpair->group == family) && (snacpair->subtype == subtype))
			{
				return rateclass;
			}
		}
	}

	return NULL;
}

/*
 * Attempt to calculate what our new current average would be if we
 * were to send a SNAC in this rateclass at the given time.
 */
static guint32
rateclass_get_new_current(FlapConnection *conn, struct rateclass *rateclass, struct timeval now)
{
	unsigned long timediff; /* In milliseconds */

	timediff = (now.tv_sec - rateclass->last.tv_sec) * 1000 + (now.tv_usec - rateclass->last.tv_usec) / 1000;

	/* This formula is taken from the joscar API docs. Preesh. */
	return MIN(((rateclass->current * (rateclass->windowsize - 1)) + timediff) / rateclass->windowsize, rateclass->max);
}

static gboolean flap_connection_send_queued(gpointer data)
{
	FlapConnection *conn;
	struct timeval now;

	conn = data;
	gettimeofday(&now, NULL);

	while (conn->queued_snacs != NULL)
	{
		QueuedSnac *queued_snac;
		struct rateclass *rateclass;

		queued_snac = conn->queued_snacs->data;

		rateclass = flap_connection_get_rateclass(conn, queued_snac->family, queued_snac->subtype);
		if (rateclass != NULL)
		{
			guint32 new_current;

			new_current = rateclass_get_new_current(conn, rateclass, now);

			if (new_current < rateclass->alert)
				/* Not ready to send this SNAC yet--keep waiting. */
				return TRUE;

			rateclass->current = new_current;
			rateclass->last.tv_sec = now.tv_sec;
			rateclass->last.tv_usec = now.tv_usec;
		}

		flap_connection_send(conn, queued_snac->frame);
		g_free(queued_snac);
		conn->queued_snacs = g_slist_delete_link(conn->queued_snacs, conn->queued_snacs);
	}

	conn->outgoing_timeout = 0;
	return FALSE;
}

/**
 * This sends a channel 2 FLAP containing a SNAC.  The SNAC family and
 * subtype are looked up in the rate info for this connection, and if
 * sending this SNAC will induce rate limiting then we delay sending
 * of the SNAC by putting it into an outgoing holding queue.
 *
 * @param data The optional bytestream that makes up the data portion
 *        of this SNAC.  For empty SNACs this should be NULL.
 */
void
flap_connection_send_snac(OscarData *od, FlapConnection *conn, guint16 family, guint16 subtype, guint16 flags, aim_snacid_t snacid, ByteStream *data)
{
	FlapFrame *frame;
	guint32 length;
	gboolean enqueue = FALSE;
	struct rateclass *rateclass;

	length = data != NULL ? data->offset : 0;

	frame = flap_frame_new(od, 0x02, 10 + length);
	aim_putsnac(&frame->data, family, subtype, flags, snacid);

	{
		byte_stream_rewind(data);
		byte_stream_putbs(&frame->data, data, length);
	}

	if (conn->outgoing_timeout != 0)
		enqueue = TRUE;
	else if ((rateclass = flap_connection_get_rateclass(conn, family, subtype)) != NULL)
	{
		struct timeval now;
		guint32 new_current;

		gettimeofday(&now, NULL);
		new_current = rateclass_get_new_current(conn, rateclass, now);

		if (new_current < rateclass->alert)
		{
			enqueue = TRUE;
		}
		else
		{
			rateclass->current = new_current;
			rateclass->last.tv_sec = now.tv_sec;
			rateclass->last.tv_usec = now.tv_usec;
		}
	}

	if (enqueue)
	{
		/* We've been sending too fast, so delay this message */
		QueuedSnac *queued_snac;

		queued_snac = g_new(QueuedSnac, 1);
		queued_snac->family = family;
		queued_snac->subtype = subtype;
		queued_snac->frame = frame;
		conn->queued_snacs = g_slist_append(conn->queued_snacs, queued_snac);

		if (conn->outgoing_timeout == 0)
			conn->outgoing_timeout = gaim_timeout_add(500, flap_connection_send_queued, conn);

		return;
	}

	flap_connection_send(conn, frame);
}

/**

		g_free(rateclass->members->data);
		rateclass->members = g_slist_delete_link(rateclass->members, rateclass->members);
	}

	free(rateclass);
}

/**
 * Free a FlapFrame
 *
 * @param frame The frame to free.
 */
static void
flap_frame_destroy(FlapFrame *frame)
{
	free(frame->data.data);
	free(frame);
}

static gboolean
flap_connection_destroy_cb(gpointer data)
{

	{
		flap_connection_destroy_rateclass(conn->rateclasses->data);
		conn->rateclasses = g_slist_delete_link(conn->rateclasses, conn->rateclasses);
	}

	while (conn->queued_snacs != NULL)
	{
		QueuedSnac *queued_snac;
		queued_snac = conn->queued_snacs->data;
		flap_frame_destroy(queued_snac->frame);
		g_free(queued_snac);
		conn->queued_snacs = g_slist_delete_link(conn->queued_snacs, conn->queued_snacs);
	}
	if (conn->outgoing_timeout > 0)
		gaim_timeout_remove(conn->outgoing_timeout);

	g_free(conn);

	return FALSE;
}

	if (datalen > 0)
		byte_stream_new(&frame->data, datalen);

	return frame;
}

static void
parse_snac(OscarData *od, FlapConnection *conn, FlapFrame *frame)
{