aim_rxhandlers.c

   1 /*
   2  * aim_rxhandlers.c
   3  *
   4  * This file contains most all of the incoming packet handlers, along
   5  * with aim_rxdispatch(), the Rx dispatcher.  Queue/list management is
   6  * actually done in aim_rxqueue.c.
   7  *
   8  */
   9
  10 #include <faim/aim.h>
  11
  12 /*
  13  * Bleck functions get called when there's no non-bleck functions
  14  * around to cleanup the mess...
  15  */
  16 faim_internal int bleck(struct aim_session_t *sess,struct command_rx_struct *workingPtr, ...)
  17 {
  18   u_short family;
  19   u_short subtype;
  20
  21   u_short maxf;
  22   u_short maxs;
  23
  24   /* XXX: this is ugly. and big just for debugging. */
  25   char *literals[14][25] = {
  26     {"Invalid",
  27      NULL
  28     },
  29     {"General",
  30      "Invalid",
  31      "Error",
  32      "Client Ready",
  33      "Server Ready",
  34      "Service Request",
  35      "Redirect",
  36      "Rate Information Request",
  37      "Rate Information",
  38      "Rate Information Ack",
  39      NULL,
  40      "Rate Information Change",
  41      "Server Pause",
  42      NULL,
  43      "Server Resume",
  44      "Request Personal User Information",
  45      "Personal User Information",
  46      "Evil Notification",
  47      NULL,
  48      "Migration notice",
  49      "Message of the Day",
  50      "Set Privacy Flags",
  51      "Well Known URL",
  52      "NOP"
  53     },
  54     {"Location",
  55       "Invalid",
  56       "Error",
  57       "Request Rights",
  58       "Rights Information",
  59       "Set user information",
  60       "Request User Information",
  61       "User Information",
  62       "Watcher Sub Request",
  63       "Watcher Notification"
  64     },
  65     {"Buddy List Management",
  66       "Invalid",
  67       "Error",
  68       "Request Rights",
  69       "Rights Information",
  70       "Add Buddy",
  71       "Remove Buddy",
  72       "Watcher List Query",
  73       "Watcher List Response",
  74       "Watcher SubRequest",
  75       "Watcher Notification",
  76       "Reject Notification",
  77       "Oncoming Buddy",
  78       "Offgoing Buddy"
  79     },
  80     {"Messeging",
  81       "Invalid",
  82       "Error",
  83       "Add ICBM Parameter",
  84       "Remove ICBM Parameter",
  85       "Request Parameter Information",
  86       "Parameter Information",
  87       "Outgoing Message",
  88       "Incoming Message",
  89       "Evil Request",
  90       "Evil Reply",
  91       "Missed Calls",
  92       "Message Error",
  93       "Host Ack"
  94     },
  95     {"Advertisements",
  96       "Invalid",
  97       "Error",
  98       "Request Ad",
  99       "Ad Data (GIFs)"
 100     },
 101     {"Invitation / Client-to-Client",
 102      "Invalid",
 103      "Error",
 104      "Invite a Friend",
 105      "Invitation Ack"
 106     },
 107     {"Administrative",
 108       "Invalid",
 109       "Error",
 110       "Information Request",
 111       "Information Reply",
 112       "Information Change Request",
 113       "Information Chat Reply",
 114       "Account Confirm Request",
 115       "Account Confirm Reply",
 116       "Account Delete Request",
 117       "Account Delete Reply"
 118     },
 119     {"Popups",
 120       "Invalid",
 121       "Error",
 122       "Display Popup"
 123     },
 124     {"BOS",
 125       "Invalid",
 126       "Error",
 127       "Request Rights",
 128       "Rights Response",
 129       "Set group permission mask",
 130       "Add permission list entries",
 131       "Delete permission list entries",
 132       "Add deny list entries",
 133       "Delete deny list entries",
 134       "Server Error"
 135     },
 136     {"User Lookup",
 137       "Invalid",
 138       "Error",
 139       "Search Request",
 140       "Search Response"
 141     },
 142     {"Stats",
 143       "Invalid",
 144       "Error",
 145       "Set minimum report interval",
 146       "Report Events"
 147     },
 148     {"Translate",
 149       "Invalid",
 150       "Error",
 151       "Translate Request",
 152       "Translate Reply",
 153     },
 154     {"Chat Navigation",
 155       "Invalid",
 156       "Error",
 157       "Request rights",
 158       "Request Exchange Information",
 159       "Request Room Information",
 160       "Request Occupant List",
 161       "Search for Room",
 162       "Outgoing Message",
 163       "Incoming Message",
 164       "Evil Request",
 165       "Evil Reply",
 166       "Chat Error",
 167     }
 168   };
 169
 170   maxf = sizeof(literals) / sizeof(literals[0]);
 171   maxs = sizeof(literals[0]) / sizeof(literals[0][0]);
 172
 173   family = aimutil_get16(workingPtr->data+0);
 174   subtype= aimutil_get16(workingPtr->data+2);
 175
 176   if((family < maxf) && (subtype+1 < maxs) && (literals[family][subtype] != NULL))
 177     printf("bleck: null handler for %04x/%04x (%s)\n", family, subtype, literals[family][subtype+1]);
 178   else
 179     printf("bleck: null handler for %04x/%04x (no literal)\n",family,subtype);
 180
 181   return 1;
 182 }
 183
 184 faim_export int aim_conn_addhandler(struct aim_session_t *sess,
 185                         struct aim_conn_t *conn,
 186                         u_short family,
 187                         u_short type,
 188                         rxcallback_t newhandler,
 189                         u_short flags)
 190 {
 191   struct aim_rxcblist_t *newcb;
 192
 193   if (!conn)
 194     return -1;
 195
 196   faimdprintf(1, "aim_conn_addhandler: adding for %04x/%04x\n", family, type);
 197
 198   if (!(newcb = (struct aim_rxcblist_t *)calloc(1, sizeof(struct aim_rxcblist_t))))
 199     return -1;
 200   newcb->family = family;
 201   newcb->type = type;
 202   newcb->flags = flags;
 203   if (!newhandler)
 204     newcb->handler = &bleck;
 205   else
 206     newcb->handler = newhandler;
 207   newcb->next = NULL;
 208
 209   if (!conn->handlerlist)
 210     conn->handlerlist = newcb;
 211   else {
 212     struct aim_rxcblist_t *cur;
 213
 214     cur = conn->handlerlist;
 215
 216     while (cur->next)
 217       cur = cur->next;
 218     cur->next = newcb;
 219   }
 220
 221   return 0;
 222 }
 223
 224 faim_export int aim_clearhandlers(struct aim_conn_t *conn)
 225 {
 226  struct aim_rxcblist_t *cur;
 227
 228  if (!conn)
 229    return -1;
 230
 231  for (cur = conn->handlerlist; cur; ) {
 232    struct aim_rxcblist_t *tmp;
 233
 234    tmp = cur->next;
 235    free(cur);
 236    cur = tmp;
 237  }
 238  conn->handlerlist = NULL;
 239
 240  return 0;
 241 }
 242
 243 faim_internal rxcallback_t aim_callhandler(struct aim_conn_t *conn,
 244                                          u_short family,
 245                                          u_short type)
 246 {
 247   struct aim_rxcblist_t *cur;
 248
 249   if (!conn)
 250     return NULL;
 251
 252   faimdprintf(1, "aim_callhandler: calling for %04x/%04x\n", family, type);
 253
 254   cur = conn->handlerlist;
 255   while(cur)
 256     {
 257       if ( (cur->family == family) && (cur->type == type) )
 258         return cur->handler;
 259       cur = cur->next;
 260     }
 261
 262   if (type==0xffff)
 263     return NULL;
 264
 265   return aim_callhandler(conn, family, 0xffff);
 266 }
 267
 268 faim_internal int aim_callhandler_noparam(struct aim_session_t *sess,
 269                                           struct aim_conn_t *conn,
 270                                           u_short family,
 271                                           u_short type,
 272                                           struct command_rx_struct *ptr)
 273 {
 274   rxcallback_t userfunc = NULL;
 275   userfunc = aim_callhandler(conn, family, type);
 276   if (userfunc)
 277     return userfunc(sess, ptr);
 278   return 1; /* XXX */
 279 }
 280
 281 /*
 282   aim_rxdispatch()
 283
 284   Basically, heres what this should do:
 285     1) Determine correct packet handler for this packet
 286     2) Mark the packet handled (so it can be dequeued in purge_queue())
 287     3) Send the packet to the packet handler
 288     4) Go to next packet in the queue and start over
 289     5) When done, run purge_queue() to purge handled commands
 290
 291   Note that any unhandlable packets should probably be left in the
 292   queue.  This is the best way to prevent data loss.  This means
 293   that a single packet may get looked at by this function multiple
 294   times.  This is more good than bad!  This behavior may change.
 295
 296   Aren't queue's fun?
 297
 298   TODO: Get rid of all the ugly if's.
 299   TODO: Clean up.
 300   TODO: More support for mid-level handlers.
 301   TODO: Allow for NULL handlers.
 302
 303  */
 304 faim_export int aim_rxdispatch(struct aim_session_t *sess)
 305 {
 306   int i = 0;
 307   struct command_rx_struct *workingPtr = NULL;
 308
 309   if (sess->queue_incoming == NULL) {
 310     faimdprintf(1, "parse_generic: incoming packet queue empty.\n");
 311     return 0;
 312   } else {
 313     workingPtr = sess->queue_incoming;
 314     for (i = 0; workingPtr != NULL; workingPtr = workingPtr->next, i++) {
 315       /*
 316        * XXX: This is still fairly ugly.
 317        */
 318       if (workingPtr->handled)
 319         continue;
 320
 321       /*
 322        * This is a debugging/sanity check only and probably could/should be removed
 323        * for stable code.
 324        */
 325       if (((workingPtr->hdrtype == AIM_FRAMETYPE_OFT) &&
 326            (workingPtr->conn->type != AIM_CONN_TYPE_RENDEZVOUS)) ||
 327           ((workingPtr->hdrtype == AIM_FRAMETYPE_OSCAR) &&
 328            (workingPtr->conn->type == AIM_CONN_TYPE_RENDEZVOUS))) {
 329         printf("faim: rxhandlers: incompatible frame type %d on connection type 0x%04x\n", workingPtr->hdrtype, workingPtr->conn->type);
 330         workingPtr->handled = 1;
 331         continue;
 332       }
 333
 334       switch(workingPtr->conn->type) {
 335       case -1:
 336         /*
 337          * This can happen if we have a queued command
 338          * that was recieved after a connection has
 339          * been terminated.  In which case, the handler
 340          * list has been cleared, and there's nothing we
 341          * can do for it.  We can only cancel it.
 342          */
 343         workingPtr->handled = 1;
 344         break;
 345       case AIM_CONN_TYPE_AUTH: {
 346         unsigned long head;
 347
 348         head = aimutil_get32(workingPtr->data);
 349         if ((head == 0x00000001) && (workingPtr->commandlen == 4)) {
 350           faimdprintf(1, "got connection ack on auth line\n");
 351           workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_FLAPVER, workingPtr);
 352         } else if (workingPtr->hdr.oscar.type == 0x04) {
 353           /* Used only by the older login protocol */
 354           workingPtr->handled = aim_authparse(sess, workingPtr);
 355         } else {
 356           unsigned short family,subtype;
 357
 358           family = aimutil_get16(workingPtr->data);
 359           subtype = aimutil_get16(workingPtr->data+2);
 360
 361           switch (family) {
 362             /* New login protocol */
 363           case 0x0017:
 364             if (subtype == 0x0001)
 365               workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0017, 0x0001, workingPtr);
 366             else if (subtype == 0x0003)
 367               workingPtr->handled = aim_authparse(sess, workingPtr);
 368             else if (subtype == 0x0007)
 369               workingPtr->handled = aim_authkeyparse(sess, workingPtr);
 370             else
 371               workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0017, 0xffff, workingPtr);
 372             break;
 373           case 0x0001:
 374             if (subtype == 0x0003)
 375               workingPtr->handled = aim_parse_hostonline(sess, workingPtr);
 376             else
 377               workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0017, 0xffff, workingPtr);
 378             break;
 379           case 0x0007:
 380             if (subtype == 0x0005)
 381               workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_ADM, AIM_CB_ADM_INFOCHANGE_REPLY, workingPtr);
 382             break;
 383           case AIM_CB_FAM_SPECIAL:
 384             if (subtype == AIM_CB_SPECIAL_DEBUGCONN_CONNECT) {
 385               workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, family, subtype, workingPtr);
 386               break;
 387             } else
 388               workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0017, 0xffff, workingPtr);
 389             break;
 390           default:
 391             break;
 392           }
 393         }
 394         break;
 395       }
 396       case AIM_CONN_TYPE_BOS: {
 397         u_short family;
 398         u_short subtype;
 399
 400         if (workingPtr->hdr.oscar.type == 0x04) {
 401           workingPtr->handled = aim_negchan_middle(sess, workingPtr);
 402           break;
 403         }
 404
 405         family = aimutil_get16(workingPtr->data);
 406         subtype = aimutil_get16(workingPtr->data+2);
 407
 408         switch (family) {
 409         case 0x0000: /* not really a family, but it works */
 410           if (subtype == 0x0001)
 411             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_FLAPVER, workingPtr);
 412           else
 413             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, workingPtr);
 414           break;
 415         case 0x0001: /* Family: General */
 416           switch (subtype) {
 417           case 0x0001:
 418             workingPtr->handled = aim_parse_generalerrs(sess, workingPtr);
 419             break;
 420           case 0x0003:
 421             workingPtr->handled = aim_parse_hostonline(sess, workingPtr);
 422             break;
 423           case 0x0005:
 424             workingPtr->handled = aim_handleredirect_middle(sess, workingPtr);
 425             break;
 426           case 0x0007:
 427             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x0007, workingPtr);
 428             break;
 429           case 0x000a:
 430             workingPtr->handled = aim_parse_ratechange_middle(sess, workingPtr);
 431             break;
 432           case 0x000f:
 433             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x000f, workingPtr);
 434             break;
 435           case 0x0010:
 436             workingPtr->handled = aim_parse_evilnotify_middle(sess, workingPtr);
 437             break;
 438           case 0x0013:
 439             workingPtr->handled = aim_parsemotd_middle(sess, workingPtr);
 440             break;
 441           case 0x0018:
 442             workingPtr->handled = aim_parse_hostversions(sess, workingPtr);
 443             break;
 444           default:
 445             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_GEN, AIM_CB_GEN_DEFAULT, workingPtr);
 446             break;
 447           }
 448           break;
 449         case 0x0002: /* Family: Location */
 450           switch (subtype) {
 451           case 0x0001:
 452             workingPtr->handled = aim_parse_locateerr(sess, workingPtr);
 453             break;
 454           case 0x0003:
 455             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0002, 0x0003, workingPtr);
 456             break;
 457           case 0x0006:
 458             workingPtr->handled = aim_parse_userinfo_middle(sess, workingPtr);
 459             break;
 460           default:
 461             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_LOC, AIM_CB_LOC_DEFAULT, workingPtr);
 462             break;
 463           }
 464           break;
 465         case 0x0003: /* Family: Buddy List */
 466           switch (subtype) {
 467           case 0x0001:
 468             workingPtr->handled = aim_parse_generalerrs(sess, workingPtr);
 469             break;
 470           case 0x0003:
 471             workingPtr->handled = aim_parse_buddyrights(sess, workingPtr);
 472             break;
 473           case 0x000b: /* oncoming buddy */
 474             workingPtr->handled = aim_parse_oncoming_middle(sess, workingPtr);
 475             break;
 476           case 0x000c: /* offgoing buddy */
 477             workingPtr->handled = aim_parse_offgoing_middle(sess, workingPtr);
 478             break;
 479           default:
 480             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_BUD, AIM_CB_BUD_DEFAULT, workingPtr);
 481           }
 482           break;
 483         case 0x0004: /* Family: Messeging */
 484           switch (subtype) {
 485           case 0x0001:
 486             workingPtr->handled = aim_parse_msgerror_middle(sess, workingPtr);
 487             break;
 488           case 0x0005:
 489             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0004, 0x0005, workingPtr);
 490             break;
 491           case 0x0006:
 492             workingPtr->handled = aim_parse_outgoing_im_middle(sess, workingPtr);
 493             break;
 494           case 0x0007:
 495             workingPtr->handled = aim_parse_incoming_im_middle(sess, workingPtr);
 496             break;
 497           case 0x000a:
 498             workingPtr->handled = aim_parse_missedcall(sess, workingPtr);
 499             break;
 500           case 0x000c:
 501             workingPtr->handled = aim_parse_msgack_middle(sess, workingPtr);
 502             break;
 503           default:
 504             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_MSG, AIM_CB_MSG_DEFAULT, workingPtr);
 505           }
 506           break;
 507         case 0x0009:
 508           if (subtype == 0x0001)
 509             workingPtr->handled = aim_parse_generalerrs(sess, workingPtr);
 510           else if (subtype == 0x0003)
 511             workingPtr->handled = aim_parse_bosrights(sess, workingPtr);
 512           else
 513             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_BOS, AIM_CB_BOS_DEFAULT, workingPtr);
 514           break;
 515         case 0x000a:  /* Family: User lookup */
 516           switch (subtype) {
 517           case 0x0001:
 518             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x000a, 0x0001, workingPtr);
 519             break;
 520           case 0x0003:
 521             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x000a, 0x0003, workingPtr);
 522             break;
 523           default:
 524             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_LOK, AIM_CB_LOK_DEFAULT, workingPtr);
 525           }
 526           break;
 527         case 0x000b: {
 528           if (subtype == 0x0001)
 529             workingPtr->handled = aim_parse_generalerrs(sess, workingPtr);
 530           else if (subtype == 0x0002)
 531             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x000b, 0x0002, workingPtr);
 532           else
 533             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_STS, AIM_CB_STS_DEFAULT, workingPtr);
 534           break;
 535         }
 536         case AIM_CB_FAM_SPECIAL:
 537           workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, family, subtype, workingPtr);
 538           break;
 539         default:
 540           workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, workingPtr);
 541           break;
 542         } /* switch(family) */
 543         break;
 544       } /* AIM_CONN_TYPE_BOS */
 545       case AIM_CONN_TYPE_CHATNAV: {
 546         u_short family;
 547         u_short subtype;
 548         family = aimutil_get16(workingPtr->data);
 549         subtype= aimutil_get16(workingPtr->data+2);
 550
 551         if ((family == 0x0000) && (subtype == 0x00001)) {
 552           workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_FLAPVER, workingPtr);
 553         } else if ((family == 0x0001) && (subtype == 0x0003)) {
 554           workingPtr->handled = aim_parse_hostonline(sess, workingPtr);
 555         } else if ((family == 0x000d) && (subtype == 0x0009)) {
 556           workingPtr->handled = aim_chatnav_parse_info(sess, workingPtr);
 557         } else {
 558           workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, family, subtype, workingPtr);
 559         }
 560         break;
 561       }
 562       case AIM_CONN_TYPE_CHAT: {
 563         u_short family, subtype;
 564
 565         family = aimutil_get16(workingPtr->data);
 566         subtype= aimutil_get16(workingPtr->data+2);
 567
 568         if ((family == 0x0000) && (subtype == 0x00001)) {
 569           workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_FLAPVER, workingPtr);
 570         } else if (family == 0x0001) {
 571           if (subtype == 0x0001)
 572             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x0001, workingPtr);
 573           else if (subtype == 0x0003)
 574             workingPtr->handled = aim_parse_hostonline(sess, workingPtr);
 575           else if (subtype == 0x0007)
 576             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, 0x0001, 0x0007, workingPtr);
 577           else if (subtype == 0x000a)
 578             workingPtr->handled = aim_parse_ratechange_middle(sess, workingPtr);
 579           else
 580             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, family, subtype, workingPtr);
 581         } else if (family == 0x000e) {
 582           if (subtype == 0x0002)
 583             workingPtr->handled = aim_chat_parse_infoupdate(sess, workingPtr);
 584           else if (subtype == 0x0003)
 585             workingPtr->handled = aim_chat_parse_joined(sess, workingPtr);
 586           else if (subtype == 0x0004)
 587             workingPtr->handled = aim_chat_parse_leave(sess, workingPtr);
 588           else if (subtype == 0x0006)
 589             workingPtr->handled = aim_chat_parse_incoming(sess, workingPtr);
 590           else
 591             printf("Chat: unknown snac %04x/%04x\n", family, subtype);
 592         } else {
 593           printf("Chat: unknown snac %04x/%04x\n", family, subtype);
 594           workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_DEFAULT, workingPtr);
 595         }
 596         break;
 597       }
 598       case AIM_CONN_TYPE_RENDEZVOUS: {
 599         /* make sure that we only get OFT frames on these connections */
 600         if (workingPtr->hdrtype != AIM_FRAMETYPE_OFT) {
 601           printf("faim: internal error: non-OFT frames on OFT connection\n");
 602           workingPtr->handled = 1; /* get rid of it */
 603           break;
 604         }
 605
 606         /* XXX: implement this */
 607         printf("faim: OFT frame!\n");
 608
 609         break;
 610       }
 611       case AIM_CONN_TYPE_RENDEZVOUS_OUT: {
 612         /* not possible */
 613         break;
 614       }
 615       default:
 616         printf("\ninternal error: unknown connection type (very bad.) (type = %d, fd = %d, commandlen = %02x)\n\n", workingPtr->conn->type, workingPtr->conn->fd, workingPtr->commandlen);
 617         workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, workingPtr);
 618         break;
 619       }
 620     }
 621   }
 622
 623   /*
 624    * This doesn't have to be called here.  It could easily be done
 625    * by a seperate thread or something. It's an administrative operation,
 626    * and can take a while. Though the less you call it the less memory
 627    * you'll have :)
 628    */
 629   aim_purge_rxqueue(sess);
 630
 631   return 0;
 632 }
 633
 634 faim_internal int aim_parse_msgack_middle(struct aim_session_t *sess, struct command_rx_struct *command)
 635 {
 636   rxcallback_t userfunc = NULL;
 637   char sn[MAXSNLEN];
 638   unsigned short type;
 639   int i = 10+8; /* skip SNAC and cookie */
 640   int ret = 1;
 641   unsigned char snlen;
 642
 643   type = aimutil_get16(command->data+i);
 644   i += 2;
 645
 646   snlen = aimutil_get8(command->data+i);
 647   i++;
 648
 649   memset(sn, 0, sizeof(sn));
 650   strncpy(sn, (char *)command->data+i, snlen);
 651
 652   if ((userfunc = aim_callhandler(command->conn, 0x0004, 0x000c)))
 653     ret =  userfunc(sess, command, type, sn);
 654
 655   return ret;
 656 }
 657
 658 faim_internal int aim_parse_ratechange_middle(struct aim_session_t *sess, struct command_rx_struct *command)
 659 {
 660   rxcallback_t userfunc = NULL;
 661   int ret = 1;
 662   int i;
 663   int code;
 664   unsigned long parmid, windowsize, clear, alert, limit, disconnect;
 665   unsigned long currentavg, maxavg;
 666
 667   i = 10;
 668
 669   code = aimutil_get16(command->data+i);
 670   i += 2;
 671
 672   parmid = aimutil_get16(command->data+i);
 673   i += 2;
 674
 675   windowsize = aimutil_get32(command->data+i);
 676   i += 4;
 677   clear = aimutil_get32(command->data+i);
 678   i += 4;
 679   alert = aimutil_get32(command->data+i);
 680   i += 4;
 681   limit = aimutil_get32(command->data+i);
 682   i += 4;
 683   disconnect = aimutil_get32(command->data+i);
 684   i += 4;
 685   currentavg = aimutil_get32(command->data+i);
 686   i += 4;
 687   maxavg = aimutil_get32(command->data+i);
 688   i += 4;
 689
 690   if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x000a)))
 691     ret =  userfunc(sess, command, code, parmid, windowsize, clear, alert, limit, disconnect, currentavg, maxavg);
 692
 693   return ret;
 694 }
 695
 696 faim_internal int aim_parse_evilnotify_middle(struct aim_session_t *sess, struct command_rx_struct *command)
 697 {
 698   rxcallback_t userfunc = NULL;
 699   int ret = 1, pos;
 700   char *sn = NULL;
 701
 702   if(command->commandlen < 12) /* a warning level dec sends this */
 703     return 1;
 704
 705   if ((pos = aimutil_get8(command->data+ 12)) > MAXSNLEN)
 706     return 1;
 707
 708   if(!(sn = (char *)calloc(1, pos+1)))
 709     return 1;
 710
 711   memcpy(sn, command->data+13, pos);
 712
 713   if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0010)))
 714     ret = userfunc(sess, command, sn);
 715
 716   free(sn);
 717
 718   return ret;
 719 }
 720
 721 faim_internal int aim_parsemotd_middle(struct aim_session_t *sess,
 722                                        struct command_rx_struct *command, ...)
 723 {
 724   rxcallback_t userfunc = NULL;
 725   char *msg;
 726   int ret=1;
 727   struct aim_tlvlist_t *tlvlist;
 728   u_short id;
 729
 730   /*
 731    * Code.
 732    *
 733    * Valid values:
 734    *   1 Mandatory upgrade
 735    *   2 Advisory upgrade
 736    *   3 System bulletin
 737    *   4 Nothing's wrong ("top o the world" -- normal)
 738    *
 739    */
 740   id = aimutil_get16(command->data+10);
 741
 742   /*
 743    * TLVs follow
 744    */
 745   if (!(tlvlist = aim_readtlvchain(command->data+12, command->commandlen-12)))
 746     return ret;
 747
 748   if (!(msg = aim_gettlv_str(tlvlist, 0x000b, 1))) {
 749     aim_freetlvchain(&tlvlist);
 750     return ret;
 751   }
 752
 753   userfunc = aim_callhandler(command->conn, 0x0001, 0x0013);
 754   if (userfunc)
 755     ret =  userfunc(sess, command, id, msg);
 756
 757   aim_freetlvchain(&tlvlist);
 758   free(msg);
 759
 760   return ret;
 761 }
 762
 763 faim_internal int aim_parse_hostonline(struct aim_session_t *sess,
 764                                        struct command_rx_struct *command, ...)
 765 {
 766   rxcallback_t userfunc = NULL;
 767   int ret = 1;
 768   unsigned short *families = NULL;
 769   int famcount = 0, i;
 770
 771   famcount = (command->commandlen-10)/2;
 772   if (!(families = malloc(command->commandlen-10)))
 773     return ret;
 774
 775   for (i = 0; i < famcount; i++)
 776     families[i] = aimutil_get16(command->data+((i*2)+10));
 777
 778   if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0003)))
 779     ret = userfunc(sess, command, famcount, families);
 780
 781   free(families);
 782
 783   return ret;
 784 }
 785
 786 faim_internal int aim_parse_hostversions(struct aim_session_t *sess,
 787                                          struct command_rx_struct *command, ...)
 788 {
 789   rxcallback_t userfunc = NULL;
 790   int ret = 1;
 791   int vercount;
 792
 793   vercount = (command->commandlen-10)/4;
 794
 795   if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0018)))
 796     ret = userfunc(sess, command, vercount, command->data+10);
 797
 798   return ret;
 799 }
 800
 801 faim_internal int aim_handleredirect_middle(struct aim_session_t *sess,
 802                                             struct command_rx_struct *command, ...)
 803 {
 804   int serviceid = 0;
 805   unsigned char *cookie = NULL;
 806   char *ip = NULL;
 807   rxcallback_t userfunc = NULL;
 808   struct aim_tlvlist_t *tlvlist;
 809   int ret = 1;
 810
 811   tlvlist = aim_readtlvchain(command->data+10, command->commandlen-10);
 812
 813   if (aim_gettlv(tlvlist, 0x000d, 1))
 814     serviceid = aim_gettlv16(tlvlist, 0x000d, 1);
 815   if (aim_gettlv(tlvlist, 0x0005, 1))
 816     ip = aim_gettlv_str(tlvlist, 0x0005, 1);
 817   if (aim_gettlv(tlvlist, 0x0006, 1))
 818     cookie = aim_gettlv_str(tlvlist, 0x0006, 1);
 819
 820   if ((serviceid == AIM_CONN_TYPE_CHAT) && sess->pendingjoin) {
 821
 822     /*
 823      * Chat hack.
 824      *
 825      */
 826     if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0005)))
 827       ret =  userfunc(sess, command, serviceid, ip, cookie, sess->pendingjoin, (int)sess->pendingjoinexchange);
 828       free(sess->pendingjoin);
 829       sess->pendingjoin = NULL;
 830       sess->pendingjoinexchange = 0;
 831   } else if (!serviceid || !ip || !cookie) { /* yeep! */
 832     ret = 1;
 833   } else {
 834     if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0005)))
 835       ret =  userfunc(sess, command, serviceid, ip, cookie);
 836   }
 837
 838   if (ip)
 839     free(ip);
 840   if (cookie)
 841     free(cookie);
 842
 843   aim_freetlvchain(&tlvlist);
 844
 845   return ret;
 846 }
 847
 848 faim_internal int aim_parse_unknown(struct aim_session_t *sess,
 849                                           struct command_rx_struct *command, ...)
 850 {
 851   u_int i = 0;
 852
 853   if (!sess || !command)
 854     return 1;
 855
 856   faimdprintf(1, "\nRecieved unknown packet:");
 857
 858   for (i = 0; i < command->commandlen; i++)
 859     {
 860       if ((i % 8) == 0)
 861         faimdprintf(1, "\n\t");
 862
 863       faimdprintf(1, "0x%2x ", command->data[i]);
 864     }
 865
 866   faimdprintf(1, "\n\n");
 867
 868   return 1;
 869 }
 870
 871
 872 faim_internal int aim_negchan_middle(struct aim_session_t *sess,
 873                                      struct command_rx_struct *command)
 874 {
 875   struct aim_tlvlist_t *tlvlist;
 876   char *msg = NULL;
 877   unsigned short code = 0;
 878   rxcallback_t userfunc = NULL;
 879   int ret = 1;
 880
 881   tlvlist = aim_readtlvchain(command->data, command->commandlen);
 882
 883   if (aim_gettlv(tlvlist, 0x0009, 1))
 884     code = aim_gettlv16(tlvlist, 0x0009, 1);
 885
 886   if (aim_gettlv(tlvlist, 0x000b, 1))
 887     msg = aim_gettlv_str(tlvlist, 0x000b, 1);
 888
 889   if ((userfunc = aim_callhandler(command->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR)))
 890     ret =  userfunc(sess, command, code, msg);
 891
 892   aim_freetlvchain(&tlvlist);
 893
 894   if (msg)
 895     free(msg);
 896
 897   return ret;
 898 }
 899
 900 /*
 901  * aim_parse_generalerrs()
 902  *
 903  * Middle handler for 0x0001 snac of each family.
 904  *
 905  */
 906 faim_internal int aim_parse_generalerrs(struct aim_session_t *sess,
 907                                         struct command_rx_struct *command, ...)
 908 {
 909   u_short family;
 910   u_short subtype;
 911
 912   family = aimutil_get16(command->data+0);
 913   subtype= aimutil_get16(command->data+2);
 914
 915   switch(family)
 916     {
 917     default:
 918       /* Unknown family */
 919       return aim_callhandler_noparam(sess, command->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, command);
 920     }
 921
 922   return 1;
 923 }
 924
 925
 926