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
 578             workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, family, subtype, workingPtr);
 579         } else if (family == 0x000e) {
 580           if (subtype == 0x0002)
 581             workingPtr->handled = aim_chat_parse_infoupdate(sess, workingPtr);
 582           else if (subtype == 0x0003)
 583             workingPtr->handled = aim_chat_parse_joined(sess, workingPtr);
 584           else if (subtype == 0x0004)
 585             workingPtr->handled = aim_chat_parse_leave(sess, workingPtr);
 586           else if (subtype == 0x0006)
 587             workingPtr->handled = aim_chat_parse_incoming(sess, workingPtr);
 588           else
 589             printf("Chat: unknown snac %04x/%04x\n", family, subtype);
 590         } else {
 591           printf("Chat: unknown snac %04x/%04x\n", family, subtype);
 592           workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_DEFAULT, workingPtr);
 593         }
 594         break;
 595       }
 596       case AIM_CONN_TYPE_RENDEZVOUS: {
 597         /* make sure that we only get OFT frames on these connections */
 598         if (workingPtr->hdrtype != AIM_FRAMETYPE_OFT) {
 599           printf("faim: internal error: non-OFT frames on OFT connection\n");
 600           workingPtr->handled = 1; /* get rid of it */
 601           break;
 602         }
 603
 604         /* XXX: implement this */
 605         printf("faim: OFT frame!\n");
 606
 607         break;
 608       }
 609       case AIM_CONN_TYPE_RENDEZVOUS_OUT: {
 610         /* not possible */
 611         break;
 612       }
 613       default:
 614         printf("\ninternal error: unknown connection type (very bad.) (type = %d, fd = %d, commandlen = %02x)\n\n", workingPtr->conn->type, workingPtr->conn->fd, workingPtr->commandlen);
 615         workingPtr->handled = aim_callhandler_noparam(sess, workingPtr->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, workingPtr);
 616         break;
 617       }
 618     }
 619   }
 620
 621   /*
 622    * This doesn't have to be called here.  It could easily be done
 623    * by a seperate thread or something. It's an administrative operation,
 624    * and can take a while. Though the less you call it the less memory
 625    * you'll have :)
 626    */
 627   aim_purge_rxqueue(sess);
 628
 629   return 0;
 630 }
 631
 632 faim_internal int aim_parse_msgack_middle(struct aim_session_t *sess, struct command_rx_struct *command)
 633 {
 634   rxcallback_t userfunc = NULL;
 635   char sn[MAXSNLEN];
 636   unsigned short type;
 637   int i = 10+8; /* skip SNAC and cookie */
 638   int ret = 1;
 639   unsigned char snlen;
 640
 641   type = aimutil_get16(command->data+i);
 642   i += 2;
 643
 644   snlen = aimutil_get8(command->data+i);
 645   i++;
 646
 647   memset(sn, 0, sizeof(sn));
 648   strncpy(sn, (char *)command->data+i, snlen);
 649
 650   if ((userfunc = aim_callhandler(command->conn, 0x0004, 0x000c)))
 651     ret =  userfunc(sess, command, type, sn);
 652
 653   return ret;
 654 }
 655
 656 faim_internal int aim_parse_ratechange_middle(struct aim_session_t *sess, struct command_rx_struct *command)
 657 {
 658   rxcallback_t userfunc = NULL;
 659   int ret = 1;
 660   unsigned long newrate;
 661
 662   if (command->commandlen != 0x2f) {
 663     printf("faim: unknown rate change length 0x%04x\n", command->commandlen);
 664     return 1;
 665   }
 666
 667   newrate = aimutil_get32(command->data+34);
 668
 669   if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x000a)))
 670     ret =  userfunc(sess, command, newrate);
 671
 672   return ret;
 673 }
 674
 675 faim_internal int aim_parse_evilnotify_middle(struct aim_session_t *sess, struct command_rx_struct *command)
 676 {
 677   rxcallback_t userfunc = NULL;
 678   int ret = 1, pos;
 679   char *sn = NULL;
 680
 681   if(command->commandlen < 12) /* a warning level dec sends this */
 682     return 1;
 683
 684   if ((pos = aimutil_get8(command->data+ 12)) > MAXSNLEN)
 685     return 1;
 686
 687   if(!(sn = (char *)calloc(1, pos+1)))
 688     return 1;
 689
 690   memcpy(sn, command->data+13, pos);
 691
 692   if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0010)))
 693     ret = userfunc(sess, command, sn);
 694
 695   free(sn);
 696
 697   return ret;
 698 }
 699
 700 faim_internal int aim_parsemotd_middle(struct aim_session_t *sess,
 701                                        struct command_rx_struct *command, ...)
 702 {
 703   rxcallback_t userfunc = NULL;
 704   char *msg;
 705   int ret=1;
 706   struct aim_tlvlist_t *tlvlist;
 707   u_short id;
 708
 709   /*
 710    * Code.
 711    *
 712    * Valid values:
 713    *   1 Mandatory upgrade
 714    *   2 Advisory upgrade
 715    *   3 System bulletin
 716    *   4 Nothing's wrong ("top o the world" -- normal)
 717    *
 718    */
 719   id = aimutil_get16(command->data+10);
 720
 721   /*
 722    * TLVs follow
 723    */
 724   if (!(tlvlist = aim_readtlvchain(command->data+12, command->commandlen-12)))
 725     return ret;
 726
 727   if (!(msg = aim_gettlv_str(tlvlist, 0x000b, 1))) {
 728     aim_freetlvchain(&tlvlist);
 729     return ret;
 730   }
 731
 732   userfunc = aim_callhandler(command->conn, 0x0001, 0x0013);
 733   if (userfunc)
 734     ret =  userfunc(sess, command, id, msg);
 735
 736   aim_freetlvchain(&tlvlist);
 737   free(msg);
 738
 739   return ret;
 740 }
 741
 742 faim_internal int aim_parse_hostonline(struct aim_session_t *sess,
 743                                        struct command_rx_struct *command, ...)
 744 {
 745   rxcallback_t userfunc = NULL;
 746   int ret = 1;
 747   unsigned short *families = NULL;
 748   int famcount = 0, i;
 749
 750   famcount = (command->commandlen-10)/2;
 751   if (!(families = malloc(command->commandlen-10)))
 752     return ret;
 753
 754   for (i = 0; i < famcount; i++)
 755     families[i] = aimutil_get16(command->data+((i*2)+10));
 756
 757   if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0003)))
 758     ret = userfunc(sess, command, famcount, families);
 759
 760   free(families);
 761
 762   return ret;
 763 }
 764
 765 faim_internal int aim_parse_hostversions(struct aim_session_t *sess,
 766                                          struct command_rx_struct *command, ...)
 767 {
 768   rxcallback_t userfunc = NULL;
 769   int ret = 1;
 770   int vercount;
 771
 772   vercount = (command->commandlen-10)/4;
 773
 774   if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0018)))
 775     ret = userfunc(sess, command, vercount, command->data+10);
 776
 777   return ret;
 778 }
 779
 780 faim_internal int aim_handleredirect_middle(struct aim_session_t *sess,
 781                                             struct command_rx_struct *command, ...)
 782 {
 783   int serviceid = 0;
 784   unsigned char *cookie = NULL;
 785   char *ip = NULL;
 786   rxcallback_t userfunc = NULL;
 787   struct aim_tlvlist_t *tlvlist;
 788   int ret = 1;
 789
 790   tlvlist = aim_readtlvchain(command->data+10, command->commandlen-10);
 791
 792   if (aim_gettlv(tlvlist, 0x000d, 1))
 793     serviceid = aim_gettlv16(tlvlist, 0x000d, 1);
 794   if (aim_gettlv(tlvlist, 0x0005, 1))
 795     ip = aim_gettlv_str(tlvlist, 0x0005, 1);
 796   if (aim_gettlv(tlvlist, 0x0006, 1))
 797     cookie = aim_gettlv_str(tlvlist, 0x0006, 1);
 798
 799   if ((serviceid == AIM_CONN_TYPE_CHAT) && sess->pendingjoin) {
 800
 801     /*
 802      * Chat hack.
 803      *
 804      */
 805     if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0005)))
 806       ret =  userfunc(sess, command, serviceid, ip, cookie, sess->pendingjoin, (int)sess->pendingjoinexchange);
 807       free(sess->pendingjoin);
 808       sess->pendingjoin = NULL;
 809       sess->pendingjoinexchange = 0;
 810   } else if (!serviceid || !ip || !cookie) { /* yeep! */
 811     ret = 1;
 812   } else {
 813     if ((userfunc = aim_callhandler(command->conn, 0x0001, 0x0005)))
 814       ret =  userfunc(sess, command, serviceid, ip, cookie);
 815   }
 816
 817   if (ip)
 818     free(ip);
 819   if (cookie)
 820     free(cookie);
 821
 822   aim_freetlvchain(&tlvlist);
 823
 824   return ret;
 825 }
 826
 827 faim_internal int aim_parse_unknown(struct aim_session_t *sess,
 828                                           struct command_rx_struct *command, ...)
 829 {
 830   u_int i = 0;
 831
 832   if (!sess || !command)
 833     return 1;
 834
 835   faimdprintf(1, "\nRecieved unknown packet:");
 836
 837   for (i = 0; i < command->commandlen; i++)
 838     {
 839       if ((i % 8) == 0)
 840         faimdprintf(1, "\n\t");
 841
 842       faimdprintf(1, "0x%2x ", command->data[i]);
 843     }
 844
 845   faimdprintf(1, "\n\n");
 846
 847   return 1;
 848 }
 849
 850
 851 faim_internal int aim_negchan_middle(struct aim_session_t *sess,
 852                                      struct command_rx_struct *command)
 853 {
 854   struct aim_tlvlist_t *tlvlist;
 855   char *msg = NULL;
 856   unsigned short code = 0;
 857   rxcallback_t userfunc = NULL;
 858   int ret = 1;
 859
 860   tlvlist = aim_readtlvchain(command->data, command->commandlen);
 861
 862   if (aim_gettlv(tlvlist, 0x0009, 1))
 863     code = aim_gettlv16(tlvlist, 0x0009, 1);
 864
 865   if (aim_gettlv(tlvlist, 0x000b, 1))
 866     msg = aim_gettlv_str(tlvlist, 0x000b, 1);
 867
 868   if ((userfunc = aim_callhandler(command->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR)))
 869     ret =  userfunc(sess, command, code, msg);
 870
 871   aim_freetlvchain(&tlvlist);
 872
 873   if (msg)
 874     free(msg);
 875
 876   return ret;
 877 }
 878
 879 /*
 880  * aim_parse_generalerrs()
 881  *
 882  * Middle handler for 0x0001 snac of each family.
 883  *
 884  */
 885 faim_internal int aim_parse_generalerrs(struct aim_session_t *sess,
 886                                         struct command_rx_struct *command, ...)
 887 {
 888   u_short family;
 889   u_short subtype;
 890
 891   family = aimutil_get16(command->data+0);
 892   subtype= aimutil_get16(command->data+2);
 893
 894   switch(family)
 895     {
 896     default:
 897       /* Unknown family */
 898       return aim_callhandler_noparam(sess, command->conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_UNKNOWN, command);
 899     }
 900
 901   return 1;
 902 }
 903
 904
 905