Return to adsp_Packet.c CVS log

Up to [Apple XNU] / XNU / bsd / netat

Annotation of XNU/bsd/netat/adsp_Packet.c, revision 1.1

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.