bsd/netat/adsp_Packet.c

   1 /*
   2  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_OSREFERENCE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License.  The rights granted to you under the
  10  * License may not be used to create, or enable the creation or
  11  * redistribution of, unlawful or unlicensed copies of an Apple operating
  12  * system, or to circumvent, violate, or enable the circumvention or
  13  * violation of, any terms of an Apple operating system software license
  14  * agreement.
  15  *
  16  * Please obtain a copy of the License at
  17  * http://www.opensource.apple.com/apsl/ and read it before using this
  18  * file.
  19  *
  20  * The Original Code and all software distributed under the License are
  21  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  22  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  23  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  25  * Please see the License for the specific language governing rights and
  26  * limitations under the License.
  27  *
  28  * @APPLE_LICENSE_OSREFERENCE_HEADER_END@
  29  */
  30 /*
  31  * Packet.c
  32  *
  33  * v01.23  All incoming packets come here first    06/21/90 mbs
  34  *    Modified for MP, 1996 by Tuyen Nguyen
  35  *   Modified, April 9, 1997 by Tuyen Nguyen for MacOSX.
  36  */
  37
  38 #include <sys/errno.h>
  39 #include <sys/types.h>
  40 #include <sys/param.h>
  41 #include <machine/spl.h>
  42 #include <sys/systm.h>
  43 #include <sys/kernel.h>
  44 #include <sys/proc.h>
  45 #include <sys/filedesc.h>
  46 #include <sys/fcntl.h>
  47 #include <sys/mbuf.h>
  48 #include <sys/ioctl.h>
  49 #include <sys/malloc.h>
  50 #include <sys/socket.h>
  51 #include <sys/socketvar.h>
  52 #include <sys/time.h>
  53
  54 #include <net/if.h>
  55
  56 #include <netat/sysglue.h>
  57 #include <netat/appletalk.h>
  58 #include <netat/at_pcb.h>
  59 #include <netat/ddp.h>
  60 #include <netat/at_var.h>
  61
  62 #include <netat/adsp.h>
  63 #include <netat/adsp_internal.h>
  64
  65 extern at_ifaddr_t *ifID_home;
  66
  67 /*
  68  * GleanSession
  69  *
  70  * We just got a packet for this session, glean its address &
  71  * reset probe timer
  72  *
  73  * INPUTS:
  74  *    Session
  75  * OUTPUTS:
  76  *    none
  77  */
  78 static void GleanSession(sp)            /* (CCBPtr sp) */
  79     CCBPtr sp;
  80 {
  81     if (sp->openState == O_STATE_OPEN) {
  82         /* This is true for both state = sOpen & sClosing */
  83         RemoveTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer);
  84         InsertTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer,
  85                         sp->probeInterval);
  86         sp->probeCntr   = 4;
  87     }
  88
  89 }
  90
  91
  92 /*
  93  * The same code handles incoming Open Connection Request,
  94  * Open Request + Ack, Open Connection Ack, Open Connection Denial
  95  *
  96  * We could be in four different states, LISTEN, OPENWAIT, ESTABLISHED,
  97  * OPEN.
  98  */
  99
 100 /*
 101  *
 102  * Ok, there are 16 combinations.  8 are do-nothings, 2 have to be
 103  * special cased (Open Deny and Req+Ack on Open session)
 104  *
 105  * Build a table of actions:
 106  *    Ignore?
 107  *    What to match on (local socket, whole address, DestCID, SrcCID)
 108  *    What to send (Ack or Req+Ack)
 109  *    Next State (both the ccb state and the open state)
 110  */
 111
 112 /*
 113  *
 114  */
 115 typedef struct {
 116     u_char match;               /* Characteristics that have to match
 117                                  * (Bit-Mapped, see below) */
 118     char action;                /* What to do if CCB matches */
 119     char send;                  /* What to send in response
 120                                  * (Bit mapped, same as sendCtl field of
 121                                  * CCB) */
 122     char openState;             /* Next Open state */
 123     char state;                 /* Next ccb state. */
 124     char pad;                   /* Too bad we need this to make structure
 125                                  * even size */
 126 } TBL, *TBLPtr;
 127
 128 #define M_LSOC          0x01    /* bit  0 - Match on local socket */
 129 #define M_ADDR          0x02    /* bit  1 - Match on whole address */
 130 #define M_DCID          0x04    /* bit  2 - Match on DestCID */
 131 #define M_SCID          0x08    /* bit  3 - Match SrcCID */
 132 #define M_DCIDZERO      0x10    /* bit  4 - Dest CID must be 0 */
 133 #define M_SCIDZERO      0x20    /* bit  5 - Src CID must be 0 */
 134 #define M_FILTER        0x40    /* bit  6 - Match address filter */
 135 #define M_IGNORE        0x80    /* bit  7 - Ignore */
 136
 137 #define A_COMPLETE      0x01    /* Complete open parameter block */
 138 #define A_SAVEPARMS     0x02    /* Save connection parameters */
 139 #define A_OREQACKOPEN   0x04    /* special case for open Req+Ack on
 140                                  * OPEN session */
 141 #define A_GLEAN         0x08    /* We'll be talking back to this guy */
 142 #define A_DENY          0x10    /* We've been denied! */
 143
 144
 145 /*
 146  * So here's our table
 147  */
 148
 149 static TBL tbl[16] = {
 150
 151 /*
 152  * For Open Request ($81)
 153  *
 154  *      LISTENING
 155  *              Match on destination socket
 156  *              Match on address filter
 157  *              Dest CID must be 0
 158  *              Glean connection
 159  *              Save Open Connection parameters
 160  *              Send OREQACK
 161  *              Change state to ESTABLISHED
 162  */
 163         {       M_LSOC + M_DCIDZERO + M_FILTER,
 164                 A_SAVEPARMS + A_GLEAN,
 165                 B_CTL_OREQACK,
 166                 O_STATE_ESTABLISHED,
 167                 sOpening,
 168                 0
 169         },
 170
 171 /*
 172  *
 173  *      OPENWAIT
 174  *              Match on Remote Address & destination socket
 175  *              Dest CID must be 0
 176  *              Save Open Connection parameters
 177  *              Send Ack
 178  *              Change state to ESTABLISHED
 179  */
 180         {       M_LSOC + M_ADDR + M_DCIDZERO,
 181                 A_SAVEPARMS + A_GLEAN,
 182                 B_CTL_OACK,
 183                 O_STATE_ESTABLISHED,
 184                 sOpening,
 185                 0
 186         },
 187 /*
 188  *
 189  *      ESTABLISHED
 190  *              Match on Remote Address & SrcCID
 191  *              Dest CID must be 0
 192  *              Send Req + Ack
 193  */
 194         {       M_ADDR + M_SCID + M_DCIDZERO,
 195                 A_GLEAN,
 196                 B_CTL_OACK,
 197                 O_STATE_ESTABLISHED,
 198                 sOpening,
 199                 0
 200         },
 201 /*
 202  *      OPEN
 203  *              Ignore
 204  */
 205         {       M_IGNORE,
 206                 0,
 207                 0,
 208                 0,
 209                 0,
 210                 0
 211         },
 212
 213 /*
 214  *
 215  * For Open Ack ($82)
 216  *
 217  *      LISTENING
 218  *              Ignore
 219  */
 220         {       M_IGNORE,
 221                 0,
 222                 0,
 223                 0,
 224                 0,
 225                 0
 226         },
 227 /*
 228  *
 229  *      OPENWAIT
 230  *              Ignore
 231  */
 232         {       M_IGNORE,
 233                 0,
 234                 0,
 235                 0,
 236                 0,
 237                 0
 238         },
 239 /*
 240  *
 241  *      ESTABLISHED
 242  *              Match on SrcCID & DestCID & Address & Local Socket
 243  *              Complete Listen or Connect PB
 244  *              OPEN
 245  */
 246         {       M_ADDR + M_DCID + M_SCID + M_LSOC,
 247                 A_COMPLETE + A_GLEAN,
 248                 0,
 249                 O_STATE_OPEN,
 250                 sOpen,
 251                 0
 252         },
 253 /*
 254  *
 255  *      OPEN
 256  *              Ignore
 257 */
 258         {       M_IGNORE,
 259                 0,
 260                 0,
 261                 0,
 262                 0,
 263                 0
 264         },
 265
 266 /*
 267  *
 268  * For Open Request + Ack ($83)
 269  *
 270  *      LISTENING
 271  *              Ignore
 272 */
 273         {       M_IGNORE,
 274                 0,
 275                 0,
 276                 0,
 277                 0,
 278                 0
 279         },
 280 /*
 281  *
 282  *      OPENWAIT
 283  *              Match on DestCID & socket
 284  *                      Do not test remote address -- our open req could have
 285  *                      been passed to another address by a connection server
 286  *              Save Open Connection parameters
 287  *              Complete Connect parameter block
 288  *              Send Ack
 289  *              OPEN
 290  */
 291         {       M_DCID + M_LSOC,
 292                 A_COMPLETE + A_SAVEPARMS + A_GLEAN,
 293                 B_CTL_OACK,
 294                 O_STATE_OPEN,
 295                 sOpen,
 296                 0
 297         },
 298 /*
 299  *
 300  *      ESTABLISHED
 301  *              Ignore
 302  */
 303         {       M_IGNORE,
 304                 0,
 305                 0,
 306                 0,
 307                 0,
 308                 0
 309         },
 310 /*
 311  *
 312  *      OPEN
 313  *              Match on Remote Address & SrcCID & DestCID & Local Socket
 314  *              If we've never gotten any data
 315  *              Send Ack & Retransmit
 316  */
 317         {       M_ADDR + M_DCID + M_SCID + M_LSOC,
 318                 A_OREQACKOPEN + A_GLEAN,
 319                 B_CTL_OACK,
 320                 O_STATE_OPEN,
 321                 sOpen,
 322                 0
 323         },
 324
 325 /*
 326  *
 327  *
 328  * For Open Deny ($84)
 329  *
 330  *      LISTENING
 331  *              Ignore
 332  */
 333         {       M_IGNORE,
 334                 0,
 335                 0,
 336                 0,
 337                 0,
 338                 0
 339         },
 340 /*
 341  *
 342  *      OPENWAIT
 343  *              Match on DestCID & Address
 344  *              Source CID must be 0
 345  *              Complete with error
 346  */
 347         {       M_SCIDZERO + M_DCID + M_ADDR,
 348                 A_DENY,
 349                 0,
 350                 O_STATE_NOTHING,
 351                 sClosed,
 352                 0
 353         },
 354 /*
 355  *
 356  *      ESTABLISHED
 357  *              Ignore
 358  */
 359         {       M_IGNORE,
 360                 0,
 361                 0,
 362                 0,
 363                 0,
 364                 0
 365         },      /* %%% No we probably don't want to ignore in this case */
 366 /*
 367  *
 368  *    OPEN
 369  *       Ignore
 370  */
 371         {       M_IGNORE,
 372                 0,
 373                 0,
 374                 0,
 375                 0,
 376                 0
 377         }
 378 };
 379
 380 extern at_ifaddr_t *ifID_table[];
 381
 382 /*
 383  * Used to search down queue of sessions for a session waiting for an
 384  * open request.
 385  */
 386 typedef struct {
 387    AddrUnion    addr;
 388    word         dstCID;
 389    word         srcCID;
 390    byte         socket;
 391    byte         descriptor;
 392    byte         idx;            /* Index into state tables */
 393    TBLPtr       t;              /* Ptr to entry in table above */
 394 } MATCH, *MATCHPtr;
 395
 396 /*
 397  * MatchStream
 398  *
 399  * Called by Rx connection to find which stream (if any) should get this open
 400  * request/ack/req+ack/deny packet.
 401  *
 402  */
 403
 404 static boolean
 405 MatchStream(sp, m)              /* (CCBPtr sp, MATCHPtr m) */
 406     CCBPtr sp;
 407     MATCHPtr m;
 408 {
 409         unsigned char match;
 410         struct adspcmd  *opb;
 411
 412         if (sp->openState < O_STATE_LISTEN ||
 413             sp->openState > O_STATE_OPEN)
 414             return 0;
 415
 416
 417         m->t = &tbl[sp->openState - O_STATE_LISTEN + m->idx];
 418
 419         match = m->t->match;    /* Get match criteria */
 420
 421         if (match & M_IGNORE)   /* Ignore this combination */
 422             return 0;
 423
 424         if (match & M_LSOC) {   /* Match on Local socket */
 425             if (sp->localSocket != m->socket)
 426                 return 0;
 427         }
 428
 429         if (match & M_ADDR) {   /* Match on Address */
 430             AddrUnion   addr;
 431             addr = m->addr;     /* Make local copy for efficiency */
 432             if (sp->remoteAddress.a.node != addr.a.node)
 433                 return 0;
 434             if (sp->remoteAddress.a.socket != addr.a.socket)
 435                 return 0;
 436             if (sp->remoteAddress.a.net && addr.a.net &&
 437                 (sp->remoteAddress.a.net != addr.a.net))
 438                 return 0;
 439
 440             /*
 441              * Handle special case to reject self-sent open request
 442              */
 443             if ((m->srcCID == sp->locCID) &&
 444                 (addr.a.node == ifID_home->ifThisNode.s_node) &&
 445                 /* *** was (addr.a.node == ddpcfg.node_addr.node) && *** */
 446                 ((addr.a.net == 0) ||
 447                  (ifID_home->ifThisNode.s_net == 0) ||
 448                  (ifID_home->ifThisNode.s_net == addr.a.net)) )
 449               /* *** was
 450                 (NET_VALUE(ddpcfg.node_addr.net) == 0) ||
 451                 (NET_VALUE(ddpcfg.node_addr.net) == NET_VALUE(addr.a.net))) )
 452                  *** */
 453                                 /* CID's match, and */
 454                                 /* If nodeID matches, and */
 455                                 /* network matches, */
 456                 return 0;       /* then came from us! */
 457         }
 458
 459         if (match & M_DCID) {   /* Match on DestCID */
 460             if (sp->locCID != m->dstCID)
 461                 return 0;
 462         }
 463
 464         if (match & M_SCID) {   /* Match on SourceCID */
 465             if (sp->remCID != m->srcCID)
 466                 return 0;
 467         }
 468
 469         if (match & M_DCIDZERO) { /* Destination CID must be 0 */
 470             if (m->dstCID != 0)
 471                 return 0;
 472         }
 473
 474         if (match & M_SCIDZERO) /* Source CID must be 0 */
 475         {
 476             if (m->srcCID != 0)
 477                 return 0;
 478         }
 479
 480         if (match & M_FILTER) { /* Check address filter? */
 481             if ((opb = sp->opb)) /* There should be a param block... */
 482             {
 483                 AddrUnion       addr;
 484                 addr = m->addr; /* Make local copy for efficiency */
 485                 if ((opb->u.openParams.filterAddress.net &&
 486                      addr.a.net &&
 487                      opb->u.openParams.filterAddress.net != addr.a.net) ||
 488                     (opb->u.openParams.filterAddress.node != 0 &&
 489                      opb->u.openParams.filterAddress.node != addr.a.node)||
 490                     (opb->u.openParams.filterAddress.socket != 0 &&
 491                      opb->u.openParams.filterAddress.socket != addr.a.socket))
 492                     return 0;
 493             }
 494         }
 495
 496         return 1;
 497 }
 498
 499 /*
 500  * MatchListener
 501  *
 502  * Called by rx connection to see which connection listener (if any) should
 503  * get this incoming open connection request.
 504  *
 505  */
 506
 507 static boolean MatchListener(sp, m) /* (CCBPtr sp, MATCHPtr m) */
 508     CCBPtr sp;
 509     MATCHPtr m;
 510 {
 511
 512     if ((sp->state == (word)sListening) && /* This CCB is a listener */
 513         (sp->localSocket == m->socket)) /* on the right socket */
 514         return 1;
 515
 516     return 0;
 517 }
 518
 519 /*
 520  * RXConnection
 521  *
 522  * We just received one of the 4 Open Connection packets
 523  * Interrupts are masked OFF at this point
 524  *
 525  * INPUTS:
 526  *      spPtr   Place to put ptr to stream (if we found one -- not
 527  *                                              for listeners)
 528  *      f       Pointer to ADSP header for packet, data follows behind it
 529  *      len     # of byte in ADSP header + data
 530  *      addr    Who sent the packet
 531  *      dsoc    Where they sent it to
 532  *
 533  * OUTPUTS:
 534  *    Returns 1 if packet was ignored
 535  */
 536 static int RXConnection(gref, spPtr, f, len, addr, dsoc)
 537     /* (CCBPtr *spPtr, ADSP_FRAMEPtr f, word len, AddrUnion addr, byte dsoc) */
 538     gref_t *gref;                       /* READ queue */
 539     CCBPtr *spPtr;
 540     ADSP_FRAMEPtr f;
 541     int len;
 542     AddrUnion addr;
 543     unsigned char dsoc;
 544 {
 545     CCBPtr sp;
 546     ADSP_OPEN_DATAPtr op;
 547     struct adspcmd *pb;
 548     MATCH m;
 549     gbuf_t *mp;
 550     ADSP_FRAMEPtr adspp;
 551     ADSP_OPEN_DATAPtr adspop;
 552
 553     op = (ADSP_OPEN_DATAPtr)&f->data[0]; /* Point to Open-Connection parms */
 554     len -= ADSP_FRAME_LEN;
 555
 556     if (len < (sizeof(ADSP_OPEN_DATA))) /* Packet too small */
 557         return 1;
 558
 559
 560     if (UAS_VALUE(op->version) != netw(0x0100)) { /* Check version num (on even-byte) */
 561         /*
 562          * The open request has been denied.  Try to send him a denial.
 563          */
 564
 565         mp = gbuf_alloc(AT_WR_OFFSET + DDPL_FRAME_LEN + ADSP_FRAME_LEN + ADSP_OPEN_FRAME_LEN,
 566                     PRI_LO);
 567         gbuf_rinc(mp,AT_WR_OFFSET);
 568         gbuf_wset(mp,DDPL_FRAME_LEN);
 569         adspp = (ADSP_FRAMEPtr)gbuf_wptr(mp);
 570         gbuf_winc(mp,ADSP_FRAME_LEN);
 571         bzero((caddr_t) gbuf_rptr(mp),DDPL_FRAME_LEN + ADSP_FRAME_LEN +
 572               ADSP_OPEN_FRAME_LEN);
 573         adspp->descriptor = ADSP_CONTROL_BIT | ADSP_CTL_ODENY;
 574         adspop = (ADSP_OPEN_DATAPtr)gbuf_wptr(mp);
 575         gbuf_winc(mp,ADSP_OPEN_FRAME_LEN);
 576         UAS_UAS(adspop->dstCID, f->CID);
 577         UAS_ASSIGN_HTON(adspop->version, 0x100);
 578         adsp_sendddp(0, mp, DDPL_FRAME_LEN + ADSP_FRAME_LEN +
 579                    ADSP_OPEN_FRAME_LEN, &addr, DDP_ADSP);
 580
 581         return 0;
 582     }
 583     m.addr = addr;
 584     m.socket = dsoc;
 585     m.descriptor = f->descriptor;
 586     m.srcCID = UAS_VALUE_NTOH(f->CID);
 587     m.dstCID = UAS_VALUE_NTOH(op->dstCID);      /* On even-byte boundry */
 588     m.idx = ((f->descriptor & ADSP_CONTROL_MASK) - 1) * 4;
 589
 590     /*
 591      * See if we can find a stream that knows what to do with this packet
 592      */
 593     if ((sp = (CCBPtr)qfind_m(AT_ADSP_STREAMS, &m, (ProcPtr)MatchStream)) == 0)
 594     {
 595         struct adspcmd *p;
 596         struct adspcmd *n;
 597         /*
 598          * No match, so look for connection listeners if this is an
 599          * open request
 600          */
 601         if ((f->descriptor & ADSP_CONTROL_MASK) != (byte)ADSP_CTL_OREQ)
 602             return 1;
 603
 604         if ((sp = (CCBPtr)qfind_m(AT_ADSP_STREAMS, &m,
 605                                   (ProcPtr)MatchListener)) == 0)
 606             return 1;
 607
 608         p = (struct adspcmd *)&sp->opb;
 609         while (n = (struct adspcmd *)p->qLink) /* Hunt down list of listens */
 610         {
 611             /* Check address filter */
 612             if (((n->u.openParams.filterAddress.net == 0) ||
 613                  (addr.a.net == 0) ||
 614                  (n->u.openParams.filterAddress.net == addr.a.net)) &&
 615
 616                 ((n->u.openParams.filterAddress.node == 0) ||
 617                  (n->u.openParams.filterAddress.node == addr.a.node)) &&
 618
 619                 ((n->u.openParams.filterAddress.socket == 0) ||
 620                  (n->u.openParams.filterAddress.socket == addr.a.socket))) {
 621                 p->qLink = n->qLink; /* Unlink this param block */
 622                 n->u.openParams.remoteCID = m.srcCID;
 623                 *((AddrUnionPtr)&n->u.openParams.remoteAddress) = addr;
 624                 n->u.openParams.sendSeq = UAL_VALUE_NTOH(f->pktNextRecvSeq);
 625                 n->u.openParams.sendWindow = UAS_VALUE_NTOH(f->pktRecvWdw);
 626                 n->u.openParams.attnSendSeq = UAL_VALUE_NTOH(op->pktAttnRecvSeq);
 627                 n->ioResult = 0;
 628                 completepb(sp, n); /* complete copy of request */
 629                                 /* complete(n, 0); */
 630                 return 0;
 631             }                   /* found CLListen */
 632
 633             p = n;              /* down the list we go... */
 634
 635         }                       /* while */
 636
 637         return 1;
 638     }
 639
 640     *spPtr = sp;                /* Save ptr to stream we just found */
 641
 642     sp->openState = m.t->openState; /* Move to next state (may be same) */
 643     sp->state = m.t->state;     /* Move to next state (may be same) */
 644
 645     if (m.t->action & A_SAVEPARMS) { /* Need to Save open-conn parms */
 646         sp->firstRtmtSeq = sp->sendSeq = UAL_VALUE_NTOH(f->pktNextRecvSeq);
 647         sp->sendWdwSeq = UAL_VALUE_NTOH(f->pktNextRecvSeq) + UAS_VALUE_NTOH(f->pktRecvWdw) - 1;
 648         sp->attnSendSeq = UAL_VALUE_NTOH(op->pktAttnRecvSeq); /* on even boundry */
 649
 650
 651         sp->remCID = UAS_VALUE_NTOH(f->CID);    /* Save Source CID as RemCID */
 652         UAS_UAS(sp->of.dstCID, f->CID); /* Save CID in open ctl packet */
 653
 654         sp->remoteAddress = addr; /* Save his address */
 655
 656     }
 657
 658     if (m.t->action & A_DENY) { /* We've been denied ! */
 659         DoClose(sp, errOpenDenied, -1);
 660     }
 661
 662     if (m.t->action & A_OREQACKOPEN) {
 663                                 /* Special case for OREQACK */
 664                                 /* on an open session */
 665         RemoveTimerElem(&adspGlobal.fastTimers, &sp->RetryTimer);
 666         sp->sendSeq = sp->firstRtmtSeq;
 667         sp->pktSendCnt  = 0;
 668         sp->waitingAck  = 0;
 669         sp->callSend = 1;
 670     }
 671
 672     if (m.t->send) {            /* Need to send a response */
 673         sp->sendCtl |= m.t->send;
 674         sp->callSend = 1;
 675     }
 676
 677     if (m.t->action & A_COMPLETE) { /* Need to complete open param blk */
 678         RemoveTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer);
 679
 680         if (pb = sp->opb) {
 681             sp->opb = 0;
 682             pb->u.openParams.localCID = sp->locCID;
 683             pb->u.openParams.remoteCID = sp->remCID;
 684             pb->u.openParams.remoteAddress =
 685                 *((at_inet_t *)&sp->remoteAddress);
 686             pb->u.openParams.sendSeq = sp->sendSeq;
 687             pb->u.openParams.sendWindow = sp->sendWdwSeq - sp->sendSeq;
 688             pb->u.openParams.attnSendSeq = sp->attnSendSeq;
 689             pb->ioResult = 0;
 690             completepb(sp, pb); /* complete(pb, 0); */
 691             return 0;
 692         }
 693                                 /* Start probe timer */
 694         InsertTimerElem(&adspGlobal.slowTimers, &sp->ProbeTimer,
 695                         sp->probeInterval);
 696     }
 697     return 0;
 698 }
 699
 700 /*
 701  * ADSPPacket
 702  *
 703  * When a packet is received by the protocol stack with DDP type equal
 704  * to ADSP, then execution comes here
 705  *
 706  * DS is set to ATALK's DGROUP
 707  *
 708  * This routine, or one of its children MUST call glean packet
 709  *
 710  * INPUTS:
 711  *    Pointer to DDP header
 712  * OUTPUTS:
 713  *    none
 714  *
 715  * Note that the incoming message block (mp) is usually discarded, either
 716  * by the "ignored" path, or via the "checksend" path.  The only case
 717  * where the message is NOT freed is via the RxData case in the
 718  * non control packet switch.  I zero mp after the RxData case succeeds
 719  * so that mp will not be freed.
 720  */
 721 int adspPacket(gref, mp)
 722     /* (bytePtr data, word len, AddrUnion a, byte dsoc) */
 723     gref_t *gref;
 724     gbuf_t *mp;
 725 {
 726     unsigned char *bp;
 727     int len;
 728     AddrUnion a;
 729     int dsoc;
 730     register DDPX_FRAME *ddp;   /* DDP frame pointer */
 731     register ADSP_FRAMEPtr f;   /* Frame */
 732     CCBPtr sp;
 733
 734     sp = 0;                     /* No stream */
 735     bp = (unsigned char *)gbuf_rptr(mp);
 736     ddp = (DDPX_FRAME *)bp;
 737     if (ddp->ddpx_type != DDP_ADSP)
 738         return -1;
 739     f = (ADSP_FRAMEPtr)(bp + DDPL_FRAME_LEN);
 740
 741     len = UAS_VALUE_NTOH(ddp->ddpx_length) & 0x3ff; /* (ten bits of length) */
 742     len -= DDPL_FRAME_LEN;
 743     if (len < (sizeof(ADSP_FRAME) - 1)) /* Packet too small */
 744         return -1;              /* mark the failure */
 745
 746     a.a.net = NET_VALUE(ddp->ddpx_snet);
 747     a.a.node = ddp->ddpx_snode;
 748     a.a.socket = ddp->ddpx_source;
 749
 750     dsoc = ddp->ddpx_dest;
 751
 752     if (sp = (CCBPtr)FindSender(f, a))
 753         GleanSession(sp);
 754
 755     if (f->descriptor & ADSP_ATTENTION_BIT) { /* ATTN packet */
 756         if (sp && RXAttention(sp, mp, f, len))
 757             goto ignore;
 758         else
 759             mp = 0;             /* attention data is being held */
 760     }                           /* ATTENTION BIT */
 761
 762     else if (f->descriptor & ADSP_CONTROL_BIT) { /* Control packet */
 763         switch (f->descriptor & ADSP_CONTROL_MASK) {
 764         case ADSP_CTL_PROBE:    /* Probe or acknowledgement */
 765             if (sp)
 766                 CheckRecvSeq(sp, f);
 767             break;
 768
 769         case ADSP_CTL_OREQ:     /* Open Connection Request */
 770         case ADSP_CTL_OREQACK:  /* Open Request and acknowledgement */
 771         case ADSP_CTL_OACK:     /* Open Request acknowledgment */
 772         case ADSP_CTL_ODENY:    /* Open Request denial */
 773             if (RXConnection(gref, &sp, f, len, a, dsoc))
 774                 goto ignore;
 775             break;
 776
 777         case ADSP_CTL_CLOSE:    /* Close connection advice */
 778             if (sp) {
 779                 /* This pkt may also ack some data we sent */
 780                 CheckRecvSeq(sp, f);
 781                 RxClose(sp);
 782                 sp = 0;
 783             } else
 784                 goto ignore;
 785             break;
 786
 787         case ADSP_CTL_FRESET:   /* Forward Reset */
 788                                 /* May I rot in hell for the code below... */
 789             if (sp && (CheckRecvSeq(sp, f), RXFReset(sp, f)))
 790                 goto ignore;
 791             break;
 792
 793         case ADSP_CTL_FRESET_ACK: /* Forward Reset Acknowledgement */
 794             if (sp && (CheckRecvSeq(sp, f), RXFResetAck(sp, f)))
 795                 goto ignore;
 796             break;
 797
 798         case ADSP_CTL_RETRANSMIT: /* Retransmit advice */
 799             if (sp) {
 800                 /* This pkt may also ack some data we sent */
 801                 CheckRecvSeq(sp, f);
 802                 RemoveTimerElem(&adspGlobal.fastTimers, &sp->RetryTimer);
 803                 sp->sendSeq = sp->firstRtmtSeq;
 804                 sp->pktSendCnt = 0;
 805                 sp->waitingAck = 0;
 806                 sp->callSend = 1;
 807             } else
 808                 goto ignore;
 809             break;
 810
 811         default:
 812             goto ignore;
 813         }                       /* switch */
 814     }                           /* Control packet */
 815
 816     else {                      /* Data Packet */
 817         if ((sp == 0) || RXData(sp, mp, f, len))
 818             goto ignore;
 819         else
 820             mp = 0;             /* RXData used up the data, DONT free it! */
 821     }                           /* Data Packet */
 822
 823     if (mp)
 824         gbuf_freem(mp);
 825
 826 checksend:                      /* incoming data was not ignored */
 827     if (sp && sp->callSend)     /* If we have a stream & we need to send */
 828         CheckSend(sp);
 829
 830     return 0;
 831
 832 ignore:
 833     gbuf_freem(mp);
 834     return 0;
 835 }