![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys_glue.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 sys_glue.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: * Copyright (c) 1995 Apple Computer, Inc.
27: *
28: * The information contained herein is subject to change without
29: * notice and should not be construed as a commitment by Apple
30: * Computer, Inc. Apple Computer, Inc. assumes no responsibility
31: * for any errors that may appear.
32: *
33: * Confidential and Proprietary to Apple Computer, Inc.
34: *
35: */
36: #ifdef _AIX
37: #include <sys/sleep.h>
38: #include <sys/poll.h>
39: #endif
40: #include <sys/ioccom.h>
41: #include <h/sysglue.h>
42: #include <at/appletalk.h>
43: #include <at/elap.h>
44: #include <at/ddp.h>
45: #include <at/at_lap.h>
46: #include <at_elap.h>
47: #include <h/at_ddp.h>
48: #undef e_sleep_thread
49:
50: /*definition of dbgBits moved here to avoid multiple redefinition */
51: dbgBits_t dbgBits;
52:
53: int _ATsocket(proto, err, proc)
54: int proto;
55: int *err;
56: void *proc;
57: {
58: int fd;
59: gref_t *gref;
60:
61: /* make sure the specified protocol id is valid */
62: switch (proto) {
63: case ATPROTO_DDP:
64: case ATPROTO_LAP:
65: case ATPROTO_ATP:
66: case ATPROTO_ASP:
67: case ATPROTO_AURP:
68: case ATPROTO_ADSP:
69: break;
70: default:
71: *err = EPROTOTYPE;
72: #ifdef APPLETALK_DEBUG
73: kprintf("_ATsocket: error EPROTOTYPE =%d\n", *err);
74: #endif
75: return -1;
76: }
77:
78: /* allocate a protocol channel */
79: if ((*err = gref_open(&gref)) != 0) {
80: #ifdef APPLETALK_DEBUG
81: kprintf("_ATsocket: error gref_open =%d\n", *err);
82: #endif
83: return -1;
84: }
85: gref->proto = proto;
86: #ifdef NEXT
87: gref->pid = ((struct proc *)proc)->p_pid;
88: #endif
89:
90: /* open the specified protocol */
91: switch (gref->proto) {
92: case ATPROTO_DDP:
93: *err = ddp_open(gref); break;
94: case ATPROTO_LAP:
95: *err = lap_open(gref); break;
96: case ATPROTO_ATP:
97: *err = atp_open(gref, 1); break;
98: case ATPROTO_ASP:
99: *err = asp_open(gref); break;
100: #ifdef AURP_SUPPORT
101: case ATPROTO_AURP:
102: *err = aurp_open(gref); break;
103: #endif
104: case ATPROTO_ADSP:
105: *err = adsp_open(gref); break;
106: }
107:
108: /* create the descriptor for the channel */
109: if (*err)
110: gref->proto = ATPROTO_NONE;
111: if (*err || (*err = atalk_openref(gref, &fd, proc))) {
112: #ifdef APPLETALK_DEBUG
113: kprintf("_ATsocket: error atalk_openref =%d\n", *err);
114: #endif
115: gref_close(gref);
116: return -1;
117: }
118: /*
119: kprintf("_ATsocket: proto=%d return=%d fd=%d\n", proto, *err, fd);
120: */
121: return fd;
122: }
123:
124: int _ATgetmsg(fd, ctlptr, datptr, flags, err, proc)
125: int fd;
126: strbuf_t *ctlptr;
127: strbuf_t *datptr;
128: int *flags;
129: int *err;
130: void *proc;
131: {
132: int rc = -1;
133: gref_t *gref;
134:
135: if ((*err = atalk_getref(0, fd, &gref, proc)) == 0) {
136: switch (gref->proto) {
137: case ATPROTO_ASP:
138: rc = ASPgetmsg(gref, ctlptr, datptr, flags, err); break;
139: case ATPROTO_AURP:
140: #ifdef AURP_SUPPORT
141: rc = AURPgetmsg(err); break;
142: #endif
143: default:
144: *err = EPROTONOSUPPORT; break;
145: }
146: }
147:
148:
149: /* kprintf("_ATgetmsg: return=%d\n", *err);*/
150: return rc;
151: }
152:
153: int _ATputmsg(fd, ctlptr, datptr, flags, err, proc)
154: int fd;
155: strbuf_t *ctlptr;
156: strbuf_t *datptr;
157: int flags;
158: int *err;
159: void *proc;
160: {
161: int rc = -1;
162: gref_t *gref;
163:
164: if ((*err = atalk_getref(0, fd, &gref, proc)) == 0) {
165: switch (gref->proto) {
166: case ATPROTO_ASP:
167: rc = ASPputmsg(gref, ctlptr, datptr, flags, err); break;
168: default:
169: *err = EPROTONOSUPPORT; break;
170: }
171: }
172:
173: /* kprintf("_ATputmsg: return=%d\n", *err); */
174: return rc;
175: }
176:
177: int _ATclose(fp, proc)
178: void *fp;
179: void *proc;
180: {
181: int err;
182: gref_t *gref;
183:
184: if ((err = atalk_closeref(fp, &gref)) != 0)
185: return err;
186:
187: gref_close(gref);
188: return 0;
189: }
190:
191: int _ATrw(fp, rw, uio, ext)
192: void *fp;
193: enum uio_rw rw;
194: struct uio *uio;
195: int ext;
196: {
197: void gref_wput();
198: int s, err, len, rlen, clen, res;
199: gref_t *gref;
200: gbuf_t *m, *mhead, *mprev;
201:
202: if ((err = atalk_getref(fp, 0, &gref, 0)) != 0)
203: return err;
204:
205: if ((len = uio->uio_resid) == 0)
206: return 0;
207:
208: ATDISABLE(s, gref->lock);
209: if (gref->errno) {
210: ATENABLE(s, gref->lock);
211: return (int)gref->errno;
212: }
213:
214: if (rw == UIO_READ) {
215: while ((gref->errno == 0) && ((mhead = gref->rdhead) == 0)) {
216: gref->sevents |= POLLMSG;
217: err = tsleep(&gref->event, PSOCK | PCATCH, "AT read", 0);
218: gref->sevents &= ~POLLMSG;
219: if (err != 0) {
220: ATENABLE(s, gref->lock);
221: return err;
222: }
223: }
224:
225: if (gref->errno) {
226: ATENABLE(s, gref->lock);
227: return EPIPE;
228: }
229: if ((gref->rdhead = gbuf_next(mhead)) == 0)
230: gref->rdtail = 0;
231:
232: ATENABLE(s, gref->lock);
233:
234: gbuf_next(mhead) = 0;
235:
236: for (mprev=0, m=mhead, rlen=0; m && len; rlen+=clen, len-=clen) {
237: if ((clen = gbuf_len(m)) > 0) {
238: if (clen > len)
239: clen = len;
240: #ifdef _AIX
241: if (uiomove((caddr_t)gbuf_rptr(m), clen, UIO_READ, uio) == -1)
242: break;
243: #else
244: uio->uio_rw = UIO_READ;
245: res= uiomove((caddr_t)gbuf_rptr(m), clen, uio);
246: /* kprintf("_ATrw: UIO_READ: res=%d\n", res); */
247: if (res == -1)
248: break;
249: #endif
250: if (gbuf_len(m) > len) {
251: gbuf_rinc(m,clen);
252: break;
253: }
254: }
255: mprev = m;
256: m = gbuf_cont(m);
257: }
258: if (m) {
259: if (mprev)
260: gbuf_cont(mprev) = 0;
261: else
262: mhead = 0;
263: ATDISABLE(s, gref->lock);
264: if (gref->rdhead == 0)
265: gref->rdtail = m;
266: gbuf_next(m) = gref->rdhead;
267: gref->rdhead = m;
268: ATENABLE(s, gref->lock);
269: }
270: if (mhead)
271: gbuf_freem(mhead);
272:
273: } else {
274: if (gref->writeable) {
275: while (!(*gref->writeable)(gref)) {
276: /* flow control on, wait to be enabled to write */
277: gref->sevents |= POLLSYNC;
278: err = tsleep(&gref->event, PSOCK | PCATCH, "AT write", 0);
279: gref->sevents &= ~POLLSYNC;
280: if (err != 0) {
281: ATENABLE(s, gref->lock);
282: return err;
283: }
284: }
285: }
286:
287: ATENABLE(s, gref->lock);
288:
289: /* allocate a buffer to copy in the write data */
290: if ((m = gbuf_alloc(AT_WR_OFFSET+len, PRI_MED)) == 0)
291: return ENOBUFS;
292: gbuf_rinc(m,AT_WR_OFFSET);
293: gbuf_wset(m,len);
294:
295: /* copy in the write data */
296: #ifdef _AIX
297: if (uiomove((caddr_t)gbuf_rptr(m), len, UIO_WRITE, uio) == -1) {
298: #else
299: uio->uio_rw = UIO_WRITE;
300: res= uiomove((caddr_t)gbuf_rptr(m), len, uio);
301: /* kprintf("_ATrw: UIO_WRITE: res=%d\n", res); */
302: if (res == -1) {
303: #endif
304: gbuf_freeb(m);
305: return EIO;
306: }
307:
308: /* forward the write data to the appropriate protocol module */
309: gref_wput(gref, m);
310: }
311:
312: return 0;
313: }
314:
315: int _ATread(fp, uio, cred)
316: void *fp;
317: struct uio *uio;
318: void *cred;
319: {
320: return _ATrw(fp, UIO_READ, uio, 0);
321: }
322:
323: int _ATwrite(fp, uio, cred)
324: void *fp;
325: struct uio *uio;
326: void *cred;
327: {
328: return _ATrw(fp, UIO_WRITE, uio, 0);
329: }
330: /*
331: struct at_ioctl_args {
332: int fdes;
333: u_long cmd;
334: caddr_t arg;
335: };
336: int _ATioctl(p, uap, retval)
337: struct proc *p;
338: register struct at_ioctl_args *uap;
339: register_t *retval;
340: */
341: int _ATioctl(fp, cmd, arg, proc)
342: void *fp;
343: u_long cmd;
344: register caddr_t arg;
345: void *proc;
346: {
347: void gref_wput();
348: int s, err, len;
349: gref_t *gref;
350: gbuf_t *m, *mdata;
351: ioc_t *ioc;
352: ioccmd_t ioccmd;
353:
354:
355: if ((err = atalk_getref(fp, 0, &gref, 0)) != 0) {
356: #ifdef APPLETALK_DEBUG
357: kprintf("_ATioctl: atalk_getref=%d\n", err);
358: #endif
359: return err;
360: }
361:
362: /* error if not for us */
363: if ((cmd & 0xffff) != 0xff99)
364: return EOPNOTSUPP;
365:
366: /* copy in ioc command info */
367: /*
368: kprintf("_ATioctl: arg ioccmd.ic_cmd=%x ic_len=%x gref->lock=%x, gref->event=%x\n",
369: ((ioccmd_t *)arg)->ic_cmd, ((ioccmd_t *)arg)->ic_len, gref->lock, gref->event);
370: */
371: if ((err = copyin((caddr_t)arg,
372: (caddr_t)&ioccmd, sizeof(ioccmd_t))) != 0) {
373: #ifdef APPLETALK_DEBUG
374: kprintf("_ATioctl: err = %d, copyin(%x, %x, %d)\n", err, (caddr_t)arg,
375: (caddr_t)&ioccmd, sizeof(ioccmd_t));
376: #endif
377: return err;
378: }
379:
380: /* allocate a buffer to create an ioc command */
381: if ((m = gbuf_alloc(sizeof(ioc_t), PRI_HI)) == 0)
382: return ENOBUFS;
383: gbuf_wset(m,sizeof(ioc_t));
384: gbuf_set_type(m, MSG_IOCTL);
385:
386: /* create the ioc command */
387: if (ioccmd.ic_len) {
388: if ((gbuf_cont(m) = gbuf_alloc(ioccmd.ic_len, PRI_HI)) == 0) {
389: gbuf_freem(m);
390: #ifdef APPLETALK_DEBUG
391: kprintf("_ATioctl: gbuf_alloc err=%d\n",ENOBUFS);
392: #endif
393: return ENOBUFS;
394: }
395: gbuf_wset(gbuf_cont(m),ioccmd.ic_len);
396: if ((err = copyin((caddr_t)ioccmd.ic_dp,
397: (caddr_t)gbuf_rptr(gbuf_cont(m)), ioccmd.ic_len)) != 0) {
398: gbuf_freem(m);
399: return err;
400: }
401: }
402: ioc = (ioc_t *)gbuf_rptr(m);
403: ioc->ioc_cmd = ioccmd.ic_cmd;
404: ioc->ioc_count = ioccmd.ic_len;
405: ioc->ioc_error = 0;
406: ioc->ioc_rval = 0;
407:
408: /* send the ioc command to the appropriate recipient */
409: gref_wput(gref, m);
410:
411: /* wait for the ioc ack */
412: ATDISABLE(s, gref->lock);
413: while ((m = gref->ichead) == 0) {
414: gref->sevents |= POLLPRI;
415: err = tsleep(&gref->iocevent, PSOCK | PCATCH, "AT ioctl", 0);
416: gref->sevents &= ~POLLPRI;
417: if (err != 0) {
418: ATENABLE(s, gref->lock);
419: #ifdef APPLETALK_DEBUG
420: kprintf("_ATioctl: EINTR\n");
421: #endif
422: return err;
423: }
424: }
425:
426: /* PR-2224797 */
427: if (gbuf_next(m) == m) /* error case */
428: gbuf_next(m) = 0;
429:
430: gref->ichead = gbuf_next(m);
431:
432: ATENABLE(s, gref->lock);
433:
434:
435: /* kprintf("_ATioctl: woke up from tread sleep\n"); */
436: /* process the ioc response */
437: ioc = (ioc_t *)gbuf_rptr(m);
438: if ((err = ioc->ioc_error) == 0) {
439: ioccmd.ic_timout = ioc->ioc_rval;
440: ioccmd.ic_len = 0;
441: mdata = gbuf_cont(m);
442: if (mdata && ioccmd.ic_dp) {
443: ioccmd.ic_len = gbuf_msgsize(mdata);
444: for (len=0; mdata; mdata=gbuf_cont(mdata)) {
445: if ((err = copyout((caddr_t)gbuf_rptr(mdata),
446: (caddr_t)&ioccmd.ic_dp[len], gbuf_len(mdata))) < 0) {
447: #ifdef APPLETALK_DEBUG
448: kprintf("_ATioctl: len=%d error copyout=%d from=%x to=%x gbuf_len=%x\n",
449: len, err, (caddr_t)gbuf_rptr(mdata),
450: (caddr_t)&ioccmd.ic_dp[len], gbuf_len(mdata));
451: #endif
452: goto l_done;
453: }
454: len += gbuf_len(mdata);
455: }
456: }
457: if ((err = copyout((caddr_t)&ioccmd,
458: (caddr_t)arg, sizeof(ioccmd_t))) != 0) {
459: #ifdef APPLETALK_DEBUG
460: kprintf("_ATioctl: error copyout2=%d from=%x to=%x len=%d\n",
461: err, &ioccmd, arg, sizeof(ioccmd_t));
462: #endif
463: goto l_done;
464: }
465: }
466:
467: l_done:
468: gbuf_freem(m);
469: /*kprintf("_ATioctl: I_done=%d\n", err);*/
470: return err;
471: }
472:
473: #ifndef _AIX
474: int _ATselect(fp, which, proc)
475: void *fp;
476: int which;
477: void *proc;
478: {
479: int s, err, rc = 0;
480: gref_t *gref;
481:
482: if ((err = atalk_getref(fp, 0, &gref, 0)) != 0)
483: return err;
484:
485: ATDISABLE(s, gref->lock);
486: if (which == FREAD) {
487: if (gref->rdhead || (gref->readable && (*gref->readable)(gref)))
488: rc = 1;
489: else {
490: gref->sevents |= POLLIN;
491: selrecord(proc, &gref->si);
492: }
493: }
494:
495: else if (which == POLLOUT) {
496: if (gref->writeable) {
497: if ((*gref->writeable)(gref))
498: rc = 1;
499: else {
500: gref->sevents |= POLLOUT;
501: selrecord(proc, &gref->si);
502: }
503: } else
504: rc = 1;
505: }
506: ATENABLE(s, gref->lock);
507:
508: return rc;
509: }
510:
511: #else /* AIX code is no longer supported. */
512:
513: int _ATselect(fp, corl, reqevents, retevents, notify)
514: void *fp;
515: int corl;
516: unsigned short reqevents;
517: unsigned short *retevents;
518: void (*notify)();
519: {
520: int s, err, rc = 0;
521: gref_t *gref;
522: unsigned short sevents = 0;
523:
524: if ((err = atalk_getref(fp, 0, &gref, 0)) != 0)
525: return err;
526:
527: ATDISABLE(s, gref->lock);
528: if (reqevents & POLLIN) {
529: if (gref->rdhead || (gref->readable && (*gref->readable)(gref)))
530: sevents |= POLLIN;
531: }
532:
533: if (reqevents & POLLOUT) {
534: if (gref->writeable) {
535: if ((*gref->writeable)(gref))
536: sevents |= POLLOUT;
537: } else
538: sevents |= POLLOUT;
539: }
540:
541: if ((sevents == 0) && ((reqevents & POLLSYNC) == 0)) {
542: if (rc = selreg(corl, 99, gref, reqevents, notify)) {
543: ATENABLE(s, gref->lock);
544: goto l_done;
545: }
546:
547: if (reqevents & POLLIN) {
548: if (gref->rdhead || (gref->readable && (*gref->readable)(gref)))
549: sevents |= POLLIN;
550: else
551: gref->sevents |= POLLIN;
552: }
553:
554: if (reqevents & POLLOUT) {
555: if (gref->writeable) {
556: if ((*gref->writeable)(gref))
557: sevents |= POLLOUT;
558: else
559: gref->sevents |= POLLOUT;
560: } else
561: sevents |= POLLOUT;
562: }
563: }
564: ATENABLE(s, gref->lock);
565: *retevents = sevents;
566:
567: l_done:
568: return rc;
569: }
570:
571: int _ATstat()
572: {
573: return 0;
574: }
575: #endif /* end AIX section */
576:
577: void atalk_putnext(gref, m)
578: gref_t *gref;
579: gbuf_t *m;
580: {
581: int s;
582:
583: ATDISABLE(s, gref->lock);
584:
585: gbuf_next(m) = 0;
586:
587: if ((gbuf_type(m) == MSG_IOCACK) || (gbuf_type(m) == MSG_IOCNAK)) {
588: if (gref->ichead)
589: gbuf_next(gref->ichead) = m;
590: else {
591: gref->ichead = m;
592: if (gref->sevents & POLLPRI) {
593: /*kprintf("atalk_putnext: wake up gref->event=%x\n", &gref->event);*/
594: thread_wakeup(&gref->iocevent);
595: }
596: atalk_notify_sel(gref);
597: }
598:
599: } else {
600: if (gref->errno == 0) {
601: if (gbuf_type(m) == MSG_ERROR) {
602: gref->errno = *gbuf_rptr(m);
603: if (gref->rdhead) {
604: gbuf_freel(gref->rdhead);
605: gref->rdhead = 0;
606: }
607: if (gref->sevents & POLLMSG) {
608: gref->sevents &= ~POLLMSG;
609: /*kprintf("atalk_putnext: wake up gref->event=%x\n", &gref->event);*/
610: thread_wakeup(&gref->event);
611: }
612: if (gref->sevents & POLLIN) {
613: gref->sevents &= ~POLLIN;
614: /*kprintf("atalk_putnext: selwakeup gref->si=%x\n", &gref->si); */
615: selwakeup(&gref->si);
616: }
617: } else if (gref->rdhead) {
618: gbuf_next(gref->rdtail) = m;
619: gref->rdtail = m;
620: } else {
621: gref->rdhead = m;
622: if (gref->sevents & POLLMSG) {
623: gref->sevents &= ~POLLMSG;
624: /*kprintf("atalk_putnext: wake up2 gref->event=%x\n", &gref->event);*/
625: thread_wakeup(&gref->event);
626: }
627: if (gref->sevents & POLLIN) {
628: gref->sevents &= ~POLLIN;
629: /*kprintf("atalk_putnext: selwakeup2 gref->si=%x\n", &gref->si);*/
630: selwakeup(&gref->si);
631: }
632: gref->rdtail = m;
633: }
634: }
635: }
636:
637: ATENABLE(s, gref->lock);
638: }
639:
640: void atalk_enablew(gref)
641: gref_t *gref;
642: {
643: if (gref->sevents & POLLSYNC)
644: #ifdef _AIX
645: e_wakeup(&gref->event);
646: #else
647: thread_wakeup(&gref->event);
648: #endif
649: }
650:
651: void atalk_flush(gref)
652: gref_t *gref;
653: {
654: int s;
655:
656: ATDISABLE(s, gref->lock);
657: if (gref->rdhead) {
658: gbuf_freel(gref->rdhead);
659: gref->rdhead = 0;
660: }
661: if (gref->ichead) {
662: gbuf_freel(gref->ichead);
663: gref->ichead = 0;
664: }
665: ATENABLE(s, gref->lock);
666: }
667:
668: void atalk_notify_sel(gref)
669: gref_t *gref;
670: {
671: int s;
672:
673: ATDISABLE(s, gref->lock);
674: if (gref->sevents & POLLIN) {
675: gref->sevents &= ~POLLIN;
676: selwakeup(&gref->si);
677: }
678: ATENABLE(s, gref->lock);
679: }
680:
681: int atalk_peek(gref, event)
682: gref_t *gref;
683: unsigned char *event;
684: {
685: int s, rc;
686:
687: ATDISABLE(s, gref->lock);
688: if (gref->rdhead) {
689: *event = *gbuf_rptr(gref->rdhead);
690: rc = 0;
691: } else
692: rc = -1;
693: ATENABLE(s, gref->lock);
694:
695: return rc;
696: }
697:
698: static gbuf_t *trace_msg;
699:
700: void atalk_settrace(str, p1, p2, p3, p4, p5)
701: char *str;
702: {
703: int len;
704: gbuf_t *m, *nextm;
705: char trace_buf[256];
706:
707: sprintf(trace_buf, str, p1, p2, p3, p4, p5);
708: len = strlen(trace_buf);
709: #ifdef APPLETALK_DEBUG
710: kprintf("atalk_settrace: gbufalloc size=%d\n", len+1);
711: #endif
712: if ((m = gbuf_alloc(len+1, PRI_MED)) == 0)
713: return;
714: gbuf_wset(m,len);
715: strcpy(gbuf_rptr(m), trace_buf);
716: if (trace_msg) {
717: for (nextm=trace_msg; gbuf_cont(nextm); nextm=gbuf_cont(nextm)) ;
718: gbuf_cont(nextm) = m;
719: } else
720: trace_msg = m;
721: }
722:
723: void atalk_gettrace(m)
724: gbuf_t *m;
725: {
726: if (trace_msg) {
727: gbuf_cont(m) = trace_msg;
728: trace_msg = 0;
729: }
730: }
731:
732: #define GREF_PER_BLK 32
733: static gref_t *gref_free_list = 0;
734: atlock_t refall_lock;
735:
736: void gref_init()
737: {
738: ATLOCKINIT(refall_lock);
739: }
740:
741: gref_t *gref_alloc()
742: {
743: extern gbuf_t *atp_resource_m;
744: int i, s;
745: gbuf_t *m;
746: gref_t *gref, *gref_array;
747:
748: ATDISABLE(s, refall_lock);
749: if (gref_free_list == 0) {
750: ATENABLE(s, refall_lock);
751: #ifdef APPLETALK_DEBUG
752: kprintf("gref_alloc: gbufalloc size=%d\n", GREF_PER_BLK*sizeof(gref_t));
753: #endif
754: if ((m = gbuf_alloc(GREF_PER_BLK*sizeof(gref_t),PRI_HI)) == 0)
755: return (gref_t *)0;
756: bzero(gbuf_rptr(m), GREF_PER_BLK*sizeof(gref_t));
757: gref_array = (gref_t *)gbuf_rptr(m);
758: for (i=0; i < GREF_PER_BLK-1; i++)
759: gref_array[i].next = (gref_t *)&gref_array[i+1];
760: ATDISABLE(s, refall_lock);
761: gbuf_cont(m) = atp_resource_m;
762: atp_resource_m = m;
763: gref_array[i].next = gref_free_list;
764: gref_free_list = (gref_t *)&gref_array[0];
765: }
766:
767: gref = gref_free_list;
768: gref_free_list = gref->next;
769: ATENABLE(s, refall_lock);
770: ATLOCKINIT(gref->lock);
771: ATEVENTINIT(gref->event);
772: ATEVENTINIT(gref->iocevent);
773:
774: return gref;
775: }
776:
777: void gref_free(gref)
778: gref_t *gref;
779: {
780: int s;
781:
782: ATDISABLE(s, refall_lock);
783: bzero((char *)gref, sizeof(gref_t));
784: gref->next = gref_free_list;
785: gref_free_list = gref;
786: ATENABLE(s, refall_lock);
787: }
788:
789: int gref_open(grefp)
790: gref_t **grefp;
791: {
792: gref_t *gref;
793:
794: /*
795: * if no gref structure available, return failure
796: */
797: if ((gref = (gref_t *)gref_alloc()) == 0)
798: return ENOBUFS;
799: #ifndef NEXT
800: gref->pid = getpid();
801: #endif
802: *grefp = gref;
803:
804: return 0;
805: }
806:
807: int gref_close(gref)
808: gref_t *gref;
809: {
810: int rc;
811:
812: switch (gref->proto) {
813: case ATPROTO_DDP:
814: rc = ddp_close(gref); break;
815: case ATPROTO_LAP:
816: rc = lap_close(gref); break;
817: case ATPROTO_ATP:
818: rc = atp_close(gref, 1); break;
819: case ATPROTO_ASP:
820: rc = asp_close(gref); break;
821: #ifdef AURP_SUPPORT
822: case ATPROTO_AURP:
823: rc = aurp_close(gref); break;
824: break;
825: #endif
826: case ATPROTO_ADSP:
827: rc = adsp_close(gref); break;
828: default:
829: rc = 0;
830: break;
831: }
832:
833: if (rc == 0) {
834: atalk_flush(gref);
835: selthreadclear(&gref->si);
836: gref_free(gref);
837: }
838:
839: return rc;
840: }
841:
842: void gref_wput(gref, m)
843: gref_t *gref;
844: gbuf_t *m;
845: {
846:
847: switch (gref->proto) {
848: case ATPROTO_DDP:
849: ddp_putmsg(gref, m); break;
850: case ATPROTO_LAP:
851: elap_wput(gref, m); break;
852: case ATPROTO_ATP:
853: atp_wput(gref, m); break;
854: case ATPROTO_ASP:
855: asp_wput(gref, m); break;
856: #ifdef AURP_SUPPORT
857: case ATPROTO_AURP:
858: aurp_wput(gref, m); break;
859: #endif
860: case ATPROTO_ADSP:
861: adsp_wput(gref, m); break;
862: case ATPROTO_NONE:
863: if (gbuf_type(m) == MSG_IOCTL) {
864: gbuf_freem(gbuf_cont(m));
865: gbuf_cont(m) = 0;
866: ((ioc_t *)gbuf_rptr(m))->ioc_rval = -1;
867: ((ioc_t *)gbuf_rptr(m))->ioc_error = EPROTO;
868: gbuf_set_type(m, MSG_IOCNAK);
869: atalk_putnext(gref, m);
870: } else
871: gbuf_freem(m);
872: break;
873: default:
874: gbuf_freem(m);
875: break;
876: }
877: }
878:
879: int gbuf_msgsize(m)
880: gbuf_t *m;
881: {
882: int size;
883:
884: for (size=0; m; m=gbuf_cont(m))
885: size += gbuf_len(m);
886: return size;
887: }
888:
889: /* Duplicate a single mbuf, attaching existing external storage. */
890: gbuf_t *gbuf_dupb(m)
891: gbuf_t *m;
892: {
893: return((gbuf_t *)m_copym(m, 0, gbuf_len(m), M_DONTWAIT));
894: }
895:
896: gbuf_t *gbuf_dupb_wait(m, wait)
897: gbuf_t *m;
898: int wait;
899: {
900: return((gbuf_t *)m_copym(m, 0, gbuf_len(m), (wait)? M_WAIT: M_DONTWAIT));
901: }
902:
903: /* Duplicate an mbuf chain, attaching existing external storage. */
904: gbuf_t *gbuf_dupm(mlist)
905: gbuf_t *mlist;
906: {
907: return((gbuf_t *)m_copym(mlist, 0, M_COPYALL, M_DONTWAIT));
908: }
909:
910: gbuf_t *gbuf_copym(mlist)
911: gbuf_t *mlist;
912: {
913: int len, offset;
914: gbuf_t *m, *mcurr, *mprev, *mhead;
915:
916: offset = AT_WR_OFFSET;
917: for (mhead = 0, m = mlist; m; m = gbuf_cont(m)) {
918: if ((len = gbuf_len(m)) == 0)
919: continue;
920: if ((mcurr = gbuf_alloc(offset+len, PRI_MED)) == 0) {
921: if (mhead)
922: gbuf_freem(mhead);
923: return (gbuf_t *)0;
924: }
925: gbuf_rinc(mcurr,offset);
926: gbuf_wset(mcurr,len);
927: gbuf_set_type(mcurr, gbuf_type(m));
928: bcopy(gbuf_rptr(m), gbuf_rptr(mcurr), len);
929: if (mhead)
930: gbuf_cont(mprev) = mcurr;
931: else {
932: mhead = mcurr;
933: offset = 0;
934: }
935: mprev = mcurr;
936: }
937:
938: return (gbuf_t *)mhead;
939: }
940:
941: void gbuf_freem(mlist)
942: gbuf_t *mlist;
943: {
944: m_freem((struct mbuf *)mlist);
945: }
946:
947: void gbuf_linkb(m1, m2)
948: gbuf_t *m1;
949: gbuf_t *m2;
950: {
951: while (gbuf_cont(m1) != 0)
952: m1 = gbuf_cont(m1);
953: gbuf_cont(m1) = m2;
954: }
955:
956: /**************************************/
957:
958: int ddp_adjmsg(m, len)
959: gbuf_t *m;
960: int len;
961: {
962: int buf_len;
963: gbuf_t *curr_m, *prev_m;
964:
965: if (m == (gbuf_t *)0)
966: return 0;
967:
968: if (len > 0) {
969: for (curr_m=m; curr_m;) {
970: buf_len = gbuf_len(curr_m);
971: if (len < buf_len) {
972: gbuf_rinc(curr_m,len);
973: return 1;
974: }
975: len -= buf_len;
976: gbuf_rinc(curr_m,buf_len);
977: if ((curr_m = gbuf_cont(curr_m)) == 0) {
978: gbuf_freem(m);
979: return 0;
980: }
981: }
982:
983: } else if (len < 0) {
984: len = -len;
985: l_cont: prev_m = 0;
986: for (curr_m=m; gbuf_cont(curr_m);
987: prev_m=curr_m, curr_m=gbuf_cont(curr_m)) ;
988: buf_len = gbuf_len(curr_m);
989: if (len < buf_len) {
990: gbuf_wdec(curr_m,len);
991: return 1;
992: }
993: if (prev_m == 0)
994: return 0;
995: gbuf_cont(prev_m) = 0;
996: gbuf_freeb(curr_m);
997: len -= buf_len;
998: goto l_cont;
999:
1000: } else
1001: return 1;
1002: }
1003:
1004: /*
1005: * The message chain, m is grown in size by len contiguous bytes.
1006: * If len is non-negative, len bytes are added to the
1007: * end of the gbuf_t chain. If len is negative, the
1008: * bytes are added to the front. ddp_growmsg only adds bytes to
1009: * message blocks of the same type.
1010: * It returns a pointer to the new gbuf_t on sucess, 0 on failure.
1011: */
1012:
1013: gbuf_t *ddp_growmsg(mp, len)
1014: gbuf_t *mp;
1015: int len;
1016: {
1017: gbuf_t *m, *d;
1018:
1019: if ((m = mp) == (gbuf_t *) 0)
1020: return ((gbuf_t *) 0);
1021:
1022: if (len <= 0) {
1023: len = -len;
1024: if ((d = gbuf_alloc(len, PRI_MED)) == 0)
1025: return ((gbuf_t *) 0);
1026: gbuf_set_type(d, gbuf_type(m));
1027: gbuf_wset(d,len);
1028: /* link in new gbuf_t */
1029: gbuf_cont(d) = m;
1030: return (d);
1031:
1032: } else {
1033: register int count;
1034: /*
1035: * Add to tail.
1036: */
1037: if ((count = gbuf_msgsize(m)) < 0)
1038: return ((gbuf_t *) 0);
1039: /* find end of chain */
1040: for ( ; m; m = gbuf_cont(m)) {
1041: if (gbuf_len(m) >= count)
1042: break;
1043: count -= gbuf_len(m);
1044: }
1045: /* m now points to gbuf_t to add to */
1046: if ((d = gbuf_alloc(len, PRI_MED)) == 0)
1047: return ((gbuf_t *) 0);
1048: gbuf_set_type(d, gbuf_type(m));
1049: /* link in new gbuf_t */
1050: gbuf_cont(d) = gbuf_cont(m);
1051: gbuf_cont(m) = d;
1052: gbuf_wset(d,len);
1053: return (d);
1054: }
1055: }
1056:
1057:
1058:
1059: /*
1060: * return an MSG_ERROR on the read stream. Note that the same message
1061: * block that caused the problem is used as the vehicle. So chained
1062: * blocks to this message will be free'd; i.e. ASSUMES no multiple
1063: * references.
1064: * Used by other appletalk modules, so it is not static!
1065: */
1066:
1067: void data_error(errno,mp,gref)
1068: int errno;
1069: register gbuf_t *mp;
1070: register gref_t *gref;
1071: {
1072:
1073: gbuf_set_type(mp, MSG_ERROR);
1074:
1075: *gbuf_rptr(mp) = (unsigned char)errno;
1076: gbuf_wset(mp,1);
1077: if (gbuf_cont(mp)) {
1078: gbuf_freem(gbuf_cont(mp));
1079: gbuf_cont(mp) = 0;
1080: }
1081:
1082: atalk_putnext(gref, mp);
1083: }
1084:
1085: /*
1086: * return the MSG_IOCACK/MSG_IOCNAK. Note that the same message
1087: * block is used as the vehicle, and that if there is an error return,
1088: * then linked blocks are lopped off. BEWARE of multiple references.
1089: * Used by other appletalk modules, so it is not static!
1090: */
1091:
1092: void ioc_ack(errno, m, gref)
1093: int errno;
1094: register gbuf_t *m;
1095: register gref_t *gref;
1096:
1097: {
1098: ioc_t *iocbp = (ioc_t *)gbuf_rptr(m);
1099:
1100: /*kprintf("ioc_ack: m=%x gref=%x errno=%d\n", m, gref, errno);*/
1101:
1102: if (gref->info == NULL) {
1103: gbuf_freem(m);
1104: #ifdef APPLETALK_DEBUG
1105: kprintf("ioc_ack: gref->info == NULL: free m\n");
1106: #endif
1107: return;
1108: }
1109: if ((iocbp->ioc_error = errno) != 0)
1110: { /* errno != 0, then there is an error, get rid of linked blocks! */
1111:
1112: if (gbuf_cont(m)) {
1113: gbuf_freem(gbuf_cont(m));
1114: gbuf_cont(m) = 0;
1115: }
1116: gbuf_set_type(m, MSG_IOCNAK);
1117: iocbp->ioc_count = 0; /* only make zero length if error */
1118: iocbp->ioc_rval = -1;
1119: } else
1120: gbuf_set_type(m, MSG_IOCACK);
1121:
1122: atalk_putnext(gref, m);
1123: }
1124:
1125: /* Queue management functions */
1126:
1127: void
1128: ddp_remque(elem)
1129: register LIB_QELEM_T *elem;
1130: {
1131: elem->q_back->q_forw = elem->q_forw;
1132: elem->q_forw->q_back = elem->q_back;
1133: }
1134:
1135: void
1136: ddp_insque(elem, prev)
1137: register LIB_QELEM_T *elem, *prev;
1138: {
1139: elem->q_back = prev;
1140: elem->q_forw = prev->q_forw;
1141: prev->q_forw->q_back = elem;
1142: prev->q_forw = elem;
1143: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.