aim_misc.c

   1
   2 /*
   3  * aim_misc.c
   4  *
   5  * TODO: Seperate a lot of this into an aim_bos.c.
   6  *
   7  * Other things...
   8  *
   9  *   - Idle setting
  10  *
  11  *
  12  */
  13
  14 #include <faim/aim.h>
  15
  16 /*
  17  * aim_bos_setidle()
  18  *
  19  *  Should set your current idle time in seconds.  Idealy, OSCAR should
  20  *  do this for us.  But, it doesn't.  The client must call this to set idle
  21  *  time.
  22  *
  23  */
  24 faim_export unsigned long aim_bos_setidle(struct aim_session_t *sess,
  25                                           struct aim_conn_t *conn,
  26                                           u_long idletime)
  27 {
  28   return aim_genericreq_l(sess, conn, 0x0001, 0x0011, &idletime);
  29 }
  30
  31
  32 /*
  33  * aim_bos_changevisibility(conn, changtype, namelist)
  34  *
  35  * Changes your visibility depending on changetype:
  36  *
  37  *  AIM_VISIBILITYCHANGE_PERMITADD: Lets provided list of names see you
  38  *  AIM_VISIBILITYCHANGE_PERMIDREMOVE: Removes listed names from permit list
  39  *  AIM_VISIBILITYCHANGE_DENYADD: Hides you from provided list of names
  40  *  AIM_VISIBILITYCHANGE_DENYREMOVE: Lets list see you again
  41  *
  42  * list should be a list of
  43  * screen names in the form "Screen Name One&ScreenNameTwo&" etc.
  44  *
  45  * Equivelents to options in WinAIM:
  46  *   - Allow all users to contact me: Send an AIM_VISIBILITYCHANGE_DENYADD
  47  *      with only your name on it.
  48  *   - Allow only users on my Buddy List: Send an
  49  *      AIM_VISIBILITYCHANGE_PERMITADD with the list the same as your
  50  *      buddy list
  51  *   - Allow only the uesrs below: Send an AIM_VISIBILITYCHANGE_PERMITADD
  52  *      with everyone listed that you want to see you.
  53  *   - Block all users: Send an AIM_VISIBILITYCHANGE_PERMITADD with only
  54  *      yourself in the list
  55  *   - Block the users below: Send an AIM_VISIBILITYCHANGE_DENYADD with
  56  *      the list of users to be blocked
  57  *
  58  *
  59  */
  60 faim_export unsigned long aim_bos_changevisibility(struct aim_session_t *sess,
  61                                                    struct aim_conn_t *conn,
  62                                                    int changetype,
  63                                                    char *denylist)
  64 {
  65   struct command_tx_struct *newpacket;
  66   int packlen = 0;
  67   u_short subtype;
  68
  69   char *localcpy = NULL;
  70   char *tmpptr = NULL;
  71   int i,j;
  72   int listcount;
  73
  74   if (!denylist)
  75     return 0;
  76
  77   localcpy = (char *) malloc(strlen(denylist)+1);
  78   memcpy(localcpy, denylist, strlen(denylist)+1);
  79
  80   listcount = aimutil_itemcnt(localcpy, '&');
  81   packlen = aimutil_tokslen(localcpy, 99, '&') + listcount + 9;
  82
  83   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, packlen)))
  84     return -1;
  85
  86   newpacket->lock = 1;
  87
  88   switch(changetype)
  89     {
  90     case AIM_VISIBILITYCHANGE_PERMITADD:    subtype = 0x05; break;
  91     case AIM_VISIBILITYCHANGE_PERMITREMOVE: subtype = 0x06; break;
  92     case AIM_VISIBILITYCHANGE_DENYADD:      subtype = 0x07; break;
  93     case AIM_VISIBILITYCHANGE_DENYREMOVE:   subtype = 0x08; break;
  94     default:
  95       free(newpacket->data);
  96       free(newpacket);
  97       return 0;
  98     }
  99
 100   /* We actually DO NOT send a SNAC ID with this one! */
 101   aim_putsnac(newpacket->data, 0x0009, subtype, 0x00, 0);
 102
 103   j = 10;  /* the next byte */
 104
 105   for (i=0; (i < (listcount - 1)) && (i < 99); i++)
 106     {
 107       tmpptr = aimutil_itemidx(localcpy, i, '&');
 108
 109       newpacket->data[j] = strlen(tmpptr);
 110       memcpy(&(newpacket->data[j+1]), tmpptr, strlen(tmpptr));
 111       j += strlen(tmpptr)+1;
 112       free(tmpptr);
 113     }
 114   free(localcpy);
 115
 116   newpacket->lock = 0;
 117
 118   aim_tx_enqueue(sess, newpacket);
 119
 120   return (sess->snac_nextid); /* dont increment */
 121
 122 }
 123
 124
 125
 126 /*
 127  * aim_bos_setbuddylist(buddylist)
 128  *
 129  * This just builds the "set buddy list" command then queues it.
 130  *
 131  * buddy_list = "Screen Name One&ScreenNameTwo&";
 132  *
 133  * TODO: Clean this up.
 134  *
 135  * XXX: I can't stress the TODO enough.
 136  *
 137  */
 138 faim_export unsigned long aim_bos_setbuddylist(struct aim_session_t *sess,
 139                                                struct aim_conn_t *conn,
 140                                                char *buddy_list)
 141 {
 142   int i, j;
 143
 144   struct command_tx_struct *newpacket;
 145
 146   int len = 0;
 147
 148   char *localcpy = NULL;
 149   char *tmpptr = NULL;
 150
 151   len = 10; /* 10B SNAC headers */
 152
 153   if (!buddy_list || !(localcpy = (char *) malloc(strlen(buddy_list)+1)))
 154     return -1;
 155   strncpy(localcpy, buddy_list, strlen(buddy_list)+1);
 156
 157   i = 0;
 158   tmpptr = strtok(localcpy, "&");
 159   while ((tmpptr != NULL) && (i < 150)) {
 160 #if debug > 0
 161     printf("---adding %d: %s (%d)\n", i, tmpptr, strlen(tmpptr));
 162 #endif
 163     len += 1+strlen(tmpptr);
 164     i++;
 165     tmpptr = strtok(NULL, "&");
 166   }
 167 #if debug > 0
 168   printf("*** send buddy list len: %d (%x)\n", len, len);
 169 #endif
 170
 171   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, len)))
 172     return -1;
 173
 174   newpacket->lock = 1;
 175
 176   aim_putsnac(newpacket->data, 0x0003, 0x0004, 0x0000, 0);
 177
 178   j = 10;  /* the next byte */
 179
 180   strncpy(localcpy, buddy_list, strlen(buddy_list)+1);
 181   i = 0;
 182   tmpptr = strtok(localcpy, "&");
 183   while ((tmpptr != NULL) & (i < 150)) {
 184 #if debug > 0
 185     printf("---adding %d: %s (%d)\n", i, tmpptr, strlen(tmpptr));
 186 #endif
 187     newpacket->data[j] = strlen(tmpptr);
 188     memcpy(&(newpacket->data[j+1]), tmpptr, strlen(tmpptr));
 189     j += 1+strlen(tmpptr);
 190     i++;
 191     tmpptr = strtok(NULL, "&");
 192   }
 193
 194   newpacket->lock = 0;
 195
 196   aim_tx_enqueue(sess, newpacket);
 197
 198   free(localcpy);
 199
 200   return (sess->snac_nextid);
 201 }
 202
 203 /*
 204  * aim_bos_setprofile(profile)
 205  *
 206  * Gives BOS your profile.
 207  *
 208  *
 209  */
 210 faim_export unsigned long aim_bos_setprofile(struct aim_session_t *sess,
 211                                              struct aim_conn_t *conn,
 212                                              char *profile,
 213                                              char *awaymsg,
 214                                              unsigned short caps)
 215 {
 216   struct command_tx_struct *newpacket;
 217   int i = 0, tmp, caplen;
 218
 219   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 1152+strlen(profile)+1+(awaymsg?strlen(awaymsg):0))))
 220     return -1;
 221
 222   i += aim_putsnac(newpacket->data, 0x0002, 0x004, 0x0000, sess->snac_nextid);
 223   i += aim_puttlv_str(newpacket->data+i, 0x0001, strlen("text/x-aolrtf; charset=\"us-ascii\""), "text/x-aolrtf; charset=\"us-ascii\"");
 224   i += aim_puttlv_str(newpacket->data+i, 0x0002, strlen(profile), profile);
 225   /* why do we send this twice?  */
 226   i += aim_puttlv_str(newpacket->data+i, 0x0003, strlen("text/x-aolrtf; charset=\"us-ascii\""), "text/x-aolrtf; charset=\"us-ascii\"");
 227
 228   /* Away message -- we send this no matter what, even if its blank */
 229   if (awaymsg)
 230     i += aim_puttlv_str(newpacket->data+i, 0x0004, strlen(awaymsg), awaymsg);
 231   else
 232     i += aim_puttlv_str(newpacket->data+i, 0x0004, 0x0000, NULL);
 233
 234   /* Capability information. */
 235
 236   tmp = (i += aimutil_put16(newpacket->data+i, 0x0005));
 237   i += aimutil_put16(newpacket->data+i, 0x0000); /* rewritten later */
 238   i += (caplen = aim_putcap(newpacket->data+i, 512, caps));
 239   aimutil_put16(newpacket->data+tmp, caplen); /* rewrite TLV size */
 240
 241   newpacket->commandlen = i;
 242   aim_tx_enqueue(sess, newpacket);
 243
 244   return (sess->snac_nextid++);
 245 }
 246
 247 /*
 248  * aim_bos_setgroupperm(mask)
 249  *
 250  * Set group permisson mask.  Normally 0x1f (all classes).
 251  *
 252  * The group permission mask allows you to keep users of a certain
 253  * class or classes from talking to you.  The mask should be
 254  * a bitwise OR of all the user classes you want to see you.
 255  *
 256  */
 257 faim_export unsigned long aim_bos_setgroupperm(struct aim_session_t *sess,
 258                                                struct aim_conn_t *conn,
 259                                                u_long mask)
 260 {
 261   return aim_genericreq_l(sess, conn, 0x0009, 0x0004, &mask);
 262 }
 263
 264 faim_internal int aim_parse_bosrights(struct aim_session_t *sess,
 265                                       struct command_rx_struct *command, ...)
 266 {
 267   rxcallback_t userfunc = NULL;
 268   int ret=1;
 269   struct aim_tlvlist_t *tlvlist;
 270   struct aim_tlv_t *tlv;
 271   unsigned short maxpermits = 0, maxdenies = 0;
 272
 273   /*
 274    * TLVs follow
 275    */
 276   if (!(tlvlist = aim_readtlvchain(command->data+10, command->commandlen-10)))
 277     return ret;
 278
 279   /*
 280    * TLV type 0x0001: Maximum number of buddies on permit list.
 281    */
 282   if ((tlv = aim_gettlv(tlvlist, 0x0001, 1))) {
 283     maxpermits = aimutil_get16(tlv->value);
 284   }
 285
 286   /*
 287    * TLV type 0x0002: Maximum number of buddies on deny list.
 288    *
 289    */
 290   if ((tlv = aim_gettlv(tlvlist, 0x0002, 1))) {
 291     maxdenies = aimutil_get16(tlv->value);
 292   }
 293
 294   userfunc = aim_callhandler(command->conn, 0x0009, 0x0003);
 295   if (userfunc)
 296     ret =  userfunc(sess, command, maxpermits, maxdenies);
 297
 298   aim_freetlvchain(&tlvlist);
 299
 300   return ret;
 301 }
 302
 303 /*
 304  * aim_bos_clientready()
 305  *
 306  * Send Client Ready.
 307  *
 308  * TODO: Dynamisize.
 309  *
 310  */
 311 faim_export unsigned long aim_bos_clientready(struct aim_session_t *sess,
 312                                               struct aim_conn_t *conn)
 313 {
 314   u_char command_2[] = {
 315      /* placeholders for dynamic data */
 316      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 317      0xff, 0xff,
 318      /* real data */
 319      0x00, 0x01,
 320      0x00, 0x03,
 321      0x00, 0x04,
 322      0x07, 0xda,
 323
 324      0x00, 0x02,
 325      0x00, 0x01,
 326      0x00, 0x04,
 327      0x00, 0x01,
 328
 329      0x00, 0x03,
 330      0x00, 0x01,
 331      0x00, 0x04,
 332      0x00, 0x01,
 333
 334      0x00, 0x04,
 335      0x00, 0x01,
 336      0x00, 0x04,
 337      0x00, 0x01,
 338
 339      0x00, 0x06,
 340      0x00, 0x01,
 341      0x00, 0x04,
 342      0x00, 0x01,
 343      0x00, 0x08,
 344      0x00, 0x01,
 345      0x00, 0x04,
 346      0x00, 0x01,
 347
 348      0x00, 0x09,
 349      0x00, 0x01,
 350      0x00, 0x04,
 351      0x00, 0x01,
 352      0x00, 0x0a,
 353      0x00, 0x01,
 354      0x00, 0x04,
 355      0x00, 0x01,
 356
 357      0x00, 0x0b,
 358      0x00, 0x01,
 359      0x00, 0x04,
 360      0x00, 0x01
 361   };
 362   int command_2_len = 0x52;
 363   struct command_tx_struct *newpacket;
 364
 365   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, command_2_len)))
 366     return -1;
 367
 368   newpacket->lock = 1;
 369
 370   memcpy(newpacket->data, command_2, command_2_len);
 371
 372   /* This write over the dynamic parts of the byte block */
 373   aim_putsnac(newpacket->data, 0x0001, 0x0002, 0x0000, sess->snac_nextid);
 374
 375   aim_tx_enqueue(sess, newpacket);
 376
 377   return (sess->snac_nextid++);
 378 }
 379
 380 /*
 381  *  Request Rate Information.
 382  *
 383  */
 384 faim_export unsigned long aim_bos_reqrate(struct aim_session_t *sess,
 385                                           struct aim_conn_t *conn)
 386 {
 387   return aim_genericreq_n(sess, conn, 0x0001, 0x0006);
 388 }
 389
 390 /*
 391  *  Rate Information Response Acknowledge.
 392  *
 393  */
 394 faim_export unsigned long aim_bos_ackrateresp(struct aim_session_t *sess,
 395                                               struct aim_conn_t *conn)
 396 {
 397   struct command_tx_struct *newpacket;
 398   int packlen = 20, i=0;
 399
 400   if(!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, packlen)))
 401     return (sess->snac_nextid);
 402
 403   newpacket->lock = 1;
 404
 405   i = aim_putsnac(newpacket->data, 0x0001, 0x0008, 0x0000, 0);
 406   i += aimutil_put16(newpacket->data+i, 0x0001);
 407   i += aimutil_put16(newpacket->data+i, 0x0002);
 408   i += aimutil_put16(newpacket->data+i, 0x0003);
 409   i += aimutil_put16(newpacket->data+i, 0x0004);
 410   i += aimutil_put16(newpacket->data+i, 0x0005);
 411
 412   aim_tx_enqueue(sess, newpacket);
 413
 414   return (sess->snac_nextid);
 415 }
 416
 417 /*
 418  * aim_bos_setprivacyflags()
 419  *
 420  * Sets privacy flags. Normally 0x03.
 421  *
 422  *  Bit 1:  Allows other AIM users to see how long you've been idle.
 423  *  Bit 2:  Allows other AIM users to see how long you've been a member.
 424  *
 425  */
 426 faim_export unsigned long aim_bos_setprivacyflags(struct aim_session_t *sess,
 427                                                   struct aim_conn_t *conn,
 428                                                   u_long flags)
 429 {
 430   return aim_genericreq_l(sess, conn, 0x0001, 0x0014, &flags);
 431 }
 432
 433 /*
 434  * aim_bos_reqpersonalinfo()
 435  *
 436  * Requests the current user's information. Can't go generic on this one
 437  * because aparently it uses SNAC flags.
 438  *
 439  */
 440 faim_export unsigned long aim_bos_reqpersonalinfo(struct aim_session_t *sess,
 441                                                   struct aim_conn_t *conn)
 442 {
 443   return aim_genericreq_n(sess, conn, 0x0001, 0x000e);
 444 }
 445
 446 faim_export unsigned long aim_setversions(struct aim_session_t *sess,
 447                                           struct aim_conn_t *conn)
 448 {
 449   struct command_tx_struct *newpacket;
 450   int i;
 451
 452   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10 + (4*12))))
 453     return -1;
 454
 455   newpacket->lock = 1;
 456
 457   i = aim_putsnac(newpacket->data, 0x0001, 0x0017, 0x0000, sess->snac_nextid);
 458
 459   i += aimutil_put16(newpacket->data+i, 0x0001);
 460   i += aimutil_put16(newpacket->data+i, 0x0003);
 461
 462   i += aimutil_put16(newpacket->data+i, 0x0002);
 463   i += aimutil_put16(newpacket->data+i, 0x0001);
 464
 465   i += aimutil_put16(newpacket->data+i, 0x0003);
 466   i += aimutil_put16(newpacket->data+i, 0x0001);
 467
 468   i += aimutil_put16(newpacket->data+i, 0x0004);
 469   i += aimutil_put16(newpacket->data+i, 0x0001);
 470
 471   i += aimutil_put16(newpacket->data+i, 0x0006);
 472   i += aimutil_put16(newpacket->data+i, 0x0001);
 473
 474   i += aimutil_put16(newpacket->data+i, 0x0008);
 475   i += aimutil_put16(newpacket->data+i, 0x0001);
 476
 477   i += aimutil_put16(newpacket->data+i, 0x0009);
 478   i += aimutil_put16(newpacket->data+i, 0x0001);
 479
 480   i += aimutil_put16(newpacket->data+i, 0x000a);
 481   i += aimutil_put16(newpacket->data+i, 0x0001);
 482
 483   i += aimutil_put16(newpacket->data+i, 0x000b);
 484   i += aimutil_put16(newpacket->data+i, 0x0002);
 485
 486   i += aimutil_put16(newpacket->data+i, 0x000c);
 487   i += aimutil_put16(newpacket->data+i, 0x0001);
 488
 489   i += aimutil_put16(newpacket->data+i, 0x0013);
 490   i += aimutil_put16(newpacket->data+i, 0x0001);
 491
 492   i += aimutil_put16(newpacket->data+i, 0x0015);
 493   i += aimutil_put16(newpacket->data+i, 0x0001);
 494
 495 #if 0
 496   for (j = 0; j < 0x10; j++) {
 497     i += aimutil_put16(newpacket->data+i, j); /* family */
 498     i += aimutil_put16(newpacket->data+i, 0x0003); /* version */
 499   }
 500 #endif
 501   newpacket->lock = 0;
 502   aim_tx_enqueue(sess, newpacket);
 503
 504   return (sess->snac_nextid++);
 505 }
 506
 507
 508 /*
 509  * aim_bos_reqservice(serviceid)
 510  *
 511  * Service request.
 512  *
 513  */
 514 faim_export unsigned long aim_bos_reqservice(struct aim_session_t *sess,
 515                           struct aim_conn_t *conn,
 516                           u_short serviceid)
 517 {
 518   return aim_genericreq_s(sess, conn, 0x0001, 0x0004, &serviceid);
 519 }
 520
 521 /*
 522  * aim_bos_nop()
 523  *
 524  * No-op.  WinAIM sends these every 4min or so to keep
 525  * the connection alive.  Its not real necessary.
 526  *
 527  */
 528 faim_export unsigned long aim_bos_nop(struct aim_session_t *sess,
 529                                       struct aim_conn_t *conn)
 530 {
 531   return aim_genericreq_n(sess, conn, 0x0001, 0x0016);
 532 }
 533
 534 /*
 535  * aim_bos_reqrights()
 536  *
 537  * Request BOS rights.
 538  *
 539  */
 540 faim_export unsigned long aim_bos_reqrights(struct aim_session_t *sess,
 541                                             struct aim_conn_t *conn)
 542 {
 543   return aim_genericreq_n(sess, conn, 0x0009, 0x0002);
 544 }
 545
 546 /*
 547  * aim_bos_reqbuddyrights()
 548  *
 549  * Request Buddy List rights.
 550  *
 551  */
 552 faim_export unsigned long aim_bos_reqbuddyrights(struct aim_session_t *sess,
 553                                                  struct aim_conn_t *conn)
 554 {
 555   return aim_genericreq_n(sess, conn, 0x0003, 0x0002);
 556 }
 557
 558 /*
 559  * aim_send_warning(struct aim_session_t *sess,
 560  *                  struct aim_conn_t *conn, char *destsn, int anon)
 561  * send a warning to destsn.
 562  * anon is anonymous or not;
 563  *  AIM_WARN_ANON anonymous
 564  *
 565  * returns -1 on error (couldn't alloc packet), next snacid on success.
 566  *
 567  */
 568 faim_export int aim_send_warning(struct aim_session_t *sess, struct aim_conn_t *conn, char *destsn, int anon)
 569 {
 570   struct command_tx_struct *newpacket;
 571   int curbyte;
 572
 573   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, strlen(destsn)+13)))
 574     return -1;
 575
 576   newpacket->lock = 1;
 577
 578   curbyte  = 0;
 579   curbyte += aim_putsnac(newpacket->data+curbyte,
 580                         0x0004, 0x0008, 0x0000, sess->snac_nextid);
 581
 582   curbyte += aimutil_put16(newpacket->data+curbyte, (anon & AIM_WARN_ANON)?1:0);
 583
 584   curbyte += aimutil_put8(newpacket->data+curbyte, strlen(destsn));
 585
 586   curbyte += aimutil_putstr(newpacket->data+curbyte, destsn, strlen(destsn));
 587
 588   newpacket->commandlen = curbyte;
 589   newpacket->lock = 0;
 590
 591   aim_tx_enqueue(sess, newpacket);
 592
 593   return (sess->snac_nextid++);
 594 }
 595
 596 /*
 597  * aim_debugconn_sendconnect()
 598  *
 599  * For aimdebugd.  If you don't know what it is, you don't want to.
 600  */
 601 faim_export unsigned long aim_debugconn_sendconnect(struct aim_session_t *sess,
 602                                                     struct aim_conn_t *conn)
 603 {
 604   return aim_genericreq_n(sess, conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_DEBUGCONN_CONNECT);
 605 }
 606
 607 /*
 608  * Generic routine for sending commands.
 609  *
 610  *
 611  * I know I can do this in a smarter way...but I'm not thinking straight
 612  * right now...
 613  *
 614  * I had one big function that handled all three cases, but then it broke
 615  * and I split it up into three.  But then I fixed it.  I just never went
 616  * back to the single.  I don't see any advantage to doing it either way.
 617  *
 618  */
 619 faim_internal unsigned long aim_genericreq_n(struct aim_session_t *sess,
 620                                              struct aim_conn_t *conn,
 621                                              u_short family, u_short subtype)
 622 {
 623   struct command_tx_struct *newpacket;
 624
 625   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10)))
 626     return 0;
 627
 628   newpacket->lock = 1;
 629
 630   aim_putsnac(newpacket->data, family, subtype, 0x0000, sess->snac_nextid);
 631
 632   aim_tx_enqueue(sess, newpacket);
 633   return (sess->snac_nextid++);
 634 }
 635
 636 /*
 637  *
 638  *
 639  */
 640 faim_internal unsigned long aim_genericreq_l(struct aim_session_t *sess,
 641                                              struct aim_conn_t *conn,
 642                                              u_short family, u_short subtype,
 643                                              u_long *longdata)
 644 {
 645   struct command_tx_struct *newpacket;
 646   u_long newlong;
 647
 648   /* If we don't have data, there's no reason to use this function */
 649   if (!longdata)
 650     return aim_genericreq_n(sess, conn, family, subtype);
 651
 652   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10+sizeof(u_long))))
 653     return -1;
 654
 655   newpacket->lock = 1;
 656
 657   aim_putsnac(newpacket->data, family, subtype, 0x0000, sess->snac_nextid);
 658
 659   /* copy in data */
 660   newlong = htonl(*longdata);
 661   memcpy(&(newpacket->data[10]), &newlong, sizeof(u_long));
 662
 663   aim_tx_enqueue(sess, newpacket);
 664   return (sess->snac_nextid++);
 665 }
 666
 667 faim_internal unsigned long aim_genericreq_s(struct aim_session_t *sess,
 668                                              struct aim_conn_t *conn,
 669                                              u_short family, u_short subtype,
 670                                              u_short *shortdata)
 671 {
 672   struct command_tx_struct *newpacket;
 673   u_short newshort;
 674
 675   /* If we don't have data, there's no reason to use this function */
 676   if (!shortdata)
 677     return aim_genericreq_n(sess, conn, family, subtype);
 678
 679   if (!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, 10+sizeof(u_short))))
 680     return -1;
 681
 682   newpacket->lock = 1;
 683
 684   aim_putsnac(newpacket->data, family, subtype, 0x0000, sess->snac_nextid);
 685
 686   /* copy in data */
 687   newshort = htons(*shortdata);
 688   memcpy(&(newpacket->data[10]), &newshort, sizeof(u_short));
 689
 690   aim_tx_enqueue(sess, newpacket);
 691   return (sess->snac_nextid++);
 692 }
 693
 694 /*
 695  * aim_bos_reqlocaterights()
 696  *
 697  * Request Location services rights.
 698  *
 699  */
 700 faim_export unsigned long aim_bos_reqlocaterights(struct aim_session_t *sess,
 701                                                   struct aim_conn_t *conn)
 702 {
 703   return aim_genericreq_n(sess, conn, 0x0002, 0x0002);
 704 }
 705
 706 /*
 707 * aim_bos_reqicbmparaminfo()
 708  *
 709  * Request ICBM parameter information.
 710  *
 711  */
 712 faim_export unsigned long aim_bos_reqicbmparaminfo(struct aim_session_t *sess,
 713                                                    struct aim_conn_t *conn)
 714 {
 715   return aim_genericreq_n(sess, conn, 0x0004, 0x0004);
 716 }
 717
 718 /*
 719  * Add ICBM parameter? Huh?
 720  */
 721 faim_export unsigned long aim_addicbmparam(struct aim_session_t *sess,
 722                                            struct aim_conn_t *conn)
 723 {
 724   struct command_tx_struct *newpacket;
 725   int packlen = 10+16, i=0;
 726
 727   if(!(newpacket = aim_tx_new(AIM_FRAMETYPE_OSCAR, 0x0002, conn, packlen)))
 728     return (sess->snac_nextid);
 729
 730   newpacket->lock = 1;
 731
 732   i = aim_putsnac(newpacket->data, 0x0004, 0x0002, 0x0000, sess->snac_nextid);
 733   i += aimutil_put16(newpacket->data+i, 0x0000);
 734   i += aimutil_put16(newpacket->data+i, 0x0000);
 735   i += aimutil_put16(newpacket->data+i, 0x0003);
 736   i += aimutil_put16(newpacket->data+i, 0x1f40);
 737   i += aimutil_put16(newpacket->data+i, 0x03e7);
 738   i += aimutil_put16(newpacket->data+i, 0x03e7);
 739   i += aimutil_put16(newpacket->data+i, 0x0000);
 740   i += aimutil_put16(newpacket->data+i, 0x0000);
 741
 742   aim_tx_enqueue(sess, newpacket);
 743
 744   return (sess->snac_nextid);
 745 }