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           return 1;
 290         }
 291
 292       /*
 293        * Extracting the message from the unknown cruft.
 294        *
 295        * This is a bit messy, and I'm not really qualified,
 296        * even as the author, to comment on it.  At least
 297        * its not as bad as a while loop shooting into infinity.
 298        *
 299        * "Do you believe in magic?"
 300        *
 301        */
 302       msgblock = msgblocktlv->value;
 303       j = 0;
 304
 305       wastebits = aimutil_get8(msgblock+j++);
 306       wastebits = aimutil_get8(msgblock+j++);
 307
 308       y = aimutil_get16(msgblock+j);
 309       j += 2;
 310       for (z = 0; z < y; z++)
 311         wastebits = aimutil_get8(msgblock+j++);
 312       wastebits = aimutil_get8(msgblock+j++);
 313       wastebits = aimutil_get8(msgblock+j++);
 314
 315       /*
 316        * Message string length, including flag words.
 317        */
 318       i = aimutil_get16(msgblock+j);
 319       j += 2;
 320
 321       /*
 322        * Flag words.
 323        *
 324        * Its rumored that these can kick in some funky
 325        * 16bit-wide char stuff that used to really kill
 326        * libfaim.  Hopefully the latter is no longer true.
 327        *
 328        * Though someone should investiagte the former.
 329        *
 330        */
 331       flag1 = aimutil_get16(msgblock+j);
 332       j += 2;
 333       flag2 = aimutil_get16(msgblock+j);
 334       j += 2;
 335
 336       if (flag1 || flag2)
 337         printf("faim: icbm: **warning: encoding flags are being used! {%04x, %04x}\n", flag1, flag2);
 338
 339       /*
 340        * Message string.
 341        */
 342       i -= 4;
 343       msg = (char *)malloc(i+1);
 344       memcpy(msg, msgblock+j, i);
 345       msg[i] = '\0';
 346
 347       /*
 348        * Call client.
 349        */
 350       userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
 351       if (userfunc)
 352         i = userfunc(sess, command, channel, &userinfo, msg, icbmflags, flag1, flag2);
 353       else
 354         i = 0;
 355
 356       free(msg);
 357     }
 358   else if (channel == 0x0002)
 359     {
 360       int rendtype;
 361       struct aim_tlv_t *block1;
 362       struct aim_tlvlist_t *list2;
 363       struct aim_tlv_t *tmptlv;
 364       int a;
 365
 366       /* Class. */
 367       if ((tmptlv = aim_gettlv(tlvlist, 0x0001, 1)))
 368         userinfo.class = aimutil_get16(tmptlv->value);
 369       /* On-since date */
 370       if ((tmptlv = aim_gettlv(tlvlist, 0x0003, 1)))
 371         userinfo.onlinesince = aimutil_get32(tmptlv->value);
 372       /* Idle-time */
 373       if ((tmptlv = aim_gettlv(tlvlist, 0x0004, 1)))
 374         userinfo.idletime = aimutil_get16(tmptlv->value);
 375       /* Session Length (AIM) */
 376       if ((tmptlv = aim_gettlv(tlvlist, 0x000f, 1)))
 377         userinfo.sessionlen = aimutil_get16(tmptlv->value);
 378       /* Session Length (AOL) */
 379       if ((tmptlv = aim_gettlv(tlvlist, 0x0010, 1)))
 380         userinfo.sessionlen = aimutil_get16(tmptlv->value);
 381
 382       /*
 383        * There's another block of TLVs embedded in the type 5 here.
 384        */
 385       block1 = aim_gettlv(tlvlist, 0x0005, 1);
 386       if (!block1)
 387         return 1; /* major problem */
 388
 389       a = 0x1a; /* skip -- not sure what this information is! */
 390
 391       /*
 392        * XXX: Ignore if there's no data, only cookie information.
 393        *
 394        * Its probably just an accepted invitation or something.
 395        *
 396        */
 397       if (block1->length <= 0x1a)
 398         {
 399           aim_freetlvchain(&tlvlist);
 400           return 1;
 401         }
 402
 403       list2 = aim_readtlvchain(block1->value+a, block1->length-a);
 404
 405       if (aim_gettlv(list2, 0x0004, 1) /* start connection */ ||
 406           aim_gettlv(list2, 0x000b, 1) /* close conncetion */)
 407         {
 408           rendtype = 1; /* voice request */
 409
 410           /*
 411            * Call client.
 412            */
 413           userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
 414           if (userfunc)
 415             i = userfunc(sess,
 416                          command,
 417                          channel,
 418                          rendtype,
 419                          &userinfo);
 420           else
 421             i = 0;
 422         }
 423       else
 424         {
 425           struct aim_chat_roominfo roominfo;
 426           char *msg=NULL,*encoding=NULL,*lang=NULL;
 427
 428           rendtype = 0; /* chat invite */
 429           if (aim_gettlv(list2, 0x2711, 1))
 430             {
 431               struct aim_tlv_t *nametlv;
 432
 433               nametlv = aim_gettlv(list2, 0x2711, 1);
 434               aim_chat_readroominfo(nametlv->value, &roominfo);
 435             }
 436
 437           if (aim_gettlv(list2, 0x000c, 1))
 438             msg = aim_gettlv_str(list2, 0x000c, 1);
 439
 440           if (aim_gettlv(list2, 0x000d, 1))
 441             encoding = aim_gettlv_str(list2, 0x000d, 1);
 442
 443           if (aim_gettlv(list2, 0x000e, 1))
 444             lang = aim_gettlv_str(list2, 0x000e, 1);
 445
 446           /*
 447            * Call client.
 448            */
 449           userfunc = aim_callhandler(command->conn, 0x0004, 0x0007);
 450           if (userfunc)
 451             i = userfunc(sess,
 452                          command,
 453                          channel,
 454                          rendtype,
 455                          &userinfo,
 456                          &roominfo,
 457                          msg,
 458                          encoding?encoding+1:NULL,
 459                          lang?lang+1:NULL);
 460           else
 461             i = 0;
 462
 463           free(roominfo.name);
 464           free(msg);
 465           free(encoding);
 466           free(lang);
 467         }
 468       aim_freetlvchain(&list2);
 469     }
 470
 471   /*
 472    * Free up the TLV chain.
 473    */
 474   aim_freetlvchain(&tlvlist);
 475
 476
 477   return i;
 478 }
 479
 480 /*
 481  * Not real sure what this does, nor does anyone I've talk to.
 482  *
 483  * Didn't use to send it.  But now I think it might be a good
 484  * idea.
 485  *
 486  */
 487 u_long aim_seticbmparam(struct aim_session_t *sess,
 488                         struct aim_conn_t *conn)
 489 {
 490   struct command_tx_struct newpacket;
 491   int curbyte;
 492
 493   newpacket.lock = 1;
 494   if (conn)
 495     newpacket.conn = conn;
 496   else
 497     newpacket.conn = aim_getconn_type(sess, AIM_CONN_TYPE_BOS);
 498   newpacket.type = 0x02;
 499
 500   newpacket.commandlen = 10 + 16;
 501   newpacket.data = (u_char *) malloc (newpacket.commandlen);
 502
 503   curbyte = aim_putsnac(newpacket.data, 0x0004, 0x0002, 0x0000, sess->snac_nextid);
 504   curbyte += aimutil_put16(newpacket.data+curbyte, 0x0000);
 505   curbyte += aimutil_put32(newpacket.data+curbyte, 0x00000003);
 506   curbyte += aimutil_put8(newpacket.data+curbyte,  0x1f);
 507   curbyte += aimutil_put8(newpacket.data+curbyte,  0x40);
 508   curbyte += aimutil_put8(newpacket.data+curbyte,  0x03);
 509   curbyte += aimutil_put8(newpacket.data+curbyte,  0xe7);
 510   curbyte += aimutil_put8(newpacket.data+curbyte,  0x03);
 511   curbyte += aimutil_put8(newpacket.data+curbyte,  0xe7);
 512   curbyte += aimutil_put16(newpacket.data+curbyte, 0x0000);
 513   curbyte += aimutil_put16(newpacket.data+curbyte, 0x0000);
 514
 515   aim_tx_enqueue(sess, &newpacket);
 516
 517   return (sess->snac_nextid++);
 518 }
 519
 520 int aim_parse_msgerror_middle(struct aim_session_t *sess,
 521                               struct command_rx_struct *command)
 522 {
 523   u_long snacid = 0x000000000;
 524   struct aim_snac_t *snac = NULL;
 525   int ret = 0;
 526   rxcallback_t userfunc = NULL;
 527
 528   /*
 529    * Get SNAC from packet and look it up
 530    * the list of unrepliedto/outstanding
 531    * SNACs.
 532    *
 533    * After its looked up, the SN that the
 534    * message should've gone to will be
 535    * in the ->data element of the snac struct.
 536    *
 537    */
 538   snacid = aimutil_get32(command->data+6);
 539   snac = aim_remsnac(sess, snacid);
 540
 541   if (!snac)
 542     {
 543       printf("faim: msgerr: got an ICBM-failed error on an unknown SNAC ID! (%08lx)\n", snacid);
 544     }
 545
 546   /*
 547    * Call client.
 548    */
 549   userfunc = aim_callhandler(command->conn, 0x0004, 0x0001);
 550   if (userfunc)
 551     ret =  userfunc(sess, command, (snac)?snac->data:"(UNKNOWN)");
 552   else
 553     ret = 0;
 554
 555   free(snac->data);
 556   free(snac);
 557
 558   return ret;
 559 }
 560
 561