aim_chatnav.c

   1 /*
   2  *
   3  *
   4  *
   5  *
   6  */
   7
   8 #include <faim/aim.h>
   9
  10
  11 /*
  12  * conn must be a chatnav connection!
  13  */
  14 faim_export unsigned long aim_chatnav_reqrights(struct aim_session_t *sess,
  15                                                 struct aim_conn_t *conn)
  16 {
  17   struct aim_snac_t snac;
  18
  19   snac.id = aim_genericreq_n(sess, conn, 0x000d, 0x0002);
  20
  21   snac.family = 0x000d;
  22   snac.type = 0x0002;
  23   snac.flags = 0x0000;
  24   snac.data = NULL;
  25
  26   aim_newsnac(sess, &snac);
  27
  28   return (sess->snac_nextid); /* already incremented */
  29 }
  30
  31 faim_export unsigned long aim_chatnav_clientready(struct aim_session_t *sess,
  32                                                   struct aim_conn_t *conn)
  33 {
  34   struct command_tx_struct *newpacket;
  35   int i;
  36
  37   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 0x20)))
  38     return -1;
  39
  40   newpacket->lock = 1;
  41
  42   i = aim_putsnac(newpacket->data, 0x0001, 0x0002, 0x0000, sess->snac_nextid);
  43
  44   i+= aimutil_put16(newpacket->data+i, 0x000d);
  45   i+= aimutil_put16(newpacket->data+i, 0x0001);
  46
  47   i+= aimutil_put16(newpacket->data+i, 0x0004);
  48   i+= aimutil_put16(newpacket->data+i, 0x0001);
  49
  50   i+= aimutil_put16(newpacket->data+i, 0x0001);
  51   i+= aimutil_put16(newpacket->data+i, 0x0003);
  52
  53   i+= aimutil_put16(newpacket->data+i, 0x0004);
  54   i+= aimutil_put16(newpacket->data+i, 0x0686);
  55
  56   aim_tx_enqueue(sess, newpacket);
  57
  58   return (sess->snac_nextid++);
  59 }
  60
  61 /*
  62  * Since multiple things can trigger this callback,
  63  * we must lookup the snacid to determine the original
  64  * snac subtype that was called.
  65  */
  66 faim_internal int aim_chatnav_parse_info(struct aim_session_t *sess, struct command_rx_struct *command)
  67 {
  68   struct aim_snac_t *snac;
  69   u_long snacid;
  70   rxcallback_t userfunc;
  71   int ret=1;
  72
  73   snacid = aimutil_get32(command->data+6);
  74   snac = aim_remsnac(sess, snacid);
  75
  76   if (!snac)
  77     {
  78       printf("faim: chatnav_parse_info: received response to unknown request! (%08lx)\n", snacid);
  79       return 1;
  80     }
  81
  82   if (snac->family != 0x000d)
  83     {
  84       printf("faim: chatnav_parse_info: recieved response that maps to corrupt request! (fam=%04x)\n", snac->family);
  85       return 1;
  86     }
  87
  88   /*
  89    * We now know what the original SNAC subtype was.
  90    */
  91   switch(snac->type)
  92     {
  93     case 0x0002: /* request chat rights */
  94       {
  95           struct aim_tlvlist_t *tlvlist;
  96           struct aim_chat_exchangeinfo *exchanges = NULL;
  97           int curexchange = 0;
  98           struct aim_tlv_t *exchangetlv;
  99           u_char maxrooms = 0;
 100           struct aim_tlvlist_t *innerlist;
 101
 102           tlvlist = aim_readtlvchain(command->data+10, command->commandlen-10);
 103
 104           /*
 105            * Type 0x0002: Maximum concurrent rooms.
 106            */
 107           if (aim_gettlv(tlvlist, 0x0002, 1))
 108             {
 109               struct aim_tlv_t *maxroomstlv;
 110               maxroomstlv = aim_gettlv(tlvlist, 0x0002, 1);
 111               maxrooms = aimutil_get8(maxroomstlv->value);
 112             }
 113
 114           /*
 115            * Type 0x0003: Exchange information
 116            *
 117            * There can be any number of these, each one
 118            * representing another exchange.
 119            *
 120            */
 121           curexchange = 0;
 122           while ((exchangetlv = aim_gettlv(tlvlist, 0x0003, curexchange+1)))
 123             {
 124               curexchange++;
 125               exchanges = realloc(exchanges, curexchange * sizeof(struct aim_chat_exchangeinfo));
 126
 127
 128               /* exchange number */
 129               exchanges[curexchange-1].number = aimutil_get16(exchangetlv->value);
 130               innerlist = aim_readtlvchain(exchangetlv->value+2, exchangetlv->length-2);
 131
 132               /*
 133                * Type 0x000d: Unknown.
 134                */
 135               if (aim_gettlv(innerlist, 0x000d, 1))
 136                 ;
 137
 138               /*
 139                * Type 0x0004: Unknown
 140                */
 141               if (aim_gettlv(innerlist, 0x0004, 1))
 142                 ;
 143
 144               /*
 145                * Type 0x0002: Unknown
 146                */
 147               if (aim_gettlv(innerlist, 0x0002, 1)) {
 148                 struct aim_tlv_t *tmptlv;
 149                 unsigned short classperms = 0;
 150
 151                 tmptlv = aim_gettlv(innerlist, 0x0002, 1);
 152                 classperms = aimutil_get16(tmptlv->value);
 153
 154                 printf("faim: class permissions %x\n", classperms);
 155               }
 156
 157               /*
 158                * Type 0x00c9: Unknown
 159                */
 160               if (aim_gettlv(innerlist, 0x00c9, 1))
 161                 ;
 162
 163               /*
 164                * Type 0x00ca: Creation Date
 165                */
 166               if (aim_gettlv(innerlist, 0x00ca, 1))
 167                 ;
 168
 169               /*
 170                * Type 0x00d0: Mandatory Channels?
 171                */
 172               if (aim_gettlv(innerlist, 0x00d0, 1))
 173                 ;
 174
 175               /*
 176                * Type 0x00d1: Maximum Message length
 177                */
 178               if (aim_gettlv(innerlist, 0x00d1, 1))
 179                 ;
 180
 181               /*
 182                * Type 0x00d2: Maximum Occupancy?
 183                */
 184               if (aim_gettlv(innerlist, 0x00d2, 1))
 185                 ;
 186
 187               /*
 188                * Type 0x00d3: Exchange Name
 189                */
 190               if (aim_gettlv(innerlist, 0x00d3, 1))
 191                 exchanges[curexchange-1].name = aim_gettlv_str(innerlist, 0x00d3, 1);
 192               else
 193                 exchanges[curexchange-1].name = NULL;
 194
 195               /*
 196                * Type 0x00d5: Creation Permissions
 197                *
 198                * 0  Creation not allowed
 199                * 1  Room creation allowed
 200                * 2  Exchange creation allowed
 201                *
 202                */
 203               if (aim_gettlv(innerlist, 0x00d5, 1)) {
 204                 struct aim_tlv_t *tmptlv;
 205                 unsigned char createperms = 0;
 206
 207                 tmptlv = aim_gettlv(innerlist, 0x00d5, 1);
 208                 createperms = aimutil_get8(tmptlv->value);
 209
 210                 printf("faim: creation permissions %x\n", createperms);
 211               }
 212
 213               /*
 214                * Type 0x00d6: Character Set (First Time)
 215                */
 216               if (aim_gettlv(innerlist, 0x00d6, 1))
 217                 exchanges[curexchange-1].charset1 = aim_gettlv_str(innerlist, 0x00d6, 1);
 218               else
 219                 exchanges[curexchange-1].charset1 = NULL;
 220
 221               /*
 222                * Type 0x00d7: Language (First Time)
 223                */
 224               if (aim_gettlv(innerlist, 0x00d7, 1))
 225                 exchanges[curexchange-1].lang1 = aim_gettlv_str(innerlist, 0x00d7, 1);
 226               else
 227                 exchanges[curexchange-1].lang1 = NULL;
 228
 229               /*
 230                * Type 0x00d8: Character Set (Second Time)
 231                */
 232               if (aim_gettlv(innerlist, 0x00d8, 1))
 233                 exchanges[curexchange-1].charset2 = aim_gettlv_str(innerlist, 0x00d8, 1);
 234               else
 235                 exchanges[curexchange-1].charset2 = NULL;
 236
 237               /*
 238                * Type 0x00d9: Language (Second Time)
 239                */
 240               if (aim_gettlv(innerlist, 0x00d9, 1))
 241                 exchanges[curexchange-1].lang2 = aim_gettlv_str(innerlist, 0x00d9, 1);
 242               else
 243                 exchanges[curexchange-1].lang2 = NULL;
 244
 245               aim_freetlvchain(&innerlist);
 246             }
 247
 248           /*
 249            * Call client.
 250            */
 251           userfunc = aim_callhandler(command->conn, 0x000d, 0x0009);
 252           if (userfunc)
 253             ret = userfunc(sess,
 254                            command,
 255                            snac->type,
 256                            maxrooms,
 257                            curexchange,
 258                            exchanges);
 259           curexchange--;
 260           while(curexchange >= 0)
 261             {
 262               if (exchanges[curexchange].name)
 263                 free(exchanges[curexchange].name);
 264               if (exchanges[curexchange].charset1)
 265                 free(exchanges[curexchange].charset1);
 266               if (exchanges[curexchange].lang1)
 267                 free(exchanges[curexchange].lang1);
 268               if (exchanges[curexchange].charset2)
 269                 free(exchanges[curexchange].charset2);
 270               if (exchanges[curexchange].lang2)
 271                 free(exchanges[curexchange].lang2);
 272               curexchange--;
 273             }
 274           free(exchanges);
 275           aim_freetlvchain(&tlvlist);
 276
 277           break;
 278       }
 279     case 0x0003: /* request exchange info */
 280       printf("faim: chatnav_parse_info: resposne to exchange info\n");
 281       break;
 282     case 0x0004: /* request room info */
 283       printf("faim: chatnav_parse_info: response to room info\n");
 284       break;
 285     case 0x0005: /* request more room info */
 286       printf("faim: chatnav_parse_info: response to more room info\n");
 287       break;
 288     case 0x0006: /* request occupant list */
 289       printf("faim: chatnav_parse_info: response to occupant info\n");
 290       break;
 291     case 0x0007: /* search for a room */
 292       printf("faim: chatnav_parse_info: search results\n");
 293       break;
 294     case 0x0008: { /* create room */
 295       /*
 296         000d 0009 0000 0000 0010
 297
 298         0004 0053
 299              0004 -- exchange
 300              0c 7a 6f6f 6f6d 7a6f 6f6f 6d34 32 cookie/name
 301              0000 -- instance
 302              02 -- detail level
 303              0007 -- unknown!
 304              006a 000c 7a 6f 6f6f 6d7a 6f6f 6f6d 3432 -- fully qualified name
 305              00c9 0002 0011 -- flags
 306              00ca 0004 39c0 0883 -- create time
 307              00d1 0002 0200 -- max msg len
 308              00d2 0002 0018 -- max occupants
 309              00d3 000c -- name
 310                   7a6f 6f6f 6d7a 6f6f 6f6d 3432
 311              00d5 0001 02 -- creation permission
 312        */
 313       struct aim_tlvlist_t *tlvlist, *innerlist;
 314       char *ck = NULL, *fqcn = NULL, *name = NULL;
 315       unsigned short exchange, instance, unknown, flags, maxmsglen, maxoccupancy;
 316       unsigned long createtime = 0;
 317       unsigned char createperms;
 318       int i, cklen;
 319       struct aim_tlv_t *bigblock, *tmp;
 320
 321       i = 10;
 322       if (!(tlvlist = aim_readtlvchain(command->data+i, command->commandlen-i))) {
 323         printf("faim: unable to read top tlv in create room response\n");
 324         break;
 325       }
 326
 327       if (!(bigblock = aim_gettlv(tlvlist, 0x0004, 1))) {
 328         printf("faim: no bigblock in top tlv in create room response\n");
 329         aim_freetlvchain(&tlvlist);
 330         break;
 331       }
 332       i = 0;
 333
 334       exchange = aimutil_get16(bigblock->value+i);
 335       i += 2;
 336
 337       cklen = aimutil_get8(bigblock->value+i);
 338       i++;
 339
 340       ck = malloc(cklen+1);
 341       memcpy(ck, bigblock->value+i, cklen);
 342       ck[cklen] = '\0';
 343       i += cklen;
 344
 345       instance = aimutil_get16(bigblock->value+i);
 346       i += 2;
 347
 348       if (aimutil_get8(bigblock->value+i) != 0x02) {
 349         printf("faim: unknown detaillevel in create room response (0x%02x)\n", aimutil_get8(bigblock->value+i));
 350         aim_freetlvchain(&tlvlist);
 351         free(ck);
 352         break;
 353       }
 354       i += 1;
 355
 356       unknown = aimutil_get16(bigblock->value+i);
 357       i += 2;
 358
 359       if (!(innerlist = aim_readtlvchain(bigblock->value+i, bigblock->length-i))) {
 360         printf("faim: unable to read inner tlv chain in create room response\n");
 361         aim_freetlvchain(&tlvlist);
 362         free(ck);
 363         break;
 364       }
 365
 366       if (aim_gettlv(innerlist, 0x006a, 1))
 367         fqcn = aim_gettlv_str(innerlist, 0x006a, 1);
 368
 369       if ((tmp = aim_gettlv(innerlist, 0x00c9, 1)))
 370         flags = aimutil_get16(tmp->value);
 371
 372       if ((tmp = aim_gettlv(innerlist, 0x00ca, 1)))
 373         createtime = aimutil_get32(tmp->value);
 374
 375       if ((tmp = aim_gettlv(innerlist, 0x00d1, 1)))
 376         maxmsglen = aimutil_get16(tmp->value);
 377
 378       if ((tmp = aim_gettlv(innerlist, 0x00d2, 1)))
 379         maxoccupancy = aimutil_get16(tmp->value);
 380
 381       if (aim_gettlv(innerlist, 0x00d3, 1))
 382         name = aim_gettlv_str(innerlist, 0x00d3, 1);
 383
 384       if ((tmp = aim_gettlv(innerlist, 0x00d5, 1)))
 385         createperms = aimutil_get8(tmp->value);
 386
 387       if ((userfunc = aim_callhandler(command->conn, 0x000d, 0x0009))) {
 388         ret = userfunc(sess, command, snac->type, fqcn, instance, flags, createtime, maxmsglen, maxoccupancy, createperms, unknown, name, ck);
 389       }
 390
 391       if (ck)
 392         free(ck);
 393       if (name)
 394         free(name);
 395       if (fqcn)
 396         free(fqcn);
 397       aim_freetlvchain(&innerlist);
 398       aim_freetlvchain(&tlvlist);
 399
 400       break;
 401     }
 402     default: /* unknown */
 403       printf("faim: chatnav_parse_info: unknown request subtype (%04x)\n", snac->type);
 404     }
 405
 406   if (snac && snac->data)
 407     free(snac->data);
 408   if (snac)
 409     free(snac);
 410
 411   return ret;
 412 }
 413
 414 faim_export unsigned long aim_chatnav_createroom(struct aim_session_t *sess,
 415                                                  struct aim_conn_t *conn,
 416                                                  char *name,
 417                                                  u_short exchange)
 418 {
 419   struct command_tx_struct *newpacket;
 420   int i;
 421   struct aim_snac_t snac;
 422
 423   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10+12+strlen("invite")+strlen(name))))
 424     return -1;
 425
 426   newpacket->lock = 1;
 427
 428   i = aim_putsnac(newpacket->data, 0x000d, 0x0008, 0x0000, sess->snac_nextid);
 429
 430   /* exchange */
 431   i+= aimutil_put16(newpacket->data+i, exchange);
 432
 433   /* room cookie */
 434   i+= aimutil_put8(newpacket->data+i, strlen("invite"));
 435   i+= aimutil_putstr(newpacket->data+i, "invite", strlen("invite"));
 436
 437   /* instance */
 438   i+= aimutil_put16(newpacket->data+i, 0xffff);
 439
 440   /* detail level */
 441   i+= aimutil_put8(newpacket->data+i, 0x01);
 442
 443   /* tlvcount */
 444   i+= aimutil_put16(newpacket->data+i, 0x0001);
 445
 446   /* room name */
 447   i+= aim_puttlv_str(newpacket->data+i, 0x00d3, strlen(name), name);
 448
 449   snac.id = sess->snac_nextid;
 450   snac.family = 0x000d;
 451   snac.type = 0x0008;
 452   snac.flags = 0x0000;
 453   snac.data = NULL;
 454
 455   aim_newsnac(sess, &snac);
 456
 457   aim_tx_enqueue(sess, newpacket);
 458
 459   return (sess->snac_nextid++);
 460 }