src/rxhandlers.c

/*
 * aim_rxhandlers.c
 *
 * This file contains most all of the incoming packet handlers, along
 * with aim_rxdispatch(), the Rx dispatcher.  Queue/list management is
 * actually done in aim_rxqueue.c.
 *
 */

#define FAIM_INTERNAL
#include <aim.h>

static aim_module_t *findmodule(struct aim_session_t *sess, const char *name)
{
  aim_module_t *cur;

  for (cur = (aim_module_t *)sess->modlistv; cur; cur = cur->next) {
    if (strcmp(name, cur->name) == 0)
      return cur;
  }

  return NULL;
}

faim_internal int aim__registermodule(struct aim_session_t *sess, int (*modfirst)(struct aim_session_t *, aim_module_t *))
{
  aim_module_t *mod;

  if (!sess || !modfirst)
    return -1;

  if (!(mod = malloc(sizeof(aim_module_t))))
    return -1;
  memset(mod, 0, sizeof(aim_module_t));

  if (modfirst(sess, mod) == -1) {
    free(mod);
    return -1;
  }

  if (findmodule(sess, mod->name)) {
    if (mod->shutdown)
      mod->shutdown(sess, mod);
    free(mod);
    return -1;
  }

  mod->next = (aim_module_t *)sess->modlistv;
  (aim_module_t *)sess->modlistv = mod;

  faimdprintf(sess, 1, "registered module %s (family 0x%04x)\n", mod->name, mod->family);

  return 0;
}

faim_internal void aim__shutdownmodules(struct aim_session_t *sess)
{
  aim_module_t *cur;

  for (cur = (aim_module_t *)sess->modlistv; cur; ) {
    aim_module_t *tmp;

    tmp = cur->next;

    if (cur->shutdown)
      cur->shutdown(sess, cur);

    free(cur);

    cur = tmp;
  }

  sess->modlistv = NULL;

  return;
}

static int consumesnac(struct aim_session_t *sess, struct command_rx_struct *rx)
{
  aim_module_t *cur;
  aim_modsnac_t snac;

  snac.family = aimutil_get16(rx->data+0);
  snac.subtype = aimutil_get16(rx->data+2);
  snac.flags = aimutil_get16(rx->data+4);
  snac.id = aimutil_get32(rx->data+6);

  for (cur = (aim_module_t *)sess->modlistv; cur; cur = cur->next) {

    if (!(cur->flags & AIM_MODFLAG_MULTIFAMILY) &&
	(cur->family != snac.family))
      continue;

    if (cur->snachandler(sess, cur, rx, &snac, rx->data+10, rx->commandlen-10))
      return 1;

  }

  return 0;
}

static int consumenonsnac(struct aim_session_t *sess, struct command_rx_struct *rx, unsigned short family, unsigned short subtype)
{
  aim_module_t *cur;
  aim_modsnac_t snac;

  snac.family = family;
  snac.subtype = subtype;
  snac.flags = snac.id = 0;

  for (cur = (aim_module_t *)sess->modlistv; cur; cur = cur->next) {

    if (!(cur->flags & AIM_MODFLAG_MULTIFAMILY) &&
	(cur->family != snac.family))
      continue;

    if (cur->snachandler(sess, cur, rx, &snac, rx->data, rx->commandlen))
      return 1;

  }

  return 0;
}

/*
 * Bleck functions get called when there's no non-bleck functions
 * around to cleanup the mess...
 */
faim_internal int bleck(struct aim_session_t *sess,struct command_rx_struct *workingPtr, ...)
{
  u_short family;
  u_short subtype;

  u_short maxf;
  u_short maxs;

  /* XXX: this is ugly. and big just for debugging. */
  char *literals[14][25] = {
    {"Invalid",
     NULL
    },
    {"General",
     "Invalid",
     "Error",
     "Client Ready",
     "Server Ready",
     "Service Request",
     "Redirect",
     "Rate Information Request",
     "Rate Information",
     "Rate Information Ack",
     NULL,
     "Rate Information Change",
     "Server Pause",
     NULL,
     "Server Resume",
     "Request Personal User Information",
     "Personal User Information",
     "Evil Notification",
     NULL,
     "Migration notice",
     "Message of the Day",
     "Set Privacy Flags",
     "Well Known URL",
     "NOP"
    },
    {"Location",
      "Invalid",
      "Error",
      "Request Rights",
      "Rights Information",
      "Set user information",
      "Request User Information",
      "User Information",
      "Watcher Sub Request",
      "Watcher Notification"
    },
    {"Buddy List Management",
      "Invalid",
      "Error",
      "Request Rights",
      "Rights Information",
      "Add Buddy",
      "Remove Buddy",
      "Watcher List Query",
      "Watcher List Response",
      "Watcher SubRequest",
      "Watcher Notification",
      "Reject Notification",
      "Oncoming Buddy",
      "Offgoing Buddy"
    },
    {"Messeging",
      "Invalid",
      "Error",
      "Add ICBM Parameter",
      "Remove ICBM Parameter",
      "Request Parameter Information",
      "Parameter Information",
      "Outgoing Message",
      "Incoming Message",
      "Evil Request",
      "Evil Reply",
      "Missed Calls",
      "Message Error",
      "Host Ack"
    },
    {"Advertisements",
      "Invalid",
      "Error",
      "Request Ad",
      "Ad Data (GIFs)"
    },
    {"Invitation / Client-to-Client",
     "Invalid",
     "Error",
     "Invite a Friend",
     "Invitation Ack"
    },
    {"Administrative",
      "Invalid",
      "Error",
      "Information Request",
      "Information Reply",
      "Information Change Request",
      "Information Chat Reply",
      "Account Confirm Request",
      "Account Confirm Reply",
      "Account Delete Request",
      "Account Delete Reply"
    },
    {"Popups",
      "Invalid",
      "Error",
      "Display Popup"
    },
    {"BOS",
      "Invalid",
      "Error",
      "Request Rights",
      "Rights Response",
      "Set group permission mask",
      "Add permission list entries",
      "Delete permission list entries",
      "Add deny list entries",
      "Delete deny list entries",
      "Server Error"
    },
    {"User Lookup",
      "Invalid",
      "Error",
      "Search Request",
      "Search Response"
    },
    {"Stats",
      "Invalid",
      "Error",
      "Set minimum report interval",
      "Report Events"
    },
    {"Translate",
      "Invalid",
      "Error",
      "Translate Request",
      "Translate Reply",
    },
    {"Chat Navigation",
      "Invalid",
      "Error",
      "Request rights",
      "Request Exchange Information",
      "Request Room Information",
      "Request Occupant List",
      "Search for Room",
      "Outgoing Message",
      "Incoming Message",
      "Evil Request",
      "Evil Reply",
      "Chat Error",
    }
  };

  maxf = sizeof(literals) / sizeof(literals[0]);
  maxs = sizeof(literals[0]) / sizeof(literals[0][0]);

  family = aimutil_get16(workingPtr->data+0);
  subtype= aimutil_get16(workingPtr->data+2);

  if((family < maxf) && (subtype+1 < maxs) && (literals[family][subtype] != NULL))
    faimdprintf(sess, 0, "bleck: null handler for %04x/%04x (%s)\n", family, subtype, literals[family][subtype+1]);
  else
    faimdprintf(sess, 0, "bleck: null handler for %04x/%04x (no literal)\n",family,subtype);

  return 1;
}

faim_export int aim_conn_addhandler(struct aim_session_t *sess,
				    struct aim_conn_t *conn,
				    u_short family,
				    u_short type,
				    aim_rxcallback_t newhandler,
				    u_short flags)
{
  struct aim_rxcblist_t *newcb;

  if (!conn)
    return -1;

  faimdprintf(sess, 1, "aim_conn_addhandler: adding for %04x/%04x\n", family, type);

  if (!(newcb = (struct aim_rxcblist_t *)calloc(1, sizeof(struct aim_rxcblist_t))))
    return -1;
  newcb->family = family;
  newcb->type = type;
  newcb->flags = flags;
  if (!newhandler)
    newcb->handler = &bleck;
  else
    newcb->handler = newhandler;
  newcb->next = NULL;

  if (!conn->handlerlist)
    conn->handlerlist = newcb;
  else {
    struct aim_rxcblist_t *cur;

    cur = conn->handlerlist;

    while (cur->next)
      cur = cur->next;
    cur->next = newcb;
  }

  return 0;
}

faim_export int aim_clearhandlers(struct aim_conn_t *conn)
{
 struct aim_rxcblist_t *cur;

 if (!conn)
   return -1;

 for (cur = conn->handlerlist; cur; ) {
   struct aim_rxcblist_t *tmp;

   tmp = cur->next;
   free(cur);
   cur = tmp;
 }
 conn->handlerlist = NULL;

 return 0;
}

faim_internal aim_rxcallback_t aim_callhandler(struct aim_session_t *sess,
					       struct aim_conn_t *conn,
					       unsigned short family,
					       unsigned short type)
{
  struct aim_rxcblist_t *cur;

  if (!conn)
    return NULL;

  faimdprintf(sess, 1, "aim_callhandler: calling for %04x/%04x\n", family, type);

  for (cur = conn->handlerlist; cur; cur = cur->next) {
    if ((cur->family == family) && (cur->type == type))
      return cur->handler;
  }

  if (type == AIM_CB_SPECIAL_DEFAULT) {
    faimdprintf(sess, 1, "aim_callhandler: no default handler for family 0x%04x\n", family);
    return NULL; /* prevent infinite recursion */
  }

  faimdprintf(sess, 1, "aim_callhandler: no handler for  0x%04x/0x%04x\n", family, type);

  return aim_callhandler(sess, conn, family, AIM_CB_SPECIAL_DEFAULT);
}

faim_internal int aim_callhandler_noparam(struct aim_session_t *sess,
					  struct aim_conn_t *conn,
					  u_short family,
					  u_short type,
					  struct command_rx_struct *ptr)
{
  aim_rxcallback_t userfunc = NULL;
  userfunc = aim_callhandler(sess, conn, family, type);
  if (userfunc)
    return userfunc(sess, ptr);
  return 1; /* XXX */
}

/*
  aim_rxdispatch()

  Basically, heres what this should do:
    1) Determine correct packet handler for this packet
    2) Mark the packet handled (so it can be dequeued in purge_queue())
    3) Send the packet to the packet handler
    4) Go to next packet in the queue and start over
    5) When done, run purge_queue() to purge handled commands

  Note that any unhandlable packets should probably be left in the
  queue.  This is the best way to prevent data loss.  This means
  that a single packet may get looked at by this function multiple
  times.  This is more good than bad!  This behavior may change.

  Aren't queue's fun?

  TODO: Get rid of all the ugly if's.
  TODO: Clean up.
  TODO: More support for mid-level handlers.
  TODO: Allow for NULL handlers.

 */
faim_export int aim_rxdispatch(struct aim_session_t *sess)
{
  int i = 0;
  struct command_rx_struct *workingPtr = NULL;
  static int critical = 0;

  if (critical)
    return 0; /* don't call recursively! */

  critical = 1;

  if (sess->queue_incoming == NULL) {
    faimdprintf(sess, 1, "parse_generic: incoming packet queue empty.\n");
  } else {
    workingPtr = sess->queue_incoming;
    for (i = 0; workingPtr != NULL; workingPtr = workingPtr->next, i++) {
      unsigned short family,subtype;

      /*
       * XXX: This is still fairly ugly.
       */
      if (workingPtr->handled)
	continue;

      /*
       * This is a debugging/sanity check only and probably could/should be removed
       * for stable code.
       */
      if (((workingPtr->hdrtype == AIM_FRAMETYPE_OFT) &&
	   (workingPtr->conn->type != AIM_CONN_TYPE_RENDEZVOUS)) ||
	  ((workingPtr->hdrtype == AIM_FRAMETYPE_OSCAR) &&
	   (workingPtr->conn->type == AIM_CONN_TYPE_RENDEZVOUS))) {
	faimdprintf(sess, 0, "rxhandlers: incompatible frame type %d on connection type 0x%04x\n", workingPtr->hdrtype, workingPtr->conn->type);
	workingPtr->handled = 1;
	continue;
      }

      if (workingPtr->conn->type == AIM_CONN_TYPE_RENDEZVOUS) {
	/* make sure that we only get OFT frames on these connections */
	if (workingPtr->hdrtype != AIM_FRAMETYPE_OFT) {
	  faimdprintf(sess, 0, "internal error: non-OFT frames on OFT connection\n");
	  workingPtr->handled = 1; /* get rid of it */
	} else {
	  /* XXX: implement this */
	  faimdprintf(sess, 0, "faim: OFT frame!\n");
	  workingPtr->handled = 1; /* get rid of it */
	}
	continue;
      }

      if (workingPtr->conn->type == AIM_CONN_TYPE_RENDEZVOUS_OUT) {
	/* not possible */
	faimdprintf(sess, 0, "rxdispatch called on RENDEZVOUS_OUT connection!\n");
	workingPtr->handled = 1;
	continue;
      }

      if ((workingPtr->commandlen == 4) &&
	  (aimutil_get32(workingPtr->data) == 0x00000001)) {
	workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_FLAPVER, workingPtr);
	continue;
      }

      if (workingPtr->hdr.oscar.type == 0x04) {
	workingPtr->handled = aim_negchan_middle(sess, workingPtr);
	continue;
      }

      if ((workingPtr->handled = consumesnac(sess, workingPtr)))
	continue;

      if (!workingPtr->handled) {
	family = aimutil_get16(workingPtr->data);
	subtype = aimutil_get16(workingPtr->data+2);

	faimdprintf(sess, 1, "warning: unhandled packet %04x/%04x\n", family, subtype);
	consumenonsnac(sess, workingPtr, 0xffff, 0xffff); /* last chance! */
	workingPtr->handled = 1;
      }
    }
  }

  /*
   * This doesn't have to be called here.  It could easily be done
   * by a seperate thread or something. It's an administrative operation,
   * and can take a while. Though the less you call it the less memory
   * you'll have :)
   */
  aim_purge_rxqueue(sess);

  critical = 0;

  return 0;
}

faim_internal int aim_parse_unknown(struct aim_session_t *sess,
					  struct command_rx_struct *command, ...)
{
  u_int i = 0;

  if (!sess || !command)
    return 1;

  faimdprintf(sess, 1, "\nRecieved unknown packet:");

  for (i = 0; i < command->commandlen; i++)
    {
      if ((i % 8) == 0)
	faimdprintf(sess, 1, "\n\t");

      faimdprintf(sess, 1, "0x%2x ", command->data[i]);
    }

  faimdprintf(sess, 1, "\n\n");

  return 1;
}


faim_internal int aim_negchan_middle(struct aim_session_t *sess,
				     struct command_rx_struct *command)
{
  struct aim_tlvlist_t *tlvlist;
  char *msg = NULL;
  unsigned short code = 0;
  aim_rxcallback_t userfunc = NULL;
  int ret = 1;

  /* Used only by the older login protocol */
  /* XXX remove this special case? */
  if (command->conn->type == AIM_CONN_TYPE_AUTH)
    return consumenonsnac(sess, command, 0x0017, 0x0003);

  tlvlist = aim_readtlvchain(command->data, command->commandlen);

  if (aim_gettlv(tlvlist, 0x0009, 1))
    code = aim_gettlv16(tlvlist, 0x0009, 1);

  if (aim_gettlv(tlvlist, 0x000b, 1))
    msg = aim_gettlv_str(tlvlist, 0x000b, 1);

  if ((userfunc = aim_callhandler(sess, command->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR)))
    ret = userfunc(sess, command, code, msg);

  aim_freetlvchain(&tlvlist);

  if (msg)
    free(msg);

  return ret;
}
Commit	Line	Data
	1	/*
	2	* aim_rxhandlers.c
	3	*
	4	* This file contains most all of the incoming packet handlers, along
	5	* with aim_rxdispatch(), the Rx dispatcher. Queue/list management is
	6	* actually done in aim_rxqueue.c.
	7	*
	8	*/
	9
	10	#define FAIM_INTERNAL
	11	#include <aim.h>
	12
	13	static aim_module_t findmodule(struct aim_session_t sess, const char *name)
	14	{
	15	aim_module_t *cur;
	16
	17	for (cur = (aim_module_t *)sess->modlistv; cur; cur = cur->next) {
	18	if (strcmp(name, cur->name) == 0)
	19	return cur;
	20	}
	21
	22	return NULL;
	23	}
	24
	25	faim_internal int aim__registermodule(struct aim_session_t sess, int (modfirst)(struct aim_session_t , aim_module_t ))
	26	{
	27	aim_module_t *mod;
	28
	29	if (!sess \|\| !modfirst)
	30	return -1;
	31
	32	if (!(mod = malloc(sizeof(aim_module_t))))
	33	return -1;
	34	memset(mod, 0, sizeof(aim_module_t));
	35
	36	if (modfirst(sess, mod) == -1) {
	37	free(mod);
	38	return -1;
	39	}
	40
	41	if (findmodule(sess, mod->name)) {
	42	if (mod->shutdown)
	43	mod->shutdown(sess, mod);
	44	free(mod);
	45	return -1;
	46	}
	47
	48	mod->next = (aim_module_t *)sess->modlistv;
	49	(aim_module_t *)sess->modlistv = mod;
	50
	51	faimdprintf(sess, 1, "registered module %s (family 0x%04x)\n", mod->name, mod->family);
	52
	53	return 0;
	54	}
	55
	56	faim_internal void aim__shutdownmodules(struct aim_session_t *sess)
	57	{
	58	aim_module_t *cur;
	59
	60	for (cur = (aim_module_t *)sess->modlistv; cur; ) {
	61	aim_module_t *tmp;
	62
	63	tmp = cur->next;
	64
	65	if (cur->shutdown)
	66	cur->shutdown(sess, cur);
	67
	68	free(cur);
	69
	70	cur = tmp;
	71	}
	72
	73	sess->modlistv = NULL;
	74
	75	return;
	76	}
	77
	78	static int consumesnac(struct aim_session_t sess, struct command_rx_struct rx)
	79	{
	80	aim_module_t *cur;
	81	aim_modsnac_t snac;
	82
	83	snac.family = aimutil_get16(rx->data+0);
	84	snac.subtype = aimutil_get16(rx->data+2);
	85	snac.flags = aimutil_get16(rx->data+4);
	86	snac.id = aimutil_get32(rx->data+6);
	87
	88	for (cur = (aim_module_t *)sess->modlistv; cur; cur = cur->next) {
	89
	90	if (!(cur->flags & AIM_MODFLAG_MULTIFAMILY) &&
	91	(cur->family != snac.family))
	92	continue;
	93
	94	if (cur->snachandler(sess, cur, rx, &snac, rx->data+10, rx->commandlen-10))
	95	return 1;
	96
	97	}
	98
	99	return 0;
	100	}
	101
	102	static int consumenonsnac(struct aim_session_t sess, struct command_rx_struct rx, unsigned short family, unsigned short subtype)
	103	{
	104	aim_module_t *cur;
	105	aim_modsnac_t snac;
	106
	107	snac.family = family;
	108	snac.subtype = subtype;
	109	snac.flags = snac.id = 0;
	110
	111	for (cur = (aim_module_t *)sess->modlistv; cur; cur = cur->next) {
	112
	113	if (!(cur->flags & AIM_MODFLAG_MULTIFAMILY) &&
	114	(cur->family != snac.family))
	115	continue;
	116
	117	if (cur->snachandler(sess, cur, rx, &snac, rx->data, rx->commandlen))
	118	return 1;
	119
	120	}
	121
	122	return 0;
	123	}
	124
	125	/*
	126	* Bleck functions get called when there's no non-bleck functions
	127	* around to cleanup the mess...
	128	*/
	129	faim_internal int bleck(struct aim_session_t sess,struct command_rx_struct workingPtr, ...)
	130	{
	131	u_short family;
	132	u_short subtype;
	133
	134	u_short maxf;
	135	u_short maxs;
	136
	137	/* XXX: this is ugly. and big just for debugging. */
	138	char *literals[14][25] = {
	139	{"Invalid",
	140	NULL
	141	},
	142	{"General",
	143	"Invalid",
	144	"Error",
	145	"Client Ready",
	146	"Server Ready",
	147	"Service Request",
	148	"Redirect",
	149	"Rate Information Request",
	150	"Rate Information",
	151	"Rate Information Ack",
	152	NULL,
	153	"Rate Information Change",
	154	"Server Pause",
	155	NULL,
	156	"Server Resume",
	157	"Request Personal User Information",
	158	"Personal User Information",
	159	"Evil Notification",
	160	NULL,
	161	"Migration notice",
	162	"Message of the Day",
	163	"Set Privacy Flags",
	164	"Well Known URL",
	165	"NOP"
	166	},
	167	{"Location",
	168	"Invalid",
	169	"Error",
	170	"Request Rights",
	171	"Rights Information",
	172	"Set user information",
	173	"Request User Information",
	174	"User Information",
	175	"Watcher Sub Request",
	176	"Watcher Notification"
	177	},
	178	{"Buddy List Management",
	179	"Invalid",
	180	"Error",
	181	"Request Rights",
	182	"Rights Information",
	183	"Add Buddy",
	184	"Remove Buddy",
	185	"Watcher List Query",
	186	"Watcher List Response",
	187	"Watcher SubRequest",
	188	"Watcher Notification",
	189	"Reject Notification",
	190	"Oncoming Buddy",
	191	"Offgoing Buddy"
	192	},
	193	{"Messeging",
	194	"Invalid",
	195	"Error",
	196	"Add ICBM Parameter",
	197	"Remove ICBM Parameter",
	198	"Request Parameter Information",
	199	"Parameter Information",
	200	"Outgoing Message",
	201	"Incoming Message",
	202	"Evil Request",
	203	"Evil Reply",
	204	"Missed Calls",
	205	"Message Error",
	206	"Host Ack"
	207	},
	208	{"Advertisements",
	209	"Invalid",
	210	"Error",
	211	"Request Ad",
	212	"Ad Data (GIFs)"
	213	},
	214	{"Invitation / Client-to-Client",
	215	"Invalid",
	216	"Error",
	217	"Invite a Friend",
	218	"Invitation Ack"
	219	},
	220	{"Administrative",
	221	"Invalid",
	222	"Error",
	223	"Information Request",
	224	"Information Reply",
	225	"Information Change Request",
	226	"Information Chat Reply",
	227	"Account Confirm Request",
	228	"Account Confirm Reply",
	229	"Account Delete Request",
	230	"Account Delete Reply"
	231	},
	232	{"Popups",
	233	"Invalid",
	234	"Error",
	235	"Display Popup"
	236	},
	237	{"BOS",
	238	"Invalid",
	239	"Error",
	240	"Request Rights",
	241	"Rights Response",
	242	"Set group permission mask",
	243	"Add permission list entries",
	244	"Delete permission list entries",
	245	"Add deny list entries",
	246	"Delete deny list entries",
	247	"Server Error"
	248	},
	249	{"User Lookup",
	250	"Invalid",
	251	"Error",
	252	"Search Request",
	253	"Search Response"
	254	},
	255	{"Stats",
	256	"Invalid",
	257	"Error",
	258	"Set minimum report interval",
	259	"Report Events"
	260	},
	261	{"Translate",
	262	"Invalid",
	263	"Error",
	264	"Translate Request",
	265	"Translate Reply",
	266	},
	267	{"Chat Navigation",
	268	"Invalid",
	269	"Error",
	270	"Request rights",
	271	"Request Exchange Information",
	272	"Request Room Information",
	273	"Request Occupant List",
	274	"Search for Room",
	275	"Outgoing Message",
	276	"Incoming Message",
	277	"Evil Request",
	278	"Evil Reply",
	279	"Chat Error",
	280	}
	281	};
	282
	283	maxf = sizeof(literals) / sizeof(literals[0]);
	284	maxs = sizeof(literals[0]) / sizeof(literals[0][0]);
	285
	286	family = aimutil_get16(workingPtr->data+0);
	287	subtype= aimutil_get16(workingPtr->data+2);
	288
	289	if((family < maxf) && (subtype+1 < maxs) && (literals[family][subtype] != NULL))
	290	faimdprintf(sess, 0, "bleck: null handler for %04x/%04x (%s)\n", family, subtype, literals[family][subtype+1]);
	291	else
	292	faimdprintf(sess, 0, "bleck: null handler for %04x/%04x (no literal)\n",family,subtype);
	293
	294	return 1;
	295	}
	296
	297	faim_export int aim_conn_addhandler(struct aim_session_t *sess,
	298	struct aim_conn_t *conn,
	299	u_short family,
	300	u_short type,
	301	aim_rxcallback_t newhandler,
	302	u_short flags)
	303	{
	304	struct aim_rxcblist_t *newcb;
	305
	306	if (!conn)
	307	return -1;
	308
	309	faimdprintf(sess, 1, "aim_conn_addhandler: adding for %04x/%04x\n", family, type);
	310
	311	if (!(newcb = (struct aim_rxcblist_t *)calloc(1, sizeof(struct aim_rxcblist_t))))
	312	return -1;
	313	newcb->family = family;
	314	newcb->type = type;
	315	newcb->flags = flags;
	316	if (!newhandler)
	317	newcb->handler = &bleck;
	318	else
	319	newcb->handler = newhandler;
	320	newcb->next = NULL;
	321
	322	if (!conn->handlerlist)
	323	conn->handlerlist = newcb;
	324	else {
	325	struct aim_rxcblist_t *cur;
	326
	327	cur = conn->handlerlist;
	328
	329	while (cur->next)
	330	cur = cur->next;
	331	cur->next = newcb;
	332	}
	333
	334	return 0;
	335	}
	336
	337	faim_export int aim_clearhandlers(struct aim_conn_t *conn)
	338	{
	339	struct aim_rxcblist_t *cur;
	340
	341	if (!conn)
	342	return -1;
	343
	344	for (cur = conn->handlerlist; cur; ) {
	345	struct aim_rxcblist_t *tmp;
	346
	347	tmp = cur->next;
	348	free(cur);
	349	cur = tmp;
	350	}
	351	conn->handlerlist = NULL;
	352
	353	return 0;
	354	}
	355
	356	faim_internal aim_rxcallback_t aim_callhandler(struct aim_session_t *sess,
	357	struct aim_conn_t *conn,
	358	unsigned short family,
	359	unsigned short type)
	360	{
	361	struct aim_rxcblist_t *cur;
	362
	363	if (!conn)
	364	return NULL;
	365
	366	faimdprintf(sess, 1, "aim_callhandler: calling for %04x/%04x\n", family, type);
	367
	368	for (cur = conn->handlerlist; cur; cur = cur->next) {
	369	if ((cur->family == family) && (cur->type == type))
	370	return cur->handler;
	371	}
	372
	373	if (type == AIM_CB_SPECIAL_DEFAULT) {
	374	faimdprintf(sess, 1, "aim_callhandler: no default handler for family 0x%04x\n", family);
	375	return NULL; /* prevent infinite recursion */
	376	}
	377
	378	faimdprintf(sess, 1, "aim_callhandler: no handler for 0x%04x/0x%04x\n", family, type);
	379
	380	return aim_callhandler(sess, conn, family, AIM_CB_SPECIAL_DEFAULT);
	381	}
	382
	383	faim_internal int aim_callhandler_noparam(struct aim_session_t *sess,
	384	struct aim_conn_t *conn,
	385	u_short family,
	386	u_short type,
	387	struct command_rx_struct *ptr)
	388	{
	389	aim_rxcallback_t userfunc = NULL;
	390	userfunc = aim_callhandler(sess, conn, family, type);
	391	if (userfunc)
	392	return userfunc(sess, ptr);
	393	return 1; /* XXX */
	394	}
	395
	396	/*
	397	aim_rxdispatch()
	398
	399	Basically, heres what this should do:
	400	1) Determine correct packet handler for this packet
	401	2) Mark the packet handled (so it can be dequeued in purge_queue())
	402	3) Send the packet to the packet handler
	403	4) Go to next packet in the queue and start over
	404	5) When done, run purge_queue() to purge handled commands
	405
	406	Note that any unhandlable packets should probably be left in the
	407	queue. This is the best way to prevent data loss. This means
	408	that a single packet may get looked at by this function multiple
	409	times. This is more good than bad! This behavior may change.
	410
	411	Aren't queue's fun?
	412
	413	TODO: Get rid of all the ugly if's.
	414	TODO: Clean up.
	415	TODO: More support for mid-level handlers.
	416	TODO: Allow for NULL handlers.
	417
	418	*/
	419	faim_export int aim_rxdispatch(struct aim_session_t *sess)
	420	{
	421	int i = 0;
	422	struct command_rx_struct *workingPtr = NULL;
	423	static int critical = 0;
	424
	425	if (critical)
	426	return 0; /* don't call recursively! */
	427
	428	critical = 1;
	429
	430	if (sess->queue_incoming == NULL) {
	431	faimdprintf(sess, 1, "parse_generic: incoming packet queue empty.\n");
	432	} else {
	433	workingPtr = sess->queue_incoming;
	434	for (i = 0; workingPtr != NULL; workingPtr = workingPtr->next, i++) {
	435	unsigned short family,subtype;
	436
	437	/*
	438	* XXX: This is still fairly ugly.
	439	*/
	440	if (workingPtr->handled)
	441	continue;
	442
	443	/*
	444	* This is a debugging/sanity check only and probably could/should be removed
	445	* for stable code.
	446	*/
	447	if (((workingPtr->hdrtype == AIM_FRAMETYPE_OFT) &&
	448	(workingPtr->conn->type != AIM_CONN_TYPE_RENDEZVOUS)) \|\|
	449	((workingPtr->hdrtype == AIM_FRAMETYPE_OSCAR) &&
	450	(workingPtr->conn->type == AIM_CONN_TYPE_RENDEZVOUS))) {
	451	faimdprintf(sess, 0, "rxhandlers: incompatible frame type %d on connection type 0x%04x\n", workingPtr->hdrtype, workingPtr->conn->type);
	452	workingPtr->handled = 1;
	453	continue;
	454	}
	455
	456	if (workingPtr->conn->type == AIM_CONN_TYPE_RENDEZVOUS) {
	457	/* make sure that we only get OFT frames on these connections */
	458	if (workingPtr->hdrtype != AIM_FRAMETYPE_OFT) {
	459	faimdprintf(sess, 0, "internal error: non-OFT frames on OFT connection\n");
	460	workingPtr->handled = 1; /* get rid of it */
	461	} else {
	462	/* XXX: implement this */
	463	faimdprintf(sess, 0, "faim: OFT frame!\n");
	464	workingPtr->handled = 1; /* get rid of it */
	465	}
	466	continue;
	467	}
	468
	469	if (workingPtr->conn->type == AIM_CONN_TYPE_RENDEZVOUS_OUT) {
	470	/* not possible */
	471	faimdprintf(sess, 0, "rxdispatch called on RENDEZVOUS_OUT connection!\n");
	472	workingPtr->handled = 1;
	473	continue;
	474	}
	475
	476	if ((workingPtr->commandlen == 4) &&
	477	(aimutil_get32(workingPtr->data) == 0x00000001)) {
	478	workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_FLAPVER, workingPtr);
	479	continue;
	480	}
	481
	482	if (workingPtr->hdr.oscar.type == 0x04) {
	483	workingPtr->handled = aim_negchan_middle(sess, workingPtr);
	484	continue;
	485	}
	486
	487	if ((workingPtr->handled = consumesnac(sess, workingPtr)))
	488	continue;
	489
	490	if (!workingPtr->handled) {
	491	family = aimutil_get16(workingPtr->data);
	492	subtype = aimutil_get16(workingPtr->data+2);
	493
	494	faimdprintf(sess, 1, "warning: unhandled packet %04x/%04x\n", family, subtype);
	495	consumenonsnac(sess, workingPtr, 0xffff, 0xffff); /* last chance! */
	496	workingPtr->handled = 1;
	497	}
	498	}
	499	}
	500
	501	/*
	502	* This doesn't have to be called here. It could easily be done
	503	* by a seperate thread or something. It's an administrative operation,
	504	* and can take a while. Though the less you call it the less memory
	505	* you'll have :)
	506	*/
	507	aim_purge_rxqueue(sess);
	508
	509	critical = 0;
	510
	511	return 0;
	512	}
	513
	514	faim_internal int aim_parse_unknown(struct aim_session_t *sess,
	515	struct command_rx_struct *command, ...)
	516	{
	517	u_int i = 0;
	518
	519	if (!sess \|\| !command)
	520	return 1;
	521
	522	faimdprintf(sess, 1, "\nRecieved unknown packet:");
	523
	524	for (i = 0; i < command->commandlen; i++)
	525	{
	526	if ((i % 8) == 0)
	527	faimdprintf(sess, 1, "\n\t");
	528
	529	faimdprintf(sess, 1, "0x%2x ", command->data[i]);
	530	}
	531
	532	faimdprintf(sess, 1, "\n\n");
	533
	534	return 1;
	535	}
	536
	537
	538	faim_internal int aim_negchan_middle(struct aim_session_t *sess,
	539	struct command_rx_struct *command)
	540	{
	541	struct aim_tlvlist_t *tlvlist;
	542	char *msg = NULL;
	543	unsigned short code = 0;
	544	aim_rxcallback_t userfunc = NULL;
	545	int ret = 1;
	546
	547	/* Used only by the older login protocol */
	548	/* XXX remove this special case? */
	549	if (command->conn->type == AIM_CONN_TYPE_AUTH)
	550	return consumenonsnac(sess, command, 0x0017, 0x0003);
	551
	552	tlvlist = aim_readtlvchain(command->data, command->commandlen);
	553
	554	if (aim_gettlv(tlvlist, 0x0009, 1))
	555	code = aim_gettlv16(tlvlist, 0x0009, 1);
	556
	557	if (aim_gettlv(tlvlist, 0x000b, 1))
	558	msg = aim_gettlv_str(tlvlist, 0x000b, 1);
	559
	560	if ((userfunc = aim_callhandler(sess, command->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR)))
	561	ret = userfunc(sess, command, code, msg);
	562
	563	aim_freetlvchain(&tlvlist);
	564
	565	if (msg)
	566	free(msg);
	567
	568	return ret;
	569	}
	570