X-Git-Url: http://andersk.mit.edu/gitweb/libfaim.git/blobdiff_plain/a25832e66b80e7159f37795cff5593b748ac5f59..9193124799d56ddd6b72f1c5f3cda244dd9a21b0:/aim_rxqueue.c

diff --git a/aim_rxqueue.c b/aim_rxqueue.c
index 73fd5a3..d82d6f4 100644
--- a/aim_rxqueue.c
+++ b/aim_rxqueue.c
@@ -1,266 +1,171 @@
 /*
-  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.
  */
 
 #include <faim/aim.h> 
 
 /*
- * This is a modified read() to make SURE we get the number
- * of bytes we are told to, otherwise block.
- *
- * Modified to count errno (Sébastien Carpe <scarpe@atos-group.com>)
- * 
-*/
-int Read(int fd, u_char *buf, int len)
-{
-  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;
-}
-
-/*  
- * 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)
+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);
-
-  if (conn==NULL)
-    return 0;  /* nothing waiting */
-
-  s = conn->fd;
+  u_char generic[6]; 
+  struct command_rx_struct *newrx = NULL;
 
-  if (s < 3) 
+  if (!sess || !conn)
     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 (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;
-    }
+  if (conn->fd < 3)  /* can happen when people abuse the interface */
+    return 0;
 
-  isav = i;
+  /*
+   * 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 (read(conn->fd, generic, 6) < 6){
+    aim_conn_close(conn);
+    faim_mutex_unlock(&conn->active);
+    return -1;
+  }
+  faim_mutex_unlock(&conn->active);
+
+  /*
+   * 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!");
+    return -1;
+  }	
 
   /* allocate a new struct */
-  workingStruct = (struct command_rx_struct *) malloc(sizeof(struct command_rx_struct));
-  workingStruct->lock = 1;  /* lock the struct */
+  newrx = (struct command_rx_struct *)malloc(sizeof(struct command_rx_struct));
+  if (!newrx)
+    return -1;
+  memset(newrx, 0x00, sizeof(struct command_rx_struct));
+
+  newrx->lock = 1;  /* lock the struct */
 
   /* store channel -- byte 2 */
-  workingStruct->type = (char) generic[1];
+  newrx->type = (char) generic[1];
 
   /* store seqnum -- bytes 3 and 4 */
-  workingStruct->seqnum = aimutil_get16(generic+2);
+  newrx->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);
+  newrx->data = (u_char *) malloc(newrx->commandlen);
+  if (!newrx->data) {
+    free(newrx);
+    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 debug > 0
-  printf(" done. (%db+%db read, %db skipped)\n", isav, i, j);
-#endif
+  faim_mutex_lock(&conn->active);
+  if (read(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);
 
-  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)
+void aim_purge_rxqueue(struct aim_session_t *sess)
 {
-  struct command_rx_struct *workingPtr = NULL;
-  struct command_rx_struct *workingPtr2 = NULL;
-
-  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;
+  struct command_rx_struct *cur = NULL;
+  struct command_rx_struct *tmp;
 
-      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) {
+	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) {
+	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;
 }