1 files changed, 113 insertions, 79 deletions

diff --git a/protocols/oscar/rxqueue.c b/protocols/oscar/rxqueue.c
index 9ac8466e..e5c52376 100644
--- a/protocols/oscar/rxqueue.c
+++ b/protocols/oscar/rxqueue.c
@@ -6,7 +6,7 @@
  * aim_rxhandlers.c.
  */
 
-#include <aim.h> 
+#include <aim.h>
 
 #include <sys/socket.h>
 
@@ -15,16 +15,17 @@
  */
 int aim_recv(int fd, void *buf, size_t count)
 {
-	int left, cur; 
+	int left, cur;
 
 	for (cur = 0, left = count; left; ) {
 		int ret;
-		
-		ret = recv(fd, ((unsigned char *)buf)+cur, left, 0);
+
+		ret = recv(fd, ((unsigned char *) buf) + cur, left, 0);
 
 		/* Of course EOF is an error, only morons disagree with that. */
-		if (ret <= 0)
+		if (ret <= 0) {
 			return -1;
+		}
 
 		cur += ret;
 		left -= ret;
@@ -41,18 +42,21 @@ static int aim_bstream_recv(aim_bstream_t *bs, int fd, size_t count)
 {
 	int red = 0;
 
-	if (!bs || (fd < 0) || (count < 0))
+	if (!bs || (fd < 0) || (count < 0)) {
 		return -1;
-	
-	if (count > (bs->len - bs->offset))
+	}
+
+	if (count > (bs->len - bs->offset)) {
 		count = bs->len - bs->offset; /* truncate to remaining space */
 
+	}
 	if (count) {
 
 		red = aim_recv(fd, bs->data + bs->offset, count);
 
-		if (red <= 0)
+		if (red <= 0) {
 			return -1;
+		}
 	}
 
 	bs->offset += red;
@@ -62,9 +66,10 @@ static int aim_bstream_recv(aim_bstream_t *bs, int fd, size_t count)
 
 int aim_bstream_init(aim_bstream_t *bs, guint8 *data, int len)
 {
-	
-	if (!bs)
+
+	if (!bs) {
 		return -1;
+	}
 
 	bs->data = data;
 	bs->len = len;
@@ -86,8 +91,9 @@ int aim_bstream_curpos(aim_bstream_t *bs)
 int aim_bstream_setpos(aim_bstream_t *bs, int off)
 {
 
-	if (off > bs->len)
+	if (off > bs->len) {
 		return -1;
+	}
 
 	bs->offset = off;
 
@@ -105,9 +111,10 @@ void aim_bstream_rewind(aim_bstream_t *bs)
 int aim_bstream_advance(aim_bstream_t *bs, int n)
 {
 
-	if (aim_bstream_empty(bs) < n)
+	if (aim_bstream_empty(bs) < n) {
 		return 0; /* XXX throw an exception */
 
+	}
 	bs->offset += n;
 
 	return n;
@@ -115,76 +122,83 @@ int aim_bstream_advance(aim_bstream_t *bs, int n)
 
 guint8 aimbs_get8(aim_bstream_t *bs)
 {
-	
-	if (aim_bstream_empty(bs) < 1)
+
+	if (aim_bstream_empty(bs) < 1) {
 		return 0; /* XXX throw an exception */
-	
+
+	}
 	bs->offset++;
-	
+
 	return aimutil_get8(bs->data + bs->offset - 1);
 }
 
 guint16 aimbs_get16(aim_bstream_t *bs)
 {
-	
-	if (aim_bstream_empty(bs) < 2)
+
+	if (aim_bstream_empty(bs) < 2) {
 		return 0; /* XXX throw an exception */
-	
+
+	}
 	bs->offset += 2;
-	
+
 	return aimutil_get16(bs->data + bs->offset - 2);
 }
 
 guint32 aimbs_get32(aim_bstream_t *bs)
 {
-	
-	if (aim_bstream_empty(bs) < 4)
+
+	if (aim_bstream_empty(bs) < 4) {
 		return 0; /* XXX throw an exception */
-	
+
+	}
 	bs->offset += 4;
-	
+
 	return aimutil_get32(bs->data + bs->offset - 4);
 }
 
 guint8 aimbs_getle8(aim_bstream_t *bs)
 {
-	
-	if (aim_bstream_empty(bs) < 1)
+
+	if (aim_bstream_empty(bs) < 1) {
 		return 0; /* XXX throw an exception */
-	
+
+	}
 	bs->offset++;
-	
+
 	return aimutil_getle8(bs->data + bs->offset - 1);
 }
 
 guint16 aimbs_getle16(aim_bstream_t *bs)
 {
-	
-	if (aim_bstream_empty(bs) < 2)
+
+	if (aim_bstream_empty(bs) < 2) {
 		return 0; /* XXX throw an exception */
-	
+
+	}
 	bs->offset += 2;
-	
+
 	return aimutil_getle16(bs->data + bs->offset - 2);
 }
 
 guint32 aimbs_getle32(aim_bstream_t *bs)
 {
-	
-	if (aim_bstream_empty(bs) < 4)
+
+	if (aim_bstream_empty(bs) < 4) {
 		return 0; /* XXX throw an exception */
-	
+
+	}
 	bs->offset += 4;
-	
+
 	return aimutil_getle32(bs->data + bs->offset - 4);
 }
 
 int aimbs_put8(aim_bstream_t *bs, guint8 v)
 {
 
-	if (aim_bstream_empty(bs) < 1)
+	if (aim_bstream_empty(bs) < 1) {
 		return 0; /* XXX throw an exception */
 
+	}
 	bs->offset += aimutil_put8(bs->data + bs->offset, v);
 
 	return 1;
@@ -193,9 +207,10 @@ int aimbs_put8(aim_bstream_t *bs, guint8 v)
 int aimbs_put16(aim_bstream_t *bs, guint16 v)
 {
 
-	if (aim_bstream_empty(bs) < 2)
+	if (aim_bstream_empty(bs) < 2) {
 		return 0; /* XXX throw an exception */
 
+	}
 	bs->offset += aimutil_put16(bs->data + bs->offset, v);
 
 	return 2;
@@ -204,9 +219,10 @@ int aimbs_put16(aim_bstream_t *bs, guint16 v)
 int aimbs_put32(aim_bstream_t *bs, guint32 v)
 {
 
-	if (aim_bstream_empty(bs) < 4)
+	if (aim_bstream_empty(bs) < 4) {
 		return 0; /* XXX throw an exception */
 
+	}
 	bs->offset += aimutil_put32(bs->data + bs->offset, v);
 
 	return 1;
@@ -215,9 +231,10 @@ int aimbs_put32(aim_bstream_t *bs, guint32 v)
 int aimbs_putle8(aim_bstream_t *bs, guint8 v)
 {
 
-	if (aim_bstream_empty(bs) < 1)
+	if (aim_bstream_empty(bs) < 1) {
 		return 0; /* XXX throw an exception */
 
+	}
 	bs->offset += aimutil_putle8(bs->data + bs->offset, v);
 
 	return 1;
@@ -226,9 +243,10 @@ int aimbs_putle8(aim_bstream_t *bs, guint8 v)
 int aimbs_putle16(aim_bstream_t *bs, guint16 v)
 {
 
-	if (aim_bstream_empty(bs) < 2)
+	if (aim_bstream_empty(bs) < 2) {
 		return 0; /* XXX throw an exception */
 
+	}
 	bs->offset += aimutil_putle16(bs->data + bs->offset, v);
 
 	return 2;
@@ -237,9 +255,10 @@ int aimbs_putle16(aim_bstream_t *bs, guint16 v)
 int aimbs_putle32(aim_bstream_t *bs, guint32 v)
 {
 
-	if (aim_bstream_empty(bs) < 4)
+	if (aim_bstream_empty(bs) < 4) {
 		return 0; /* XXX throw an exception */
 
+	}
 	bs->offset += aimutil_putle32(bs->data + bs->offset, v);
 
 	return 1;
@@ -248,8 +267,9 @@ int aimbs_putle32(aim_bstream_t *bs, guint32 v)
 int aimbs_getrawbuf(aim_bstream_t *bs, guint8 *buf, int len)
 {
 
-	if (aim_bstream_empty(bs) < len)
+	if (aim_bstream_empty(bs) < len) {
 		return 0;
+	}
 
 	memcpy(buf, bs->data + bs->offset, len);
 	bs->offset += len;
@@ -261,8 +281,9 @@ guint8 *aimbs_getraw(aim_bstream_t *bs, int len)
 {
 	guint8 *ob;
 
-	if (!(ob = g_malloc(len)))
+	if (!(ob = g_malloc(len))) {
 		return NULL;
+	}
 
 	if (aimbs_getrawbuf(bs, ob, len) < len) {
 		g_free(ob);
@@ -276,25 +297,27 @@ char *aimbs_getstr(aim_bstream_t *bs, int len)
 {
 	guint8 *ob;
 
-	if (!(ob = g_malloc(len+1)))
+	if (!(ob = g_malloc(len + 1))) {
 		return NULL;
+	}
 
 	if (aimbs_getrawbuf(bs, ob, len) < len) {
 		g_free(ob);
 		return NULL;
 	}
-	
+
 	ob[len] = '\0';
 
-	return (char *)ob;
+	return (char *) ob;
 }
 
 int aimbs_putraw(aim_bstream_t *bs, const guint8 *v, int len)
 {
 
-	if (aim_bstream_empty(bs) < len)
+	if (aim_bstream_empty(bs) < len) {
 		return 0; /* XXX throw an exception */
 
+	}
 	memcpy(bs->data + bs->offset, v, len);
 	bs->offset += len;
 
@@ -304,12 +327,14 @@ int aimbs_putraw(aim_bstream_t *bs, const guint8 *v, int len)
 int aimbs_putbs(aim_bstream_t *bs, aim_bstream_t *srcbs, int len)
 {
 
-	if (aim_bstream_empty(srcbs) < len)
+	if (aim_bstream_empty(srcbs) < len) {
 		return 0; /* XXX throw exception (underrun) */
 
-	if (aim_bstream_empty(bs) < len)
+	}
+	if (aim_bstream_empty(bs) < len) {
 		return 0; /* XXX throw exception (overflow) */
 
+	}
 	memcpy(bs->data + bs->offset, srcbs->data + srcbs->offset, len);
 	bs->offset += len;
 	srcbs->offset += len;
@@ -318,10 +343,10 @@ int aimbs_putbs(aim_bstream_t *bs, aim_bstream_t *srcbs, int len)
 }
 
 /**
- * aim_frame_destroy - free aim_frame_t 
- * @frame: the frame to free  
+ * aim_frame_destroy - free aim_frame_t
+ * @frame: the frame to free
  *
- * returns -1 on error; 0 on success.  
+ * returns -1 on error; 0 on success.
  *
  */
 void aim_frame_destroy(aim_frame_t *frame)
@@ -330,7 +355,7 @@ void aim_frame_destroy(aim_frame_t *frame)
 	g_free(frame->data.data); /* XXX aim_bstream_free */
 
 	g_free(frame);
-} 
+}
 
 
 /*
@@ -343,34 +368,37 @@ int aim_get_command(aim_session_t *sess, aim_conn_t *conn)
 	aim_bstream_t flaphdr;
 	aim_frame_t *newrx;
 	guint16 payloadlen;
-	
-	if (!sess || !conn)
+
+	if (!sess || !conn) {
 		return 0;
+	}
 
-	if (conn->fd == -1)
+	if (conn->fd == -1) {
 		return -1; /* its a aim_conn_close()'d connection */
 
+	}
 	/* KIDS, THIS IS WHAT HAPPENS IF YOU USE CODE WRITTEN FOR GUIS IN A DAEMON!
-	   
+
 	   And wouldn't it make sense to return something that prevents this function
 	   from being called again IMMEDIATELY (and making the program suck up all
 	   CPU time)?...
-	   
+
 	if (conn->fd < 3)
-		return 0;
+	        return 0;
 	*/
 
-	if (conn->status & AIM_CONN_STATUS_INPROGRESS)
+	if (conn->status & AIM_CONN_STATUS_INPROGRESS) {
 		return aim_conn_completeconnect(sess, conn);
+	}
 
 	aim_bstream_init(&flaphdr, flaphdr_raw, sizeof(flaphdr_raw));
 
 	/*
 	 * Read FLAP header.  Six bytes:
-	 *    
+	 *
 	 *   0 char  -- Always 0x2a
 	 *   1 char  -- Channel ID.  Usually 2 -- 1 and 4 are used during login.
-	 *   2 short -- Sequence number 
+	 *   2 short -- Sequence number
 	 *   4 short -- Number of data bytes that follow.
 	 */
 	if (aim_bstream_recv(&flaphdr, conn->fd, 6) < 6) {
@@ -390,15 +418,16 @@ int aim_get_command(aim_session_t *sess, aim_conn_t *conn)
 		imcb_error(sess->aux_data, "FLAP framing disrupted");
 		aim_conn_close(conn);
 		return -1;
-	}	
+	}
 
 	/* allocate a new struct */
-	if (!(newrx = (aim_frame_t *)g_new0(aim_frame_t,1)))
+	if (!(newrx = (aim_frame_t *) g_new0(aim_frame_t, 1))) {
 		return -1;
+	}
 
 	/* we're doing FLAP if we're here */
 	newrx->hdrtype = AIM_FRAMETYPE_FLAP;
-	
+
 	newrx->hdr.flap.type = aimbs_get8(&flaphdr);
 	newrx->hdr.flap.seqnum = aimbs_get16(&flaphdr);
 	payloadlen = aimbs_get16(&flaphdr);
@@ -421,8 +450,9 @@ int aim_get_command(aim_session_t *sess, aim_conn_t *conn)
 			aim_conn_close(conn);
 			return -1;
 		}
-	} else
+	} else {
 		aim_bstream_init(&newrx->data, NULL, 0);
+	}
 
 
 	aim_bstream_rewind(&newrx->data);
@@ -431,27 +461,28 @@ int aim_get_command(aim_session_t *sess, aim_conn_t *conn)
 
 	newrx->next = NULL;  /* this will always be at the bottom */
 
-	if (!sess->queue_incoming)
+	if (!sess->queue_incoming) {
 		sess->queue_incoming = newrx;
-	else {
+	} else {
 		aim_frame_t *cur;
 
-		for (cur = sess->queue_incoming; cur->next; cur = cur->next)
+		for (cur = sess->queue_incoming; cur->next; cur = cur->next) {
 			;
+		}
 		cur->next = newrx;
 	}
 
 	newrx->conn->lastactivity = time(NULL);
 
-	return 0;  
+	return 0;
 }
 
 /*
  * Purge recieve queue of all handled commands (->handled==1).  Also
  * allows for selective freeing using ->nofree so that the client can
- * keep the data for various purposes.  
+ * keep the data for various purposes.
  *
- * If ->nofree is nonzero, the frame will be delinked from the global list, 
+ * If ->nofree is nonzero, the frame will be delinked from the global list,
  * but will not be free'ed.  The client _must_ keep a pointer to the
  * data -- libfaim will not!  If the client marks ->nofree but
  * does not keep a pointer, it's lost forever.
@@ -465,12 +496,14 @@ void aim_purge_rxqueue(aim_session_t *sess)
 		if (cur->handled) {
 
 			*prev = cur->next;
-			
-			if (!cur->nofree)
+
+			if (!cur->nofree) {
 				aim_frame_destroy(cur);
+			}
 
-		} else
+		} else {
 			prev = &cur->next;
+		}
 	}
 
 	return;
@@ -488,9 +521,10 @@ void aim_rxqueue_cleanbyconn(aim_session_t *sess, aim_conn_t *conn)
 	aim_frame_t *currx;
 
 	for (currx = sess->queue_incoming; currx; currx = currx->next) {
-		if ((!currx->handled) && (currx->conn == conn))
+		if ((!currx->handled) && (currx->conn == conn)) {
 			currx->handled = 1;
-	}	
+		}
+	}
 	return;
 }