[libfaim.git] / aim_im.c

/*
 *  aim_im.c
 *
 *  The routines for sending/receiving Instant Messages.
 *
 */

#include <faim/aim.h>

/*
 * Send an ICBM (instant message).  
 *
 *
 * Possible flags:
 *   AIM_IMFLAGS_AWAY  -- Marks the message as an autoresponse
 *   AIM_IMFLAGS_ACK   -- Requests that the server send an ack
 *                        when the message is received (of type 0x0004/0x000c)
 *
 */
u_long aim_send_im(struct aim_session_t *sess,
		   struct aim_conn_t *conn, 
		   char *destsn, u_int flags, char *msg)
{   

  int curbyte,i;
  struct command_tx_struct *newpacket;
  
  if (strlen(msg) >= MAXMSGLEN)
    return -1;

  if (!(newpacket = aim_tx_new(0x0002, conn, strlen(msg)+256)))
    return -1;

  newpacket->lock = 1; /* lock struct */

  curbyte  = 0;
  curbyte += aim_putsnac(newpacket->data+curbyte, 
			 0x0004, 0x0006, 0x0000, sess->snac_nextid);

  /* 
   * Generate a random message cookie 
   *
   * We could cache these like we do SNAC IDs.  (In fact, it 
   * might be a good idea.)  In the message error functions, 
   * the 8byte message cookie is returned as well as the 
   * SNAC ID.
   *
   */
  for (i=0;i<8;i++)
    curbyte += aimutil_put8(newpacket->data+curbyte, (u_char) random());

  /*
   * Channel ID
   */
  curbyte += aimutil_put16(newpacket->data+curbyte,0x0001);

  /* 
   * Destination SN (prepended with byte length)
   */
  curbyte += aimutil_put8(newpacket->data+curbyte,strlen(destsn));
  curbyte += aimutil_putstr(newpacket->data+curbyte, destsn, strlen(destsn));

  /*
   * metaTLV start.
   */
  curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
  curbyte += aimutil_put16(newpacket->data+curbyte, strlen(msg) + 0x0d);

  /*
   * Flag data?
   */
  curbyte += aimutil_put16(newpacket->data+curbyte, 0x0501);
  curbyte += aimutil_put16(newpacket->data+curbyte, 0x0001);
  curbyte += aimutil_put16(newpacket->data+curbyte, 0x0101);
  curbyte += aimutil_put8 (newpacket->data+curbyte, 0x01);

  /* 
   * Message block length.
   */
  curbyte += aimutil_put16(newpacket->data+curbyte, strlen(msg) + 0x04);

  /*
   * Character set data? 
   */
  curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
  curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);

  /*
   * Message.  Not terminated.
   */
  curbyte += aimutil_putstr(newpacket->data+curbyte,msg, strlen(msg));

  /*
   * Set the Request Acknowledge flag.  
   */
  if (flags & AIM_IMFLAGS_ACK) {
    curbyte += aimutil_put16(newpacket->data+curbyte,0x0003);
    curbyte += aimutil_put16(newpacket->data+curbyte,0x0000);
  }
  
  /*
   * Set the Autoresponse flag.
   */
  if (flags & AIM_IMFLAGS_AWAY) {
    curbyte += aimutil_put16(newpacket->data+curbyte,0x0004);
    curbyte += aimutil_put16(newpacket->data+curbyte,0x0000);
  }
  
  newpacket->commandlen = curbyte;
  newpacket->lock = 0;

  aim_tx_enqueue(sess, newpacket);

#ifdef USE_SNAC_FOR_IMS
 {
    struct aim_snac_t snac;

    snac.id = sess->snac_nextid;
    snac.family = 0x0004;
    snac.type = 0x0006;
    snac.flags = 0x0000;

    snac.data = malloc(strlen(destsn)+1);
    memcpy(snac.data, destsn, strlen(destsn)+1);

    aim_newsnac(sess, &snac);
  }

 aim_cleansnacs(sess, 60); /* clean out all SNACs over 60sec old */
#endif

  return (sess->snac_nextid++);
}

/*
 * It can easily be said that parsing ICBMs is THE single
 * most difficult thing to do in the in AIM protocol.  In
 * fact, I think I just did say that.
 *
 * Below is the best damned solution I've come up with
 * over the past sixteen months of battling with it. This
 * can parse both away and normal messages from every client
 * I have access to.  Its not fast, its not clean.  But it works.
 *
 * We should also support at least minimal parsing of 
 * Channel 2, so that we can at least know the name of the
 * room we're invited to, but obviously can't attend...
 *
 */
int aim_parse_incoming_im_middle(struct aim_session_t *sess,
				 struct command_rx_struct *command)
{
  u_int i = 0,z;
  rxcallback_t userfunc = NULL;
  u_char cookie[8];
  int channel;
  struct aim_tlvlist_t *tlvlist;
  struct aim_userinfo_s userinfo;
  u_short wastebits;

  memset(&userinfo, 0x00, sizeof(struct aim_userinfo_s));
 
  i = 10; /* Skip SNAC header */

  /*
   * Read ICBM Cookie.  And throw away.
   */
  for (z=0; z<8; z++,i++)
    cookie[z] = command->data[i];
  
  /*
   * Channel ID.
   *
   * Channel 0x0001 is the message channel.  There are 
   * other channels for things called "rendevous"
   * which represent chat and some of the other new
   * features of AIM2/3/3.5. 
   *
   * Channel 0x0002 is the Rendevous channel, which
   * is where Chat Invitiations and various client-client
   * connection negotiations come from.
   * 
   */
  channel = aimutil_get16(command->data+i);
  i += 2;
  
  /*
   *
   */
  if ((channel != 0x01) && (channel != 0x02))
    {
      printf("faim: icbm: ICBM received on an unsupported channel.  Ignoring.\n (chan = %04x)", channel);
      return 1;
    }

  /*
   * Source screen name.
   */
  memcpy(userinfo.sn, command->data+i+1, (int)command->data[i]);
  userinfo.sn[(int)command->data[i]] = '\0';
  i += 1 + (int)command->data[i];

  /*
   * Warning Level
   */
  userinfo.warnlevel = aimutil_get16(command->data+i); /* guess */
  i += 2;

  /*
   * Number of TLVs that follow.  Not needed.
   */
  wastebits = aimutil_get16(command->data+i);
  i += 2;
  
  /*
   * Read block of TLVs.  All further data is derived
   * from what is parsed here.
   */
  tlvlist = aim_readtlvchain(command->data+i, command->commandlen-i);

  /*
   * From here on, its depends on what channel we're on.
   */
  if (channel == 1)
    {
     u_int j = 0, y = 0, z = 0;
      char *msg = NULL;
      u_int icbmflags = 0;
      struct aim_tlv_t *msgblocktlv, *tmptlv;
      u_char *msgblock;
      u_short flag1,flag2;
           
      /*
       * Check Autoresponse status.  If it is an autoresponse,
       * it will contain a second type 0x0004 TLV, with zero length.
       */
      if (aim_gettlv(tlvlist, 0x0004, 2))
	icbmflags |= AIM_IMFLAGS_AWAY;
      
      /*
       * Check Ack Request status.
       */
      if (aim_gettlv(tlvlist, 0x0003, 2))
	icbmflags |= AIM_IMFLAGS_ACK;
      
      /*
       * Extract the various pieces of the userinfo struct.
       */
      /* Class. */
      if ((tmptlv = aim_gettlv(tlvlist, 0x0001, 1)))
	userinfo.class = aimutil_get16(tmptlv->value);
      /* Member-since date. */
      if ((tmptlv = aim_gettlv(tlvlist, 0x0002, 1)))
	{
	  /* If this is larger than 4, its probably the message block, skip */
	  if (tmptlv->length <= 4)
	    userinfo.membersince = aimutil_get32(tmptlv->value);
	}
      /* On-since date */
      if ((tmptlv = aim_gettlv(tlvlist, 0x0003, 1)))
	userinfo.onlinesince = aimutil_get32(tmptlv->value);
      /* Idle-time */
      if ((tmptlv = aim_gettlv(tlvlist, 0x0004, 1)))
	userinfo.idletime = aimutil_get16(tmptlv->value);
      /* Session Length (AIM) */
      if ((tmptlv = aim_gettlv(tlvlist, 0x000f, 1)))
	userinfo.sessionlen = aimutil_get16(tmptlv->value);
      /* Session Length (AOL) */
      if ((tmptlv = aim_gettlv(tlvlist, 0x0010, 1)))
	userinfo.sessionlen = aimutil_get16(tmptlv->value);
      
      /*
       * Message block.
       *
       * XXX: Will the msgblock always be the second 0x0002? 
       */
      msgblocktlv = aim_gettlv(tlvlist, 0x0002, 1);
      if (!msgblocktlv)
	{
	  printf("faim: icbm: major error! no message block TLV found!\n");
	  aim_freetlvchain(&tlvlist);
	  return 1;
	}
      
      /*
       * Extracting the message from the unknown cruft.
       * 
       * This is a bit messy, and I'm not really qualified,
       * even as the author, to comment on it.  At least
       * its not as bad as a while loop shooting into infinity.
       *
       * "Do you believe in magic?"
       *
       */
      msgblock = msgblocktlv->value;
      j = 0;
      
      wastebits = aimutil_get8(msgblock+j++);
      wastebits = aimutil_get8(msgblock+j++);
      
      y = aimutil_get16(msgblock+j);
      j += 2;
      for (z = 0; z < y; z++)
	wastebits = aimutil_get8(msgblock+j++);
      wastebits = aimutil_get8(msgblock+j++);
      wastebits = aimutil_get8(msgblock+j++);
      
      /* 
       * Message string length, including flag words.
       */
      i = aimutil_get16(msgblock+j);
      j += 2;
      
      /*
       * Flag words.
       *
       * Its rumored that these can kick in some funky
       * 16bit-wide char stuff that used to really kill
       * libfaim.  Hopefully the latter is no longer true.
       *
       * Though someone should investiagte the former.
       *
       */
      flag1 = aimutil_get16(msgblock+j);
      j += 2;
      flag2 = aimutil_get16(msgblock+j);
      j += 2;
      
      if (flag1 || flag2)
	printf("faim: icbm: **warning: encoding flags are being used! {%04x, %04x}\n", flag1, flag2);
      
      /* 
       * Message string. 
       */
      i -= 4;
      msg = (char *)malloc(i+1);
      memcpy(msg, msgblock+j, i);
      msg[i] = '\0';
      
      /*
       * Call client.
       */
      userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
      if (userfunc)
	i = userfunc(sess, command, channel, &userinfo, msg, icbmflags, flag1, flag2);
      else 
	i = 0;
      
      free(msg);
    }
  else if (channel == 0x0002)
    {	
      int rendtype;
      struct aim_tlv_t *block1;
      struct aim_tlvlist_t *list2;
      struct aim_tlv_t *tmptlv;
      int a;
      
      /* Class. */
      if ((tmptlv = aim_gettlv(tlvlist, 0x0001, 1)))
	userinfo.class = aimutil_get16(tmptlv->value);
      /* On-since date */
      if ((tmptlv = aim_gettlv(tlvlist, 0x0003, 1)))
	userinfo.onlinesince = aimutil_get32(tmptlv->value);
      /* Idle-time */
      if ((tmptlv = aim_gettlv(tlvlist, 0x0004, 1)))
	userinfo.idletime = aimutil_get16(tmptlv->value);
      /* Session Length (AIM) */
      if ((tmptlv = aim_gettlv(tlvlist, 0x000f, 1)))
	userinfo.sessionlen = aimutil_get16(tmptlv->value);
      /* Session Length (AOL) */
      if ((tmptlv = aim_gettlv(tlvlist, 0x0010, 1)))
	userinfo.sessionlen = aimutil_get16(tmptlv->value);

      /*
       * There's another block of TLVs embedded in the type 5 here. 
       */
      block1 = aim_gettlv(tlvlist, 0x0005, 1);
      if (!block1)
	return 1; /* major problem */

      a = 0x1a; /* skip -- not sure what this information is! */

      /*
       * XXX: Ignore if there's no data, only cookie information.
       *
       * Its probably just an accepted invitation or something.
       *  
       */
      if (block1->length <= 0x1a)
	{
	  aim_freetlvchain(&tlvlist);
	  return 1;
	}

      list2 = aim_readtlvchain(block1->value+a, block1->length-a);

      if (aim_gettlv(list2, 0x0004, 1) /* start connection */ ||  
	  aim_gettlv(list2, 0x000b, 1) /* close conncetion */)
	{
	  rendtype = 1; /* voice request */

	  /*
	   * Call client.
	   */
	  userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
	  if (userfunc)
	    i = userfunc(sess, 
			 command, 
			 channel, 
			 rendtype,
			 &userinfo);
	  else 
	    i = 0;
	}
      else
	{
	  struct aim_chat_roominfo roominfo;
	  char *msg=NULL,*encoding=NULL,*lang=NULL;

	  rendtype = 0; /* chat invite */
	  if (aim_gettlv(list2, 0x2711, 1))
	    {
	      struct aim_tlv_t *nametlv;
	      
	      nametlv = aim_gettlv(list2, 0x2711, 1);
	      aim_chat_readroominfo(nametlv->value, &roominfo);
	    }
	  
	  if (aim_gettlv(list2, 0x000c, 1))
	    msg = aim_gettlv_str(list2, 0x000c, 1);
	  
	  if (aim_gettlv(list2, 0x000d, 1))
	    encoding = aim_gettlv_str(list2, 0x000d, 1);
	  
	  if (aim_gettlv(list2, 0x000e, 1))
	    lang = aim_gettlv_str(list2, 0x000e, 1);
      
	  /*
	   * Call client.
	   */
	  userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
	  if (userfunc)
	    i = userfunc(sess, 
			 command, 
			 channel, 
			 rendtype,
			 &userinfo, 
			 &roominfo, 
			 msg, 
			 encoding?encoding+1:NULL, 
			 lang?lang+1:NULL);
	  else 
	    i = 0;
      
	  free(roominfo.name);
	  free(msg);
	  free(encoding);
	  free(lang);
	}
      aim_freetlvchain(&list2);
    }

  /*
   * Free up the TLV chain.
   */
  aim_freetlvchain(&tlvlist);
  

  return i;
}

/*
 * Not real sure what this does, nor does anyone I've talk to.
 *
 * Didn't use to send it.  But now I think it might be a good
 * idea. 
 *
 */
u_long aim_seticbmparam(struct aim_session_t *sess,
			struct aim_conn_t *conn)
{
  struct command_tx_struct *newpacket;
  int curbyte;

  if(!(newpacket = aim_tx_new(0x0002, conn, 10+16)))
    return -1;

  newpacket->lock = 1;

  curbyte = aim_putsnac(newpacket->data, 0x0004, 0x0002, 0x0000, sess->snac_nextid);
  curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
  curbyte += aimutil_put32(newpacket->data+curbyte, 0x00000003);
  curbyte += aimutil_put8(newpacket->data+curbyte,  0x1f);
  curbyte += aimutil_put8(newpacket->data+curbyte,  0x40);
  curbyte += aimutil_put8(newpacket->data+curbyte,  0x03);
  curbyte += aimutil_put8(newpacket->data+curbyte,  0xe7);
  curbyte += aimutil_put8(newpacket->data+curbyte,  0x03);
  curbyte += aimutil_put8(newpacket->data+curbyte,  0xe7);
  curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
  curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);

  newpacket->lock = 0;
  aim_tx_enqueue(sess, newpacket);

  return (sess->snac_nextid++);
}

int aim_parse_msgerror_middle(struct aim_session_t *sess,
			      struct command_rx_struct *command)
{
  u_long snacid = 0x000000000;
  struct aim_snac_t *snac = NULL;
  int ret = 0;
  rxcallback_t userfunc = NULL;

  /*
   * Get SNAC from packet and look it up 
   * the list of unrepliedto/outstanding
   * SNACs.
   *
   * After its looked up, the SN that the
   * message should've gone to will be 
   * in the ->data element of the snac struct.
   *
   */
  snacid = aimutil_get32(command->data+6);
  snac = aim_remsnac(sess, snacid);

  if (!snac)
    {
      printf("faim: msgerr: got an ICBM-failed error on an unknown SNAC ID! (%08lx)\n", snacid);
    }

  /*
   * Call client.
   */
  userfunc = aim_callhandler(command->conn, 0x0004, 0x0001);
  if (userfunc)
    ret =  userfunc(sess, command, (snac)?snac->data:"(UNKNOWN)");
  else
    ret = 0;
  
  free(snac->data);
  free(snac);

  return ret;
}
Commit	Line	Data
9de3ca7e	1	/*
	2	* aim_im.c
	3	*
	4	* The routines for sending/receiving Instant Messages.
	5	*
	6	*/
	7
a25832e6	8	#include <faim/aim.h>
9de3ca7e	9
	10	/*
	11	* Send an ICBM (instant message).
	12	*
	13	*
	14	* Possible flags:
	15	* AIM_IMFLAGS_AWAY -- Marks the message as an autoresponse
	16	* AIM_IMFLAGS_ACK -- Requests that the server send an ack
	17	* when the message is received (of type 0x0004/0x000c)
	18	*
9de3ca7e	19	*/
a25832e6	20	u_long aim_send_im(struct aim_session_t *sess,
	21	struct aim_conn_t *conn,
	22	char destsn, u_int flags, char msg)
9de3ca7e	23	{
9de3ca7e	24
49c8a2fa	25	int curbyte,i;
5b79dc93	26	struct command_tx_struct *newpacket;
9de3ca7e	27
91931247	28	if (strlen(msg) >= MAXMSGLEN)
	29	return -1;
	30
	31	if (!(newpacket = aim_tx_new(0x0002, conn, strlen(msg)+256)))
5b79dc93	32	return -1;
9de3ca7e	33
5b79dc93	34	newpacket->lock = 1; /* lock struct */
9de3ca7e	35
9de3ca7e	36	curbyte = 0;
5b79dc93	37	curbyte += aim_putsnac(newpacket->data+curbyte,
a25832e6	38	0x0004, 0x0006, 0x0000, sess->snac_nextid);
9de3ca7e	39
49c8a2fa	40	/*
49c8a2fa	41	* Generate a random message cookie
a25832e6	42	*
	43	* We could cache these like we do SNAC IDs. (In fact, it
	44	* might be a good idea.) In the message error functions,
	45	* the 8byte message cookie is returned as well as the
	46	* SNAC ID.
	47	*
49c8a2fa	48	*/
49c8a2fa	49	for (i=0;i<8;i++)
5b79dc93	50	curbyte += aimutil_put8(newpacket->data+curbyte, (u_char) random());
9de3ca7e	51
49c8a2fa	52	/*
	53	* Channel ID
	54	*/
5b79dc93	55	curbyte += aimutil_put16(newpacket->data+curbyte,0x0001);
9de3ca7e	56
49c8a2fa	57	/*
	58	* Destination SN (prepended with byte length)
	59	*/
5b79dc93	60	curbyte += aimutil_put8(newpacket->data+curbyte,strlen(destsn));
5b79dc93	61	curbyte += aimutil_putstr(newpacket->data+curbyte, destsn, strlen(destsn));
9de3ca7e	62
49c8a2fa	63	/*
	64	* metaTLV start.
	65	*/
5b79dc93	66	curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
5b79dc93	67	curbyte += aimutil_put16(newpacket->data+curbyte, strlen(msg) + 0x0d);
9de3ca7e	68
49c8a2fa	69	/*
	70	* Flag data?
	71	*/
5b79dc93	72	curbyte += aimutil_put16(newpacket->data+curbyte, 0x0501);
	73	curbyte += aimutil_put16(newpacket->data+curbyte, 0x0001);
	74	curbyte += aimutil_put16(newpacket->data+curbyte, 0x0101);
	75	curbyte += aimutil_put8 (newpacket->data+curbyte, 0x01);
9de3ca7e	76
49c8a2fa	77	/*
	78	* Message block length.
	79	*/
5b79dc93	80	curbyte += aimutil_put16(newpacket->data+curbyte, strlen(msg) + 0x04);
9de3ca7e	81
49c8a2fa	82	/*
	83	* Character set data?
	84	*/
5b79dc93	85	curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
5b79dc93	86	curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
9de3ca7e	87
49c8a2fa	88	/*
	89	* Message. Not terminated.
	90	*/
5b79dc93	91	curbyte += aimutil_putstr(newpacket->data+curbyte,msg, strlen(msg));
9de3ca7e	92
49c8a2fa	93	/*
	94	* Set the Request Acknowledge flag.
	95	*/
5b79dc93	96	if (flags & AIM_IMFLAGS_ACK) {
	97	curbyte += aimutil_put16(newpacket->data+curbyte,0x0003);
	98	curbyte += aimutil_put16(newpacket->data+curbyte,0x0000);
	99	}
49c8a2fa	100
	101	/*
	102	* Set the Autoresponse flag.
	103	*/
5b79dc93	104	if (flags & AIM_IMFLAGS_AWAY) {
	105	curbyte += aimutil_put16(newpacket->data+curbyte,0x0004);
	106	curbyte += aimutil_put16(newpacket->data+curbyte,0x0000);
	107	}
49c8a2fa	108
5b79dc93	109	newpacket->commandlen = curbyte;
5b79dc93	110	newpacket->lock = 0;
9de3ca7e	111
5b79dc93	112	aim_tx_enqueue(sess, newpacket);
49c8a2fa	113
9de3ca7e	114	#ifdef USE_SNAC_FOR_IMS
	115	{
	116	struct aim_snac_t snac;
	117
a25832e6	118	snac.id = sess->snac_nextid;
9de3ca7e	119	snac.family = 0x0004;
	120	snac.type = 0x0006;
	121	snac.flags = 0x0000;
	122
	123	snac.data = malloc(strlen(destsn)+1);
	124	memcpy(snac.data, destsn, strlen(destsn)+1);
	125
a25832e6	126	aim_newsnac(sess, &snac);
9de3ca7e	127	}
9de3ca7e	128
a25832e6	129	aim_cleansnacs(sess, 60); /* clean out all SNACs over 60sec old */
9de3ca7e	130	#endif
9de3ca7e	131
a25832e6	132	return (sess->snac_nextid++);
9de3ca7e	133	}
9de3ca7e	134
49c8a2fa	135	/*
	136	* It can easily be said that parsing ICBMs is THE single
	137	* most difficult thing to do in the in AIM protocol. In
	138	* fact, I think I just did say that.
	139	*
	140	* Below is the best damned solution I've come up with
	141	* over the past sixteen months of battling with it. This
	142	* can parse both away and normal messages from every client
	143	* I have access to. Its not fast, its not clean. But it works.
	144	*
	145	* We should also support at least minimal parsing of
	146	* Channel 2, so that we can at least know the name of the
	147	* room we're invited to, but obviously can't attend...
	148	*
	149	*/
a25832e6	150	int aim_parse_incoming_im_middle(struct aim_session_t *sess,
a25832e6	151	struct command_rx_struct *command)
9de3ca7e	152	{
26af6789	153	u_int i = 0,z;
9de3ca7e	154	rxcallback_t userfunc = NULL;
49c8a2fa	155	u_char cookie[8];
	156	int channel;
	157	struct aim_tlvlist_t *tlvlist;
26af6789	158	struct aim_userinfo_s userinfo;
49c8a2fa	159	u_short wastebits;
49c8a2fa	160
95d7332a	161	memset(&userinfo, 0x00, sizeof(struct aim_userinfo_s));
95d7332a	162
49c8a2fa	163	i = 10; /* Skip SNAC header */
49c8a2fa	164
9de3ca7e	165	/*
49c8a2fa	166	* Read ICBM Cookie. And throw away.
9de3ca7e	167	*/
49c8a2fa	168	for (z=0; z<8; z++,i++)
49c8a2fa	169	cookie[z] = command->data[i];
9de3ca7e	170
49c8a2fa	171	/*
	172	* Channel ID.
	173	*
	174	* Channel 0x0001 is the message channel. There are
	175	* other channels for things called "rendevous"
	176	* which represent chat and some of the other new
26af6789	177	* features of AIM2/3/3.5.
	178	*
	179	* Channel 0x0002 is the Rendevous channel, which
50443ea0	180	* is where Chat Invitiations and various client-client
50443ea0	181	* connection negotiations come from.
26af6789	182	*
49c8a2fa	183	*/
49c8a2fa	184	channel = aimutil_get16(command->data+i);
9de3ca7e	185	i += 2;
26af6789	186
	187	/*
	188	*
	189	*/
	190	if ((channel != 0x01) && (channel != 0x02))
9de3ca7e	191	{
49c8a2fa	192	printf("faim: icbm: ICBM received on an unsupported channel. Ignoring.\n (chan = %04x)", channel);
49c8a2fa	193	return 1;
9de3ca7e	194	}
9de3ca7e	195
49c8a2fa	196	/*
	197	* Source screen name.
	198	*/
	199	memcpy(userinfo.sn, command->data+i+1, (int)command->data[i]);
	200	userinfo.sn[(int)command->data[i]] = '\0';
	201	i += 1 + (int)command->data[i];
95d7332a	202
49c8a2fa	203	/*
26af6789	204	* Warning Level
49c8a2fa	205	*/
26af6789	206	userinfo.warnlevel = aimutil_get16(command->data+i); /* guess */
49c8a2fa	207	i += 2;
26af6789	208
	209	/*
	210	* Number of TLVs that follow. Not needed.
	211	*/
49c8a2fa	212	wastebits = aimutil_get16(command->data+i);
9de3ca7e	213	i += 2;
26af6789	214
49c8a2fa	215	/*
	216	* Read block of TLVs. All further data is derived
	217	* from what is parsed here.
	218	*/
	219	tlvlist = aim_readtlvchain(command->data+i, command->commandlen-i);
9de3ca7e	220
49c8a2fa	221	/*
26af6789	222	* From here on, its depends on what channel we're on.
49c8a2fa	223	*/
26af6789	224	if (channel == 1)
49c8a2fa	225	{
26af6789	226	u_int j = 0, y = 0, z = 0;
	227	char *msg = NULL;
	228	u_int icbmflags = 0;
	229	struct aim_tlv_t msgblocktlv, tmptlv;
	230	u_char *msgblock;
	231	u_short flag1,flag2;
95d7332a	232
26af6789	233	/*
	234	* Check Autoresponse status. If it is an autoresponse,
	235	* it will contain a second type 0x0004 TLV, with zero length.
	236	*/
	237	if (aim_gettlv(tlvlist, 0x0004, 2))
	238	icbmflags \|= AIM_IMFLAGS_AWAY;
	239
	240	/*
	241	* Check Ack Request status.
	242	*/
	243	if (aim_gettlv(tlvlist, 0x0003, 2))
	244	icbmflags \|= AIM_IMFLAGS_ACK;
	245
	246	/*
	247	* Extract the various pieces of the userinfo struct.
	248	*/
	249	/* Class. */
	250	if ((tmptlv = aim_gettlv(tlvlist, 0x0001, 1)))
	251	userinfo.class = aimutil_get16(tmptlv->value);
	252	/* Member-since date. */
	253	if ((tmptlv = aim_gettlv(tlvlist, 0x0002, 1)))
	254	{
	255	/* If this is larger than 4, its probably the message block, skip */
	256	if (tmptlv->length <= 4)
	257	userinfo.membersince = aimutil_get32(tmptlv->value);
	258	}
	259	/* On-since date */
	260	if ((tmptlv = aim_gettlv(tlvlist, 0x0003, 1)))
	261	userinfo.onlinesince = aimutil_get32(tmptlv->value);
	262	/* Idle-time */
	263	if ((tmptlv = aim_gettlv(tlvlist, 0x0004, 1)))
	264	userinfo.idletime = aimutil_get16(tmptlv->value);
	265	/* Session Length (AIM) */
	266	if ((tmptlv = aim_gettlv(tlvlist, 0x000f, 1)))
	267	userinfo.sessionlen = aimutil_get16(tmptlv->value);
	268	/* Session Length (AOL) */
	269	if ((tmptlv = aim_gettlv(tlvlist, 0x0010, 1)))
	270	userinfo.sessionlen = aimutil_get16(tmptlv->value);
	271
	272	/*
	273	* Message block.
	274	*
	275	* XXX: Will the msgblock always be the second 0x0002?
	276	*/
	277	msgblocktlv = aim_gettlv(tlvlist, 0x0002, 1);
	278	if (!msgblocktlv)
	279	{
	280	printf("faim: icbm: major error! no message block TLV found!\n");
	281	aim_freetlvchain(&tlvlist);
e6b05d80	282	return 1;
26af6789	283	}
	284
	285	/*
	286	* Extracting the message from the unknown cruft.
	287	*
	288	* This is a bit messy, and I'm not really qualified,
	289	* even as the author, to comment on it. At least
	290	* its not as bad as a while loop shooting into infinity.
	291	*
	292	* "Do you believe in magic?"
	293	*
	294	*/
	295	msgblock = msgblocktlv->value;
	296	j = 0;
	297
	298	wastebits = aimutil_get8(msgblock+j++);
	299	wastebits = aimutil_get8(msgblock+j++);
	300
	301	y = aimutil_get16(msgblock+j);
	302	j += 2;
	303	for (z = 0; z < y; z++)
	304	wastebits = aimutil_get8(msgblock+j++);
	305	wastebits = aimutil_get8(msgblock+j++);
	306	wastebits = aimutil_get8(msgblock+j++);
	307
	308	/*
	309	* Message string length, including flag words.
	310	*/
	311	i = aimutil_get16(msgblock+j);
	312	j += 2;
	313
	314	/*
	315	* Flag words.
	316	*
	317	* Its rumored that these can kick in some funky
	318	* 16bit-wide char stuff that used to really kill
	319	* libfaim. Hopefully the latter is no longer true.
	320	*
	321	* Though someone should investiagte the former.
	322	*
	323	*/
	324	flag1 = aimutil_get16(msgblock+j);
	325	j += 2;
	326	flag2 = aimutil_get16(msgblock+j);
	327	j += 2;
	328
	329	if (flag1 \|\| flag2)
	330	printf("faim: icbm: **warning: encoding flags are being used! {%04x, %04x}\n", flag1, flag2);
	331
	332	/*
	333	* Message string.
	334	*/
	335	i -= 4;
	336	msg = (char *)malloc(i+1);
	337	memcpy(msg, msgblock+j, i);
	338	msg[i] = '\0';
	339
	340	/*
	341	* Call client.
	342	*/
	343	userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
	344	if (userfunc)
	345	i = userfunc(sess, command, channel, &userinfo, msg, icbmflags, flag1, flag2);
	346	else
347	i = 0;
348
349	free(msg);
49c8a2fa	350	}
26af6789	351	else if (channel == 0x0002)
0c20631f	352	{
0c20631f	353	int rendtype;
26af6789	354	struct aim_tlv_t *block1;
	355	struct aim_tlvlist_t *list2;
	356	struct aim_tlv_t *tmptlv;
	357	int a;
26af6789	358
	359	/* Class. */
	360	if ((tmptlv = aim_gettlv(tlvlist, 0x0001, 1)))
	361	userinfo.class = aimutil_get16(tmptlv->value);
	362	/* On-since date */
	363	if ((tmptlv = aim_gettlv(tlvlist, 0x0003, 1)))
	364	userinfo.onlinesince = aimutil_get32(tmptlv->value);
	365	/* Idle-time */
	366	if ((tmptlv = aim_gettlv(tlvlist, 0x0004, 1)))
	367	userinfo.idletime = aimutil_get16(tmptlv->value);
	368	/* Session Length (AIM) */
	369	if ((tmptlv = aim_gettlv(tlvlist, 0x000f, 1)))
	370	userinfo.sessionlen = aimutil_get16(tmptlv->value);
	371	/* Session Length (AOL) */
	372	if ((tmptlv = aim_gettlv(tlvlist, 0x0010, 1)))
	373	userinfo.sessionlen = aimutil_get16(tmptlv->value);
	374
	375	/*
	376	* There's another block of TLVs embedded in the type 5 here.
	377	*/
	378	block1 = aim_gettlv(tlvlist, 0x0005, 1);
	379	if (!block1)
	380	return 1; /* major problem */
	381
	382	a = 0x1a; /* skip -- not sure what this information is! */
	383
0c20631f	384	/*
	385	* XXX: Ignore if there's no data, only cookie information.
	386	*
	387	* Its probably just an accepted invitation or something.
	388	*
	389	*/
	390	if (block1->length <= 0x1a)
26af6789	391	{
0c20631f	392	aim_freetlvchain(&tlvlist);
0c20631f	393	return 1;
26af6789	394	}
26af6789	395
0c20631f	396	list2 = aim_readtlvchain(block1->value+a, block1->length-a);
26af6789	397
0c20631f	398	if (aim_gettlv(list2, 0x0004, 1) /* start connection */ \|\|
	399	aim_gettlv(list2, 0x000b, 1) /* close conncetion */)
	400	{
	401	rendtype = 1; /* voice request */
	402
	403	/*
	404	* Call client.
	405	*/
	406	userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
	407	if (userfunc)
	408	i = userfunc(sess,
	409	command,
	410	channel,
	411	rendtype,
	412	&userinfo);
	413	else
	414	i = 0;
	415	}
	416	else
	417	{
	418	struct aim_chat_roominfo roominfo;
	419	char msg=NULL,encoding=NULL,*lang=NULL;
	420
	421	rendtype = 0; /* chat invite */
	422	if (aim_gettlv(list2, 0x2711, 1))
	423	{
	424	struct aim_tlv_t *nametlv;
	425
	426	nametlv = aim_gettlv(list2, 0x2711, 1);
	427	aim_chat_readroominfo(nametlv->value, &roominfo);
	428	}
	429
	430	if (aim_gettlv(list2, 0x000c, 1))
	431	msg = aim_gettlv_str(list2, 0x000c, 1);
	432
	433	if (aim_gettlv(list2, 0x000d, 1))
	434	encoding = aim_gettlv_str(list2, 0x000d, 1);
	435
	436	if (aim_gettlv(list2, 0x000e, 1))
	437	lang = aim_gettlv_str(list2, 0x000e, 1);
26af6789	438
0c20631f	439	/*
	440	* Call client.
	441	*/
	442	userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
	443	if (userfunc)
	444	i = userfunc(sess,
	445	command,
	446	channel,
	447	rendtype,
	448	&userinfo,
	449	&roominfo,
	450	msg,
	451	encoding?encoding+1:NULL,
	452	lang?lang+1:NULL);
	453	else
	454	i = 0;
26af6789	455
0c20631f	456	free(roominfo.name);
	457	free(msg);
	458	free(encoding);
	459	free(lang);
	460	}
26af6789	461	aim_freetlvchain(&list2);
26af6789	462	}
9de3ca7e	463
49c8a2fa	464	/*
	465	* Free up the TLV chain.
	466	*/
	467	aim_freetlvchain(&tlvlist);
26af6789	468
49c8a2fa	469
26af6789	470	return i;
49c8a2fa	471	}
	472
	473	/*
	474	* Not real sure what this does, nor does anyone I've talk to.
	475	*
	476	* Didn't use to send it. But now I think it might be a good
	477	* idea.
	478	*
	479	*/
a25832e6	480	u_long aim_seticbmparam(struct aim_session_t *sess,
a25832e6	481	struct aim_conn_t *conn)
49c8a2fa	482	{
5b79dc93	483	struct command_tx_struct *newpacket;
49c8a2fa	484	int curbyte;
49c8a2fa	485
5b79dc93	486	if(!(newpacket = aim_tx_new(0x0002, conn, 10+16)))
	487	return -1;
	488
	489	newpacket->lock = 1;
	490
	491	curbyte = aim_putsnac(newpacket->data, 0x0004, 0x0002, 0x0000, sess->snac_nextid);
	492	curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
	493	curbyte += aimutil_put32(newpacket->data+curbyte, 0x00000003);
	494	curbyte += aimutil_put8(newpacket->data+curbyte, 0x1f);
	495	curbyte += aimutil_put8(newpacket->data+curbyte, 0x40);
	496	curbyte += aimutil_put8(newpacket->data+curbyte, 0x03);
	497	curbyte += aimutil_put8(newpacket->data+curbyte, 0xe7);
	498	curbyte += aimutil_put8(newpacket->data+curbyte, 0x03);
	499	curbyte += aimutil_put8(newpacket->data+curbyte, 0xe7);
	500	curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
	501	curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
	502
	503	newpacket->lock = 0;
	504	aim_tx_enqueue(sess, newpacket);
a25832e6	505
	506	return (sess->snac_nextid++);
	507	}
	508
	509	int aim_parse_msgerror_middle(struct aim_session_t *sess,
	510	struct command_rx_struct *command)
	511	{
	512	u_long snacid = 0x000000000;
	513	struct aim_snac_t *snac = NULL;
	514	int ret = 0;
	515	rxcallback_t userfunc = NULL;
	516
	517	/*
	518	* Get SNAC from packet and look it up
	519	* the list of unrepliedto/outstanding
	520	* SNACs.
	521	*
	522	* After its looked up, the SN that the
	523	* message should've gone to will be
	524	* in the ->data element of the snac struct.
	525	*
	526	*/
	527	snacid = aimutil_get32(command->data+6);
	528	snac = aim_remsnac(sess, snacid);
	529
	530	if (!snac)
	531	{
	532	printf("faim: msgerr: got an ICBM-failed error on an unknown SNAC ID! (%08lx)\n", snacid);
	533	}
	534
	535	/*
	536	* Call client.
	537	*/
	538	userfunc = aim_callhandler(command->conn, 0x0004, 0x0001);
	539	if (userfunc)
	540	ret = userfunc(sess, command, (snac)?snac->data:"(UNKNOWN)");
	541	else
	542	ret = 0;
	543
	544	free(snac->data);
	545	free(snac);
49c8a2fa	546
a25832e6	547	return ret;
9de3ca7e	548	}
e6b05d80	549
e6b05d80	550