src/chat.c

   1 /*
   2  * aim_chat.c
   3  *
   4  * Routines for the Chat service.
   5  *
   6  */
   7
   8 #define FAIM_INTERNAL
   9 #include <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       faimdprintf(sess, 0, "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 /* XXX convert this to use tlvchains */
  55 faim_export unsigned long aim_chat_send_im(struct aim_session_t *sess,
  56                                            struct aim_conn_t *conn,
  57                                            char *msg)
  58 {
  59
  60   int curbyte,i;
  61   struct command_tx_struct *newpacket;
  62   struct aim_msgcookie_t *cookie;
  63
  64   if (!sess || !conn || !msg)
  65     return 0;
  66
  67   if (!(newpacket = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 1152)))
  68     return -1;
  69
  70   newpacket->lock = 1; /* lock struct */
  71
  72   curbyte  = 0;
  73   curbyte += aim_putsnac(newpacket->data+curbyte,
  74                          0x000e, 0x0005, 0x0000, sess->snac_nextid);
  75
  76   /*
  77    * Generate a random message cookie
  78    */
  79   for (i=0;i<8;i++)
  80     curbyte += aimutil_put8(newpacket->data+curbyte, (u_char) rand());
  81
  82   cookie = aim_mkcookie(newpacket->data+curbyte-8, AIM_COOKIETYPE_CHAT, NULL);
  83   cookie->data = strdup(conn->priv); /* chat hack dependent */
  84
  85   aim_cachecookie(sess, cookie);
  86
  87   /*
  88    * Channel ID.
  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(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 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       faimdprintf(sess, 0, "faim: chat_roomupdateinfo: detail level 1 not supported\n");
 248     else
 249       faimdprintf(sess, 0, "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(sess, 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(sess, 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(sess, command->data+i, &userinfo[curcount-1]);
 361   }
 362
 363   if ((userfunc = aim_callhandler(sess, 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(sess, command->data+i, &userinfo[curcount-1]);
 387   }
 388
 389   if ((userfunc = aim_callhandler(sess, 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  * General outline of this SNAC:
 407  *   snac
 408  *   cookie
 409  *   channel id
 410  *   tlvlist
 411  *     unknown
 412  *     source user info
 413  *       name
 414  *       evility
 415  *       userinfo tlvs
 416  *         online time
 417  *         etc
 418  *     message metatlv
 419  *       message tlv
 420  *         message string
 421  *       possibly others
 422  *
 423  */
 424 faim_internal int aim_chat_parse_incoming(struct aim_session_t *sess,
 425                                           struct command_rx_struct *command)
 426 {
 427   struct aim_userinfo_s userinfo;
 428   rxcallback_t userfunc=NULL;
 429   int ret = 1, i = 0, z = 0;
 430   unsigned char cookie[8];
 431   int channel;
 432   struct aim_tlvlist_t *outerlist;
 433   char *msg = NULL;
 434   struct aim_msgcookie_t *ck;
 435
 436   memset(&userinfo, 0x00, sizeof(struct aim_userinfo_s));
 437
 438   i = 10; /* skip snac */
 439
 440   /*
 441    * ICBM Cookie.  Cache it.
 442    */
 443   for (z=0; z<8; z++,i++)
 444     cookie[z] = command->data[i];
 445
 446   if ((ck = aim_uncachecookie(sess, cookie, AIM_COOKIETYPE_CHAT))) {
 447     if (ck->data)
 448       free(ck->data);
 449     free(ck);
 450   }
 451
 452   /*
 453    * Channel ID
 454    *
 455    * Channels 1 and 2 are implemented in the normal ICBM
 456    * parser.
 457    *
 458    * We only do channel 3 here.
 459    *
 460    */
 461   channel = aimutil_get16(command->data+i);
 462   i += 2;
 463
 464   if (channel != 0x0003) {
 465     faimdprintf(sess, 0, "faim: chat_incoming: unknown channel! (0x%04x)\n", channel);
 466     return 1;
 467   }
 468
 469   /*
 470    * Start parsing TLVs right away.
 471    */
 472   outerlist = aim_readtlvchain(command->data+i, command->commandlen-i);
 473
 474   /*
 475    * Type 0x0003: Source User Information
 476    */
 477   if (aim_gettlv(outerlist, 0x0003, 1)) {
 478     struct aim_tlv_t *userinfotlv;
 479
 480     userinfotlv = aim_gettlv(outerlist, 0x0003, 1);
 481     aim_extractuserinfo(sess, userinfotlv->value, &userinfo);
 482   }
 483
 484   /*
 485    * Type 0x0001: Unknown.
 486    */
 487   if (aim_gettlv(outerlist, 0x0001, 1))
 488     ;
 489
 490   /*
 491    * Type 0x0005: Message Block.  Conains more TLVs.
 492    */
 493   if (aim_gettlv(outerlist, 0x0005, 1))
 494     {
 495       struct aim_tlvlist_t *innerlist;
 496       struct aim_tlv_t *msgblock;
 497
 498       msgblock = aim_gettlv(outerlist, 0x0005, 1);
 499       innerlist = aim_readtlvchain(msgblock->value, msgblock->length);
 500
 501       /*
 502        * Type 0x0001: Message.
 503        */
 504       if (aim_gettlv(innerlist, 0x0001, 1))
 505           msg = aim_gettlv_str(innerlist, 0x0001, 1);
 506
 507       aim_freetlvchain(&innerlist);
 508     }
 509
 510   userfunc = aim_callhandler(sess, command->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_INCOMINGMSG);
 511   if (userfunc)
 512     {
 513       ret = userfunc(sess,
 514                      command,
 515                      &userinfo,
 516                      msg);
 517     }
 518   free(msg);
 519   aim_freetlvchain(&outerlist);
 520
 521   return ret;
 522 }
 523
 524 faim_export unsigned long aim_chat_clientready(struct aim_session_t *sess,
 525                                                struct aim_conn_t *conn)
 526 {
 527   struct command_tx_struct *newpacket;
 528   int i;
 529
 530   if (!(newpacket = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 0x20)))
 531     return -1;
 532
 533   newpacket->lock = 1;
 534
 535   i = aim_putsnac(newpacket->data, 0x0001, 0x0002, 0x0000, sess->snac_nextid);
 536
 537   i+= aimutil_put16(newpacket->data+i, 0x000e);
 538   i+= aimutil_put16(newpacket->data+i, 0x0001);
 539
 540   i+= aimutil_put16(newpacket->data+i, 0x0004);
 541   i+= aimutil_put16(newpacket->data+i, 0x0001);
 542
 543   i+= aimutil_put16(newpacket->data+i, 0x0001);
 544   i+= aimutil_put16(newpacket->data+i, 0x0003);
 545
 546   i+= aimutil_put16(newpacket->data+i, 0x0004);
 547   i+= aimutil_put16(newpacket->data+i, 0x0686);
 548
 549   newpacket->lock = 0;
 550   aim_tx_enqueue(sess, newpacket);
 551
 552   return (sess->snac_nextid++);
 553 }
 554
 555 faim_export int aim_chat_leaveroom(struct aim_session_t *sess, char *name)
 556 {
 557   struct aim_conn_t *conn;
 558
 559   if ((conn = aim_chat_getconn(sess, name)))
 560     aim_conn_close(conn);
 561
 562   if (!conn)
 563     return -1;
 564   return 0;
 565 }
 566
 567 /*
 568  * conn must be a BOS connection!
 569  */
 570 faim_export unsigned long aim_chat_invite(struct aim_session_t *sess,
 571                                           struct aim_conn_t *conn,
 572                                           char *sn,
 573                                           char *msg,
 574                                           u_short exchange,
 575                                           char *roomname,
 576                                           u_short instance)
 577 {
 578   struct command_tx_struct *newpacket;
 579   int i,curbyte=0;
 580   struct aim_msgcookie_t *cookie;
 581   struct aim_invite_priv *priv;
 582
 583   if (!sess || !conn || !sn || !msg || !roomname)
 584     return -1;
 585
 586   if (conn->type != AIM_CONN_TYPE_BOS)
 587     return -1;
 588
 589   if (!(newpacket = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 1152+strlen(sn)+strlen(roomname)+strlen(msg))))
 590     return -1;
 591
 592   newpacket->lock = 1;
 593
 594   curbyte = aim_putsnac(newpacket->data, 0x0004, 0x0006, 0x0000, sess->snac_nextid);
 595
 596   /*
 597    * Cookie
 598    */
 599   for (i=0;i<8;i++)
 600     curbyte += aimutil_put8(newpacket->data+curbyte, (u_char)rand());
 601
 602   /* XXX this should get uncached by the unwritten 'invite accept' handler */
 603   if(!(priv = calloc(sizeof(struct aim_invite_priv), 1)))
 604     return -1;
 605   priv->sn = strdup(sn);
 606   priv->roomname = strdup(roomname);
 607   priv->exchange = exchange;
 608   priv->instance = instance;
 609
 610   if(!(cookie = aim_mkcookie(newpacket->data+curbyte-8, AIM_COOKIETYPE_INVITE, priv)))
 611     return -1;
 612   aim_cachecookie(sess, cookie);
 613
 614   /*
 615    * Channel (2)
 616    */
 617   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
 618
 619   /*
 620    * Dest sn
 621    */
 622   curbyte += aimutil_put8(newpacket->data+curbyte, strlen(sn));
 623   curbyte += aimutil_putstr(newpacket->data+curbyte, sn, strlen(sn));
 624
 625   /*
 626    * TLV t(0005)
 627    */
 628   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0005);
 629   curbyte += aimutil_put16(newpacket->data+curbyte, 0x28+strlen(msg)+0x04+0x03+strlen(roomname)+0x02);
 630
 631   /*
 632    * Unknown info
 633    */
 634   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
 635   curbyte += aimutil_put16(newpacket->data+curbyte, 0x3131);
 636   curbyte += aimutil_put16(newpacket->data+curbyte, 0x3538);
 637   curbyte += aimutil_put16(newpacket->data+curbyte, 0x3446);
 638   curbyte += aimutil_put16(newpacket->data+curbyte, 0x4100);
 639   curbyte += aimutil_put16(newpacket->data+curbyte, 0x748f);
 640   curbyte += aimutil_put16(newpacket->data+curbyte, 0x2420);
 641   curbyte += aimutil_put16(newpacket->data+curbyte, 0x6287);
 642   curbyte += aimutil_put16(newpacket->data+curbyte, 0x11d1);
 643   curbyte += aimutil_put16(newpacket->data+curbyte, 0x8222);
 644   curbyte += aimutil_put16(newpacket->data+curbyte, 0x4445);
 645   curbyte += aimutil_put16(newpacket->data+curbyte, 0x5354);
 646   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
 647
 648   /*
 649    * TLV t(000a) -- Unknown
 650    */
 651   curbyte += aimutil_put16(newpacket->data+curbyte, 0x000a);
 652   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0002);
 653   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0001);
 654
 655   /*
 656    * TLV t(000f) -- Unknown
 657    */
 658   curbyte += aimutil_put16(newpacket->data+curbyte, 0x000f);
 659   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
 660
 661   /*
 662    * TLV t(000c) -- Invitation message
 663    */
 664   curbyte += aim_puttlv_str(newpacket->data+curbyte, 0x000c, strlen(msg), msg);
 665
 666   /*
 667    * TLV t(2711) -- Container for room information
 668    */
 669   curbyte += aimutil_put16(newpacket->data+curbyte, 0x2711);
 670   curbyte += aimutil_put16(newpacket->data+curbyte, 3+strlen(roomname)+2);
 671   curbyte += aimutil_put16(newpacket->data+curbyte, exchange);
 672   curbyte += aimutil_put8(newpacket->data+curbyte, strlen(roomname));
 673   curbyte += aimutil_putstr(newpacket->data+curbyte, roomname, strlen(roomname));
 674   curbyte += aimutil_put16(newpacket->data+curbyte, instance);
 675
 676   newpacket->commandlen = curbyte;
 677   newpacket->lock = 0;
 678   aim_tx_enqueue(sess, newpacket);
 679
 680   return (sess->snac_nextid++);
 681 }