aim_rxqueue.c

   1 /*
   2  *  aim_rxqueue.c
   3  *
   4  * This file contains the management routines for the receive
   5  * (incoming packet) queue.  The actual packet handlers are in
   6  * aim_rxhandlers.c.
   7  */
   8
   9 #define FAIM_INTERNAL
  10 #include <faim/aim.h>
  11
  12 #ifndef _WIN32
  13 #include <sys/socket.h>
  14 #endif
  15
  16 /*
  17  * Since not all implementations support MSG_WAITALL, define
  18  * an alternate guarenteed read function...
  19  *
  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.
  23  *
  24  */
  25 faim_internal int aim_recv(int fd, void *buf, size_t count)
  26 {
  27 #ifdef MSG_WAITALL
  28   return recv(fd, buf, count, MSG_WAITALL);
  29 #else
  30   int left, ret, cur = 0;
  31
  32   left = count;
  33
  34   while (left) {
  35     ret = recv(fd, ((unsigned char *)buf)+cur, left, 0);
  36     if (ret == -1)
  37       return -1;
  38     if (ret == 0)
  39       return cur;
  40
  41     cur += ret;
  42     left -= ret;
  43   }
  44
  45   return cur;
  46 #endif
  47 }
  48
  49 /*
  50  * Grab a single command sequence off the socket, and enqueue
  51  * it in the incoming event queue in a seperate struct.
  52  */
  53 faim_export int aim_get_command(struct aim_session_t *sess, struct aim_conn_t *conn)
  54 {
  55   unsigned char generic[6];
  56   struct command_rx_struct *newrx = NULL;
  57
  58   if (!sess || !conn)
  59     return 0;
  60
  61   if (conn->fd == -1)
  62     return -1; /* its a aim_conn_close()'d connection */
  63
  64   if (conn->fd < 3)  /* can happen when people abuse the interface */
  65     return 0;
  66
  67   if (conn->status & AIM_CONN_STATUS_INPROGRESS)
  68     return aim_conn_completeconnect(sess, conn);
  69
  70   /*
  71    * Rendezvous (client-client) connections do not speak
  72    * FLAP, so this function will break on them.
  73    */
  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     printf("out on fd %d\n", conn->fd);
  78     return 0;
  79   }
  80
  81   /*
  82    * Read FLAP header.  Six bytes:
  83    *
  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.
  88    */
  89   faim_mutex_lock(&conn->active);
  90   if (aim_recv(conn->fd, generic, 6) < 6){
  91     aim_conn_close(conn);
  92     faim_mutex_unlock(&conn->active);
  93     return -1;
  94   }
  95
  96   /*
  97    * This shouldn't happen unless the socket breaks, the server breaks,
  98    * or we break.  We must handle it just in case.
  99    */
 100   if (generic[0] != 0x2a) {
 101     faimdprintf(1, "Bad incoming data!");
 102     aim_conn_close(conn);
 103     faim_mutex_unlock(&conn->active);
 104     return -1;
 105   }
 106
 107   /* allocate a new struct */
 108   if (!(newrx = (struct command_rx_struct *)malloc(sizeof(struct command_rx_struct)))) {
 109     faim_mutex_unlock(&conn->active);
 110     return -1;
 111   }
 112   memset(newrx, 0x00, sizeof(struct command_rx_struct));
 113
 114   newrx->lock = 1;  /* lock the struct */
 115
 116   /* we're doing OSCAR if we're here */
 117   newrx->hdrtype = AIM_FRAMETYPE_OSCAR;
 118
 119   /* store channel -- byte 2 */
 120   newrx->hdr.oscar.type = (char) generic[1];
 121
 122   /* store seqnum -- bytes 3 and 4 */
 123   newrx->hdr.oscar.seqnum = aimutil_get16(generic+2);
 124
 125   /* store commandlen -- bytes 5 and 6 */
 126   newrx->commandlen = aimutil_get16(generic+4);
 127
 128   newrx->nofree = 0; /* free by default */
 129
 130   /* malloc for data portion */
 131   if (!(newrx->data = (u_char *) malloc(newrx->commandlen))) {
 132     free(newrx);
 133     faim_mutex_unlock(&conn->active);
 134     return -1;
 135   }
 136
 137   /* read the data portion of the packet */
 138   if (aim_recv(conn->fd, newrx->data, newrx->commandlen) < newrx->commandlen){
 139     free(newrx->data);
 140     free(newrx);
 141     aim_conn_close(conn);
 142     faim_mutex_unlock(&conn->active);
 143     return -1;
 144   }
 145   faim_mutex_unlock(&conn->active);
 146
 147   newrx->conn = conn;
 148
 149   newrx->next = NULL;  /* this will always be at the bottom */
 150   newrx->lock = 0; /* unlock */
 151
 152   /* enqueue this packet */
 153   if (sess->queue_incoming == NULL) {
 154     sess->queue_incoming = newrx;
 155   } else {
 156     struct command_rx_struct *cur;
 157
 158     /*
 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.
 163      */
 164     for (cur = sess->queue_incoming; cur->next; cur = cur->next)
 165       ;
 166     cur->next = newrx;
 167   }
 168
 169   newrx->conn->lastactivity = time(NULL);
 170
 171   return 0;
 172 }
 173
 174 /*
 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.
 178  *
 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.
 183  *
 184  */
 185 faim_export void aim_purge_rxqueue(struct aim_session_t *sess)
 186 {
 187   struct command_rx_struct *cur = NULL;
 188   struct command_rx_struct *tmp;
 189
 190   if (sess->queue_incoming == NULL)
 191     return;
 192
 193   if (sess->queue_incoming->next == NULL) {
 194     if (sess->queue_incoming->handled) {
 195       tmp = sess->queue_incoming;
 196       sess->queue_incoming = NULL;
 197
 198       if (!tmp->nofree) {
 199         if (tmp->hdrtype == AIM_FRAMETYPE_OFT)
 200           free(tmp->hdr.oft.hdr2);
 201         free(tmp->data);
 202         free(tmp);
 203       } else
 204         tmp->next = NULL;
 205     }
 206     return;
 207   }
 208
 209   for(cur = sess->queue_incoming; cur->next != NULL; ) {
 210     if (cur->next->handled) {
 211       tmp = cur->next;
 212       cur->next = tmp->next;
 213       if (!tmp->nofree) {
 214         if (tmp->hdrtype == AIM_FRAMETYPE_OFT)
 215           free(tmp->hdr.oft.hdr2);
 216         free(tmp->data);
 217         free(tmp);
 218       } else
 219         tmp->next = NULL;
 220     }
 221     cur = cur->next;
 222
 223     /*
 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.
 228      */
 229     if (cur == NULL)
 230       break;
 231   }
 232
 233   return;
 234 }
 235
 236 /*
 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.
 239  *
 240  * XXX: this is something that was handled better in the old connection
 241  * handling method, but eh.
 242  */
 243 faim_internal void aim_rxqueue_cleanbyconn(struct aim_session_t *sess, struct aim_conn_t *conn)
 244 {
 245   struct command_rx_struct *currx;
 246
 247   for (currx = sess->queue_incoming; currx; currx = currx->next) {
 248     if ((!currx->handled) && (currx->conn == conn))
 249       currx->handled = 1;
 250   }
 251   return;
 252 }