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_sendconnack(struct aim_session_t *sess,
  16                                 struct aim_conn_t *conn)
  17 {
  18   int curbyte=0;
  19
  20   struct command_tx_struct *newpacket;
  21
  22   if (!(newpacket = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0001, 4)))
  23     return -1;
  24
  25   newpacket->lock = 1;
  26
  27   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0000);
  28   curbyte += aimutil_put16(newpacket->data+curbyte, 0x0001);
  29
  30   newpacket->lock = 0;
  31   return aim_tx_enqueue(sess, newpacket);
  32 }
  33
  34 /*
  35  * In AIM 3.5 protocol, the first stage of login is to request
  36  * login from the Authorizer, passing it the screen name
  37  * for verification.  If the name is invalid, a 0017/0003
  38  * is spit back, with the standard error contents.  If valid,
  39  * a 0017/0007 comes back, which is the signal to send
  40  * it the main login command (0017/0002).
  41  */
  42 faim_export int aim_request_login(struct aim_session_t *sess,
  43                                   struct aim_conn_t *conn,
  44                                   char *sn)
  45 {
  46   int curbyte;
  47   struct command_tx_struct *newpacket;
  48
  49   if (!sess || !conn || !sn)
  50     return -1;
  51
  52   /*
  53    * For ICQ, we enable the ancient horrible login and stuff
  54    * a key packet into the queue to make it look like we got
  55    * a reply back. This is so the client doesn't know we're
  56    * really not doing MD5 login.
  57    *
  58    * This may sound stupid, but I'm not in the best of moods and
  59    * I don't plan to keep support for this crap around much longer.
  60    * Its all AOL's fault anyway, really. I hate AOL.  Really.  They
  61    * always seem to be able to piss me off by doing the dumbest little
  62    * things.  Like disabling MD5 logins for ICQ UINs, or adding purposefully
  63    * wrong TLV lengths, or adding superfluous information to host strings,
  64    * or... I'll stop.
  65    *
  66    */
  67   if ((sn[0] >= '0') && (sn[0] <= '9')) {
  68     struct command_rx_struct *newrx;
  69     int i;
  70
  71     if (!(newrx = (struct command_rx_struct *)malloc(sizeof(struct command_rx_struct))))
  72       return -1;
  73     memset(newrx, 0x00, sizeof(struct command_rx_struct));
  74     newrx->lock = 1;
  75     newrx->hdrtype = AIM_FRAMETYPE_OSCAR;
  76     newrx->hdr.oscar.type = 0x02;
  77     newrx->hdr.oscar.seqnum = 0;
  78     newrx->commandlen = 10+2+1;
  79     newrx->nofree = 0;
  80     if (!(newrx->data = malloc(newrx->commandlen))) {
  81       free(newrx);
  82       return -1;
  83     }
  84
  85     i = aim_putsnac(newrx->data, 0x0017, 0x0007, 0x0000, 0x0000);
  86     i += aimutil_put16(newrx->data+i, 0x01);
  87     i += aimutil_putstr(newrx->data+i, "0", 1);
  88
  89     newrx->conn = conn;
  90
  91     newrx->next = sess->queue_incoming;
  92     sess->queue_incoming = newrx;
  93
  94     newrx->lock = 0;
  95
  96     sess->flags &= ~AIM_SESS_FLAGS_SNACLOGIN;
  97
  98     return 0;
  99   }
 100
 101   sess->flags |= AIM_SESS_FLAGS_SNACLOGIN;
 102
 103   aim_sendconnack(sess, conn);
 104
 105   if (!(newpacket = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 10+2+2+strlen(sn))))
 106     return -1;
 107
 108   newpacket->lock = 1;
 109
 110   curbyte  = aim_putsnac(newpacket->data, 0x0017, 0x0006, 0x0000, 0x00010000);
 111   curbyte += aim_puttlv_str(newpacket->data+curbyte, 0x0001, strlen(sn), sn);
 112
 113   newpacket->commandlen = curbyte;
 114   newpacket->lock = 0;
 115
 116   return aim_tx_enqueue(sess, newpacket);
 117 }
 118
 119 /*
 120  * send_login(int socket, char *sn, char *password)
 121  *
 122  * This is the initial login request packet.
 123  *
 124  * The password is encoded before transmition, as per
 125  * encode_password().  See that function for their
 126  * stupid method of doing it.
 127  *
 128  * Latest WinAIM:
 129  *   clientstring = "AOL Instant Messenger (SM), version 4.3.2188/WIN32"
 130  *   major2 = 0x0109
 131  *   major = 0x0400
 132  *   minor = 0x0003
 133  *   minor2 = 0x0000
 134  *   build = 0x088c
 135  *   unknown = 0x00000086
 136  *   lang = "en"
 137  *   country = "us"
 138  *   unknown4a = 0x01
 139  *
 140  * Latest WinAIM that libfaim can emulate without server-side buddylists:
 141  *   clientstring = "AOL Instant Messenger (SM), version 3.5.1670/WIN32"
 142  *   major2 = 0x0004
 143  *   major =  0x0003
 144  *   minor =  0x0005
 145  *   minor2 = 0x0000
 146  *   build =  0x0686
 147  *   unknown =0x0000002a
 148  *
 149  * Java AIM 1.1.19:
 150  *   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"
 151  *   major2 = 0x0001
 152  *   major  = 0x0001
 153  *   minor  = 0x0001
 154  *   minor2 = (not sent)
 155  *   build  = 0x0013
 156  *   unknown= (not sent)
 157  *
 158  * AIM for Linux 1.1.112:
 159  *   clientstring = "AOL Instant Messenger (SM)"
 160  *   major2 = 0x1d09
 161  *   major  = 0x0001
 162  *   minor  = 0x0001
 163  *   minor2 = 0x0001
 164  *   build  = 0x0070
 165  *   unknown= 0x0000008b
 166  *   serverstore = 0x01
 167  *
 168  */
 169 faim_export int aim_send_login (struct aim_session_t *sess,
 170                                 struct aim_conn_t *conn,
 171                                 char *sn, char *password,
 172                                 struct client_info_s *clientinfo,
 173                                 char *key)
 174 {
 175   int curbyte=0;
 176   struct command_tx_struct *newpacket;
 177
 178   if (!clientinfo || !sn || !password)
 179     return -1;
 180
 181   if (!(newpacket = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 1152)))
 182     return -1;
 183
 184   newpacket->lock = 1;
 185
 186   newpacket->hdr.oscar.type = (sess->flags & AIM_SESS_FLAGS_SNACLOGIN)?0x02:0x01;
 187
 188   if (sess->flags & AIM_SESS_FLAGS_SNACLOGIN)
 189     curbyte = aim_putsnac(newpacket->data, 0x0017, 0x0002, 0x0000, 0x00010000);
 190   else {
 191     curbyte  = aimutil_put16(newpacket->data, 0x0000);
 192     curbyte += aimutil_put16(newpacket->data+curbyte, 0x0001);
 193   }
 194
 195   curbyte += aim_puttlv_str(newpacket->data+curbyte, 0x0001, strlen(sn), sn);
 196
 197   if (sess->flags & AIM_SESS_FLAGS_SNACLOGIN) {
 198     unsigned char digest[16];
 199
 200     aim_encode_password_md5(password, key, digest);
 201     curbyte+= aim_puttlv_str(newpacket->data+curbyte, 0x0025, 16, (char *)digest);
 202   } else {
 203     char *password_encoded;
 204
 205     password_encoded = (char *) malloc(strlen(password));
 206     aim_encode_password(password, password_encoded);
 207     curbyte += aim_puttlv_str(newpacket->data+curbyte, 0x0002, strlen(password), password_encoded);
 208     free(password_encoded);
 209   }
 210
 211   curbyte += aim_puttlv_str(newpacket->data+curbyte, 0x0003, strlen(clientinfo->clientstring), clientinfo->clientstring);
 212
 213   if (sess->flags & AIM_SESS_FLAGS_SNACLOGIN) {
 214
 215     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0016, (unsigned short)clientinfo->major2);
 216     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0017, (unsigned short)clientinfo->major);
 217     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0018, (unsigned short)clientinfo->minor);
 218     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0019, (unsigned short)clientinfo->minor2);
 219     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x001a, (unsigned short)clientinfo->build);
 220
 221   } else {
 222     /* Use very specific version numbers, to further indicate the hack. */
 223     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0016, 0x010a);
 224     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0017, 0x0004);
 225     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0018, 0x003c);
 226     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0019, 0x0001);
 227     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x001a, 0x0cce);
 228     curbyte += aim_puttlv_32(newpacket->data+curbyte, 0x0014, 0x00000055);
 229   }
 230
 231   curbyte += aim_puttlv_str(newpacket->data+curbyte, 0x000e, strlen(clientinfo->country), clientinfo->country);
 232   curbyte += aim_puttlv_str(newpacket->data+curbyte, 0x000f, strlen(clientinfo->lang), clientinfo->lang);
 233
 234   if (sess->flags & AIM_SESS_FLAGS_SNACLOGIN) {
 235     curbyte += aim_puttlv_32(newpacket->data+curbyte, 0x0014, clientinfo->unknown);
 236     curbyte += aim_puttlv_16(newpacket->data+curbyte, 0x0009, 0x0015);
 237   }
 238
 239   newpacket->commandlen = curbyte;
 240
 241   newpacket->lock = 0;
 242   return aim_tx_enqueue(sess, newpacket);
 243 }
 244
 245 faim_export int aim_encode_password_md5(const char *password, const char *key, unsigned char *digest)
 246 {
 247   md5_state_t state;
 248
 249   md5_init(&state);
 250   md5_append(&state, (const md5_byte_t *)key, strlen(key));
 251   md5_append(&state, (const md5_byte_t *)password, strlen(password));
 252   md5_append(&state, (const md5_byte_t *)AIM_MD5_STRING, strlen(AIM_MD5_STRING));
 253   md5_finish(&state, (md5_byte_t *)digest);
 254
 255   return 0;
 256 }
 257
 258 /**
 259  * aim_encode_password - Encode a password using old XOR method
 260  * @password: incoming password
 261  * @encoded: buffer to put encoded password
 262  *
 263  * This takes a const pointer to a (null terminated) string
 264  * containing the unencoded password.  It also gets passed
 265  * an already allocated buffer to store the encoded password.
 266  * This buffer should be the exact length of the password without
 267  * the null.  The encoded password buffer /is not %NULL terminated/.
 268  *
 269  * The encoding_table seems to be a fixed set of values.  We'll
 270  * hope it doesn't change over time!
 271  *
 272  * This is only used for the XOR method, not the better MD5 method.
 273  *
 274  */
 275 static int aim_encode_password(const char *password, unsigned char *encoded)
 276 {
 277   u_char encoding_table[] = {
 278 #if 0 /* old v1 table */
 279     0xf3, 0xb3, 0x6c, 0x99,
 280     0x95, 0x3f, 0xac, 0xb6,
 281     0xc5, 0xfa, 0x6b, 0x63,
 282     0x69, 0x6c, 0xc3, 0x9f
 283 #else /* v2.1 table, also works for ICQ */
 284     0xf3, 0x26, 0x81, 0xc4,
 285     0x39, 0x86, 0xdb, 0x92,
 286     0x71, 0xa3, 0xb9, 0xe6,
 287     0x53, 0x7a, 0x95, 0x7c
 288 #endif
 289   };
 290
 291   int i;
 292
 293   for (i = 0; i < strlen(password); i++)
 294       encoded[i] = (password[i] ^ encoding_table[i]);
 295
 296   return 0;
 297 }
 298
 299 /*
 300  * Generate an authorization response.
 301  *
 302  * You probably don't want this unless you're writing an AIM server.
 303  *
 304  */
 305 faim_export unsigned long aim_sendauthresp(struct aim_session_t *sess,
 306                                            struct aim_conn_t *conn,
 307                                            char *sn, int errorcode,
 308                                            char *errorurl, char *bosip,
 309                                            char *cookie, char *email,
 310                                            int regstatus)
 311 {
 312   struct command_tx_struct *tx;
 313   struct aim_tlvlist_t *tlvlist = NULL;
 314
 315   if (!(tx = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0004, 1152)))
 316     return -1;
 317
 318   tx->lock = 1;
 319
 320   if (sn)
 321     aim_addtlvtochain_str(&tlvlist, 0x0001, sn, strlen(sn));
 322   else
 323     aim_addtlvtochain_str(&tlvlist, 0x0001, sess->sn, strlen(sess->sn));
 324
 325   if (errorcode) {
 326     aim_addtlvtochain16(&tlvlist, 0x0008, errorcode);
 327     aim_addtlvtochain_str(&tlvlist, 0x0004, errorurl, strlen(errorurl));
 328   } else {
 329     aim_addtlvtochain_str(&tlvlist, 0x0005, bosip, strlen(bosip));
 330     aim_addtlvtochain_str(&tlvlist, 0x0006, cookie, AIM_COOKIELEN);
 331     aim_addtlvtochain_str(&tlvlist, 0x0011, email, strlen(email));
 332     aim_addtlvtochain16(&tlvlist, 0x0013, (unsigned short)regstatus);
 333   }
 334
 335   tx->commandlen = aim_writetlvchain(tx->data, tx->commandlen, &tlvlist);
 336   tx->lock = 0;
 337
 338   return aim_tx_enqueue(sess, tx);
 339 }
 340
 341 /*
 342  * Generate a random cookie.  (Non-client use only)
 343  */
 344 faim_export int aim_gencookie(unsigned char *buf)
 345 {
 346   int i;
 347
 348   srand(time(NULL));
 349
 350   for (i=0; i < AIM_COOKIELEN; i++)
 351     buf[i] = 1+(int) (256.0*rand()/(RAND_MAX+0.0));
 352
 353   return i;
 354 }
 355
 356 /*
 357  * Send Server Ready.  (Non-client)
 358  */
 359 faim_export int aim_sendserverready(struct aim_session_t *sess, struct aim_conn_t *conn)
 360 {
 361   struct command_tx_struct *tx;
 362   int i = 0;
 363
 364   if (!(tx = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 10+0x22)))
 365     return -1;
 366
 367   tx->lock = 1;
 368
 369   i += aim_putsnac(tx->data, 0x0001, 0x0003, 0x0000, sess->snac_nextid++);
 370
 371   i += aimutil_put16(tx->data+i, 0x0001);
 372   i += aimutil_put16(tx->data+i, 0x0002);
 373   i += aimutil_put16(tx->data+i, 0x0003);
 374   i += aimutil_put16(tx->data+i, 0x0004);
 375   i += aimutil_put16(tx->data+i, 0x0006);
 376   i += aimutil_put16(tx->data+i, 0x0008);
 377   i += aimutil_put16(tx->data+i, 0x0009);
 378   i += aimutil_put16(tx->data+i, 0x000a);
 379   i += aimutil_put16(tx->data+i, 0x000b);
 380   i += aimutil_put16(tx->data+i, 0x000c);
 381   i += aimutil_put16(tx->data+i, 0x0013);
 382   i += aimutil_put16(tx->data+i, 0x0015);
 383
 384   tx->commandlen = i;
 385   tx->lock = 0;
 386   return aim_tx_enqueue(sess, tx);
 387 }
 388
 389
 390 /*
 391  * Send service redirect.  (Non-Client)
 392  */
 393 faim_export unsigned long aim_sendredirect(struct aim_session_t *sess,
 394                                            struct aim_conn_t *conn,
 395                                            unsigned short servid,
 396                                            char *ip,
 397                                            char *cookie)
 398 {
 399   struct command_tx_struct *tx;
 400   struct aim_tlvlist_t *tlvlist = NULL;
 401   int i = 0;
 402
 403   if (!(tx = aim_tx_new(sess, conn, AIM_FRAMETYPE_OSCAR, 0x0002, 1152)))
 404     return -1;
 405
 406   tx->lock = 1;
 407
 408   i += aim_putsnac(tx->data+i, 0x0001, 0x0005, 0x0000, 0x00000000);
 409
 410   aim_addtlvtochain16(&tlvlist, 0x000d, servid);
 411   aim_addtlvtochain_str(&tlvlist, 0x0005, ip, strlen(ip));
 412   aim_addtlvtochain_str(&tlvlist, 0x0006, cookie, AIM_COOKIELEN);
 413
 414   tx->commandlen = aim_writetlvchain(tx->data+i, tx->commandlen-i, &tlvlist)+i;
 415   aim_freetlvchain(&tlvlist);
 416
 417   tx->lock = 0;
 418   return aim_tx_enqueue(sess, tx);
 419 }
 420
 421
 422 static int hostonline(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 423 {
 424   rxcallback_t userfunc;
 425   int ret = 0;
 426   unsigned short *families;
 427   int famcount, i;
 428
 429   famcount = datalen/2;
 430
 431   if (!(families = malloc(datalen)))
 432     return 0;
 433
 434   for (i = 0; i < famcount; i++)
 435     families[i] = aimutil_get16(data+(i*2));
 436
 437   if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 438     ret = userfunc(sess, rx, famcount, families);
 439
 440   free(families);
 441
 442   return ret;
 443 }
 444
 445 static int redirect(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 446 {
 447   int serviceid;
 448   unsigned char *cookie;
 449   char *ip;
 450   rxcallback_t userfunc;
 451   struct aim_tlvlist_t *tlvlist;
 452   char *chathack = NULL;
 453   int chathackex = 0;
 454   int ret = 0;
 455
 456   tlvlist = aim_readtlvchain(data, datalen);
 457
 458   if (!aim_gettlv(tlvlist, 0x000d, 1) ||
 459       !aim_gettlv(tlvlist, 0x0005, 1) ||
 460       !aim_gettlv(tlvlist, 0x0006, 1)) {
 461     aim_freetlvchain(&tlvlist);
 462     return 0;
 463   }
 464
 465   serviceid = aim_gettlv16(tlvlist, 0x000d, 1);
 466   ip = aim_gettlv_str(tlvlist, 0x0005, 1);
 467   cookie = aim_gettlv_str(tlvlist, 0x0006, 1);
 468
 469   /*
 470    * Chat hack.
 471    *
 472    */
 473   if ((serviceid == AIM_CONN_TYPE_CHAT) && sess->pendingjoin) {
 474     chathack = sess->pendingjoin;
 475     chathackex = sess->pendingjoinexchange;
 476     sess->pendingjoin = NULL;
 477     sess->pendingjoinexchange = 0;
 478   }
 479
 480   if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 481     ret = userfunc(sess, rx, serviceid, ip, cookie, chathack, chathackex);
 482
 483   free(ip);
 484   free(cookie);
 485   free(chathack);
 486
 487   aim_freetlvchain(&tlvlist);
 488
 489   return ret;
 490 }
 491
 492 /*
 493  * The Rate Limiting System, An Abridged Guide to Nonsense.
 494  *
 495  * OSCAR defines several 'rate classes'.  Each class has seperate
 496  * rate limiting properties (limit level, alert level, disconnect
 497  * level, etc), and a set of SNAC family/type pairs associated with
 498  * it.  The rate classes, their limiting properties, and the definitions
 499  * of which SNACs are belong to which class, are defined in the
 500  * Rate Response packet at login to each host.
 501  *
 502  * Logically, all rate offenses within one class count against further
 503  * offenses for other SNACs in the same class (ie, sending messages
 504  * too fast will limit the number of user info requests you can send,
 505  * since those two SNACs are in the same rate class).
 506  *
 507  * Since the rate classes are defined dynamically at login, the values
 508  * below may change. But they seem to be fairly constant.
 509  *
 510  * Currently, BOS defines five rate classes, with the commonly used
 511  * members as follows...
 512  *
 513  *  Rate class 0x0001:
 514  *      - Everything thats not in any of the other classes
 515  *
 516  *  Rate class 0x0002:
 517  *      - Buddy list add/remove
 518  *      - Permit list add/remove
 519  *      - Deny list add/remove
 520  *
 521  *  Rate class 0x0003:
 522  *      - User information requests
 523  *      - Outgoing ICBMs
 524  *
 525  *  Rate class 0x0004:
 526  *      - A few unknowns: 2/9, 2/b, and f/2
 527  *
 528  *  Rate class 0x0005:
 529  *      - Chat room create
 530  *      - Outgoing chat ICBMs
 531  *
 532  * The only other thing of note is that class 5 (chat) has slightly looser
 533  * limiting properties than class 3 (normal messages).  But thats just a
 534  * small bit of trivia for you.
 535  *
 536  * The last thing that needs to be learned about the rate limiting
 537  * system is how the actual numbers relate to the passing of time.  This
 538  * seems to be a big mystery.
 539  *
 540  */
 541
 542 /* XXX parse this */
 543 static int rateresp(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 544 {
 545   rxcallback_t userfunc;
 546
 547   if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 548     return userfunc(sess, rx);
 549
 550   return 0;
 551 }
 552
 553 static int ratechange(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 554 {
 555   rxcallback_t userfunc;
 556   int i = 0, code;
 557   unsigned long currentavg, maxavg;
 558   unsigned long rateclass, windowsize, clear, alert, limit, disconnect;
 559
 560   code = aimutil_get16(data+i);
 561   i += 2;
 562
 563   rateclass = aimutil_get16(data+i);
 564   i += 2;
 565
 566   windowsize = aimutil_get32(data+i);
 567   i += 4;
 568   clear = aimutil_get32(data+i);
 569   i += 4;
 570   alert = aimutil_get32(data+i);
 571   i += 4;
 572   limit = aimutil_get32(data+i);
 573   i += 4;
 574   disconnect = aimutil_get32(data+i);
 575   i += 4;
 576   currentavg = aimutil_get32(data+i);
 577   i += 4;
 578   maxavg = aimutil_get32(data+i);
 579   i += 4;
 580
 581   if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 582     return userfunc(sess, rx, code, rateclass, windowsize, clear, alert, limit, disconnect, currentavg, maxavg);
 583
 584   return 0;
 585 }
 586
 587 /* XXX parse this */
 588 static int selfinfo(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 589 {
 590   rxcallback_t userfunc;
 591
 592   if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 593     return userfunc(sess, rx);
 594
 595   return 0;
 596 }
 597
 598 static int evilnotify(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 599 {
 600   rxcallback_t userfunc = NULL;
 601   int i = 0;
 602   unsigned short newevil;
 603   struct aim_userinfo_s userinfo;
 604
 605   newevil = aimutil_get16(data);
 606   i += 2;
 607
 608   memset(&userinfo, 0, sizeof(struct aim_userinfo_s));
 609
 610   if (datalen-i)
 611     i += aim_extractuserinfo(sess, data+i, &userinfo);
 612
 613   if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 614     return userfunc(sess, rx, newevil, &userinfo);
 615
 616   return 0;
 617 }
 618
 619 static int motd(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 620 {
 621   rxcallback_t userfunc;
 622   char *msg = NULL;
 623   int ret = 0;
 624   struct aim_tlvlist_t *tlvlist;
 625   unsigned short id;
 626
 627   /*
 628    * Code.
 629    *
 630    * Valid values:
 631    *   1 Mandatory upgrade
 632    *   2 Advisory upgrade
 633    *   3 System bulletin
 634    *   4 Nothing's wrong ("top o the world" -- normal)
 635    *
 636    */
 637   id = aimutil_get16(data);
 638
 639   /*
 640    * TLVs follow
 641    */
 642   if ((tlvlist = aim_readtlvchain(data+2, datalen-2)))
 643     msg = aim_gettlv_str(tlvlist, 0x000b, 1);
 644
 645   if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 646     ret =  userfunc(sess, rx, id, msg);
 647
 648   free(msg);
 649
 650   aim_freetlvchain(&tlvlist);
 651
 652   return ret;
 653 }
 654
 655 static int hostversions(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 656 {
 657   rxcallback_t userfunc;
 658   int vercount;
 659
 660   vercount = datalen/4;
 661
 662   if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
 663     return userfunc(sess, rx, vercount, data);
 664
 665   return 0;
 666 }
 667 /*
 668  * Stay tuned.  I have an explanation for here.
 669  *
 670  *
 671  */
 672 static int memrequest(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 673 {
 674   return 1;
 675 }
 676
 677 static int snachandler(struct aim_session_t *sess, aim_module_t *mod, struct command_rx_struct *rx, aim_modsnac_t *snac, unsigned char *data, int datalen)
 678 {
 679
 680   if (snac->subtype == 0x0003)
 681     return hostonline(sess, mod, rx, snac, data, datalen);
 682   else if (snac->subtype == 0x0005)
 683     return redirect(sess, mod, rx, snac, data, datalen);
 684   else if (snac->subtype == 0x0007)
 685     return rateresp(sess, mod, rx, snac, data, datalen);
 686   else if (snac->subtype == 0x000a)
 687     return ratechange(sess, mod, rx, snac, data, datalen);
 688   else if (snac->subtype == 0x000f)
 689     return selfinfo(sess, mod, rx, snac, data, datalen);
 690   else if (snac->subtype == 0x0010)
 691     return evilnotify(sess, mod, rx, snac, data, datalen);
 692   else if (snac->subtype == 0x0013)
 693     return motd(sess, mod, rx, snac, data, datalen);
 694   else if (snac->subtype == 0x0018)
 695     return hostversions(sess, mod, rx, snac, data, datalen);
 696   else if (snac->subtype == 0x001f)
 697     return memrequest(sess, mod, rx, snac, data, datalen);
 698
 699   return 0;
 700 }
 701
 702 faim_internal int general_modfirst(struct aim_session_t *sess, aim_module_t *mod)
 703 {
 704
 705   mod->family = 0x0001;
 706   mod->version = 0x0000;
 707   mod->flags = 0;
 708   strncpy(mod->name, "general", sizeof(mod->name));
 709   mod->snachandler = snachandler;
 710
 711   return 0;
 712 }