4 * This file contains the management routines for the receive
5 * (incoming packet) queue. The actual packet handlers are in
13 #include <sys/socket.h>
17 * Since not all implementations support MSG_WAITALL, define
18 * an alternate guarenteed read function...
20 * We keep recv() for systems that can do it because it means
21 * a single system call for the entire packet, where read may
22 * take more for a badly fragmented packet.
25 faim_internal int aim_recv(int fd, void *buf, size_t count)
28 return recv(fd, buf, count, MSG_WAITALL);
30 int left, ret, cur = 0;
35 ret = recv(fd, ((unsigned char *)buf)+cur, left, 0);
50 * Grab a single command sequence off the socket, and enqueue
51 * it in the incoming event queue in a seperate struct.
53 faim_export int aim_get_command(struct aim_session_t *sess, struct aim_conn_t *conn)
55 unsigned char generic[6];
56 struct command_rx_struct *newrx = NULL;
62 return -1; /* its a aim_conn_close()'d connection */
64 if (conn->fd < 3) /* can happen when people abuse the interface */
67 if (conn->status & AIM_CONN_STATUS_INPROGRESS)
68 return aim_conn_completeconnect(sess, conn);
71 * Rendezvous (client-client) connections do not speak
72 * FLAP, so this function will break on them.
74 if (conn->type == AIM_CONN_TYPE_RENDEZVOUS)
75 return aim_get_command_rendezvous(sess, conn);
76 if (conn->type == AIM_CONN_TYPE_RENDEZVOUS_OUT) {
77 faimdprintf(sess, 0, "out on fd %d\n", conn->fd);
82 * Read FLAP header. Six bytes:
84 * 0 char -- Always 0x2a
85 * 1 char -- Channel ID. Usually 2 -- 1 and 4 are used during login.
86 * 2 short -- Sequence number
87 * 4 short -- Number of data bytes that follow.
89 faim_mutex_lock(&conn->active);
90 if (aim_recv(conn->fd, generic, 6) < 6){
92 faim_mutex_unlock(&conn->active);
97 * This shouldn't happen unless the socket breaks, the server breaks,
98 * or we break. We must handle it just in case.
100 if (generic[0] != 0x2a) {
101 faimdprintf(sess, 1, "Bad incoming data!");
102 aim_conn_close(conn);
103 faim_mutex_unlock(&conn->active);
107 /* allocate a new struct */
108 if (!(newrx = (struct command_rx_struct *)malloc(sizeof(struct command_rx_struct)))) {
109 faim_mutex_unlock(&conn->active);
112 memset(newrx, 0x00, sizeof(struct command_rx_struct));
114 newrx->lock = 1; /* lock the struct */
116 /* we're doing OSCAR if we're here */
117 newrx->hdrtype = AIM_FRAMETYPE_OSCAR;
119 /* store channel -- byte 2 */
120 newrx->hdr.oscar.type = (char) generic[1];
122 /* store seqnum -- bytes 3 and 4 */
123 newrx->hdr.oscar.seqnum = aimutil_get16(generic+2);
125 /* store commandlen -- bytes 5 and 6 */
126 newrx->commandlen = aimutil_get16(generic+4);
128 newrx->nofree = 0; /* free by default */
130 /* malloc for data portion */
131 if (!(newrx->data = (u_char *) malloc(newrx->commandlen))) {
133 faim_mutex_unlock(&conn->active);
137 /* read the data portion of the packet */
138 if (aim_recv(conn->fd, newrx->data, newrx->commandlen) < newrx->commandlen){
141 aim_conn_close(conn);
142 faim_mutex_unlock(&conn->active);
145 faim_mutex_unlock(&conn->active);
149 newrx->next = NULL; /* this will always be at the bottom */
150 newrx->lock = 0; /* unlock */
152 /* enqueue this packet */
153 if (sess->queue_incoming == NULL) {
154 sess->queue_incoming = newrx;
156 struct command_rx_struct *cur;
159 * This append operation takes a while. It might be faster
160 * if we maintain a pointer to the last entry in the queue
161 * and just update that. Need to determine if the overhead
162 * to maintain that is lower than the overhead for this loop.
164 for (cur = sess->queue_incoming; cur->next; cur = cur->next)
169 newrx->conn->lastactivity = time(NULL);
175 * Purge recieve queue of all handled commands (->handled==1). Also
176 * allows for selective freeing using ->nofree so that the client can
177 * keep the data for various purposes.
179 * If ->nofree is nonzero, the frame will be delinked from the global list,
180 * but will not be free'ed. The client _must_ keep a pointer to the
181 * data -- libfaim will not! If the client marks ->nofree but
182 * does not keep a pointer, it's lost forever.
185 faim_export void aim_purge_rxqueue(struct aim_session_t *sess)
187 struct command_rx_struct *cur = NULL;
188 struct command_rx_struct *tmp;
190 if (sess->queue_incoming == NULL)
193 if (sess->queue_incoming->next == NULL) {
194 if (sess->queue_incoming->handled) {
195 tmp = sess->queue_incoming;
196 sess->queue_incoming = NULL;
199 if (tmp->hdrtype == AIM_FRAMETYPE_OFT)
200 free(tmp->hdr.oft.hdr2);
209 for(cur = sess->queue_incoming; cur->next != NULL; ) {
210 if (cur->next->handled) {
212 cur->next = tmp->next;
214 if (tmp->hdrtype == AIM_FRAMETYPE_OFT)
215 free(tmp->hdr.oft.hdr2);
224 * Be careful here. Because of the way we just
225 * manipulated the pointer, cur may be NULL and
226 * the for() will segfault doing the check unless
227 * we find this case first.
237 * Since aim_get_command will aim_conn_kill dead connections, we need
238 * to clean up the rxqueue of unprocessed connections on that socket.
240 * XXX: this is something that was handled better in the old connection
241 * handling method, but eh.
243 faim_internal void aim_rxqueue_cleanbyconn(struct aim_session_t *sess, struct aim_conn_t *conn)
245 struct command_rx_struct *currx;
247 for (currx = sess->queue_incoming; currx; currx = currx->next) {
248 if ((!currx->handled) && (currx->conn == conn))