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