X-Git-Url: http://andersk.mit.edu/gitweb/libfaim.git/blobdiff_plain/a25832e66b80e7159f37795cff5593b748ac5f59..2acf2afad3a97974e7279e37ea7b53f1ce414676:/aim_rxqueue.c diff --git a/aim_rxqueue.c b/aim_rxqueue.c index 73fd5a3..6cc1806 100644 --- a/aim_rxqueue.c +++ b/aim_rxqueue.c @@ -1,266 +1,252 @@ /* - 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 +#ifndef _WIN32 +#include +#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 ) - * -*/ -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; }