src/login.c

   1 /*
   2  *  aim_login.c
   3  *
   4  *  This contains all the functions needed to actually login.
   5  *
   6  */
   7
   8 #define FAIM_INTERNAL
   9 #include <aim.h>
  10
  11 #include "md5.h"
  12
  13 static int aim_encode_password(const char *password, unsigned char *encoded);
  14
  15 faim_export int aim_sendflapver(aim_session_t *sess, aim_conn_t *conn)
  16 {
  17         aim_frame_t *fr;
  18
  19         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x01, 4)))
  20                 return -ENOMEM;
  21
  22         aimbs_put32(&fr->data, 0x00000001);
  23
  24         aim_tx_enqueue(sess, fr);
  25
  26         return 0;
  27 }
  28
  29 /*
  30  * This is a bit confusing.
  31  *
  32  * Normal SNAC login goes like this:
  33  *   - connect
  34  *   - server sends flap version
  35  *   - client sends flap version
  36  *   - client sends screen name (17/6)
  37  *   - server sends hash key (17/7)
  38  *   - client sends auth request (17/2 -- aim_send_login)
  39  *   - server yells
  40  *
  41  * XOR login (for ICQ) goes like this:
  42  *   - connect
  43  *   - server sends flap version
  44  *   - client sends auth request which contains flap version (aim_send_login)
  45  *   - server yells
  46  *
  47  * For the client API, we make them implement the most complicated version,
  48  * and for the simpler version, we fake it and make it look like the more
  49  * complicated process.
  50  *
  51  * This is done by giving the client a faked key, just so we can convince
  52  * them to call aim_send_login right away, which will detect the session
  53  * flag that says this is XOR login and ignore the key, sending an ICQ
  54  * login request instead of the normal SNAC one.
  55  *
  56  * As soon as AOL makes ICQ log in the same way as AIM, this is /gone/.
  57  *
  58  * XXX This may cause problems if the client relies on callbacks only
  59  * being called from the context of aim_rxdispatch()...
  60  *
  61  */
  62 static int goddamnicq(aim_session_t *sess, aim_conn_t *conn, const char *sn)
  63 {
  64         aim_frame_t fr;
  65         aim_rxcallback_t userfunc;
  66
  67         sess->flags &= ~AIM_SESS_FLAGS_SNACLOGIN;
  68         sess->flags |= AIM_SESS_FLAGS_XORLOGIN;
  69
  70         fr.conn = conn;
  71
  72         if ((userfunc = aim_callhandler(sess, conn, 0x0017, 0x0007)))
  73                 userfunc(sess, &fr, "");
  74
  75         return 0;
  76 }
  77
  78 /*
  79  * In AIM 3.5 protocol, the first stage of login is to request login from the
  80  * Authorizer, passing it the screen name for verification.  If the name is
  81  * invalid, a 0017/0003 is spit back, with the standard error contents.  If
  82  * valid, a 0017/0007 comes back, which is the signal to send it the main
  83  * login command (0017/0002).
  84  *
  85  */
  86 faim_export int aim_request_login(aim_session_t *sess, aim_conn_t *conn, const char *sn)
  87 {
  88         aim_frame_t *fr;
  89         aim_snacid_t snacid;
  90         aim_tlvlist_t *tl = NULL;
  91
  92         if (!sess || !conn || !sn)
  93                 return -EINVAL;
  94
  95         if ((sn[0] >= '0') && (sn[0] <= '9'))
  96                 return goddamnicq(sess, conn, sn);
  97
  98         sess->flags |= AIM_SESS_FLAGS_SNACLOGIN;
  99
 100         aim_sendflapver(sess, conn);
 101
 102         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+2+2+strlen(sn))))
 103                 return -ENOMEM;
 104
 105         snacid = aim_cachesnac(sess, 0x0017, 0x0006, 0x0000, NULL, 0);
 106         aim_putsnac(&fr->data, 0x0017, 0x0006, 0x0000, snacid);
 107
 108         aim_addtlvtochain_raw(&tl, 0x0001, strlen(sn), sn);
 109         aim_writetlvchain(&fr->data, &tl);
 110         aim_freetlvchain(&tl);
 111
 112         aim_tx_enqueue(sess, fr);
 113
 114         return 0;
 115 }
 116
 117 /*
 118  * Part two of the ICQ hack.  Note the ignoring of the key and clientinfo.
 119  */
 120 static int goddamnicq2(aim_session_t *sess, aim_conn_t *conn, const char *sn, const char *password)
 121 {
 122         static const char clientstr[] = {"ICQ Inc. - Product of ICQ (TM) 2000b.4.65.1.3281.85"};
 123         static const char lang[] = {"en"};
 124         static const char country[] = {"us"};
 125         aim_frame_t *fr;
 126         aim_tlvlist_t *tl = NULL;
 127         char *password_encoded;
 128
 129         if (!(password_encoded = (char *) malloc(strlen(password))))
 130                 return -ENOMEM;
 131
 132         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x01, 1152))) {
 133                 free(password_encoded);
 134                 return -ENOMEM;
 135         }
 136
 137         aim_encode_password(password, password_encoded);
 138
 139         aimbs_put32(&fr->data, 0x00000001);
 140         aim_addtlvtochain_raw(&tl, 0x0001, strlen(sn), sn);
 141         aim_addtlvtochain_raw(&tl, 0x0002, strlen(password), password_encoded);
 142         aim_addtlvtochain_raw(&tl, 0x0003, strlen(clientstr), clientstr);
 143         aim_addtlvtochain16(&tl, 0x0016, 0x010a);
 144         aim_addtlvtochain16(&tl, 0x0017, 0x0004);
 145         aim_addtlvtochain16(&tl, 0x0018, 0x0041);
 146         aim_addtlvtochain16(&tl, 0x0019, 0x0001);
 147         aim_addtlvtochain16(&tl, 0x001a, 0x0cd1);
 148         aim_addtlvtochain32(&tl, 0x0014, 0x00000055);
 149         aim_addtlvtochain_raw(&tl, 0x000f, strlen(lang), lang);
 150         aim_addtlvtochain_raw(&tl, 0x000e, strlen(country), country);
 151
 152         aim_writetlvchain(&fr->data, &tl);
 153
 154         free(password_encoded);
 155         aim_freetlvchain(&tl);
 156
 157         aim_tx_enqueue(sess, fr);
 158
 159         return 0;
 160 }
 161
 162 /*
 163  * send_login(int socket, char *sn, char *password)
 164  *
 165  * This is the initial login request packet.
 166  *
 167  * NOTE!! If you want/need to make use of the aim_sendmemblock() function,
 168  * then the client information you send here must exactly match the
 169  * executable that you're pulling the data from.
 170  *
 171  * Latest WinAIM:
 172  *   clientstring = "AOL Instant Messenger (SM), version 4.3.2188/WIN32"
 173  *   major2 = 0x0109
 174  *   major = 0x0400
 175  *   minor = 0x0003
 176  *   minor2 = 0x0000
 177  *   build = 0x088c
 178  *   unknown = 0x00000086
 179  *   lang = "en"
 180  *   country = "us"
 181  *   unknown4a = 0x01
 182  *
 183  * Latest WinAIM that libfaim can emulate without server-side buddylists:
 184  *   clientstring = "AOL Instant Messenger (SM), version 4.1.2010/WIN32"
 185  *   major2 = 0x0004
 186  *   major  = 0x0004
 187  *   minor  = 0x0001
 188  *   minor2 = 0x0000
 189  *   build  = 0x07da
 190  *   unknown= 0x0000004b
 191  *
 192  * WinAIM 3.5.1670:
 193  *   clientstring = "AOL Instant Messenger (SM), version 3.5.1670/WIN32"
 194  *   major2 = 0x0004
 195  *   major =  0x0003
 196  *   minor =  0x0005
 197  *   minor2 = 0x0000
 198  *   build =  0x0686
 199  *   unknown =0x0000002a
 200  *
 201  * Java AIM 1.1.19:
 202  *   clientstring = "AOL Instant Messenger (TM) version 1.1.19 for Java built 03/24/98, freeMem 215871 totalMem 1048567, i686, Linus, #2 SMP Sun Feb 11 03:41:17 UTC 2001 2.4.1-ac9, IBM Corporation, 1.1.8, 45.3, Tue Mar 27 12:09:17 PST 2001"
 203  *   major2 = 0x0001
 204  *   major  = 0x0001
 205  *   minor  = 0x0001
 206  *   minor2 = (not sent)
 207  *   build  = 0x0013
 208  *   unknown= (not sent)
 209  *
 210  * AIM for Linux 1.1.112:
 211  *   clientstring = "AOL Instant Messenger (SM)"
 212  *   major2 = 0x1d09
 213  *   major  = 0x0001
 214  *   minor  = 0x0001
 215  *   minor2 = 0x0001
 216  *   build  = 0x0070
 217  *   unknown= 0x0000008b
 218  *   serverstore = 0x01
 219  *
 220  */
 221 faim_export int aim_send_login(aim_session_t *sess, aim_conn_t *conn, const char *sn, const char *password, struct client_info_s *clientinfo, const char *key)
 222 {
 223         aim_frame_t *fr;
 224         aim_tlvlist_t *tl = NULL;
 225         fu8_t digest[16];
 226         aim_snacid_t snacid;
 227
 228         if (!clientinfo || !sn || !password)
 229                 return -EINVAL;
 230
 231         if (sess->flags & AIM_SESS_FLAGS_XORLOGIN)
 232                 return goddamnicq2(sess, conn, sn, password);
 233
 234         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 1152)))
 235                 return -ENOMEM;
 236
 237         if (sess->flags & AIM_SESS_FLAGS_XORLOGIN) {
 238                 fr->hdr.flap.type = 0x01;
 239
 240                 /* Use very specific version numbers to further indicate hack */
 241                 clientinfo->major2 = 0x010a;
 242                 clientinfo->major = 0x0004;
 243                 clientinfo->minor = 0x003c;
 244                 clientinfo->minor2 = 0x0001;
 245                 clientinfo->build = 0x0cce;
 246                 clientinfo->unknown = 0x00000055;
 247         }
 248
 249         snacid = aim_cachesnac(sess, 0x0017, 0x0002, 0x0000, NULL, 0);
 250         aim_putsnac(&fr->data, 0x0017, 0x0002, 0x0000, snacid);
 251
 252         aim_addtlvtochain_raw(&tl, 0x0001, strlen(sn), sn);
 253
 254         aim_encode_password_md5(password, key, digest);
 255         aim_addtlvtochain_raw(&tl, 0x0025, 16, digest);
 256
 257         aim_addtlvtochain_raw(&tl, 0x0003, strlen(clientinfo->clientstring), clientinfo->clientstring);
 258         aim_addtlvtochain16(&tl, 0x0016, (fu16_t)clientinfo->major2);
 259         aim_addtlvtochain16(&tl, 0x0017, (fu16_t)clientinfo->major);
 260         aim_addtlvtochain16(&tl, 0x0018, (fu16_t)clientinfo->minor);
 261         aim_addtlvtochain16(&tl, 0x0019, (fu16_t)clientinfo->minor2);
 262         aim_addtlvtochain16(&tl, 0x001a, (fu16_t)clientinfo->build);
 263         aim_addtlvtochain_raw(&tl, 0x000e, strlen(clientinfo->country), clientinfo->country);
 264         aim_addtlvtochain_raw(&tl, 0x000f, strlen(clientinfo->lang), clientinfo->lang);
 265         aim_addtlvtochain16(&tl, 0x0009, 0x0015);
 266
 267         aim_writetlvchain(&fr->data, &tl);
 268
 269         aim_freetlvchain(&tl);
 270
 271         aim_tx_enqueue(sess, fr);
 272
 273         return 0;
 274 }
 275
 276 faim_export int aim_encode_password_md5(const char *password, const char *key, fu8_t *digest)
 277 {
 278         md5_state_t state;
 279
 280         md5_init(&state);
 281         md5_append(&state, (const md5_byte_t *)key, strlen(key));
 282         md5_append(&state, (const md5_byte_t *)password, strlen(password));
 283         md5_append(&state, (const md5_byte_t *)AIM_MD5_STRING, strlen(AIM_MD5_STRING));
 284         md5_finish(&state, (md5_byte_t *)digest);
 285
 286         return 0;
 287 }
 288
 289 /**
 290  * aim_encode_password - Encode a password using old XOR method
 291  * @password: incoming password
 292  * @encoded: buffer to put encoded password
 293  *
 294  * This takes a const pointer to a (null terminated) string
 295  * containing the unencoded password.  It also gets passed
 296  * an already allocated buffer to store the encoded password.
 297  * This buffer should be the exact length of the password without
 298  * the null.  The encoded password buffer /is not %NULL terminated/.
 299  *
 300  * The encoding_table seems to be a fixed set of values.  We'll
 301  * hope it doesn't change over time!
 302  *
 303  * This is only used for the XOR method, not the better MD5 method.
 304  *
 305  */
 306 static int aim_encode_password(const char *password, fu8_t *encoded)
 307 {
 308         fu8_t encoding_table[] = {
 309 #if 0 /* old v1 table */
 310                 0xf3, 0xb3, 0x6c, 0x99,
 311                 0x95, 0x3f, 0xac, 0xb6,
 312                 0xc5, 0xfa, 0x6b, 0x63,
 313                 0x69, 0x6c, 0xc3, 0x9f
 314 #else /* v2.1 table, also works for ICQ */
 315                 0xf3, 0x26, 0x81, 0xc4,
 316                 0x39, 0x86, 0xdb, 0x92,
 317                 0x71, 0xa3, 0xb9, 0xe6,
 318                 0x53, 0x7a, 0x95, 0x7c
 319 #endif
 320         };
 321         int i;
 322
 323         for (i = 0; i < strlen(password); i++)
 324                 encoded[i] = (password[i] ^ encoding_table[i]);
 325
 326         return 0;
 327 }
 328
 329 /*
 330  * Generate an authorization response.
 331  *
 332  * You probably don't want this unless you're writing an AIM server. Which
 333  * I hope you're not doing.  Because it's far more difficult than it looks.
 334  *
 335  */
 336 faim_export int aim_sendauthresp(aim_session_t *sess, aim_conn_t *conn, const char *sn, int errorcode, const char *errorurl, const char *bosip, const char *cookie, const char *email, int regstatus)
 337 {
 338         aim_tlvlist_t *tlvlist = NULL;
 339         aim_frame_t *fr;
 340
 341         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x04, 1152)))
 342                 return -ENOMEM;
 343
 344         if (sn)
 345                 aim_addtlvtochain_raw(&tlvlist, 0x0001, strlen(sn), sn);
 346         else
 347                 aim_addtlvtochain_raw(&tlvlist, 0x0001, strlen(sess->sn), sess->sn);
 348
 349         if (errorcode) {
 350                 aim_addtlvtochain16(&tlvlist, 0x0008, errorcode);
 351                 aim_addtlvtochain_raw(&tlvlist, 0x0004, strlen(errorurl), errorurl);
 352         } else {
 353                 aim_addtlvtochain_raw(&tlvlist, 0x0005, strlen(bosip), bosip);
 354                 aim_addtlvtochain_raw(&tlvlist, 0x0006, AIM_COOKIELEN, cookie);
 355                 aim_addtlvtochain_raw(&tlvlist, 0x0011, strlen(email), email);
 356                 aim_addtlvtochain16(&tlvlist, 0x0013, (fu16_t)regstatus);
 357         }
 358
 359         aim_writetlvchain(&fr->data, &tlvlist);
 360         aim_freetlvchain(&tlvlist);
 361
 362         aim_tx_enqueue(sess, fr);
 363
 364         return 0;
 365 }
 366
 367 /*
 368  * Generate a random cookie.  (Non-client use only)
 369  */
 370 faim_export int aim_gencookie(fu8_t *buf)
 371 {
 372         int i;
 373
 374         srand(time(NULL));
 375
 376         for (i = 0; i < AIM_COOKIELEN; i++)
 377                 buf[i] = 1+(int) (256.0*rand()/(RAND_MAX+0.0));
 378
 379         return i;
 380 }
 381
 382 /*
 383  * Send Server Ready.  (Non-client)
 384  *
 385  * XXX If anyone cares, this should be made to use the conn-stored group
 386  * system.
 387  *
 388  */
 389 faim_export int aim_sendserverready(aim_session_t *sess, aim_conn_t *conn)
 390 {
 391         aim_frame_t *fr;
 392         aim_snacid_t snacid;
 393
 394         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+0x22)))
 395                 return -ENOMEM;
 396
 397         snacid = aim_cachesnac(sess, 0x0001, 0x0003, 0x0000, NULL, 0);
 398
 399         aim_putsnac(&fr->data, 0x0001, 0x0003, 0x0000, snacid);
 400         aimbs_put16(&fr->data, 0x0001);
 401         aimbs_put16(&fr->data, 0x0002);
 402         aimbs_put16(&fr->data, 0x0003);
 403         aimbs_put16(&fr->data, 0x0004);
 404         aimbs_put16(&fr->data, 0x0006);
 405         aimbs_put16(&fr->data, 0x0008);
 406         aimbs_put16(&fr->data, 0x0009);
 407         aimbs_put16(&fr->data, 0x000a);
 408         aimbs_put16(&fr->data, 0x000b);
 409         aimbs_put16(&fr->data, 0x000c);
 410         aimbs_put16(&fr->data, 0x0013);
 411         aimbs_put16(&fr->data, 0x0015);
 412
 413         aim_tx_enqueue(sess, fr);
 414
 415         return 0;
 416 }
 417
 418 /*
 419  * Send service redirect.  (Non-Client)
 420  */
 421 faim_export int aim_sendredirect(aim_session_t *sess, aim_conn_t *conn, fu16_t servid, const char *ip, const char *cookie)
 422 {
 423         aim_tlvlist_t *tlvlist = NULL;
 424         aim_frame_t *fr;
 425         aim_snacid_t snacid;
 426
 427         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 1152)))
 428                 return -ENOMEM;
 429
 430         snacid = aim_cachesnac(sess, 0x0001, 0x0005, 0x0000, NULL, 0);
 431         aim_putsnac(&fr->data, 0x0001, 0x0005, 0x0000, snacid);
 432
 433         aim_addtlvtochain16(&tlvlist, 0x000d, servid);
 434         aim_addtlvtochain_raw(&tlvlist, 0x0005, strlen(ip), ip);
 435         aim_addtlvtochain_raw(&tlvlist, 0x0006, AIM_COOKIELEN, cookie);
 436
 437         aim_writetlvchain(&fr->data, &tlvlist);
 438         aim_freetlvchain(&tlvlist);
 439
 440         aim_tx_enqueue(sess, fr);
 441
 442         return 0;
 443 }
 444
 445 /*
 446  * See comments in conn.c about how the group associations are supposed
 447  * to work, and how they really work.
 448  *
 449  * This info probably doesn't even need to make it to the client.
 450  *
 451  */
 452 static int hostonline(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 453 {
 454         aim_rxcallback_t userfunc;
 455         int ret = 0;
 456         fu16_t *families;
 457         int famcount;
 458
 459         if (!(families = malloc(aim_bstream_empty(bs))))
 460                 return 0;
 461
 462         for (famcount = 0; aim_bstream_empty(bs); famcount++) {
 463                 families[famcount] = aimbs_get16(bs);
 464                 aim_conn_addgroup(rx->conn, families[famcount]);
 465         }
 466
 467         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 468                 ret = userfunc(sess, rx, famcount, families);
 469
 470         free(families);
 471
 472         return ret;
 473 }
 474
 475 static int redirect(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 476 {
 477         int serviceid;
 478         fu8_t *cookie;
 479         char *ip;
 480         aim_rxcallback_t userfunc;
 481         aim_tlvlist_t *tlvlist;
 482         char *chathack = NULL;
 483         int chathackex = 0;
 484         int ret = 0;
 485
 486         tlvlist = aim_readtlvchain(bs);
 487
 488         if (!aim_gettlv(tlvlist, 0x000d, 1) ||
 489                         !aim_gettlv(tlvlist, 0x0005, 1) ||
 490                         !aim_gettlv(tlvlist, 0x0006, 1)) {
 491                 aim_freetlvchain(&tlvlist);
 492                 return 0;
 493         }
 494
 495         serviceid = aim_gettlv16(tlvlist, 0x000d, 1);
 496         ip = aim_gettlv_str(tlvlist, 0x0005, 1);
 497         cookie = aim_gettlv_str(tlvlist, 0x0006, 1);
 498
 499         /*
 500          * Chat hack.
 501          */
 502         if ((serviceid == AIM_CONN_TYPE_CHAT) && sess->pendingjoin) {
 503                 chathack = sess->pendingjoin;
 504                 chathackex = sess->pendingjoinexchange;
 505                 sess->pendingjoin = NULL;
 506                 sess->pendingjoinexchange = 0;
 507         }
 508
 509         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 510                 ret = userfunc(sess, rx, serviceid, ip, cookie, chathack, chathackex);
 511
 512         free(ip);
 513         free(cookie);
 514         free(chathack);
 515
 516         aim_freetlvchain(&tlvlist);
 517
 518         return ret;
 519 }
 520
 521 /*
 522  * The Rate Limiting System, An Abridged Guide to Nonsense.
 523  *
 524  * OSCAR defines several 'rate classes'.  Each class has seperate
 525  * rate limiting properties (limit level, alert level, disconnect
 526  * level, etc), and a set of SNAC family/type pairs associated with
 527  * it.  The rate classes, their limiting properties, and the definitions
 528  * of which SNACs are belong to which class, are defined in the
 529  * Rate Response packet at login to each host.
 530  *
 531  * Logically, all rate offenses within one class count against further
 532  * offenses for other SNACs in the same class (ie, sending messages
 533  * too fast will limit the number of user info requests you can send,
 534  * since those two SNACs are in the same rate class).
 535  *
 536  * Since the rate classes are defined dynamically at login, the values
 537  * below may change. But they seem to be fairly constant.
 538  *
 539  * Currently, BOS defines five rate classes, with the commonly used
 540  * members as follows...
 541  *
 542  *  Rate class 0x0001:
 543  *      - Everything thats not in any of the other classes
 544  *
 545  *  Rate class 0x0002:
 546  *      - Buddy list add/remove
 547  *      - Permit list add/remove
 548  *      - Deny list add/remove
 549  *
 550  *  Rate class 0x0003:
 551  *      - User information requests
 552  *      - Outgoing ICBMs
 553  *
 554  *  Rate class 0x0004:
 555  *      - A few unknowns: 2/9, 2/b, and f/2
 556  *
 557  *  Rate class 0x0005:
 558  *      - Chat room create
 559  *      - Outgoing chat ICBMs
 560  *
 561  * The only other thing of note is that class 5 (chat) has slightly looser
 562  * limiting properties than class 3 (normal messages).  But thats just a
 563  * small bit of trivia for you.
 564  *
 565  * The last thing that needs to be learned about the rate limiting
 566  * system is how the actual numbers relate to the passing of time.  This
 567  * seems to be a big mystery.
 568  *
 569  */
 570
 571 /* XXX parse this */
 572 static int rateresp(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 573 {
 574         aim_rxcallback_t userfunc;
 575
 576         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 577                 return userfunc(sess, rx);
 578
 579         return 0;
 580 }
 581
 582 static int ratechange(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 583 {
 584         aim_rxcallback_t userfunc;
 585         fu16_t code, rateclass;
 586         fu32_t currentavg, maxavg, windowsize, clear, alert, limit, disconnect;
 587
 588         code = aimbs_get16(bs);
 589         rateclass = aimbs_get16(bs);
 590
 591         windowsize = aimbs_get32(bs);
 592         clear = aimbs_get32(bs);
 593         alert = aimbs_get32(bs);
 594         limit = aimbs_get32(bs);
 595         disconnect = aimbs_get32(bs);
 596         currentavg = aimbs_get32(bs);
 597         maxavg = aimbs_get32(bs);
 598
 599         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 600                 return userfunc(sess, rx, code, rateclass, windowsize, clear, alert, limit, disconnect, currentavg, maxavg);
 601
 602         return 0;
 603 }
 604
 605 /* XXX parse this */
 606 static int selfinfo(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 607 {
 608         aim_rxcallback_t userfunc;
 609
 610         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 611                 return userfunc(sess, rx);
 612
 613         return 0;
 614 }
 615
 616 static int evilnotify(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 617 {
 618         aim_rxcallback_t userfunc;
 619         fu16_t newevil;
 620         struct aim_userinfo_s userinfo;
 621
 622         memset(&userinfo, 0, sizeof(struct aim_userinfo_s));
 623
 624         newevil = aimbs_get16(bs);
 625
 626         if (aim_bstream_empty(bs))
 627                 aim_extractuserinfo(sess, bs, &userinfo);
 628
 629         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 630                 return userfunc(sess, rx, newevil, &userinfo);
 631
 632         return 0;
 633 }
 634
 635 /*
 636  * How Migrations work.
 637  *
 638  * The server sends a Server Pause message, which the client should respond to
 639  * with a Server Pause Ack, which contains the families it needs on this
 640  * connection. The server will send a Migration Notice with an IP address, and
 641  * then disconnect. Next the client should open the connection and send the
 642  * cookie.  Repeat the normal login process and pretend this never happened.
 643  *
 644  * The Server Pause contains no data.
 645  *
 646  */
 647 static int serverpause(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 648 {
 649         aim_rxcallback_t userfunc;
 650
 651         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 652                 return userfunc(sess, rx);
 653
 654         return 0;
 655 }
 656
 657 /*
 658  * It is rather important that aim_sendpauseack() gets called for the exact
 659  * same connection that the Server Pause callback was called for, since
 660  * libfaim extracts the data for the SNAC from the connection structure.
 661  *
 662  * Of course, if you don't do that, more bad things happen than just what
 663  * libfaim can cause.
 664  *
 665  */
 666 faim_export int aim_sendpauseack(aim_session_t *sess, aim_conn_t *conn)
 667 {
 668         aim_frame_t *fr;
 669         aim_snacid_t snacid;
 670         aim_conn_inside_t *ins = (aim_conn_inside_t *)conn->inside;
 671         struct snacgroup *sg;
 672
 673         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 1024)))
 674                 return -ENOMEM;
 675
 676         snacid = aim_cachesnac(sess, 0x0001, 0x000c, 0x0000, NULL, 0);
 677         aim_putsnac(&fr->data, 0x0001, 0x000c, 0x0000, snacid);
 678
 679         /*
 680          * This list should have all the groups that the original
 681          * Host Online / Server Ready said this host supports.  And
 682          * we want them all back after the migration.
 683          */
 684         for (sg = ins->groups; sg; sg = sg->next)
 685                 aimbs_put16(&fr->data, sg->group);
 686
 687         aim_tx_enqueue(sess, fr);
 688
 689         return 0;
 690 }
 691
 692 /*
 693  * This is the final SNAC sent on the original connection during a migration.
 694  * It contains the IP and cookie used to connect to the new server, and
 695  * optionally a list of the SNAC groups being migrated.
 696  *
 697  */
 698 static int migrate(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 699 {
 700         aim_rxcallback_t userfunc;
 701         int ret = 0;
 702         fu16_t groupcount, i;
 703         aim_tlvlist_t *tl;
 704         char *ip = NULL;
 705         aim_tlv_t *cktlv;
 706
 707         /*
 708          * Apparently there's some fun stuff that can happen right here. The
 709          * migration can actually be quite selective about what groups it
 710          * moves to the new server.  When not all the groups for a connection
 711          * are migrated, or they are all migrated but some groups are moved
 712          * to a different server than others, it is called a bifurcated
 713          * migration.
 714          *
 715          * Let's play dumb and not support that.
 716          *
 717          */
 718         groupcount = aimbs_get16(bs);
 719         for (i = 0; i < groupcount; i++) {
 720                 fu16_t group;
 721
 722                 group = aimbs_get16(bs);
 723
 724                 faimdprintf(sess, 0, "bifurcated migration unsupported -- group 0x%04x\n", group);
 725         }
 726
 727         tl = aim_readtlvchain(bs);
 728
 729         if (aim_gettlv(tl, 0x0005, 1))
 730                 ip = aim_gettlv_str(tl, 0x0005, 1);
 731
 732         cktlv = aim_gettlv(tl, 0x0006, 1);
 733
 734         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 735                 ret = userfunc(sess, rx, ip, cktlv ? cktlv->value : NULL);
 736
 737         aim_freetlvchain(&tl);
 738         free(ip);
 739
 740         return ret;
 741 }
 742
 743 static int motd(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 744 {
 745         aim_rxcallback_t userfunc;
 746         char *msg = NULL;
 747         int ret = 0;
 748         aim_tlvlist_t *tlvlist;
 749         fu16_t id;
 750
 751         /*
 752          * Code.
 753          *
 754          * Valid values:
 755          *   1 Mandatory upgrade
 756          *   2 Advisory upgrade
 757          *   3 System bulletin
 758          *   4 Nothing's wrong ("top o the world" -- normal)
 759          *   5 Lets-break-something.
 760          *
 761          */
 762         id = aimbs_get16(bs);
 763
 764         /*
 765          * TLVs follow
 766          */
 767         tlvlist = aim_readtlvchain(bs);
 768
 769         msg = aim_gettlv_str(tlvlist, 0x000b, 1);
 770
 771         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 772                 ret = userfunc(sess, rx, id, msg);
 773
 774         free(msg);
 775
 776         aim_freetlvchain(&tlvlist);
 777
 778         return ret;
 779 }
 780
 781 static int hostversions(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 782 {
 783         aim_rxcallback_t userfunc;
 784         int vercount;
 785         fu8_t *versions;
 786
 787         vercount = aim_bstream_empty(bs)/4;
 788         versions = aimbs_getraw(bs, aim_bstream_empty(bs));
 789
 790         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 791                 return userfunc(sess, rx, vercount, versions);
 792
 793         free(versions);
 794
 795         return 0;
 796 }
 797
 798 /*
 799  * Starting this past week (26 Mar 2001, say), AOL has started sending
 800  * this nice little extra SNAC.  AFAIK, it has never been used until now.
 801  *
 802  * The request contains eight bytes.  The first four are an offset, the
 803  * second four are a length.
 804  *
 805  * The offset is an offset into aim.exe when it is mapped during execution
 806  * on Win32.  So far, AOL has only been requesting bytes in static regions
 807  * of memory.  (I won't put it past them to start requesting data in
 808  * less static regions -- regions that are initialized at run time, but still
 809  * before the client recieves this request.)
 810  *
 811  * When the client recieves the request, it adds it to the current ds
 812  * (0x00400000) and dereferences it, copying the data into a buffer which
 813  * it then runs directly through the MD5 hasher.  The 16 byte output of
 814  * the hash is then sent back to the server.
 815  *
 816  * If the client does not send any data back, or the data does not match
 817  * the data that the specific client should have, the client will get the
 818  * following message from "AOL Instant Messenger":
 819  *    "You have been disconnected from the AOL Instant Message Service (SM)
 820  *     for accessing the AOL network using unauthorized software.  You can
 821  *     download a FREE, fully featured, and authorized client, here
 822  *     http://www.aol.com/aim/download2.html"
 823  * The connection is then closed, recieving disconnect code 1, URL
 824  * http://www.aim.aol.com/errors/USER_LOGGED_OFF_NEW_LOGIN.html.
 825  *
 826  * Note, however, that numerous inconsistencies can cause the above error,
 827  * not just sending back a bad hash.  Do not immediatly suspect this code
 828  * if you get disconnected.  AOL and the open/free software community have
 829  * played this game for a couple years now, generating the above message
 830  * on numerous ocassions.
 831  *
 832  * Anyway, neener.  We win again.
 833  *
 834  */
 835 static int memrequest(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 836 {
 837         aim_rxcallback_t userfunc;
 838         fu32_t offset, len;
 839         aim_tlvlist_t *list;
 840         char *modname;
 841
 842         offset = aimbs_get32(bs);
 843         len = aimbs_get32(bs);
 844         list = aim_readtlvchain(bs);
 845
 846         modname = aim_gettlv_str(list, 0x0001, 1);
 847
 848         faimdprintf(sess, 1, "data at 0x%08lx (%d bytes) of requested\n", offset, len, modname ? modname : "aim.exe");
 849
 850         if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 851                 return userfunc(sess, rx, offset, len, modname);
 852
 853         free(modname);
 854         aim_freetlvchain(&list);
 855
 856         return 0;
 857 }
 858
 859 #if 0
 860 static void dumpbox(aim_session_t *sess, unsigned char *buf, int len)
 861 {
 862         int i;
 863
 864         if (!sess || !buf || !len)
 865                 return;
 866
 867         faimdprintf(sess, 1, "\nDump of %d bytes at %p:", len, buf);
 868
 869         for (i = 0; i < len; i++) {
 870                 if ((i % 8) == 0)
 871                         faimdprintf(sess, 1, "\n\t");
 872
 873                 faimdprintf(sess, 1, "0x%2x ", buf[i]);
 874         }
 875
 876         faimdprintf(sess, 1, "\n\n");
 877
 878         return;
 879 }
 880 #endif
 881
 882 faim_export int aim_sendmemblock(aim_session_t *sess, aim_conn_t *conn, fu32_t offset, fu32_t len, const fu8_t *buf, fu8_t flag)
 883 {
 884         aim_frame_t *fr;
 885         aim_snacid_t snacid;
 886
 887         if (!sess || !conn)
 888                 return -EINVAL;
 889
 890         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+2+16)))
 891                 return -ENOMEM;
 892
 893         snacid = aim_cachesnac(sess, 0x0001, 0x0020, 0x0000, NULL, 0);
 894
 895         aim_putsnac(&fr->data, 0x0001, 0x0020, 0x0000, snacid);
 896         aimbs_put16(&fr->data, 0x0010); /* md5 is always 16 bytes */
 897
 898         if ((flag == AIM_SENDMEMBLOCK_FLAG_ISHASH) && buf && (len == 0x10)) { /* we're getting a hash */
 899
 900                 aimbs_putraw(&fr->data, buf, 0x10);
 901
 902         } else if (buf && (len > 0)) { /* use input buffer */
 903                 md5_state_t state;
 904                 md5_byte_t digest[0x10];
 905
 906                 md5_init(&state);
 907                 md5_append(&state, (const md5_byte_t *)buf, len);
 908                 md5_finish(&state, digest);
 909
 910                 aimbs_putraw(&fr->data, (fu8_t *)digest, 0x10);
 911
 912         } else if (len == 0) { /* no length, just hash NULL (buf is optional) */
 913                 md5_state_t state;
 914                 fu8_t nil = '\0';
 915                 md5_byte_t digest[0x10];
 916
 917                 /*
 918                  * These MD5 routines are stupid in that you have to have
 919                  * at least one append.  So thats why this doesn't look
 920                  * real logical.
 921                  */
 922                 md5_init(&state);
 923                 md5_append(&state, (const md5_byte_t *)&nil, 0);
 924                 md5_finish(&state, digest);
 925
 926                 aimbs_putraw(&fr->data, (fu8_t *)digest, 0x10);
 927
 928         } else {
 929
 930                 /*
 931                  * This data is correct for AIM 3.5.1670.
 932                  *
 933                  * Using these blocks is as close to "legal" as you can get
 934                  * without using an AIM binary.
 935                  *
 936                  */
 937                 if ((offset == 0x03ffffff) && (len == 0x03ffffff)) {
 938
 939 #if 1 /* with "AnrbnrAqhfzcd" */
 940                         aimbs_put32(&fr->data, 0x44a95d26);
 941                         aimbs_put32(&fr->data, 0xd2490423);
 942                         aimbs_put32(&fr->data, 0x93b8821f);
 943                         aimbs_put32(&fr->data, 0x51c54b01);
 944 #else /* no filename */
 945                         aimbs_put32(&fr->data, 0x1df8cbae);
 946                         aimbs_put32(&fr->data, 0x5523b839);
 947                         aimbs_put32(&fr->data, 0xa0e10db3);
 948                         aimbs_put32(&fr->data, 0xa46d3b39);
 949 #endif
 950
 951                 } else if ((offset == 0x00001000) && (len == 0x00000000)) {
 952
 953                         aimbs_put32(&fr->data, 0xd41d8cd9);
 954                         aimbs_put32(&fr->data, 0x8f00b204);
 955                         aimbs_put32(&fr->data, 0xe9800998);
 956                         aimbs_put32(&fr->data, 0xecf8427e);
 957
 958                 } else
 959                         faimdprintf(sess, 0, "sendmemblock: WARNING: unknown hash request\n");
 960
 961         }
 962
 963         aim_tx_enqueue(sess, fr);
 964
 965         return 0;
 966 }
 967
 968 static int snachandler(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
 969 {
 970
 971         if (snac->subtype == 0x0003)
 972                 return hostonline(sess, mod, rx, snac, bs);
 973         else if (snac->subtype == 0x0005)
 974                 return redirect(sess, mod, rx, snac, bs);
 975         else if (snac->subtype == 0x0007)
 976                 return rateresp(sess, mod, rx, snac, bs);
 977         else if (snac->subtype == 0x000a)
 978                 return ratechange(sess, mod, rx, snac, bs);
 979         else if (snac->subtype == 0x000b)
 980                 return serverpause(sess, mod, rx, snac, bs);
 981         else if (snac->subtype == 0x000f)
 982                 return selfinfo(sess, mod, rx, snac, bs);
 983         else if (snac->subtype == 0x0010)
 984                 return evilnotify(sess, mod, rx, snac, bs);
 985         else if (snac->subtype == 0x0012)
 986                 return migrate(sess, mod, rx, snac, bs);
 987         else if (snac->subtype == 0x0013)
 988                 return motd(sess, mod, rx, snac, bs);
 989         else if (snac->subtype == 0x0018)
 990                 return hostversions(sess, mod, rx, snac, bs);
 991         else if (snac->subtype == 0x001f)
 992                 return memrequest(sess, mod, rx, snac, bs);
 993
 994         return 0;
 995 }
 996
 997 faim_internal int general_modfirst(aim_session_t *sess, aim_module_t *mod)
 998 {
 999
1000         mod->family = 0x0001;
1001         mod->version = 0x0000;
1002         mod->flags = 0;
1003         strncpy(mod->name, "general", sizeof(mod->name));
1004         mod->snachandler = snachandler;
1005
1006         return 0;
1007 }
1008