[libfaim.git] / src / info.c

/*
 * aim_info.c
 *
 * The functions here are responsible for requesting and parsing information-
 * gathering SNACs.  
 *
 */

#define FAIM_INTERNAL
#include <aim.h>

struct aim_priv_inforeq {
  char sn[MAXSNLEN+1];
  unsigned short infotype;
};

faim_export int aim_getinfo(struct aim_session_t *sess,
			    struct aim_conn_t *conn, 
			    const char *sn,
			    unsigned short infotype)
{
  struct command_tx_struct *newpacket;
  struct aim_priv_inforeq privdata;
  int i = 0;

  if (!sess || !conn || !sn)
    return -1;

  if ((infotype != AIM_GETINFO_GENERALINFO) &&
      (infotype != AIM_GETINFO_AWAYMESSAGE))
    return -1;

  if (!(newpacket = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 12+1+strlen(sn))))
    return -1;

  newpacket->lock = 1;

  i = aim_putsnac(newpacket->data, 0x0002, 0x0005, 0x0000, sess->snac_nextid);

  i += aimutil_put16(newpacket->data+i, infotype);
  i += aimutil_put8(newpacket->data+i, strlen(sn));
  i += aimutil_putstr(newpacket->data+i, sn, strlen(sn));

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

  strncpy(privdata.sn, sn, sizeof(privdata.sn));
  privdata.infotype = infotype;
  aim_cachesnac(sess, 0x0002, 0x0005, 0x0000, &privdata, sizeof(struct aim_priv_inforeq));

  return 0;
}

/*
 * Capability blocks.  
 */
static const struct {
  unsigned short flag;
  unsigned char data[16];
} aim_caps[] = {
  
  {AIM_CAPS_BUDDYICON,
   {0x09, 0x46, 0x13, 0x46, 0x4c, 0x7f, 0x11, 0xd1, 
    0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
  
  {AIM_CAPS_VOICE,
   {0x09, 0x46, 0x13, 0x41, 0x4c, 0x7f, 0x11, 0xd1, 
    0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},

  {AIM_CAPS_IMIMAGE,
   {0x09, 0x46, 0x13, 0x45, 0x4c, 0x7f, 0x11, 0xd1, 
    0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
  
  {AIM_CAPS_CHAT,
   {0x74, 0x8f, 0x24, 0x20, 0x62, 0x87, 0x11, 0xd1, 
    0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
  
  {AIM_CAPS_GETFILE,
   {0x09, 0x46, 0x13, 0x48, 0x4c, 0x7f, 0x11, 0xd1,
    0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},

  {AIM_CAPS_SENDFILE,
   {0x09, 0x46, 0x13, 0x43, 0x4c, 0x7f, 0x11, 0xd1, 
    0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},

  {AIM_CAPS_SAVESTOCKS,
   {0x09, 0x46, 0x13, 0x47, 0x4c, 0x7f, 0x11, 0xd1,
    0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},

  /*
   * Indeed, there are two of these.  The former appears
   * to be correct, but in some versions of winaim, the
   * second one is set.  Either they forgot to fix endianness,
   * or they made a typo. It really doesn't matter which.
   */
  {AIM_CAPS_GAMES,
   {0x09, 0x46, 0x13, 0x4a, 0x4c, 0x7f, 0x11, 0xd1,
    0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
  {AIM_CAPS_GAMES2,
   {0x09, 0x46, 0x13, 0x4a, 0x4c, 0x7f, 0x11, 0xd1,
    0x22, 0x82, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},

  {AIM_CAPS_SENDBUDDYLIST,
   {0x09, 0x46, 0x13, 0x4b, 0x4c, 0x7f, 0x11, 0xd1,
    0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},

  {AIM_CAPS_LAST}
};

faim_internal unsigned short aim_getcap(struct aim_session_t *sess, unsigned char *capblock, int buflen)
{
  unsigned short flags;
  int i;
  int offset = 0;
  int identified;

  for (offset = 0, flags = 0; offset < buflen; offset += 0x0010) {

    for (i = 0, identified = 0; !(aim_caps[i].flag & AIM_CAPS_LAST); i++) {

      if (memcmp(&aim_caps[i].data, capblock+offset, 0x10) == 0) {
	flags |= aim_caps[i].flag;
	identified++;
	break; /* should only match once... */
      }

    }

    if (!identified)
      faimdprintf(sess, 0, "unknown capability!\n");

  }

  return flags;
}

faim_internal int aim_putcap(unsigned char *capblock, int buflen, unsigned short caps)
{
  int offset, i;

  if (!capblock)
    return 0;

  for (i = 0, offset = 0; 
       !(aim_caps[i].flag & AIM_CAPS_LAST) && (offset < buflen); i++) {

    if (caps & aim_caps[i].flag) {
      memcpy(capblock+offset, aim_caps[i].data, 16);
      offset += 16;
    }

  }

  return offset;
}

/*
 * AIM is fairly regular about providing user info.  This
 * is a generic routine to extract it in its standard form.
 */
faim_internal int aim_extractuserinfo(struct aim_session_t *sess, unsigned char *buf, struct aim_userinfo_s *outinfo)
{
  int i = 0;
  int tlvcnt = 0;
  int curtlv = 0;
  int tlv1 = 0;
  u_short curtype;
  int lastvalid;


  if (!buf || !outinfo)
    return -1;

  /* Clear out old data first */
  memset(outinfo, 0x00, sizeof(struct aim_userinfo_s));

  /*
   * Screen name.    Stored as an unterminated string prepended
   *                 with an unsigned byte containing its length.
   */
  if (buf[i] < MAXSNLEN) {
    memcpy(outinfo->sn, &(buf[i+1]), buf[i]);
    outinfo->sn[(int)buf[i]] = '\0';
  } else {
    memcpy(outinfo->sn, &(buf[i+1]), MAXSNLEN-1);
    outinfo->sn[MAXSNLEN] = '\0';
  }
  i = 1 + (int)buf[i];

  /*
   * Warning Level.  Stored as an unsigned short.
   */
  outinfo->warnlevel = aimutil_get16(&buf[i]);
  i += 2;

  /*
   * TLV Count.      Unsigned short representing the number of 
   *                 Type-Length-Value triples that follow.
   */
  tlvcnt = aimutil_get16(&buf[i]);
  i += 2;

  /* 
   * Parse out the Type-Length-Value triples as they're found.
   */
  while (curtlv < tlvcnt) {
    lastvalid = 1;
    curtype = aimutil_get16(&buf[i]);
    switch (curtype) {
      /*
       * Type = 0x0000: Invalid
       *
       * AOL has been trying to throw these in just to break us.
       * They're real nice guys over there at AOL.  
       *
       * Just skip the two zero bytes and continue on. (This doesn't
       * count towards tlvcnt!)
       */
    case 0x0000:
      lastvalid = 0;
      i += 2;
      break;

      /*
       * Type = 0x0001: User flags
       * 
       * Specified as any of the following bitwise ORed together:
       *      0x0001  Trial (user less than 60days)
       *      0x0002  Unknown bit 2
       *      0x0004  AOL Main Service user
       *      0x0008  Unknown bit 4
       *      0x0010  Free (AIM) user 
       *      0x0020  Away
       *
       * In some odd cases, we can end up with more
       * than one of these.  We only want the first,
       * as the others may not be something we want.
       *
       */
    case 0x0001:
      if (tlv1) /* use only the first */
	break;
      outinfo->flags = aimutil_get16(&buf[i+4]);
      tlv1++;
      break;
      
      /*
       * Type = 0x0002: Member-Since date. 
       *
       * The time/date that the user originally
       * registered for the service, stored in 
       * time_t format
       */
    case 0x0002: 
      outinfo->membersince = aimutil_get32(&buf[i+4]);
      break;
      
      /*
       * Type = 0x0003: On-Since date.
       *
       * The time/date that the user started 
       * their current session, stored in time_t
       * format.
       */
    case 0x0003:
      outinfo->onlinesince = aimutil_get32(&buf[i+4]);
      break;
      
      /*
       * Type = 0x0004: Idle time.
       *
       * Number of seconds since the user
       * actively used the service.
       */
    case 0x0004:
      outinfo->idletime = aimutil_get16(&buf[i+4]);
      break;
      
      /*
       * Type = 0x0006: ICQ Online Status
       *
       * ICQ's Away/DND/etc "enriched" status
       * Some decoding of values done by Scott <darkagl@pcnet.com>
       */
    case 0x0006:
      outinfo->icqinfo.status = aimutil_get16(buf+i+2+2+2);
      break;


      /*
       * Type = 0x000a
       *
       * ICQ User IP Address.
       * Ahh, the joy of ICQ security.
       */
    case 0x000a:
      outinfo->icqinfo.ipaddr = aimutil_get32(&buf[i+4]);
      break;

      /* Type = 0x000c
       *
       * random crap containing the IP address,
       * apparently a port number, and some Other Stuff.
       *
       */
    case 0x000c:
      memcpy(outinfo->icqinfo.crap, &buf[i+4], 0x25);
      break;

      /*
       * Type = 0x000d
       *
       * Capability information.  Not real sure of
       * actual decoding.  See comment on aim_bos_setprofile()
       * in aim_misc.c about the capability block, its the same.
       *
       */
    case 0x000d:
      {
	int len;
	len = aimutil_get16(buf+i+2);
	if (!len)
	  break;
	
	outinfo->capabilities = aim_getcap(sess, buf+i+4, len);
      }
      break;
      
      /*
       * Type = 0x000e
       *
       * Unknown.  Always of zero length, and always only
       * on AOL users.
       *
       * Ignore.
       *
       */
    case 0x000e:
      break;
      
      /*
       * Type = 0x000f: Session Length. (AIM)
       * Type = 0x0010: Session Length. (AOL)
       *
       * The duration, in seconds, of the user's
       * current session.
       *
       * Which TLV type this comes in depends
       * on the service the user is using (AIM or AOL).
       *
       */
    case 0x000f:
    case 0x0010:
      outinfo->sessionlen = aimutil_get32(&buf[i+4]);
      break;
      
      /*
       * Reaching here indicates that either AOL has
       * added yet another TLV for us to deal with, 
       * or the parsing has gone Terribly Wrong.
       *
       * Either way, inform the owner and attempt
       * recovery.
       *
       */
    default:
      {
	int len,z = 0, y = 0, x = 0;
	char tmpstr[160];

        faimdprintf(sess, 0, "userinfo: **warning: unexpected TLV:\n");
	faimdprintf(sess, 0, "userinfo:   sn    =%s\n", outinfo->sn);
	faimdprintf(sess, 0, "userinfo:   curtlv=0x%04x\n", curtlv);
	faimdprintf(sess, 0, "userinfo:   type  =0x%04x\n",aimutil_get16(&buf[i]));
	faimdprintf(sess, 0, "userinfo:   length=0x%04x\n", len = aimutil_get16(&buf[i+2]));
	faimdprintf(sess, 0, "userinfo:   data: \n");
	while (z<len)
	  {
	    x = snprintf(tmpstr, sizeof(tmpstr), "userinfo:      ");
	    for (y = 0; y < 8; y++)
	      {
		if (z<len)
		  {
		    snprintf(tmpstr+x, sizeof(tmpstr)-x, "%02x ", buf[i+4+z]);
		    z++;
		    x += 3;
		  }
		else
		  break;
	      }
	    faimdprintf(sess, 0, "%s\n", tmpstr);
	  }
      }
      break;
    }  
    /*
     * No matter what, TLV triplets should always look like this:
     *
     *   u_short type;
     *   u_short length;
     *   u_char  data[length];
     *
     */
    if (lastvalid) {
      i += (2 + 2 + aimutil_get16(&buf[i+2])); 	   
      curtlv++;
    }
  }
  
  return i;
}

/*
 * Inverse of aim_extractuserinfo()
 */
faim_internal int aim_putuserinfo(u_char *buf, int buflen, struct aim_userinfo_s *info)
{
  int i = 0, numtlv = 0;
  struct aim_tlvlist_t *tlvlist = NULL;

  if (!buf || !info)
    return 0;

  i += aimutil_put8(buf+i, strlen(info->sn));
  i += aimutil_putstr(buf+i, info->sn, strlen(info->sn));

  i += aimutil_put16(buf+i, info->warnlevel);


  aim_addtlvtochain16(&tlvlist, 0x0001, info->flags);
  numtlv++;

  aim_addtlvtochain32(&tlvlist, 0x0002, info->membersince);
  numtlv++;

  aim_addtlvtochain32(&tlvlist, 0x0003, info->onlinesince);
  numtlv++;

  aim_addtlvtochain16(&tlvlist, 0x0004, info->idletime);
  numtlv++;

#if ICQ_OSCAR_SUPPORT
  if(atoi(info->sn) != 0) {
    aim_addtlvtochain16(&tlvlist, 0x0006, info->icqinfo.status);
    aim_addtlvtochain32(&tlvlist, 0x000a, info->icqinfo.ipaddr);
  }
#endif

  aim_addtlvtochain_caps(&tlvlist, 0x000d, info->capabilities);
  numtlv++;

  aim_addtlvtochain32(&tlvlist, (unsigned short)((info->flags)&AIM_FLAG_AOL?0x0010:0x000f), info->sessionlen);
  numtlv++;

  i += aimutil_put16(buf+i, numtlv); /* tlvcount */
  i += aim_writetlvchain(buf+i, buflen-i, &tlvlist); /* tlvs */
  aim_freetlvchain(&tlvlist);

  return i;
}

faim_export int aim_sendbuddyoncoming(struct aim_session_t *sess, struct aim_conn_t *conn, struct aim_userinfo_s *info)
{
  struct command_tx_struct *tx;
  int i = 0;

  if (!sess || !conn || !info)
    return 0;

  if (!(tx = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 1152)))
    return -1;

  tx->lock = 1;

  i += aimutil_put16(tx->data+i, 0x0003);
  i += aimutil_put16(tx->data+i, 0x000b);
  i += aimutil_put16(tx->data+i, 0x0000);
  i += aimutil_put16(tx->data+i, 0x0000);
  i += aimutil_put16(tx->data+i, 0x0000);

  i += aim_putuserinfo(tx->data+i, tx->commandlen-i, info);

  tx->commandlen = i;
  tx->lock = 0;
  aim_tx_enqueue(sess, tx);

  return 0;
}

faim_export int aim_sendbuddyoffgoing(struct aim_session_t *sess, struct aim_conn_t *conn, char *sn)
{
  struct command_tx_struct *tx;
  int i = 0;

  if (!sess || !conn || !sn)
    return 0;

  if (!(tx = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 10+1+strlen(sn))))
    return -1;

  tx->lock = 1;

  i += aimutil_put16(tx->data+i, 0x0003);
  i += aimutil_put16(tx->data+i, 0x000c);
  i += aimutil_put16(tx->data+i, 0x0000);
  i += aimutil_put16(tx->data+i, 0x0000);
  i += aimutil_put16(tx->data+i, 0x0000);

  i += aimutil_put8(tx->data+i, strlen(sn));
  i += aimutil_putstr(tx->data+i, sn, strlen(sn));
  
  tx->lock = 0;
  aim_tx_enqueue(sess, tx);

  return 0;
}

faim_export int aim_0002_000b(struct aim_session_t *sess, struct aim_conn_t *conn, const char *sn)
{
  struct command_tx_struct *tx;
  int i = 0;

  if (!sess || !conn || !sn)
    return 0;

  if (!(tx = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 10+1+strlen(sn))))
    return -1;

  tx->lock = 1;

  i = aim_putsnac(tx->data, 0x0002, 0x000b, 0x0000, sess->snac_nextid);
  i += aimutil_put8(tx->data+i, strlen(sn));
  i += aimutil_putstr(tx->data+i, sn, strlen(sn));
  
  tx->commandlen = i;
  tx->lock = 0;
  aim_tx_enqueue(sess, tx);

  return 0;
}

/*
 * Normally contains:
 *   t(0001)  - short containing max profile length (value = 1024)
 *   t(0002)  - short - unknown (value = 16) [max MIME type length?]
 *   t(0003)  - short - unknown (value = 7)
 */
static int rights(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
{
  struct aim_tlvlist_t *tlvlist;
  aim_rxcallback_t userfunc;
  int ret = 0;
  unsigned short maxsiglen = 0;

  aim_parse_unknown(sess, rx);

  tlvlist = aim_readtlvchain(data, datalen);

  if (aim_gettlv(tlvlist, 0x0001, 1))
    maxsiglen = aim_gettlv16(tlvlist, 0x0001, 1);

  if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
    ret = userfunc(sess, rx, maxsiglen);

  aim_freetlvchain(&tlvlist);

  return ret;
}

static int userinfo(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
{
  struct aim_userinfo_s userinfo;
  char *text_encoding = NULL;
  char *text = NULL;
  int i = 0;
  aim_rxcallback_t userfunc;
  struct aim_tlvlist_t *tlvlist;
  struct aim_snac_t *origsnac = NULL;
  struct aim_priv_inforeq *inforeq;
  int ret = 0;

  origsnac = aim_remsnac(sess, snac->id);

  if (!origsnac || !origsnac->data) {
    faimdprintf(sess, 0, "parse_userinfo_middle: major problem: no snac stored!\n");
    return 0;
  }

  inforeq = (struct aim_priv_inforeq *)origsnac->data;

  if ((inforeq->infotype != AIM_GETINFO_GENERALINFO) &&
      (inforeq->infotype != AIM_GETINFO_AWAYMESSAGE)) {
    faimdprintf(sess, 0, "parse_userinfo_middle: unknown infotype in request! (0x%04x)\n", inforeq->infotype);
    return 0;
  }

  i = aim_extractuserinfo(sess, data, &userinfo);
  
  tlvlist = aim_readtlvchain(data+i, datalen-i);

  /* 
   * Depending on what informational text was requested, different
   * TLVs will appear here.
   *
   * Profile will be 1 and 2, away message will be 3 and 4.
   */
  if (aim_gettlv(tlvlist, 0x0001, 1)) {
    text_encoding = aim_gettlv_str(tlvlist, 0x0001, 1);
    text = aim_gettlv_str(tlvlist, 0x0002, 1);
  } else if (aim_gettlv(tlvlist, 0x0003, 1)) {
    text_encoding = aim_gettlv_str(tlvlist, 0x0003, 1);
    text = aim_gettlv_str(tlvlist, 0x0004, 1);
  }

  if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
    ret = userfunc(sess, rx, &userinfo, text_encoding, text, inforeq->infotype);

  free(text_encoding);
  free(text);

  aim_freetlvchain(&tlvlist);

  if (origsnac) {
    if (origsnac->data)
      free(origsnac->data);
    free(origsnac);
  }

  return ret;
}

static int snachandler(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
{

  if (snac->subtype == 0x0003)
    return rights(sess, mod, rx, snac, data, datalen);
  else if (snac->subtype == 0x0006)
    return userinfo(sess, mod, rx, snac, data, datalen);

  return 0;
}

faim_internal int locate_modfirst(struct aim_session_t *sess, aim_module_t *mod)
{

  mod->family = 0x0002;
  mod->version = 0x0000;
  mod->flags = 0;
  strncpy(mod->name, "locate", sizeof(mod->name));
  mod->snachandler = snachandler;

  return 0;
}
Commit	Line	Data
9de3ca7e	1	/*
	2	* aim_info.c
	3	*
	4	* The functions here are responsible for requesting and parsing information-
	5	* gathering SNACs.
	6	*
	7	*/
	8
37ee990e	9	#define FAIM_INTERNAL
dd60ff8b	10	#include <aim.h>
9de3ca7e	11
262272cc	12	struct aim_priv_inforeq {
1ea867e3	13	char sn[MAXSNLEN+1];
262272cc	14	unsigned short infotype;
	15	};
	16
00ef5271	17	faim_export int aim_getinfo(struct aim_session_t *sess,
	18	struct aim_conn_t *conn,
	19	const char *sn,
	20	unsigned short infotype)
9de3ca7e	21	{
5b79dc93	22	struct command_tx_struct *newpacket;
1ea867e3	23	struct aim_priv_inforeq privdata;
276495a3	24	int i = 0;
	25
	26	if (!sess \|\| !conn \|\| !sn)
00ef5271	27	return -1;
	28
	29	if ((infotype != AIM_GETINFO_GENERALINFO) &&
	30	(infotype != AIM_GETINFO_AWAYMESSAGE))
	31	return -1;
9de3ca7e	32
646c6b52	33	if (!(newpacket = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 12+1+strlen(sn))))
5b79dc93	34	return -1;
9de3ca7e	35
5b79dc93	36	newpacket->lock = 1;
9de3ca7e	37
5b79dc93	38	i = aim_putsnac(newpacket->data, 0x0002, 0x0005, 0x0000, sess->snac_nextid);
9de3ca7e	39
262272cc	40	i += aimutil_put16(newpacket->data+i, infotype);
5b79dc93	41	i += aimutil_put8(newpacket->data+i, strlen(sn));
5b79dc93	42	i += aimutil_putstr(newpacket->data+i, sn, strlen(sn));
9de3ca7e	43
5b79dc93	44	newpacket->lock = 0;
5b79dc93	45	aim_tx_enqueue(sess, newpacket);
9de3ca7e	46
1ea867e3	47	strncpy(privdata.sn, sn, sizeof(privdata.sn));
	48	privdata.infotype = infotype;
	49	aim_cachesnac(sess, 0x0002, 0x0005, 0x0000, &privdata, sizeof(struct aim_priv_inforeq));
9de3ca7e	50
00ef5271	51	return 0;
96f8b1ed	52	}
5b79dc93	53
	54	/*
	55	* Capability blocks.
	56	*/
f7bb124a	57	static const struct {
	58	unsigned short flag;
	59	unsigned char data[16];
	60	} aim_caps[] = {
5b79dc93	61
f7bb124a	62	{AIM_CAPS_BUDDYICON,
	63	{0x09, 0x46, 0x13, 0x46, 0x4c, 0x7f, 0x11, 0xd1,
	64	0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
5b79dc93	65
f7bb124a	66	{AIM_CAPS_VOICE,
	67	{0x09, 0x46, 0x13, 0x41, 0x4c, 0x7f, 0x11, 0xd1,
	68	0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
	69
	70	{AIM_CAPS_IMIMAGE,
	71	{0x09, 0x46, 0x13, 0x45, 0x4c, 0x7f, 0x11, 0xd1,
	72	0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
5b79dc93	73
f7bb124a	74	{AIM_CAPS_CHAT,
	75	{0x74, 0x8f, 0x24, 0x20, 0x62, 0x87, 0x11, 0xd1,
	76	0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
5b79dc93	77
f7bb124a	78	{AIM_CAPS_GETFILE,
	79	{0x09, 0x46, 0x13, 0x48, 0x4c, 0x7f, 0x11, 0xd1,
	80	0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
	81
	82	{AIM_CAPS_SENDFILE,
	83	{0x09, 0x46, 0x13, 0x43, 0x4c, 0x7f, 0x11, 0xd1,
	84	0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
	85
	86	{AIM_CAPS_SAVESTOCKS,
	87	{0x09, 0x46, 0x13, 0x47, 0x4c, 0x7f, 0x11, 0xd1,
	88	0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
	89
	90	/*
	91	* Indeed, there are two of these. The former appears
	92	* to be correct, but in some versions of winaim, the
	93	* second one is set. Either they forgot to fix endianness,
	94	* or they made a typo. It really doesn't matter which.
	95	*/
	96	{AIM_CAPS_GAMES,
	97	{0x09, 0x46, 0x13, 0x4a, 0x4c, 0x7f, 0x11, 0xd1,
	98	0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
	99	{AIM_CAPS_GAMES2,
	100	{0x09, 0x46, 0x13, 0x4a, 0x4c, 0x7f, 0x11, 0xd1,
	101	0x22, 0x82, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
	102
	103	{AIM_CAPS_SENDBUDDYLIST,
	104	{0x09, 0x46, 0x13, 0x4b, 0x4c, 0x7f, 0x11, 0xd1,
	105	0x82, 0x22, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00}},
	106
	107	{AIM_CAPS_LAST}
5b79dc93	108	};
5b79dc93	109
646c6b52	110	faim_internal unsigned short aim_getcap(struct aim_session_t sess, unsigned char capblock, int buflen)
b69540e3	111	{
f7bb124a	112	unsigned short flags;
f7bb124a	113	int i;
b69540e3	114	int offset = 0;
0589dc54	115	int identified;
b69540e3	116
f7bb124a	117	for (offset = 0, flags = 0; offset < buflen; offset += 0x0010) {
	118
	119	for (i = 0, identified = 0; !(aim_caps[i].flag & AIM_CAPS_LAST); i++) {
	120
	121	if (memcmp(&aim_caps[i].data, capblock+offset, 0x10) == 0) {
	122	flags \|= aim_caps[i].flag;
	123	identified++;
	124	break; /* should only match once... */
b69540e3	125	}
f7bb124a	126
b69540e3	127	}
f7bb124a	128
f7bb124a	129	if (!identified)
646c6b52	130	faimdprintf(sess, 0, "unknown capability!\n");
0589dc54	131
f7bb124a	132	}
	133
	134	return flags;
b69540e3	135	}
b69540e3	136
f7bb124a	137	faim_internal int aim_putcap(unsigned char *capblock, int buflen, unsigned short caps)
b69540e3	138	{
f7bb124a	139	int offset, i;
b69540e3	140
b69540e3	141	if (!capblock)
f7bb124a	142	return 0;
	143
	144	for (i = 0, offset = 0;
	145	!(aim_caps[i].flag & AIM_CAPS_LAST) && (offset < buflen); i++) {
	146
	147	if (caps & aim_caps[i].flag) {
	148	memcpy(capblock+offset, aim_caps[i].data, 16);
	149	offset += 16;
	150	}
b69540e3	151
0589dc54	152	}
b69540e3	153
	154	return offset;
	155	}
	156
9de3ca7e	157	/*
	158	* AIM is fairly regular about providing user info. This
	159	* is a generic routine to extract it in its standard form.
	160	*/
646c6b52	161	faim_internal int aim_extractuserinfo(struct aim_session_t sess, unsigned char buf, struct aim_userinfo_s *outinfo)
9de3ca7e	162	{
	163	int i = 0;
	164	int tlvcnt = 0;
	165	int curtlv = 0;
	166	int tlv1 = 0;
	167	u_short curtype;
68ac63c2	168	int lastvalid;
9de3ca7e	169
	170
	171	if (!buf \|\| !outinfo)
	172	return -1;
	173
	174	/* Clear out old data first */
	175	memset(outinfo, 0x00, sizeof(struct aim_userinfo_s));
	176
	177	/*
	178	* Screen name. Stored as an unterminated string prepended
	179	* with an unsigned byte containing its length.
	180	*/
68ac63c2	181	if (buf[i] < MAXSNLEN) {
	182	memcpy(outinfo->sn, &(buf[i+1]), buf[i]);
	183	outinfo->sn[(int)buf[i]] = '\0';
	184	} else {
	185	memcpy(outinfo->sn, &(buf[i+1]), MAXSNLEN-1);
	186	outinfo->sn[MAXSNLEN] = '\0';
	187	}
9de3ca7e	188	i = 1 + (int)buf[i];
	189
	190	/*
	191	* Warning Level. Stored as an unsigned short.
	192	*/
	193	outinfo->warnlevel = aimutil_get16(&buf[i]);
	194	i += 2;
	195
	196	/*
	197	* TLV Count. Unsigned short representing the number of
	198	* Type-Length-Value triples that follow.
	199	*/
	200	tlvcnt = aimutil_get16(&buf[i]);
	201	i += 2;
	202
	203	/*
	204	* Parse out the Type-Length-Value triples as they're found.
	205	*/
68ac63c2	206	while (curtlv < tlvcnt) {
	207	lastvalid = 1;
	208	curtype = aimutil_get16(&buf[i]);
	209	switch (curtype) {
	210	/*
	211	* Type = 0x0000: Invalid
	212	*
	213	* AOL has been trying to throw these in just to break us.
	214	* They're real nice guys over there at AOL.
	215	*
	216	* Just skip the two zero bytes and continue on. (This doesn't
	217	* count towards tlvcnt!)
	218	*/
	219	case 0x0000:
	220	lastvalid = 0;
	221	i += 2;
	222	break;
0b4acf97	223
68ac63c2	224	/*
a15d82b1	225	* Type = 0x0001: User flags
68ac63c2	226	*
	227	* Specified as any of the following bitwise ORed together:
	228	* 0x0001 Trial (user less than 60days)
	229	* 0x0002 Unknown bit 2
	230	* 0x0004 AOL Main Service user
	231	* 0x0008 Unknown bit 4
	232	* 0x0010 Free (AIM) user
	233	* 0x0020 Away
	234	*
	235	* In some odd cases, we can end up with more
	236	* than one of these. We only want the first,
	237	* as the others may not be something we want.
	238	*
	239	*/
	240	case 0x0001:
	241	if (tlv1) /* use only the first */
	242	break;
a15d82b1	243	outinfo->flags = aimutil_get16(&buf[i+4]);
68ac63c2	244	tlv1++;
	245	break;
	246
	247	/*
	248	* Type = 0x0002: Member-Since date.
	249	*
	250	* The time/date that the user originally
	251	* registered for the service, stored in
	252	* time_t format
	253	*/
	254	case 0x0002:
	255	outinfo->membersince = aimutil_get32(&buf[i+4]);
	256	break;
	257
	258	/*
	259	* Type = 0x0003: On-Since date.
	260	*
	261	* The time/date that the user started
	262	* their current session, stored in time_t
	263	* format.
	264	*/
	265	case 0x0003:
	266	outinfo->onlinesince = aimutil_get32(&buf[i+4]);
	267	break;
	268
	269	/*
	270	* Type = 0x0004: Idle time.
	271	*
	272	* Number of seconds since the user
	273	* actively used the service.
	274	*/
	275	case 0x0004:
	276	outinfo->idletime = aimutil_get16(&buf[i+4]);
	277	break;
	278
f2d214f9	279	/*
	280	* Type = 0x0006: ICQ Online Status
	281	*
	282	* ICQ's Away/DND/etc "enriched" status
	283	* Some decoding of values done by Scott <darkagl@pcnet.com>
	284	*/
	285	case 0x0006:
f2d214f9	286	outinfo->icqinfo.status = aimutil_get16(buf+i+2+2+2);
	287	break;
	288
3b101546	289
	290	/*
	291	* Type = 0x000a
	292	*
	293	* ICQ User IP Address.
	294	* Ahh, the joy of ICQ security.
	295	*/
	296	case 0x000a:
	297	outinfo->icqinfo.ipaddr = aimutil_get32(&buf[i+4]);
	298	break;
	299
	300	/* Type = 0x000c
	301	*
	302	* random crap containing the IP address,
	303	* apparently a port number, and some Other Stuff.
	304	*
	305	*/
	306	case 0x000c:
	307	memcpy(outinfo->icqinfo.crap, &buf[i+4], 0x25);
	308	break;
	309
68ac63c2	310	/*
	311	* Type = 0x000d
	312	*
	313	* Capability information. Not real sure of
	314	* actual decoding. See comment on aim_bos_setprofile()
	315	* in aim_misc.c about the capability block, its the same.
	316	*
	317	*/
	318	case 0x000d:
	319	{
	320	int len;
	321	len = aimutil_get16(buf+i+2);
	322	if (!len)
9de3ca7e	323	break;
68ac63c2	324
646c6b52	325	outinfo->capabilities = aim_getcap(sess, buf+i+4, len);
68ac63c2	326	}
	327	break;
	328
	329	/*
	330	* Type = 0x000e
	331	*
	332	* Unknown. Always of zero length, and always only
	333	* on AOL users.
	334	*
	335	* Ignore.
	336	*
	337	*/
	338	case 0x000e:
	339	break;
	340
	341	/*
	342	* Type = 0x000f: Session Length. (AIM)
	343	* Type = 0x0010: Session Length. (AOL)
	344	*
	345	* The duration, in seconds, of the user's
	346	* current session.
	347	*
	348	* Which TLV type this comes in depends
	349	* on the service the user is using (AIM or AOL).
	350	*
	351	*/
	352	case 0x000f:
	353	case 0x0010:
	354	outinfo->sessionlen = aimutil_get32(&buf[i+4]);
	355	break;
	356
	357	/*
	358	* Reaching here indicates that either AOL has
	359	* added yet another TLV for us to deal with,
	360	* or the parsing has gone Terribly Wrong.
	361	*
	362	* Either way, inform the owner and attempt
	363	* recovery.
	364	*
	365	*/
	366	default:
	367	{
	368	int len,z = 0, y = 0, x = 0;
646c6b52	369	char tmpstr[160];
	370
	371	faimdprintf(sess, 0, "userinfo: **warning: unexpected TLV:\n");
	372	faimdprintf(sess, 0, "userinfo: sn =%s\n", outinfo->sn);
	373	faimdprintf(sess, 0, "userinfo: curtlv=0x%04x\n", curtlv);
	374	faimdprintf(sess, 0, "userinfo: type =0x%04x\n",aimutil_get16(&buf[i]));
	375	faimdprintf(sess, 0, "userinfo: length=0x%04x\n", len = aimutil_get16(&buf[i+2]));
	376	faimdprintf(sess, 0, "userinfo: data: \n");
68ac63c2	377	while (z<len)
9de3ca7e	378	{
646c6b52	379	x = snprintf(tmpstr, sizeof(tmpstr), "userinfo: ");
68ac63c2	380	for (y = 0; y < 8; y++)
9de3ca7e	381	{
68ac63c2	382	if (z<len)
9de3ca7e	383	{
646c6b52	384	snprintf(tmpstr+x, sizeof(tmpstr)-x, "%02x ", buf[i+4+z]);
68ac63c2	385	z++;
68ac63c2	386	x += 3;
9de3ca7e	387	}
68ac63c2	388	else
68ac63c2	389	break;
9de3ca7e	390	}
646c6b52	391	faimdprintf(sess, 0, "%s\n", tmpstr);
9de3ca7e	392	}
68ac63c2	393	}
	394	break;
	395	}
	396	/*
	397	* No matter what, TLV triplets should always look like this:
	398	*
	399	* u_short type;
	400	* u_short length;
	401	* u_char data[length];
	402	*
	403	*/
	404	if (lastvalid) {
	405	i += (2 + 2 + aimutil_get16(&buf[i+2]));
9de3ca7e	406	curtlv++;
9de3ca7e	407	}
68ac63c2	408	}
9de3ca7e	409
	410	return i;
	411	}
	412
50443ea0	413	/*
	414	* Inverse of aim_extractuserinfo()
	415	*/
78b3fb13	416	faim_internal int aim_putuserinfo(u_char buf, int buflen, struct aim_userinfo_s info)
50443ea0	417	{
9c38f1a7	418	int i = 0, numtlv = 0;
50443ea0	419	struct aim_tlvlist_t *tlvlist = NULL;
	420
	421	if (!buf \|\| !info)
	422	return 0;
	423
	424	i += aimutil_put8(buf+i, strlen(info->sn));
	425	i += aimutil_putstr(buf+i, info->sn, strlen(info->sn));
	426
	427	i += aimutil_put16(buf+i, info->warnlevel);
	428
9c38f1a7	429
a15d82b1	430	aim_addtlvtochain16(&tlvlist, 0x0001, info->flags);
9c38f1a7	431	numtlv++;
9c38f1a7	432
50443ea0	433	aim_addtlvtochain32(&tlvlist, 0x0002, info->membersince);
9c38f1a7	434	numtlv++;
9c38f1a7	435
50443ea0	436	aim_addtlvtochain32(&tlvlist, 0x0003, info->onlinesince);
9c38f1a7	437	numtlv++;
9c38f1a7	438
50443ea0	439	aim_addtlvtochain16(&tlvlist, 0x0004, info->idletime);
9c38f1a7	440	numtlv++;
3b101546	441
	442	#if ICQ_OSCAR_SUPPORT
	443	if(atoi(info->sn) != 0) {
	444	aim_addtlvtochain16(&tlvlist, 0x0006, info->icqinfo.status);
	445	aim_addtlvtochain32(&tlvlist, 0x000a, info->icqinfo.ipaddr);
	446	}
	447	#endif
	448
	449	aim_addtlvtochain_caps(&tlvlist, 0x000d, info->capabilities);
9c38f1a7	450	numtlv++;
3b101546	451
a15d82b1	452	aim_addtlvtochain32(&tlvlist, (unsigned short)((info->flags)&AIM_FLAG_AOL?0x0010:0x000f), info->sessionlen);
9c38f1a7	453	numtlv++;
3b101546	454
9c38f1a7	455	i += aimutil_put16(buf+i, numtlv); /* tlvcount */
9c38f1a7	456	i += aim_writetlvchain(buf+i, buflen-i, &tlvlist); /* tlvs */
50443ea0	457	aim_freetlvchain(&tlvlist);
3b101546	458
50443ea0	459	return i;
	460	}
	461
78b3fb13	462	faim_export int aim_sendbuddyoncoming(struct aim_session_t sess, struct aim_conn_t conn, struct aim_userinfo_s *info)
50443ea0	463	{
5b79dc93	464	struct command_tx_struct *tx;
50443ea0	465	int i = 0;
	466
	467	if (!sess \|\| !conn \|\| !info)
	468	return 0;
	469
646c6b52	470	if (!(tx = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 1152)))
5b79dc93	471	return -1;
50443ea0	472
5b79dc93	473	tx->lock = 1;
50443ea0	474
5b79dc93	475	i += aimutil_put16(tx->data+i, 0x0003);
	476	i += aimutil_put16(tx->data+i, 0x000b);
	477	i += aimutil_put16(tx->data+i, 0x0000);
	478	i += aimutil_put16(tx->data+i, 0x0000);
	479	i += aimutil_put16(tx->data+i, 0x0000);
50443ea0	480
5b79dc93	481	i += aim_putuserinfo(tx->data+i, tx->commandlen-i, info);
50443ea0	482
5b79dc93	483	tx->commandlen = i;
	484	tx->lock = 0;
	485	aim_tx_enqueue(sess, tx);
50443ea0	486
	487	return 0;
	488	}
	489
78b3fb13	490	faim_export int aim_sendbuddyoffgoing(struct aim_session_t sess, struct aim_conn_t conn, char *sn)
50443ea0	491	{
5b79dc93	492	struct command_tx_struct *tx;
50443ea0	493	int i = 0;
	494
	495	if (!sess \|\| !conn \|\| !sn)
	496	return 0;
	497
646c6b52	498	if (!(tx = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 10+1+strlen(sn))))
5b79dc93	499	return -1;
50443ea0	500
5b79dc93	501	tx->lock = 1;
50443ea0	502
5b79dc93	503	i += aimutil_put16(tx->data+i, 0x0003);
	504	i += aimutil_put16(tx->data+i, 0x000c);
	505	i += aimutil_put16(tx->data+i, 0x0000);
	506	i += aimutil_put16(tx->data+i, 0x0000);
	507	i += aimutil_put16(tx->data+i, 0x0000);
50443ea0	508
5b79dc93	509	i += aimutil_put8(tx->data+i, strlen(sn));
5b79dc93	510	i += aimutil_putstr(tx->data+i, sn, strlen(sn));
50443ea0	511
5b79dc93	512	tx->lock = 0;
5b79dc93	513	aim_tx_enqueue(sess, tx);
50443ea0	514
	515	return 0;
	516	}
262272cc	517
e80a0fa9	518	faim_export int aim_0002_000b(struct aim_session_t sess, struct aim_conn_t conn, const char *sn)
	519	{
	520	struct command_tx_struct *tx;
	521	int i = 0;
	522
	523	if (!sess \|\| !conn \|\| !sn)
	524	return 0;
	525
	526	if (!(tx = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 10+1+strlen(sn))))
	527	return -1;
	528
	529	tx->lock = 1;
	530
	531	i = aim_putsnac(tx->data, 0x0002, 0x000b, 0x0000, sess->snac_nextid);
	532	i += aimutil_put8(tx->data+i, strlen(sn));
	533	i += aimutil_putstr(tx->data+i, sn, strlen(sn));
	534
	535	tx->commandlen = i;
	536	tx->lock = 0;
	537	aim_tx_enqueue(sess, tx);
	538
	539	return 0;
	540	}
	541
b39e0a91	542	/*
	543	* Normally contains:
	544	* t(0001) - short containing max profile length (value = 1024)
	545	* t(0002) - short - unknown (value = 16) [max MIME type length?]
	546	* t(0003) - short - unknown (value = 7)
	547	*/
00ef5271	548	static int rights(struct aim_session_t sess, aim_module_t mod, struct command_rx_struct rx, aim_modsnac_t snac, unsigned char *data, int datalen)
	549	{
	550	struct aim_tlvlist_t *tlvlist;
e677fc43	551	aim_rxcallback_t userfunc;
00ef5271	552	int ret = 0;
b39e0a91	553	unsigned short maxsiglen = 0;
	554
	555	aim_parse_unknown(sess, rx);
00ef5271	556
	557	tlvlist = aim_readtlvchain(data, datalen);
	558
b39e0a91	559	if (aim_gettlv(tlvlist, 0x0001, 1))
	560	maxsiglen = aim_gettlv16(tlvlist, 0x0001, 1);
	561
00ef5271	562	if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
b39e0a91	563	ret = userfunc(sess, rx, maxsiglen);
00ef5271	564
	565	aim_freetlvchain(&tlvlist);
	566
	567	return ret;
	568	}
	569
	570	static int userinfo(struct aim_session_t sess, aim_module_t mod, struct command_rx_struct rx, aim_modsnac_t snac, unsigned char *data, int datalen)
	571	{
	572	struct aim_userinfo_s userinfo;
	573	char *text_encoding = NULL;
	574	char *text = NULL;
	575	int i = 0;
e677fc43	576	aim_rxcallback_t userfunc;
00ef5271	577	struct aim_tlvlist_t *tlvlist;
	578	struct aim_snac_t *origsnac = NULL;
	579	struct aim_priv_inforeq *inforeq;
	580	int ret = 0;
	581
	582	origsnac = aim_remsnac(sess, snac->id);
	583
	584	if (!origsnac \|\| !origsnac->data) {
	585	faimdprintf(sess, 0, "parse_userinfo_middle: major problem: no snac stored!\n");
	586	return 0;
	587	}
	588
	589	inforeq = (struct aim_priv_inforeq *)origsnac->data;
	590
	591	if ((inforeq->infotype != AIM_GETINFO_GENERALINFO) &&
	592	(inforeq->infotype != AIM_GETINFO_AWAYMESSAGE)) {
	593	faimdprintf(sess, 0, "parse_userinfo_middle: unknown infotype in request! (0x%04x)\n", inforeq->infotype);
	594	return 0;
	595	}
	596
	597	i = aim_extractuserinfo(sess, data, &userinfo);
	598
	599	tlvlist = aim_readtlvchain(data+i, datalen-i);
	600
	601	/*
	602	* Depending on what informational text was requested, different
	603	* TLVs will appear here.
	604	*
	605	* Profile will be 1 and 2, away message will be 3 and 4.
	606	*/
	607	if (aim_gettlv(tlvlist, 0x0001, 1)) {
	608	text_encoding = aim_gettlv_str(tlvlist, 0x0001, 1);
	609	text = aim_gettlv_str(tlvlist, 0x0002, 1);
	610	} else if (aim_gettlv(tlvlist, 0x0003, 1)) {
	611	text_encoding = aim_gettlv_str(tlvlist, 0x0003, 1);
	612	text = aim_gettlv_str(tlvlist, 0x0004, 1);
	613	}
	614
	615	if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
	616	ret = userfunc(sess, rx, &userinfo, text_encoding, text, inforeq->infotype);
	617
	618	free(text_encoding);
	619	free(text);
	620
	621	aim_freetlvchain(&tlvlist);
	622
	623	if (origsnac) {
	624	if (origsnac->data)
	625	free(origsnac->data);
	626	free(origsnac);
	627	}
	628
	629	return ret;
	630	}
	631
	632	static int snachandler(struct aim_session_t sess, aim_module_t mod, struct command_rx_struct rx, aim_modsnac_t snac, unsigned char *data, int datalen)
	633	{
	634
	635	if (snac->subtype == 0x0003)
	636	return rights(sess, mod, rx, snac, data, datalen);
	637	else if (snac->subtype == 0x0006)
	638	return userinfo(sess, mod, rx, snac, data, datalen);
	639
	640	return 0;
641	}
642
643	faim_internal int locate_modfirst(struct aim_session_t sess, aim_module_t mod)
644	{
645
646	mod->family = 0x0002;
647	mod->version = 0x0000;
648	mod->flags = 0;
649	strncpy(mod->name, "locate", sizeof(mod->name));
650	mod->snachandler = snachandler;
651
652	return 0;
653	}