[libfaim.git] / aim_txqueue.c

/*
 *  aim_txqueue.c
 *
 * Herein lies all the mangement routines for the transmit (Tx) queue.
 *
 */

#include <faim/aim.h>

/*
 * aim_tx_enqeue()
 *
 * The overall purpose here is to enqueue the passed in command struct
 * into the outgoing (tx) queue.  Basically...
 *   1) Make a scope-irrelevent copy of the struct
 *   2) Lock the struct
 *   3) Mark as not-sent-yet
 *   4) Enqueue the struct into the list
 *   5) Unlock the struct once it's linked in
 *   6) Return
 *
 */

int aim_tx_enqueue(struct aim_session_t *sess,
		   struct command_tx_struct *newpacket)
{
  struct command_tx_struct *workingPtr = NULL;
  struct command_tx_struct *newpacket_copy = NULL;

  if (newpacket->conn == NULL)
    {
      printf("aim_tx_enqueue: WARNING: enqueueing packet with no connecetion,  defaulting to BOS\n");
      newpacket->conn = aim_getconn_type(sess, AIM_CONN_TYPE_BOS);
    }
 
  newpacket_copy = (struct command_tx_struct *) malloc (sizeof(struct command_tx_struct));
  memcpy(newpacket_copy, newpacket, sizeof(struct command_tx_struct));

  /* assign seqnum */
  newpacket_copy->seqnum = aim_get_next_txseqnum(newpacket_copy->conn);
  /* set some more fields */
  newpacket_copy->lock = 1; /* lock */
  newpacket_copy->sent = 0; /* not sent yet */
  newpacket_copy->next = NULL; /* always last */

  if (sess->queue_outgoing == NULL)
    {
      sess->queue_outgoing = newpacket_copy;
    }
  else
    {
      workingPtr = sess->queue_outgoing;
      while (workingPtr->next != NULL)
	workingPtr = workingPtr->next;
      workingPtr->next = newpacket_copy;
    }

  newpacket_copy->lock = 0; /* unlock so it can be sent */

#if debug > 2
  printf("calling aim_tx_printqueue()\n");
  aim_tx_printqueue();
  printf("back from aim_tx_printqueue()\n");
#endif

  /* we'll force a flush for now -- this behavior probably will change */
#if debug > 1
  printf("calling aim_tx_flushqueue()\n");
#endif
  aim_tx_flushqueue(sess);
#if debug > 1
  printf("back from aim_tx_flushqueue()\n");
#endif

  return 0;
}

/* 
 *  aim_get_next_txseqnum()
 *
 *   This increments the tx command count, and returns the seqnum
 *   that should be stamped on the next FLAP packet sent.  This is
 *   normally called during the final step of packet preparation
 *   before enqueuement (in aim_tx_enqueue()).
 *
 */
u_int aim_get_next_txseqnum(struct aim_conn_t *conn)
{
  return ( ++conn->seqnum );
}

/*
 *  aim_tx_printqueue()
 *
 *  This is basically for debuging purposes only.  It dumps all the
 *  records in the tx queue and their current status.  Very helpful
 *  if the queue isn't working quite right.
 *
 */
#if debug > 2
int aim_tx_printqueue(void)
{
  struct command_tx_struct *workingPtr = NULL;

  workingPtr = sess->queue_outgoing;
#if debug > 2
  printf("\ncurrent aim_queue_outgoing...\n");
  printf("\ttype seqnum  len  lock sent\n");  
#endif
  if (workingPtr == NULL)
    printf("aim_tx_flushqueue(): queue empty");
  else
    {
      while (workingPtr != NULL)
	{
	  printf("\t  %2x   %4x %4x   %1d    %1d\n", workingPtr->type, workingPtr->seqnum, workingPtr->commandlen, workingPtr->lock, workingPtr->sent);
	  
	  workingPtr = workingPtr->next;
	}
    }

  printf("\n(done printing queue)\n");
  
  return 0;
}
#endif

/*
 *  aim_tx_flushqueue()
 *
 *  This the function is responsable for putting the queued commands
 *  onto the wire.  This function is critical to the operation of 
 *  the queue and therefore is the most prone to brokenness.  It
 *  seems to be working quite well at this point.
 *
 *  Procedure:
 *    1) Traverse the list, only operate on commands that are unlocked
 *       and haven't been sent yet.
 *    2) Lock the struct
 *    3) Allocate a temporary buffer to store the finished, fully
 *       processed packet in.
 *    4) Build the packet from the command_tx_struct data.
 *    5) Write the packet to the socket.
 *    6) If success, mark the packet sent, if fail report failure, do NOT
 *       mark the packet sent (so it will not get purged and therefore
 *       be attempted again on next call).
 *    7) Unlock the struct.
 *    8) Free the temp buffer
 *    9) Step to next struct in list and go back to 1.
 *
 */
int aim_tx_flushqueue(struct aim_session_t *sess)
{
  struct command_tx_struct *workingPtr = NULL;
  u_char *curPacket = NULL;
#if debug > 1
  int i = 0;
#endif

  workingPtr = sess->queue_outgoing;
#if debug > 1
  printf("beginning txflush...\n");
#endif
  while (workingPtr != NULL)
    {
      /* only process if its unlocked and unsent */
      if ( (workingPtr->lock == 0) &&
	   (workingPtr->sent == 0) )
	{

	  /*
	   * And now for the meager attempt to force transmit
	   * latency and avoid missed messages.
	   */
	  if ((workingPtr->conn->lastactivity + workingPtr->conn->forcedlatency) 
	      >= time(NULL))
	    {
	      /* FIXME FIXME -- should be a break! we dont want to block the upper layers */
	      sleep((workingPtr->conn->lastactivity + workingPtr->conn->forcedlatency) - time(NULL));
	    }

	  workingPtr->lock = 1; /* lock the struct */
	  
	  /* allocate full-packet buffer */
	  curPacket = (char *) malloc(workingPtr->commandlen + 6);
	  
	  /* command byte */
	  curPacket[0] = 0x2a;

	  /* type/family byte */
	  curPacket[1] = workingPtr->type;

	  /* bytes 3+4: word: FLAP sequence number */
	  aimutil_put16(curPacket+2, workingPtr->seqnum);

	  /* bytes 5+6: word: SNAC len */
	  aimutil_put16(curPacket+4, workingPtr->commandlen);

	  /* bytes 7 and on: raw: SNAC data */
	  memcpy(&(curPacket[6]), workingPtr->data, workingPtr->commandlen);
	  
	  /* full image of raw packet data now in curPacket */
	  if ( (u_int)write(workingPtr->conn->fd, curPacket, (workingPtr->commandlen + 6)) != (workingPtr->commandlen + 6))
	    {
	      printf("\nWARNING: Error in sending packet 0x%4x -- will try again next time\n\n", workingPtr->seqnum);
	      workingPtr->sent = 0; /* mark it unsent */
	      return -1;  /* bail out */
	    }
	  else
	    {
#if debug > 2
	      printf("\nSENT 0x%4x\n\n", workingPtr->seqnum);
#endif
	      workingPtr->sent = 1; /* mark the struct as sent */
	      workingPtr->conn->lastactivity = time(NULL);
	    }
#if debug > 2
	  printf("\nPacket:");
	  for (i = 0; i < (workingPtr->commandlen + 6); i++)
	    {
	      if ((i % 8) == 0)
		printf("\n\t");
	      if (curPacket[i] >= ' ' && curPacket[i]<127)
		 printf("%c=%02x ",curPacket[i], curPacket[i]);
	      else
		 printf("0x%2x ", curPacket[i]);
	    }
	  printf("\n");
#endif
	  workingPtr->lock = 0; /* unlock the struct */
	  free(curPacket); /* free up full-packet buffer */
	}
      workingPtr = workingPtr->next;
    }

  /* purge sent commands from queue */
  /*   this may not always occur explicitly--i may put this on a timer later */
#if debug > 1
  printf("calling aim_tx_purgequeue()\n");
#endif
  aim_tx_purgequeue(sess);
#if debug > 1
  printf("back from aim_tx_purgequeu() [you must be a lucky one]\n");
#endif

  return 0;
}

/*
 *  aim_tx_purgequeue()
 *  
 *  This is responsable for removing sent commands from the transmit 
 *  queue. This is not a required operation, but it of course helps
 *  reduce memory footprint at run time!  
 *
 */
int aim_tx_purgequeue(struct aim_session_t *sess)
{
  struct command_tx_struct *workingPtr = NULL;
  struct command_tx_struct *workingPtr2 = NULL;
#if debug > 1
  printf("purgequeue(): starting purge\n");
#endif
  /* Empty queue: nothing to do */
  if (sess->queue_outgoing == NULL)
    {
#if debug > 1
      printf("purgequeue(): purge done (len=0)\n");
#endif
      return 0;
    }
  /* One Node queue: free node and return */
  else if (sess->queue_outgoing->next == NULL)
    {
#if debug > 1
      printf("purgequeue(): entered case len=1\n");
#endif
      /* only free if sent AND unlocked -- dont assume sent structs are done */
      if ( (sess->queue_outgoing->lock == 0) &&
	   (sess->queue_outgoing->sent == 1) )
	{
#if debug > 1
	  printf("purgequeue(): purging seqnum 0x%04x\n", aim_queue_outgoing->seqnum);
#endif
	  workingPtr2 = sess->queue_outgoing;
	  sess->queue_outgoing = NULL;
	  free(workingPtr2->data);
	  free(workingPtr2);
	}
#if debug > 1
      printf("purgequeue(): purge done (len=1)\n");
#endif
      return 0;
    }
  else
    {
#if debug > 1
      printf("purgequeue(): entering case len>1\n");
#endif
      while(workingPtr->next != NULL)
	{
	  if ( (workingPtr->next->lock == 0) &&
	       (workingPtr->next->sent == 1) )
	    {
#if debug > 1
	      printf("purgequeue(): purging seqnum 0x%04x\n", workingPtr->next->seqnum);
#endif
	      workingPtr2 = workingPtr->next;
	      workingPtr->next = workingPtr2->next;
	      free(workingPtr2->data);
	      free(workingPtr2);
	    }
	}
#if debug > 1
      printf("purgequeue(): purge done (len>1)\n");
#endif
      return 0;
    }

  /* no reach */
}
Commit	Line	Data
9de3ca7e	1	/*
24286d93	2	* aim_txqueue.c
	3	*
	4	* Herein lies all the mangement routines for the transmit (Tx) queue.
	5	*
9de3ca7e	6	*/
9de3ca7e	7
a25832e6	8	#include <faim/aim.h>
9de3ca7e	9
9de3ca7e	10	/*
24286d93	11	* aim_tx_enqeue()
	12	*
	13	* The overall purpose here is to enqueue the passed in command struct
	14	* into the outgoing (tx) queue. Basically...
	15	* 1) Make a scope-irrelevent copy of the struct
	16	* 2) Lock the struct
	17	* 3) Mark as not-sent-yet
	18	* 4) Enqueue the struct into the list
	19	* 5) Unlock the struct once it's linked in
	20	* 6) Return
	21	*
9de3ca7e	22	*/
9de3ca7e	23
a25832e6	24	int aim_tx_enqueue(struct aim_session_t *sess,
a25832e6	25	struct command_tx_struct *newpacket)
9de3ca7e	26	{
	27	struct command_tx_struct *workingPtr = NULL;
	28	struct command_tx_struct *newpacket_copy = NULL;
	29
	30	if (newpacket->conn == NULL)
	31	{
	32	printf("aim_tx_enqueue: WARNING: enqueueing packet with no connecetion, defaulting to BOS\n");
a25832e6	33	newpacket->conn = aim_getconn_type(sess, AIM_CONN_TYPE_BOS);
9de3ca7e	34	}
	35
	36	newpacket_copy = (struct command_tx_struct *) malloc (sizeof(struct command_tx_struct));
	37	memcpy(newpacket_copy, newpacket, sizeof(struct command_tx_struct));
	38
	39	/* assign seqnum */
	40	newpacket_copy->seqnum = aim_get_next_txseqnum(newpacket_copy->conn);
	41	/* set some more fields */
	42	newpacket_copy->lock = 1; /* lock */
	43	newpacket_copy->sent = 0; /* not sent yet */
	44	newpacket_copy->next = NULL; /* always last */
	45
a25832e6	46	if (sess->queue_outgoing == NULL)
9de3ca7e	47	{
a25832e6	48	sess->queue_outgoing = newpacket_copy;
9de3ca7e	49	}
	50	else
	51	{
a25832e6	52	workingPtr = sess->queue_outgoing;
9de3ca7e	53	while (workingPtr->next != NULL)
	54	workingPtr = workingPtr->next;
	55	workingPtr->next = newpacket_copy;
	56	}
	57
	58	newpacket_copy->lock = 0; /* unlock so it can be sent */
	59
	60	#if debug > 2
	61	printf("calling aim_tx_printqueue()\n");
	62	aim_tx_printqueue();
	63	printf("back from aim_tx_printqueue()\n");
	64	#endif
	65
	66	/* we'll force a flush for now -- this behavior probably will change */
	67	#if debug > 1
	68	printf("calling aim_tx_flushqueue()\n");
	69	#endif
a25832e6	70	aim_tx_flushqueue(sess);
9de3ca7e	71	#if debug > 1
	72	printf("back from aim_tx_flushqueue()\n");
	73	#endif
	74
	75	return 0;
	76	}
	77
	78	/*
a25832e6	79	* aim_get_next_txseqnum()
	80	*
	81	* This increments the tx command count, and returns the seqnum
	82	* that should be stamped on the next FLAP packet sent. This is
	83	* normally called during the final step of packet preparation
	84	* before enqueuement (in aim_tx_enqueue()).
	85	*
9de3ca7e	86	*/
	87	u_int aim_get_next_txseqnum(struct aim_conn_t *conn)
	88	{
	89	return ( ++conn->seqnum );
	90	}
	91
	92	/*
a25832e6	93	* aim_tx_printqueue()
	94	*
	95	* This is basically for debuging purposes only. It dumps all the
	96	* records in the tx queue and their current status. Very helpful
	97	* if the queue isn't working quite right.
	98	*
9de3ca7e	99	*/
	100	#if debug > 2
	101	int aim_tx_printqueue(void)
	102	{
	103	struct command_tx_struct *workingPtr = NULL;
	104
a25832e6	105	workingPtr = sess->queue_outgoing;
9de3ca7e	106	#if debug > 2
	107	printf("\ncurrent aim_queue_outgoing...\n");
	108	printf("\ttype seqnum len lock sent\n");
	109	#endif
	110	if (workingPtr == NULL)
	111	printf("aim_tx_flushqueue(): queue empty");
	112	else
	113	{
	114	while (workingPtr != NULL)
	115	{
	116	printf("\t %2x %4x %4x %1d %1d\n", workingPtr->type, workingPtr->seqnum, workingPtr->commandlen, workingPtr->lock, workingPtr->sent);
	117
	118	workingPtr = workingPtr->next;
	119	}
	120	}
	121
	122	printf("\n(done printing queue)\n");
	123
	124	return 0;
	125	}
	126	#endif
	127
	128	/*
a25832e6	129	* aim_tx_flushqueue()
	130	*
	131	* This the function is responsable for putting the queued commands
	132	* onto the wire. This function is critical to the operation of
	133	* the queue and therefore is the most prone to brokenness. It
	134	* seems to be working quite well at this point.
	135	*
	136	* Procedure:
	137	* 1) Traverse the list, only operate on commands that are unlocked
	138	* and haven't been sent yet.
	139	* 2) Lock the struct
	140	* 3) Allocate a temporary buffer to store the finished, fully
	141	* processed packet in.
	142	* 4) Build the packet from the command_tx_struct data.
	143	* 5) Write the packet to the socket.
	144	* 6) If success, mark the packet sent, if fail report failure, do NOT
	145	* mark the packet sent (so it will not get purged and therefore
	146	* be attempted again on next call).
	147	* 7) Unlock the struct.
	148	* 8) Free the temp buffer
	149	* 9) Step to next struct in list and go back to 1.
	150	*
9de3ca7e	151	*/
a25832e6	152	int aim_tx_flushqueue(struct aim_session_t *sess)
9de3ca7e	153	{
	154	struct command_tx_struct *workingPtr = NULL;
	155	u_char *curPacket = NULL;
	156	#if debug > 1
	157	int i = 0;
	158	#endif
	159
a25832e6	160	workingPtr = sess->queue_outgoing;
9de3ca7e	161	#if debug > 1
	162	printf("beginning txflush...\n");
	163	#endif
	164	while (workingPtr != NULL)
	165	{
	166	/* only process if its unlocked and unsent */
	167	if ( (workingPtr->lock == 0) &&
	168	(workingPtr->sent == 0) )
	169	{
	170
	171	/*
	172	* And now for the meager attempt to force transmit
	173	* latency and avoid missed messages.
	174	*/
	175	if ((workingPtr->conn->lastactivity + workingPtr->conn->forcedlatency)
	176	>= time(NULL))
	177	{
	178	/* FIXME FIXME -- should be a break! we dont want to block the upper layers */
	179	sleep((workingPtr->conn->lastactivity + workingPtr->conn->forcedlatency) - time(NULL));
	180	}
	181
	182	workingPtr->lock = 1; /* lock the struct */
	183
	184	/* allocate full-packet buffer */
	185	curPacket = (char *) malloc(workingPtr->commandlen + 6);
	186
	187	/* command byte */
	188	curPacket[0] = 0x2a;
a25832e6	189
9de3ca7e	190	/* type/family byte */
9de3ca7e	191	curPacket[1] = workingPtr->type;
a25832e6	192
9de3ca7e	193	/* bytes 3+4: word: FLAP sequence number */
a25832e6	194	aimutil_put16(curPacket+2, workingPtr->seqnum);
a25832e6	195
9de3ca7e	196	/* bytes 5+6: word: SNAC len */
a25832e6	197	aimutil_put16(curPacket+4, workingPtr->commandlen);
a25832e6	198
9de3ca7e	199	/* bytes 7 and on: raw: SNAC data */
	200	memcpy(&(curPacket[6]), workingPtr->data, workingPtr->commandlen);
	201
	202	/* full image of raw packet data now in curPacket */
9de3ca7e	203	if ( (u_int)write(workingPtr->conn->fd, curPacket, (workingPtr->commandlen + 6)) != (workingPtr->commandlen + 6))
9de3ca7e	204	{
9de3ca7e	205	printf("\nWARNING: Error in sending packet 0x%4x -- will try again next time\n\n", workingPtr->seqnum);
	206	workingPtr->sent = 0; /* mark it unsent */
	207	return -1; /* bail out */
	208	}
	209	else
	210	{
	211	#if debug > 2
	212	printf("\nSENT 0x%4x\n\n", workingPtr->seqnum);
	213	#endif
	214	workingPtr->sent = 1; /* mark the struct as sent */
	215	workingPtr->conn->lastactivity = time(NULL);
	216	}
	217	#if debug > 2
	218	printf("\nPacket:");
	219	for (i = 0; i < (workingPtr->commandlen + 6); i++)
	220	{
	221	if ((i % 8) == 0)
	222	printf("\n\t");
	223	if (curPacket[i] >= ' ' && curPacket[i]<127)
	224	printf("%c=%02x ",curPacket[i], curPacket[i]);
	225	else
	226	printf("0x%2x ", curPacket[i]);
	227	}
	228	printf("\n");
	229	#endif
	230	workingPtr->lock = 0; /* unlock the struct */
	231	free(curPacket); /* free up full-packet buffer */
	232	}
	233	workingPtr = workingPtr->next;
	234	}
	235
	236	/* purge sent commands from queue */
	237	/* this may not always occur explicitly--i may put this on a timer later */
	238	#if debug > 1
	239	printf("calling aim_tx_purgequeue()\n");
	240	#endif
a25832e6	241	aim_tx_purgequeue(sess);
9de3ca7e	242	#if debug > 1
	243	printf("back from aim_tx_purgequeu() [you must be a lucky one]\n");
	244	#endif
	245
	246	return 0;
	247	}
	248
	249	/*
a25832e6	250	* aim_tx_purgequeue()
	251	*
	252	* This is responsable for removing sent commands from the transmit
	253	* queue. This is not a required operation, but it of course helps
	254	* reduce memory footprint at run time!
	255	*
9de3ca7e	256	*/
a25832e6	257	int aim_tx_purgequeue(struct aim_session_t *sess)
9de3ca7e	258	{
	259	struct command_tx_struct *workingPtr = NULL;
	260	struct command_tx_struct *workingPtr2 = NULL;
	261	#if debug > 1
	262	printf("purgequeue(): starting purge\n");
	263	#endif
	264	/* Empty queue: nothing to do */
a25832e6	265	if (sess->queue_outgoing == NULL)
9de3ca7e	266	{
	267	#if debug > 1
	268	printf("purgequeue(): purge done (len=0)\n");
	269	#endif
	270	return 0;
	271	}
	272	/* One Node queue: free node and return */
a25832e6	273	else if (sess->queue_outgoing->next == NULL)
9de3ca7e	274	{
	275	#if debug > 1
	276	printf("purgequeue(): entered case len=1\n");
	277	#endif
	278	/* only free if sent AND unlocked -- dont assume sent structs are done */
a25832e6	279	if ( (sess->queue_outgoing->lock == 0) &&
a25832e6	280	(sess->queue_outgoing->sent == 1) )
9de3ca7e	281	{
	282	#if debug > 1
	283	printf("purgequeue(): purging seqnum 0x%04x\n", aim_queue_outgoing->seqnum);
	284	#endif
a25832e6	285	workingPtr2 = sess->queue_outgoing;
a25832e6	286	sess->queue_outgoing = NULL;
9de3ca7e	287	free(workingPtr2->data);
	288	free(workingPtr2);
	289	}
	290	#if debug > 1
	291	printf("purgequeue(): purge done (len=1)\n");
	292	#endif
	293	return 0;
	294	}
	295	else
	296	{
	297	#if debug > 1
	298	printf("purgequeue(): entering case len>1\n");
	299	#endif
	300	while(workingPtr->next != NULL)
	301	{
	302	if ( (workingPtr->next->lock == 0) &&
	303	(workingPtr->next->sent == 1) )
	304	{
	305	#if debug > 1
	306	printf("purgequeue(): purging seqnum 0x%04x\n", workingPtr->next->seqnum);
	307	#endif
	308	workingPtr2 = workingPtr->next;
	309	workingPtr->next = workingPtr2->next;
	310	free(workingPtr2->data);
	311	free(workingPtr2);
	312	}
	313	}
	314	#if debug > 1
	315	printf("purgequeue(): purge done (len>1)\n");
	316	#endif
	317	return 0;
	318	}
	319
	320	/* no reach */
	321	}