aim_im.c

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