aim_chat.c

   1 /*
   2  * aim_chat.c
   3  *
   4  * Routines for the Chat service.
   5  *
   6  */
   7
   8 #define FAIM_INTERNAL
   9 #include <faim/aim.h>
  10
  11 faim_export char *aim_chat_getname(struct aim_conn_t *conn)
  12 {
  13   if (!conn)
  14     return NULL;
  15   if (conn->type != AIM_CONN_TYPE_CHAT)
  16     return NULL;
  17
  18   return (char *)conn->priv; /* yuck ! */
  19 }
  20
  21 faim_export struct aim_conn_t *aim_chat_getconn(struct aim_session_t *sess, char *name)
  22 {
  23   struct aim_conn_t *cur;
  24
  25   faim_mutex_lock(&sess->connlistlock);
  26   for (cur = sess->connlist; cur; cur = cur->next) {
  27     if (cur->type != AIM_CONN_TYPE_CHAT)
  28       continue;
  29     if (!cur->priv) {
  30       printf("faim: chat: chat connection with no name! (fd = %d)\n", cur->fd);
  31       continue;
  32     }
  33     if (strcmp((char *)cur->priv, name) == 0)
  34       break;
  35   }
  36   faim_mutex_unlock(&sess->connlistlock);
  37
  38   return cur;
  39 }
  40
  41 faim_export int aim_chat_attachname(struct aim_conn_t *conn, char *roomname)
  42 {
  43   if (!conn || !roomname)
  44     return -1;
  45
  46   if (conn->priv)
  47     free(conn->priv);
  48
  49   conn->priv = strdup(roomname);
  50
  51   return 0;
  52 }
  53
  54 faim_export unsigned long aim_chat_send_im(struct aim_session_t *sess,
  55                                            struct aim_conn_t *conn,
  56                                            char *msg)
  57 {
  58
  59   int curbyte,i;
  60   struct command_tx_struct *newpacket;
  61   struct aim_msgcookie_t *cookie;
  62
  63   if (!sess || !conn || !msg)
  64     return 0;
  65
  66   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 1152)))
  67     return -1;
  68
  69   newpacket->lock = 1; /* lock struct */
  70
  71   curbyte  = 0;
  72   curbyte += aim_putsnac(newpacket->data+curbyte,
  73                          0x000e, 0x0005, 0x0000, sess->snac_nextid);
  74
  75   /*
  76    * Generate a random message cookie
  77    */
  78   for (i=0;i<8;i++)
  79     curbyte += aimutil_put8(newpacket->data+curbyte, (u_char) rand());
  80
  81   cookie = aim_mkcookie(newpacket->data+curbyte-8, AIM_COOKIETYPE_CHAT, NULL);
  82   cookie->data = strdup(conn->priv); /* chat hack dependent */
  83
  84   aim_cachecookie(sess, cookie);
  85
  86   /*
  87    * metaTLV start.  -- i assume this is a metaTLV.  it could be the
  88    *                    channel ID though.
  89    */
  90   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0003);
  91
  92   /*
  93    * Type 1: Unknown.  Blank.
  94    */
  95   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0001);
  96   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
  97
  98   /*
  99    * Type 6: Unknown.  Blank.
 100    */
 101   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0006);
 102   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
 103
 104   /*
 105    * Type 5: Message block.  Contains more TLVs.
 106    *
 107    * This could include other information... We just
 108    * put in a message TLV however.
 109    *
 110    */
 111   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0005);
 112   curbyte += aimutil_put16(newpacket->data+curbyte, strlen(msg)+4);
 113
 114   /*
 115    * SubTLV: Type 1: Message
 116    */
 117   curbyte += aim_puttlv_str(newpacket->data+curbyte, 0x0001, strlen(msg), msg);
 118
 119   newpacket->commandlen = curbyte;
 120
 121   newpacket->lock = 0;
 122   aim_tx_enqueue(sess, newpacket);
 123
 124   return (sess->snac_nextid++);
 125 }
 126
 127 /*
 128  * Join a room of name roomname.  This is the first
 129  * step to joining an already created room.  It's
 130  * basically a Service Request for family 0x000e,
 131  * with a little added on to specify the exchange
 132  * and room name.
 133  *
 134  */
 135 faim_export unsigned long aim_chat_join(struct aim_session_t *sess,
 136                                         struct aim_conn_t *conn,
 137                                         u_short exchange,
 138                                         const char *roomname)
 139 {
 140   struct command_tx_struct *newpacket;
 141   int i;
 142
 143   if (!sess || !conn || !roomname)
 144     return 0;
 145
 146   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10+9+strlen(roomname)+2)))
 147     return -1;
 148
 149   newpacket->lock = 1;
 150
 151   i = aim_putsnac(newpacket->data, 0x0001, 0x0004, 0x0000, sess->snac_nextid);
 152
 153   i+= aimutil_put16(newpacket->data+i, 0x000e);
 154
 155   /*
 156    * this is techinally a TLV, but we can't use normal functions
 157    * because we need the extraneous nulls and other weird things.
 158    */
 159   i+= aimutil_put16(newpacket->data+i, 0x0001);
 160   i+= aimutil_put16(newpacket->data+i, 2+1+strlen(roomname)+2);
 161   i+= aimutil_put16(newpacket->data+i, exchange);
 162   i+= aimutil_put8(newpacket->data+i, strlen(roomname));
 163   i+= aimutil_putstr(newpacket->data+i, roomname, strlen(roomname));
 164   i+= aimutil_put16(newpacket->data+i, 0x0000); /* instance? */
 165
 166   /*
 167    * Chat hack.
 168    *
 169    * XXX: A problem occurs here if we request a channel
 170    *      join but it fails....pendingjoin will be nonnull
 171    *      even though the channel is never going to get a
 172    *      redirect!
 173    *
 174    */
 175   sess->pendingjoin = strdup(roomname);
 176   sess->pendingjoinexchange = exchange;
 177
 178   newpacket->lock = 0;
 179   aim_tx_enqueue(sess, newpacket);
 180
 181   aim_cachesnac(sess, 0x0001, 0x0004, 0x0000, roomname, strlen(roomname)+1);
 182
 183   return sess->snac_nextid;
 184 }
 185
 186 faim_internal int aim_chat_readroominfo(u_char *buf, struct aim_chat_roominfo *outinfo)
 187 {
 188   int namelen = 0;
 189   int i = 0;
 190
 191   if (!buf || !outinfo)
 192     return 0;
 193
 194   outinfo->exchange = aimutil_get16(buf+i);
 195   i += 2;
 196
 197   namelen = aimutil_get8(buf+i);
 198   i += 1;
 199
 200   outinfo->name = (char *)malloc(namelen+1);
 201   memcpy(outinfo->name, buf+i, namelen);
 202   outinfo->name[namelen] = '\0';
 203   i += namelen;
 204
 205   outinfo->instance = aimutil_get16(buf+i);
 206   i += 2;
 207
 208   return i;
 209 }
 210
 211
 212 /*
 213  * General room information.  Lots of stuff.
 214  *
 215  * Values I know are in here but I havent attached
 216  * them to any of the 'Unknown's:
 217  *      - Language (English)
 218  *
 219  * SNAC 000e/0002
 220  */
 221 faim_internal int aim_chat_parse_infoupdate(struct aim_session_t *sess,
 222                                             struct command_rx_struct *command)
 223 {
 224   struct aim_userinfo_s *userinfo = NULL;
 225   rxcallback_t userfunc=NULL;
 226   int ret = 1, i = 0;
 227   int usercount = 0;
 228   u_char detaillevel = 0;
 229   char *roomname = NULL;
 230   struct aim_chat_roominfo roominfo;
 231   u_short tlvcount = 0;
 232   struct aim_tlvlist_t *tlvlist;
 233   char *roomdesc = NULL;
 234   unsigned short unknown_c9 = 0;
 235   unsigned long creationtime = 0;
 236   unsigned short maxmsglen = 0;
 237   unsigned short unknown_d2 = 0, unknown_d5 = 0;
 238
 239   i = 10;
 240   i += aim_chat_readroominfo(command->data+i, &roominfo);
 241
 242   detaillevel = aimutil_get8(command->data+i);
 243   i++;
 244
 245   if (detaillevel != 0x02) {
 246     if (detaillevel == 0x01)
 247       printf("faim: chat_roomupdateinfo: detail level 1 not supported\n");
 248     else
 249       printf("faim: chat_roomupdateinfo: unknown detail level %d\n", detaillevel);
 250     return 1;
 251   }
 252
 253   tlvcount = aimutil_get16(command->data+i);
 254   i += 2;
 255
 256   /*
 257    * Everything else are TLVs.
 258    */
 259   tlvlist = aim_readtlvchain(command->data+i, command->commandlen-i);
 260
 261   /*
 262    * TLV type 0x006a is the room name in Human Readable Form.
 263    */
 264   if (aim_gettlv(tlvlist, 0x006a, 1))
 265       roomname = aim_gettlv_str(tlvlist, 0x006a, 1);
 266
 267   /*
 268    * Type 0x006f: Number of occupants.
 269    */
 270   if (aim_gettlv(tlvlist, 0x006f, 1))
 271     usercount = aim_gettlv16(tlvlist, 0x006f, 1);
 272
 273   /*
 274    * Type 0x0073:  Occupant list.
 275    */
 276   if (aim_gettlv(tlvlist, 0x0073, 1)) {
 277     int curoccupant = 0;
 278     struct aim_tlv_t *tmptlv;
 279
 280     tmptlv = aim_gettlv(tlvlist, 0x0073, 1);
 281
 282     /* Allocate enough userinfo structs for all occupants */
 283     userinfo = calloc(usercount, sizeof(struct aim_userinfo_s));
 284
 285     i = 0;
 286     while (curoccupant < usercount)
 287       i += aim_extractuserinfo(tmptlv->value+i, &userinfo[curoccupant++]);
 288   }
 289
 290   /*
 291    * Type 0x00c9: Unknown. (2 bytes)
 292    */
 293   if (aim_gettlv(tlvlist, 0x00c9, 1))
 294     unknown_c9 = aim_gettlv16(tlvlist, 0x00c9, 1);
 295
 296   /*
 297    * Type 0x00ca: Creation time (4 bytes)
 298    */
 299   if (aim_gettlv(tlvlist, 0x00ca, 1))
 300     creationtime = aim_gettlv32(tlvlist, 0x00ca, 1);
 301
 302   /*
 303    * Type 0x00d1: Maximum Message Length
 304    */
 305   if (aim_gettlv(tlvlist, 0x00d1, 1))
 306     maxmsglen = aim_gettlv16(tlvlist, 0x00d1, 1);
 307
 308   /*
 309    * Type 0x00d2: Unknown. (2 bytes)
 310    */
 311   if (aim_gettlv(tlvlist, 0x00d2, 1))
 312     unknown_d2 = aim_gettlv16(tlvlist, 0x00d2, 1);
 313
 314   /*
 315    * Type 0x00d3: Room Description
 316    */
 317   if (aim_gettlv(tlvlist, 0x00d3, 1))
 318     roomdesc = aim_gettlv_str(tlvlist, 0x00d3, 1);
 319
 320   /*
 321    * Type 0x00d5: Unknown. (1 byte)
 322    */
 323   if (aim_gettlv(tlvlist, 0x00d5, 1))
 324     unknown_d5 = aim_gettlv8(tlvlist, 0x00d5, 1);
 325
 326
 327   if ((userfunc = aim_callhandler(command->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_ROOMINFOUPDATE))) {
 328     ret = userfunc(sess,
 329                    command,
 330                    &roominfo,
 331                    roomname,
 332                    usercount,
 333                    userinfo,
 334                    roomdesc,
 335                    unknown_c9,
 336                    creationtime,
 337                    maxmsglen,
 338                    unknown_d2,
 339                    unknown_d5);
 340   }
 341   free(roominfo.name);
 342   free(userinfo);
 343   free(roomname);
 344   free(roomdesc);
 345   aim_freetlvchain(&tlvlist);
 346
 347   return ret;
 348 }
 349
 350 faim_internal int aim_chat_parse_joined(struct aim_session_t *sess,
 351                                         struct command_rx_struct *command)
 352 {
 353   struct aim_userinfo_s *userinfo = NULL;
 354   rxcallback_t userfunc=NULL;
 355   int i = 10, curcount = 0, ret = 1;
 356
 357   while (i < command->commandlen) {
 358     curcount++;
 359     userinfo = realloc(userinfo, curcount * sizeof(struct aim_userinfo_s));
 360     i += aim_extractuserinfo(command->data+i, &userinfo[curcount-1]);
 361   }
 362
 363   if ((userfunc = aim_callhandler(command->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERJOIN))) {
 364     ret = userfunc(sess,
 365                    command,
 366                    curcount,
 367                    userinfo);
 368   }
 369
 370   free(userinfo);
 371
 372   return ret;
 373 }
 374
 375 faim_internal int aim_chat_parse_leave(struct aim_session_t *sess,
 376                                        struct command_rx_struct *command)
 377 {
 378
 379   struct aim_userinfo_s *userinfo = NULL;
 380   rxcallback_t userfunc=NULL;
 381   int i = 10, curcount = 0, ret = 1;
 382
 383   while (i < command->commandlen) {
 384     curcount++;
 385     userinfo = realloc(userinfo, curcount * sizeof(struct aim_userinfo_s));
 386     i += aim_extractuserinfo(command->data+i, &userinfo[curcount-1]);
 387   }
 388
 389   if ((userfunc = aim_callhandler(command->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERLEAVE))) {
 390     ret = userfunc(sess,
 391                    command,
 392                    curcount,
 393                    userinfo);
 394   }
 395
 396   free(userinfo);
 397
 398   return ret;
 399 }
 400
 401 /*
 402  * We could probably include this in the normal ICBM parsing
 403  * code as channel 0x0003, however, since only the start
 404  * would be the same, we might as well do it here.
 405  */
 406 faim_internal int aim_chat_parse_incoming(struct aim_session_t *sess,
 407                                           struct command_rx_struct *command)
 408 {
 409   struct aim_userinfo_s userinfo;
 410   rxcallback_t userfunc=NULL;
 411   int ret = 1, i = 0, z = 0;
 412   unsigned char cookie[8];
 413   int channel;
 414   struct aim_tlvlist_t *outerlist;
 415   char *msg = NULL;
 416   struct aim_msgcookie_t *ck;
 417
 418   memset(&userinfo, 0x00, sizeof(struct aim_userinfo_s));
 419
 420   i = 10; /* skip snac */
 421
 422   /*
 423    * ICBM Cookie.  Cache it.
 424    */
 425   for (z=0; z<8; z++,i++)
 426     cookie[z] = command->data[i];
 427
 428   if ((ck = aim_uncachecookie(sess, cookie, AIM_COOKIETYPE_CHAT))) {
 429     if (ck->data)
 430       free(ck->data);
 431     free(ck);
 432   }
 433
 434   /*
 435    * Channel ID
 436    *
 437    * Channels 1 and 2 are implemented in the normal ICBM
 438    * parser.
 439    *
 440    * We only do channel 3 here.
 441    *
 442    */
 443   channel = aimutil_get16(command->data+i);
 444   i += 2;
 445
 446   if (channel != 0x0003) {
 447     printf("faim: chat_incoming: unknown channel! (0x%04x)\n", channel);
 448     return 1;
 449   }
 450
 451   /*
 452    * Start parsing TLVs right away.
 453    */
 454   outerlist = aim_readtlvchain(command->data+i, command->commandlen-i);
 455
 456   /*
 457    * Type 0x0003: Source User Information
 458    */
 459   if (aim_gettlv(outerlist, 0x0003, 1)) {
 460     struct aim_tlv_t *userinfotlv;
 461
 462     userinfotlv = aim_gettlv(outerlist, 0x0003, 1);
 463     aim_extractuserinfo(userinfotlv->value, &userinfo);
 464   }
 465
 466   /*
 467    * Type 0x0001: Unknown.
 468    */
 469   if (aim_gettlv(outerlist, 0x0001, 1))
 470     ;
 471
 472   /*
 473    * Type 0x0005: Message Block.  Conains more TLVs.
 474    */
 475   if (aim_gettlv(outerlist, 0x0005, 1))
 476     {
 477       struct aim_tlvlist_t *innerlist;
 478       struct aim_tlv_t *msgblock;
 479
 480       msgblock = aim_gettlv(outerlist, 0x0005, 1);
 481       innerlist = aim_readtlvchain(msgblock->value, msgblock->length);
 482
 483       /*
 484        * Type 0x0001: Message.
 485        */
 486       if (aim_gettlv(innerlist, 0x0001, 1))
 487           msg = aim_gettlv_str(innerlist, 0x0001, 1);
 488
 489       aim_freetlvchain(&innerlist);
 490     }
 491
 492   userfunc = aim_callhandler(command->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_INCOMINGMSG);
 493   if (userfunc)
 494     {
 495       ret = userfunc(sess,
 496                      command,
 497                      &userinfo,
 498                      msg);
 499     }
 500   free(msg);
 501   aim_freetlvchain(&outerlist);
 502
 503   return ret;
 504 }
 505
 506 faim_export unsigned long aim_chat_clientready(struct aim_session_t *sess,
 507                                                struct aim_conn_t *conn)
 508 {
 509   struct command_tx_struct *newpacket;
 510   int i;
 511
 512   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 0x20)))
 513     return -1;
 514
 515   newpacket->lock = 1;
 516
 517   i = aim_putsnac(newpacket->data, 0x0001, 0x0002, 0x0000, sess->snac_nextid);
 518
 519   i+= aimutil_put16(newpacket->data+i, 0x000e);
 520   i+= aimutil_put16(newpacket->data+i, 0x0001);
 521
 522   i+= aimutil_put16(newpacket->data+i, 0x0004);
 523   i+= aimutil_put16(newpacket->data+i, 0x0001);
 524
 525   i+= aimutil_put16(newpacket->data+i, 0x0001);
 526   i+= aimutil_put16(newpacket->data+i, 0x0003);
 527
 528   i+= aimutil_put16(newpacket->data+i, 0x0004);
 529   i+= aimutil_put16(newpacket->data+i, 0x0686);
 530
 531   newpacket->lock = 0;
 532   aim_tx_enqueue(sess, newpacket);
 533
 534   return (sess->snac_nextid++);
 535 }
 536
 537 faim_export int aim_chat_leaveroom(struct aim_session_t *sess, char *name)
 538 {
 539   struct aim_conn_t *conn;
 540
 541   if ((conn = aim_chat_getconn(sess, name)))
 542     aim_conn_close(conn);
 543
 544   if (!conn)
 545     return -1;
 546   return 0;
 547 }
 548
 549 /*
 550  * conn must be a BOS connection!
 551  */
 552 faim_export unsigned long aim_chat_invite(struct aim_session_t *sess,
 553                                           struct aim_conn_t *conn,
 554                                           char *sn,
 555                                           char *msg,
 556                                           u_short exchange,
 557                                           char *roomname,
 558                                           u_short instance)
 559 {
 560   struct command_tx_struct *newpacket;
 561   int i,curbyte=0;
 562   struct aim_msgcookie_t *cookie;
 563   struct aim_invite_priv *priv;
 564
 565   if (!sess || !conn || !sn || !msg || !roomname)
 566     return -1;
 567
 568   if (conn->type != AIM_CONN_TYPE_BOS)
 569     return -1;
 570
 571   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 1152+strlen(sn)+strlen(roomname)+strlen(msg))))
 572     return -1;
 573
 574   newpacket->lock = 1;
 575
 576   curbyte = aim_putsnac(newpacket->data, 0x0004, 0x0006, 0x0000, sess->snac_nextid);
 577
 578   /*
 579    * Cookie
 580    */
 581   for (i=0;i<8;i++)
 582     curbyte += aimutil_put8(newpacket->data+curbyte, (u_char)rand());
 583
 584   /* XXX this should get uncached by the unwritten 'invite accept' handler */
 585   if(!(priv = calloc(sizeof(struct aim_invite_priv), 1)))
 586     return -1;
 587   priv->sn = strdup(sn);
 588   priv->roomname = strdup(roomname);
 589   priv->exchange = exchange;
 590   priv->instance = instance;
 591
 592   if(!(cookie = aim_mkcookie(newpacket->data+curbyte-8, AIM_COOKIETYPE_INVITE, priv)))
 593     return -1;
 594   aim_cachecookie(sess, cookie);
 595
 596   /*
 597    * Channel (2)
 598    */
 599   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
 600
 601   /*
 602    * Dest sn
 603    */
 604   curbyte += aimutil_put8(newpacket->data+curbyte, strlen(sn));
 605   curbyte += aimutil_putstr(newpacket->data+curbyte, sn, strlen(sn));
 606
 607   /*
 608    * TLV t(0005)
 609    */
 610   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0005);
 611   curbyte += aimutil_put16(newpacket->data+curbyte, 0x28+strlen(msg)+0x04+0x03+strlen(roomname)+0x02);
 612
 613   /*
 614    * Unknown info
 615    */
 616   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
 617   curbyte += aimutil_put16(newpacket->data+curbyte, 0x3131);
 618   curbyte += aimutil_put16(newpacket->data+curbyte, 0x3538);
 619   curbyte += aimutil_put16(newpacket->data+curbyte, 0x3446);
 620   curbyte += aimutil_put16(newpacket->data+curbyte, 0x4100);
 621   curbyte += aimutil_put16(newpacket->data+curbyte, 0x748f);
 622   curbyte += aimutil_put16(newpacket->data+curbyte, 0x2420);
 623   curbyte += aimutil_put16(newpacket->data+curbyte, 0x6287);
 624   curbyte += aimutil_put16(newpacket->data+curbyte, 0x11d1);
 625   curbyte += aimutil_put16(newpacket->data+curbyte, 0x8222);
 626   curbyte += aimutil_put16(newpacket->data+curbyte, 0x4445);
 627   curbyte += aimutil_put16(newpacket->data+curbyte, 0x5354);
 628   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
 629
 630   /*
 631    * TLV t(000a) -- Unknown
 632    */
 633   curbyte += aimutil_put16(newpacket->data+curbyte, 0x000a);
 634   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
 635   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0001);
 636
 637   /*
 638    * TLV t(000f) -- Unknown
 639    */
 640   curbyte += aimutil_put16(newpacket->data+curbyte, 0x000f);
 641   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
 642
 643   /*
 644    * TLV t(000c) -- Invitation message
 645    */
 646   curbyte += aim_puttlv_str(newpacket->data+curbyte, 0x000c, strlen(msg), msg);
 647
 648   /*
 649    * TLV t(2711) -- Container for room information
 650    */
 651   curbyte += aimutil_put16(newpacket->data+curbyte, 0x2711);
 652   curbyte += aimutil_put16(newpacket->data+curbyte, 3+strlen(roomname)+2);
 653   curbyte += aimutil_put16(newpacket->data+curbyte, exchange);
 654   curbyte += aimutil_put8(newpacket->data+curbyte, strlen(roomname));
 655   curbyte += aimutil_putstr(newpacket->data+curbyte, roomname, strlen(roomname));
 656   curbyte += aimutil_put16(newpacket->data+curbyte, instance);
 657
 658   newpacket->commandlen = curbyte;
 659   newpacket->lock = 0;
 660   aim_tx_enqueue(sess, newpacket);
 661
 662   return (sess->snac_nextid++);
 663 }