![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to adsp_stream.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netat|
Return to adsp_stream.c CVS log | Up to [Apple XNU] / XNU / bsd / netat |
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: * Copyright (c) 1995-1998 Apple Computer, Inc.
24: * All Rights Reserved.
25: */
26:
27: /*
28: * 09/07/95 - Modified for performance (Tuyen Nguyen)
29: * Modified for MP, 1996 by Tuyen Nguyen
30: * Modified, April 9, 1997 by Tuyen Nguyen for MacOSX.
31: */
32: #include <sys/errno.h>
33: #include <sys/types.h>
34: #include <sys/param.h>
35: #include <machine/spl.h>
36: #include <sys/systm.h>
37: #include <sys/kernel.h>
38: #include <sys/proc.h>
39: #include <sys/filedesc.h>
40: #include <sys/fcntl.h>
41: #include <sys/mbuf.h>
42: #include <sys/socket.h>
43: #include <sys/socketvar.h>
44: #include <sys/time.h>
45: #include <sys/ioctl.h>
46: #include <sys/malloc.h>
47:
48: #include <net/if.h>
49:
50: #include <netat/sysglue.h>
51: #include <netat/appletalk.h>
52: #include <netat/ddp.h>
53: #include <netat/at_snmp.h>
54: #include <netat/at_pcb.h>
55: #include <netat/debug.h>
56: #include <netat/at_var.h>
57: #include <netat/adsp.h>
58: #include <netat/adsp_internal.h>
59:
60: void SndMsgUp();
61: void adsp_rput();
62: static void adsp_iocack();
63: static void adsp_iocnak();
64: void adsp_dequeue_ccb();
65: unsigned char adspAssignSocket();
66: int adspallocate(), adsprelease();
67: int adspInited = 0;
68:
69: atlock_t adspall_lock;
70: atlock_t adspgen_lock;
71: GLOBAL adspGlobal;
72:
73: /**********/
74:
75: int adsp_pidM[256];
76: char adsp_inputC[256];
77: CCB *adsp_inputQ[256];
78:
79: extern char ot_adsp_socketM[];
80: extern at_ifaddr_t *ifID_home;
81:
82: CCB *ccb_used_list;
83:
84: void adsp_input(mp)
85: gbuf_t *mp;
86: {
87: gref_t *gref;
88: CCBPtr sp;
89: at_ddp_t *p;
90: int s, l;
91: gbuf_t *mb;
92:
93: switch (gbuf_type(mp)) {
94: case MSG_DATA:
95: p = (at_ddp_t *)gbuf_rptr(mp);
96: ATDISABLE(s, adspall_lock);
97: sp = adsp_inputQ[p->dst_socket];
98: if ((sp == 0) || (sp->gref==0) || (sp->state==sClosed))
99: {
100: ATENABLE(s, adspall_lock);
101: gbuf_freem(mp);
102: return;
103: }
104: else if (sp->otccbLink != 0) {
105: do {
106: if ((sp->remoteAddress.a.node == p->src_node)
107: && (sp->remoteAddress.a.socket == p->src_socket)
108: && (sp->remoteAddress.a.net == NET_VALUE(p->src_net)))
109: break;
110: } while ((sp = sp->otccbLink) != 0);
111: if (sp == 0)
112: {
113: ATENABLE(s, adspall_lock);
114: gbuf_freem(mp);
115: return;
116: }
117: }
118: if (sp->lockFlag) {
119: gbuf_next(mp) = 0;
120: if (sp->deferred_mb) {
121: for (mb=sp->deferred_mb; gbuf_next(mb); mb=gbuf_next(mb)) ;
122: gbuf_next(mb) = mp;
123: } else
124: sp->deferred_mb = mp;
125: ATENABLE(s, adspall_lock);
126: return;
127: }
128: ATDISABLE(l, sp->lockRemove);
129: sp->lockFlag = 1;
130: ATENABLE(l, adspall_lock);
131: while (mp) {
132: adsp_rput(sp->gref, mp);
133: if ((mp = sp->deferred_mb) != 0) {
134: sp->deferred_mb = gbuf_next(mp);
135: gbuf_next(mp) = 0;
136: }
137: }
138: sp->lockFlag = 0;
139: ATENABLE(s, sp->lockRemove);
140: return;
141:
142: case MSG_IOCACK:
143: case MSG_IOCNAK:
144: gref = (gref_t *)((ioc_t *)gbuf_rptr(mp))->ioc_private;
145: break;
146:
147: case MSG_IOCTL:
148: #ifdef APPLETALK_DEBUG
149: kprintf("unexpected MSG_IOCTL in adsp_input()");
150: #endif
151: /* fall through */
152:
153: default:
154: gbuf_freem(mp);
155: return;
156: }
157:
158: adsp_rput(gref, mp);
159: }
160:
161: /**********/
162: int adsp_readable(gref)
163: gref_t *gref;
164: {
165: int rc;
166: CCBPtr sp;
167:
168: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
169: rc = sp->rData;
170:
171: return rc;
172: }
173:
174: int adsp_writeable(gref)
175: gref_t *gref;
176: {
177: int s, rc;
178: CCBPtr sp;
179:
180: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
181: ATDISABLE(s, sp->lock);
182: rc = CalcSendQFree(sp);
183: ATENABLE(s, sp->lock);
184:
185: return rc;
186: }
187:
188: static void adsp_init()
189: {
190: adspInited++;
191: InitGlobals();
192: ccb_used_list = 0;
193: bzero(adsp_pidM, sizeof(adsp_pidM));
194: bzero(adsp_inputC, sizeof(adsp_inputC));
195: bzero(adsp_inputQ, sizeof(adsp_inputQ));
196: }
197:
198: /*
199: * Description:
200: * ADSP open and close routines. These routines
201: * initalize and release the ADSP structures. They do not
202: * have anything to do with "connections"
203: */
204:
205: int adsp_open(gref)
206: gref_t *gref;
207: {
208: register CCBPtr sp;
209: int s;
210:
211: if (!adspInited)
212: adsp_init();
213:
214: if (!adspAllocateCCB(gref))
215: return(ENOBUFS); /* can't get buffers */
216:
217: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
218: gref->readable = adsp_readable;
219: gref->writeable = adsp_writeable;
220: ATDISABLE(s, adspall_lock);
221: if ((sp->otccbLink = ccb_used_list) != 0)
222: sp->otccbLink->ccbLink = sp;
223: ccb_used_list = sp;
224: ATENABLE(s, adspall_lock);
225: return 0;
226: }
227:
228: int adsp_close(gref)
229: gref_t *gref;
230: {
231: int s, l;
232: unsigned char localSocket;
233:
234: /* make sure we've not yet removed the CCB (e.g., due to TrashSession) */
235: ATDISABLE(l, adspgen_lock);
236: if (gref->info) {
237: CCBPtr sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
238: ATDISABLE(s, sp->lock);
239: ATENABLE(s, adspgen_lock);
240: localSocket = sp->localSocket;
241: ATENABLE(l, sp->lock);
242: if (localSocket)
243: adspRelease(gref);
244: else
245: {
246: adsp_dequeue_ccb(sp);
247: gbuf_freeb((gbuf_t *)gref->info);
248: }
249: } else
250: ATENABLE(l, adspgen_lock);
251: return 0;
252: }
253:
254:
255: /*
256: * Name:
257: * adsp_rput
258: *
259: * Description:
260: * ADSP streams read put and service routines.
261: */
262:
263: void adsp_rput(gref, mp)
264: gref_t *gref; /* READ queue */
265: gbuf_t *mp;
266: {
267: switch (gbuf_type(mp)) {
268: case MSG_HANGUP:
269: case MSG_IOCACK:
270: case MSG_IOCNAK:
271: switch (adspReadHandler(gref, mp)) {
272: case STR_PUTNEXT:
273: atalk_putnext(gref, mp);
274: break;
275: case STR_IGNORE:
276: break;
277: }
278: break;
279: case MSG_ERROR:
280: #ifdef APPLETALK_DEBUG
281: kprintf("adsp_rput received MSG_ERROR");
282: #endif
283: /* fall through */
284: default:
285: CheckReadQueue(gbuf_rptr(((gbuf_t *)gref->info)));
286: CheckSend(gbuf_rptr(((gbuf_t *)gref->info)));
287:
288: switch (gbuf_type(mp)) {
289: case MSG_IOCTL:
290: case MSG_DATA:
291: case MSG_PROTO:
292: if (adspReadHandler(gref, mp) == STR_PUTNEXT)
293: atalk_putnext(gref, mp);
294: break;
295: default:
296: atalk_putnext(gref, mp);
297: break;
298: }
299: }
300: }
301:
302: /*
303: * Name:
304: * adsp_wput
305: *
306: * Description:
307: * ADSP streams write put and service routines.
308: *
309: */
310:
311: int adsp_wput(gref, mp)
312: gref_t *gref; /* WRITE queue */
313: gbuf_t *mp;
314: {
315: int rc;
316: int s;
317: gbuf_t *xm;
318: ioc_t *iocbp;
319: CCBPtr sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
320:
321: if (gbuf_type(mp) == MSG_IOCTL) {
322: iocbp = (ioc_t *)gbuf_rptr(mp);
323: switch (iocbp->ioc_cmd) {
324: case ADSPBINDREQ:
325: {
326: unsigned char v;
327:
328: if (gbuf_cont(mp) == NULL) {
329: iocbp->ioc_rval = -1;
330: adsp_iocnak(gref, mp, EINVAL);
331: }
332: v = *(unsigned char *)gbuf_rptr(gbuf_cont(mp));
333: ATDISABLE(s, adspall_lock);
334: if ( (v != 0)
335: && ((v > DDP_SOCKET_LAST) || (v < 2)
336: || (adsp_inputQ[v] != 0)
337: || (ot_adsp_socketM[v] != 0)) ) {
338: ATENABLE(s, adspall_lock);
339: iocbp->ioc_rval = -1;
340: adsp_iocnak(gref, mp, EINVAL);
341: }
342: else {
343: if (v == 0) {
344: ATENABLE(s, adspall_lock);
345: if ((v = adspAssignSocket(gref, 0)) == 0) {
346: iocbp->ioc_rval = -1;
347: adsp_iocnak(gref, mp, EINVAL);
348: return 0;
349: }
350: } else {
351: adsp_inputC[v] = 1;
352: adsp_inputQ[v] = sp;
353: adsp_pidM[v] = sp->pid;
354: ATENABLE(s, adspall_lock);
355: adsp_dequeue_ccb(sp);
356: }
357: *(unsigned char *)gbuf_rptr(gbuf_cont(mp)) = v;
358: sp->localSocket = v;
359: iocbp->ioc_rval = 0;
360: adsp_iocack(gref, mp);
361: }
362: return 0;
363: }
364:
365: case ADSPGETSOCK:
366: case ADSPGETPEER:
367: {
368: at_inet_t *addr;
369:
370: if (((xm = gbuf_cont(mp)) == NULL)
371: && ((xm = gbuf_alloc(sizeof(at_inet_t), PRI_MED)) == NULL)) {
372: iocbp->ioc_rval = -1;
373: adsp_iocnak(gref, mp, ENOBUFS);
374: return 0;
375: }
376: gbuf_cont(mp) = xm;
377: gbuf_wset(xm,sizeof(at_inet_t));
378: addr = (at_inet_t *)gbuf_rptr(xm);
379: if (iocbp->ioc_cmd == ADSPGETSOCK) {
380: /* Obtain Network and Node Id's from DDP */
381: /* *** was ddp_get_cfg() *** */
382: addr->net = ifID_home->ifThisNode.s_net;
383: addr->node = ifID_home->ifThisNode.s_node;
384: addr->socket = (sp)? sp->localSocket: 0;
385: } else
386: if (sp)
387: *addr = sp->remoteAddress.a;
388: else {
389: addr->net = 0;
390: addr->node = 0;
391: addr->socket = 0;
392: }
393: iocbp->ioc_rval = 0;
394: adsp_iocack(gref, mp);
395: return 0;
396: }
397: case DDP_IOC_GET_CFG:
398: /* respond to an DDP_IOC_GET_CFG sent on an adsp fd */
399: if (((xm = gbuf_cont(mp)) == NULL) &&
400: (xm = gbuf_alloc(sizeof(at_inet_t), PRI_MED)) == NULL) {
401: iocbp->ioc_rval = -1;
402: adsp_iocnak(gref, mp, ENOBUFS);
403: return 0;
404: }
405: gbuf_cont(mp) = xm;
406: gbuf_wset(xm, sizeof(ddp_addr_t));
407: /* Obtain Network and Node Id's from DDP */
408: {
409: /* *** was ddp_get_cfg() *** */
410: ddp_addr_t *cfgp =
411: (ddp_addr_t *)gbuf_rptr(gbuf_cont(mp));
412: cfgp->inet.net = ifID_home->ifThisNode.s_net;
413: cfgp->inet.node = ifID_home->ifThisNode.s_node;
414: cfgp->inet.socket = (sp)? sp->localSocket: 0;
415: cfgp->ddptype = DDP_ADSP;
416: }
417: iocbp->ioc_rval = 0;
418: adsp_iocack(gref, mp);
419: return 0;
420: } /* switch */
421: }
422:
423: if (!gref->info)
424: gbuf_freem(mp);
425: else {
426: ATDISABLE(s, sp->lockClose);
427: rc = adspWriteHandler(gref, mp);
428: ATENABLE(s, sp->lockClose);
429:
430: switch (rc) {
431: case STR_PUTNEXT:
432: if (gbuf_type(mp) == MSG_IOCTL) {
433: iocbp = (ioc_t *)gbuf_rptr(mp);
434: iocbp->ioc_private = (void *)gref;
435: }
436: DDP_OUTPUT(mp);
437: break;
438: case STR_IGNORE:
439: case STR_IGNORE+99:
440: break;
441: default:
442: gbuf_freem(mp);
443: break;
444: }
445: }
446:
447: return 0;
448: } /* adsp_wput */
449:
450: void adspioc_ack(errno, m, gref)
451: int errno;
452: gbuf_t *m;
453: gref_t *gref;
454: {
455: ioc_t *iocbp;
456:
457: if (m == NULL)
458: return;
459: iocbp = (ioc_t *) gbuf_rptr(m);
460:
461: iocbp->ioc_error = errno; /* set the errno */
462: iocbp->ioc_count = gbuf_msgsize(gbuf_cont(m));
463: if (gbuf_type(m) == MSG_IOCTL) /* if an ioctl, this is an ack */
464: gbuf_set_type(m, MSG_IOCACK); /* and ALWAYS update the user */
465: /* ioctl structure */
466: trace_mbufs(D_M_ADSP,"A ", m);
467: SndMsgUp(gref, m);
468: }
469:
470: static void adsp_iocack(gref, m)
471: gref_t *gref;
472: register gbuf_t *m;
473: {
474: if (gbuf_type(m) == MSG_IOCTL)
475: gbuf_set_type(m, MSG_IOCACK);
476:
477: if (gbuf_cont(m))
478: ((ioc_t *)gbuf_rptr(m))->ioc_count = gbuf_msgsize(gbuf_cont(m));
479: else
480: ((ioc_t *)gbuf_rptr(m))->ioc_count = 0;
481:
482: SndMsgUp(gref, m);
483: }
484:
485:
486: static void adsp_iocnak(gref, m, err)
487: gref_t *gref;
488: register gbuf_t *m;
489: register int err;
490: {
491: if (gbuf_type(m) == MSG_IOCTL)
492: gbuf_set_type(m, MSG_IOCNAK);
493: ((ioc_t *)gbuf_rptr(m))->ioc_count = 0;
494:
495: if (err == 0)
496: err = ENXIO;
497: ((ioc_t *)gbuf_rptr(m))->ioc_error = err;
498:
499: if (gbuf_cont(m)) {
500: gbuf_freem(gbuf_cont(m));
501: gbuf_cont(m) = NULL;
502: }
503: SndMsgUp(gref, m);
504: }
505:
506: unsigned char
507: adspAssignSocket(gref, flag)
508: gref_t *gref;
509: int flag;
510: {
511: unsigned char sVal, sMax, sMin, sSav, inputC;
512: CCBPtr sp;
513: int s;
514:
515: sMax = flag ? DDP_SOCKET_LAST-46 : DDP_SOCKET_LAST-6;
516: sMin = DDP_SOCKET_1st_DYNAMIC-64;
517:
518: ATDISABLE(s, adspall_lock);
519: for (inputC=255, sVal=sMax; sVal >= sMin; sVal--) {
520: if (!ot_adsp_socketM[sVal]) {
521: if (!adsp_inputQ[sVal])
522: break;
523: else if (flag) {
524: if ((adsp_inputC[sVal] < inputC)
525: && (adsp_inputQ[sVal]->state == sOpen)) {
526: inputC = adsp_inputC[sVal];
527: sSav = sVal;
528: }
529: }
530: }
531: }
532:
533: if (sVal < sMin) {
534: if (!flag || (inputC == 255)) {
535: ATENABLE(s, adspall_lock);
536: return 0;
537: }
538: sVal = sSav;
539: }
540: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
541: ATENABLE(s, adspall_lock);
542: adsp_dequeue_ccb(sp);
543: ATDISABLE(s, adspall_lock);
544: adsp_inputC[sVal]++;
545: sp->otccbLink = adsp_inputQ[sVal];
546: adsp_inputQ[sVal] = sp;
547: if (!flag)
548: adsp_pidM[sVal] = sp->pid;
549: ATENABLE(s, adspall_lock);
550: return sVal;
551: }
552:
553: int
554: adspDeassignSocket(sp)
555: CCBPtr sp;
556: {
557: unsigned char sVal;
558: CCBPtr curr_sp;
559: CCBPtr prev_sp;
560: int pid = 0;
561: int s, l;
562:
563: dPrintf(D_M_ADSP, D_L_TRACE, ("adspDeassignSocket: pid=%d,s=%d\n",
564: sp->pid, sp->localSocket));
565: ATDISABLE(s, adspall_lock);
566: sVal = sp->localSocket;
567: if ((curr_sp = adsp_inputQ[sVal]) != 0) {
568: prev_sp = 0;
569: while (curr_sp != sp) {
570: prev_sp = curr_sp;
571: curr_sp = curr_sp->otccbLink;
572: }
573: if (curr_sp) {
574: ATDISABLE(l, sp->lockRemove);
575: if (prev_sp)
576: prev_sp->otccbLink = sp->otccbLink;
577: else
578: adsp_inputQ[sVal] = sp->otccbLink;
579: ATENABLE(l, sp->lockRemove);
580: if (adsp_inputQ[sVal])
581: adsp_inputC[sVal]--;
582: else {
583: pid = adsp_pidM[sVal];
584: adsp_inputC[sVal] = 0;
585: adsp_pidM[sVal] = 0;
586: }
587: sp->ccbLink = 0;
588: sp->otccbLink = 0;
589: sp->localSocket = 0;
590: ATENABLE(s, adspall_lock);
591: return pid ? 0 : 1;
592: }
593: }
594: ATENABLE(s, adspall_lock);
595:
596: dPrintf(D_M_ADSP, D_L_ERROR,
597: ("adspDeassignSocket: closing, no CCB block, trouble ahead\n"));
598: return -1;
599: } /* adspDeassignSocket */
600:
601: /*
602: * remove CCB from the use list
603: */
604: void
605: adsp_dequeue_ccb(sp)
606: CCB *sp;
607: {
608: int s;
609:
610: ATDISABLE(s, adspall_lock);
611: if (sp == ccb_used_list) {
612: if ((ccb_used_list = sp->otccbLink) != 0)
613: sp->otccbLink->ccbLink = 0;
614: } else if (sp->ccbLink) {
615: if ((sp->ccbLink->otccbLink = sp->otccbLink) != 0)
616: sp->otccbLink->ccbLink = sp->ccbLink;
617: }
618:
619: sp->otccbLink = 0;
620: sp->ccbLink = 0;
621: ATENABLE(s, adspall_lock);
622: }
623:
624: void SndMsgUp(gref, mp)
625: gref_t *gref; /* WRITE queue */
626: gbuf_t *mp;
627: {
628: /*
629: dPrintf(D_M_ADSP, D_L_TRACE,
630: ("SndMsgUp: gref=0x%x, mbuf=0x%x\n", (unsigned)gref, (unsigned)mp));
631: trace_mbufs(D_M_ADSP, " m", mp);
632: */
633: atalk_putnext(gref, mp);
634: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.