/*
- aim_rxqueue.c
-
- This file contains the management routines for the receive
- (incoming packet) queue. The actual packet handlers are in
- aim_rxhandlers.c.
-
+ * aim_rxqueue.c
+ *
+ * This file contains the management routines for the receive
+ * (incoming packet) queue. The actual packet handlers are in
+ * aim_rxhandlers.c.
*/
+#define FAIM_INTERNAL
#include <faim/aim.h>
+#ifndef _WIN32
+#include <sys/socket.h>
+#endif
+
/*
- * This is a modified read() to make SURE we get the number
- * of bytes we are told to, otherwise block.
+ * Since not all implementations support MSG_WAITALL, define
+ * an alternate guarenteed read function...
+ *
+ * We keep recv() for systems that can do it because it means
+ * a single system call for the entire packet, where read may
+ * take more for a badly fragmented packet.
*
- * Modified to count errno (Sébastien Carpe <scarpe@atos-group.com>)
- *
-*/
-int Read(int fd, u_char *buf, int len)
+ */
+faim_internal int aim_recv(int fd, void *buf, size_t count)
{
- int i = 0;
- int j = 0;
- int err_count=0;
-
- while ((i < len) && (!(i < 0)))
- {
- j = read(fd, &(buf[i]), len-i);
- if ( (j < 0) && (errno != EAGAIN))
- return -errno; /* fail */
- else if (j==0)
- {
- err_count++;
- if (err_count> MAX_READ_ERROR) {
- /*
- * Reached maximum number of allowed read errors.
- *
- * Lets suppose the connection is lost and errno didn't
- * know it.
- *
- */
- return (-1);
- }
- }
- else
- i += j; /* success, continue */
- }
- return i;
+#ifdef MSG_WAITALL
+ return recv(fd, buf, count, MSG_WAITALL);
+#else
+ int left, ret, cur = 0;
+
+ left = count;
+
+ while (left) {
+ ret = recv(fd, ((unsigned char *)buf)+cur, left, 0);
+ if (ret == -1)
+ return -1;
+ if (ret == 0)
+ return cur;
+
+ cur += ret;
+ left -= ret;
+ }
+
+ return cur;
+#endif
}
-/*
- * Grab as many command sequences as we can off the socket, and enqueue
- * each command in the incoming event queue in a seperate struct.
+/*
+ * Grab a single command sequence off the socket, and enqueue
+ * it in the incoming event queue in a seperate struct.
*/
-int aim_get_command(struct aim_session_t *sess)
+faim_export int aim_get_command(struct aim_session_t *sess, struct aim_conn_t *conn)
{
- int i, readgood, j, isav, err;
- int s;
- fd_set fds;
- struct timeval tv;
- char generic[6];
- struct command_rx_struct *workingStruct = NULL;
- struct command_rx_struct *workingPtr = NULL;
- struct aim_conn_t *conn = NULL;
-#if debug > 0
- printf("Reading generic/unknown response...");
-#endif
-
-
- /* dont wait at all (ie, never call this unless something is there) */
- tv.tv_sec = 0;
- tv.tv_usec = 0;
- conn = aim_select(sess, &tv);
+ unsigned char generic[6];
+ struct command_rx_struct *newrx = NULL;
- if (conn==NULL)
- return 0; /* nothing waiting */
+ if (!sess || !conn)
+ return 0;
- s = conn->fd;
+ if (conn->fd == -1)
+ return -1; /* its a aim_conn_close()'d connection */
- if (s < 3)
+ if (conn->fd < 3) /* can happen when people abuse the interface */
return 0;
- FD_ZERO(&fds);
- FD_SET(s, &fds);
- tv.tv_sec = 0; /* wait, but only for 10us */
- tv.tv_usec = 10;
-
- generic[0] = 0x00;
-
- readgood = 0;
- i = 0;
- j = 0;
- /* read first 6 bytes (the FLAP header only) off the socket */
- while ( (select(s+1, &fds, NULL, NULL, &tv) == 1) && (i < 6))
- {
- if ((err = Read(s, &(generic[i]), 1)) < 0)
- {
- /* error is probably not recoverable...(must be a pessimistic day) */
- aim_conn_close(conn);
- return err;
- }
-
- if (readgood == 0)
- {
- if (generic[i] == 0x2a)
- {
- readgood = 1;
-#if debug > 1
- printf("%x ", generic[i]);
- fflush(stdout);
-#endif
- i++;
- }
- else
- {
-#if debug > 1
- printf("skipping 0x%d ", generic[i]);
- fflush(stdout);
-#endif
- j++;
- }
- }
- else
- {
-#if debug > 1
- printf("%x ", generic[i]);
-#endif
- i++;
- }
- FD_ZERO(&fds);
- FD_SET(s, &fds);
- tv.tv_sec= 2;
- tv.tv_usec= 2;
- }
+ if (conn->status & AIM_CONN_STATUS_INPROGRESS)
+ return aim_conn_completeconnect(sess, conn);
+
+ /*
+ * Rendezvous (client-client) connections do not speak
+ * FLAP, so this function will break on them.
+ */
+ if (conn->type == AIM_CONN_TYPE_RENDEZVOUS)
+ return aim_get_command_rendezvous(sess, conn);
+ if (conn->type == AIM_CONN_TYPE_RENDEZVOUS_OUT) {
+ printf("out on fd %d\n", conn->fd);
+ return 0;
+ }
+
+ /*
+ * 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
+ * 4 short -- Number of data bytes that follow.
+ */
+ faim_mutex_lock(&conn->active);
+ if (aim_recv(conn->fd, generic, 6) < 6){
+ aim_conn_close(conn);
+ faim_mutex_unlock(&conn->active);
+ return -1;
+ }
+
+ /*
+ * This shouldn't happen unless the socket breaks, the server breaks,
+ * or we break. We must handle it just in case.
+ */
+ if (generic[0] != 0x2a) {
+ faimdprintf(1, "Bad incoming data!");
+ aim_conn_close(conn);
+ faim_mutex_unlock(&conn->active);
+ return -1;
+ }
- if (generic[0] != 0x2a)
- {
- /* this really shouldn't happen, since the main loop
- select() should protect us from entering this function
- without data waiting */
- printf("Bad incoming data!");
- return -1;
- }
+ /* allocate a new struct */
+ if (!(newrx = (struct command_rx_struct *)malloc(sizeof(struct command_rx_struct)))) {
+ faim_mutex_unlock(&conn->active);
+ return -1;
+ }
+ memset(newrx, 0x00, sizeof(struct command_rx_struct));
- isav = i;
+ newrx->lock = 1; /* lock the struct */
- /* allocate a new struct */
- workingStruct = (struct command_rx_struct *) malloc(sizeof(struct command_rx_struct));
- workingStruct->lock = 1; /* lock the struct */
+ /* we're doing OSCAR if we're here */
+ newrx->hdrtype = AIM_FRAMETYPE_OSCAR;
/* store channel -- byte 2 */
- workingStruct->type = (char) generic[1];
+ newrx->hdr.oscar.type = (char) generic[1];
/* store seqnum -- bytes 3 and 4 */
- workingStruct->seqnum = aimutil_get16(generic+2);
+ newrx->hdr.oscar.seqnum = aimutil_get16(generic+2);
/* store commandlen -- bytes 5 and 6 */
- workingStruct->commandlen = aimutil_get16(generic+4);
+ newrx->commandlen = aimutil_get16(generic+4);
+
+ newrx->nofree = 0; /* free by default */
/* malloc for data portion */
- workingStruct->data = (u_char *) malloc(workingStruct->commandlen);
+ if (!(newrx->data = (u_char *) malloc(newrx->commandlen))) {
+ free(newrx);
+ faim_mutex_unlock(&conn->active);
+ return -1;
+ }
/* read the data portion of the packet */
- i = Read(s, workingStruct->data, workingStruct->commandlen);
- if (i < 0)
- {
- aim_conn_close(conn);
- return i;
- }
+ if (aim_recv(conn->fd, newrx->data, newrx->commandlen) < newrx->commandlen){
+ free(newrx->data);
+ free(newrx);
+ aim_conn_close(conn);
+ faim_mutex_unlock(&conn->active);
+ return -1;
+ }
+ faim_mutex_unlock(&conn->active);
-#if debug > 0
- printf(" done. (%db+%db read, %db skipped)\n", isav, i, j);
-#endif
-
- workingStruct->conn = conn;
+ newrx->conn = conn;
- workingStruct->next = NULL; /* this will always be at the bottom */
- workingStruct->lock = 0; /* unlock */
+ newrx->next = NULL; /* this will always be at the bottom */
+ newrx->lock = 0; /* unlock */
/* enqueue this packet */
- if (sess->queue_incoming == NULL)
- {
- sess->queue_incoming = workingStruct;
- }
- else
- {
- workingPtr = sess->queue_incoming;
- while (workingPtr->next != NULL)
- workingPtr = workingPtr->next;
- workingPtr->next = workingStruct;
- }
-
+ if (sess->queue_incoming == NULL) {
+ sess->queue_incoming = newrx;
+ } else {
+ struct command_rx_struct *cur;
+
+ /*
+ * This append operation takes a while. It might be faster
+ * if we maintain a pointer to the last entry in the queue
+ * and just update that. Need to determine if the overhead
+ * to maintain that is lower than the overhead for this loop.
+ */
+ for (cur = sess->queue_incoming; cur->next; cur = cur->next)
+ ;
+ cur->next = newrx;
+ }
- workingStruct->conn->lastactivity = time(NULL);
+ newrx->conn->lastactivity = time(NULL);
return 0;
}
/*
- * purge_rxqueue()
+ * 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.
*
- * This is just what it sounds. It purges the receive (rx) queue of
- * all handled commands. This is normally called from inside
- * aim_rxdispatch() after it's processed all the commands in the queue.
+ * 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.
*
*/
-struct command_rx_struct *aim_purge_rxqueue(struct command_rx_struct *queue)
+faim_export void aim_purge_rxqueue(struct aim_session_t *sess)
{
- struct command_rx_struct *workingPtr = NULL;
- struct command_rx_struct *workingPtr2 = NULL;
+ struct command_rx_struct *cur = NULL;
+ struct command_rx_struct *tmp;
- if (queue == (struct command_rx_struct *)NULL)
- {
- /* do nothing */
- }
- else if (queue->next == (struct command_rx_struct *)NULL)
- {
- if (queue->handled == 1) {
- workingPtr = queue;
- queue = NULL;
- free(workingPtr->data);
- free(workingPtr);
- }
- }
- else
- {
- while (queue->handled == 1)
- {
- workingPtr = queue;
- queue = queue->next;
- free(workingPtr->data);
- free(workingPtr);
- }
-
- workingPtr = queue;
-
- while (workingPtr->next != (struct command_rx_struct *)NULL)
- {
- if (workingPtr->next->handled == 1)
- {
- workingPtr2 = workingPtr->next;
- workingPtr->next = workingPtr->next->next;
- free(workingPtr2->data);
- free(workingPtr2);
- }
- else /* TODO: rework this so the additional if isn't needed */
- {
- if (workingPtr->next == (struct command_rx_struct *)NULL)
- {
- if (workingPtr->handled == 1)
- {
- workingPtr2 = workingPtr;
- workingPtr = NULL;
- free(workingPtr2->data);
- free(workingPtr2);
- return queue;
- }
- }
- else
- {
- workingPtr = workingPtr->next;
- }
- }
- }
+ if (sess->queue_incoming == NULL)
+ return;
+
+ if (sess->queue_incoming->next == NULL) {
+ if (sess->queue_incoming->handled) {
+ tmp = sess->queue_incoming;
+ sess->queue_incoming = NULL;
+
+ if (!tmp->nofree) {
+ if (tmp->hdrtype == AIM_FRAMETYPE_OFT)
+ free(tmp->hdr.oft.hdr2);
+ free(tmp->data);
+ free(tmp);
+ } else
+ tmp->next = NULL;
}
- return queue;
+ return;
+ }
+
+ for(cur = sess->queue_incoming; cur->next != NULL; ) {
+ if (cur->next->handled) {
+ tmp = cur->next;
+ cur->next = tmp->next;
+ if (!tmp->nofree) {
+ if (tmp->hdrtype == AIM_FRAMETYPE_OFT)
+ free(tmp->hdr.oft.hdr2);
+ free(tmp->data);
+ free(tmp);
+ } else
+ tmp->next = NULL;
+ }
+ cur = cur->next;
+
+ /*
+ * Be careful here. Because of the way we just
+ * manipulated the pointer, cur may be NULL and
+ * the for() will segfault doing the check unless
+ * we find this case first.
+ */
+ if (cur == NULL)
+ break;
+ }
+
+ return;
+}
+
+/*
+ * Since aim_get_command will aim_conn_kill dead connections, we need
+ * to clean up the rxqueue of unprocessed connections on that socket.
+ *
+ * XXX: this is something that was handled better in the old connection
+ * handling method, but eh.
+ */
+faim_internal void aim_rxqueue_cleanbyconn(struct aim_session_t *sess, struct aim_conn_t *conn)
+{
+ struct command_rx_struct *currx;
+
+ for (currx = sess->queue_incoming; currx; currx = currx->next) {
+ if ((!currx->handled) && (currx->conn == conn))
+ currx->handled = 1;
+ }
+ return;
}
andersk / libfaim.git / blobdiff