![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chaos.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / chunix|
Return to chaos.c CVS log | Up to [Research Unix] / researchv8dc / sys / chunix |
1.1 root 1: /*
2: * UNIX device driver interface to the Chaos N.C.P.
3: */
4: #include "../chunix/chsys.h"
5: #include "../chunix/chconf.h"
6: #include "../chaos/chaos.h"
7: #include "../chaos/user.h"
8: #include "../chaos/dev.h"
9: #include "../h/inode.h"
10: #include "../h/file.h"
11: #include "../h/dir.h"
12: #include "../h/user.h"
13: #include "../h/conf.h"
14: #include "../h/ioctl.h"
15: #include "../h/buf.h"
16: #include "../h/systm.h"
17: #include "../h/tty.h"
18:
19: #ifdef VMUNIX
20: #include "cht.h"
21: #endif
22:
23: static int initted; /* NCP initialization flag */
24: int Rfcwaiting; /* Someone waiting on unmatched RFC */
25: static char *chnames[][3] = {
26: /* reading writing read/write */
27: { "uread", "ucreate", "ureadwrite", },
28: };
29:
30: #define CHFCONN(fp) ((fp)->f_conn)
31: #define CHIOPRIO (PZERO+1) /* Just interruptible */
32: #ifndef VMUNIX
33: #define setjmp save
34: #endif
35: static struct packet *fillpacket();
36: /*
37: * Open a chaos channel.
38: * Special case devices are indicated if CHHOST(dev) == CHHSPEC.
39: * See <chaos/dev.h> for the definitions.
40: * Non-special device opens imply a request to create a new connection
41: * via an RFC to a specified host, with a specified contact name string.
42: * The host number is specified one of three ways (CHHOST(dev)):
43: * CHHREAD Read an ascii host number from the remainder
44: * of the pathname (after the component that
45: * matched this device).
46: * CHHUSE Use the component that matched itself
47: * as an ascii number.
48: * else Use the CHHOST(dev) as an index into an
49: * internal host table where frequently used
50: * host numbers should reside.
51: * The contact name can also be specified in three ways (CHNAME(dev)):
52: * CHNREAD Read the contact string from the rest of the
53: * path name (possibly after host number).
54: * CHNUSE Read the contact string from the path
55: * component that matched (possibly after host
56: * number).
57: * else Use the CHNAME(dev) as an index into an
58: * internal array of contact names, also
59: * indexed by the type of open (read, write, rw).
60: */
61: chropen(dev, flag)
62: dev_t dev;
63: {
64: register struct connection *conn;
65: register struct packet *pkt;
66: int host, name, wstate;
67:
68: ch_bufalloc();
69: /* initialize the NCP somewhere else? */
70: if (!initted) {
71: chrreset(); /* Reset drivers */
72: chtimeout(); /* Start clock "process" */
73: initted++;
74: }
75: conn = NOCONN;
76: name = CHNAME(dev);
77: host = CHHOST(dev);
78: wstate = 0;
79: if (host == CHHSPEC)
80: switch (name) {
81: case CHUNMATCHED:
82: if(Chrfcrcv == 0) {
83: Chrfcrcv++;
84: return;
85: }
86: break;
87: /*
88: * Listens create a connection waiting for RFC's containing
89: * the given contact name. The returned file descriptor
90: * corresponds to a connection that may not be open yet.
91: * Use ioctls (CHIOCGSTAT, CHIOCSWAIT), to check or
92: * hang on the state of the connection.
93: */
94: case CHLISTEN:
95: if ((pkt = fillpacket("", 0)) != NOPKT)
96: conn = ch_listen(pkt);
97: break;
98: }
99: else {
100: register int len = DIRSIZ;
101: char *namp = u.u_dbuf;
102:
103: switch(host) {
104: case CHHREAD:
105: host = uatoi((char **)0);
106: break;
107: case CHHUSE:
108: host = uatoi(&namp); /* stuffs namp */
109: break;
110: default:
111: host = chhosts[host];
112: }
113: if (u.u_error)
114: host = 0;
115: switch(name) {
116: case CHNREAD:
117: namp = "";
118: len = 0;
119: break;
120: case CHNUSE:
121: len = DIRSIZ - (namp - u.u_dbuf);
122: break;
123: default:
124: len = CHMAXRFC;
125: if ((namp = chnames[name][flag-1]) == NONAME)
126: host = 0;
127: }
128: if (host != 0 && (pkt = fillpacket(namp, len)) != NOPKT &&
129: (conn = ch_open(host, CHDRWSIZE, pkt)) != NOCONN &&
130: CHHANGDEV(dev))
131: wstate = CSRFCSENT; /* Wait until OPEN/CLOSED */
132: }
133: if (conn == NOCONN) {
134: u.u_error = ENXIO;
135: ch_buffree();
136: } else {
137: register struct file *fp;
138:
139: fp = u.u_ofile[u.u_r.r_val1]; /* Yick. (see mx2.c) */
140: CHFCONN(fp) = (caddr_t)conn;
141: if (wstate) {
142: /*
143: * We should hang until the connection changes from
144: * its initial state.
145: * If interrupted, flush the connection.
146: */
147: #ifdef VMUNIX
148: if (setjmp(u.u_qsav) == 0) {
149: #else
150: if (save(u.u_qsav) == 0) {
151: #endif
152: spl6();
153: while (conn->cn_state == wstate)
154: sleep((caddr_t)conn, CHIOPRIO);
155: spl0();
156: #ifdef DEBUG
157: if (ch_badaddr((char *)conn))
158: panic("chopen");
159: #endif DEBUG
160: }
161: /*
162: * If the connection is not open, the open failed.
163: * Unless is got an ANS back.
164: */
165: if (conn->cn_state != CSOPEN &&
166: (conn->cn_state != CSCLOSED ||
167: (pkt = conn->cn_rhead) == NOPKT ||
168: pkt->pk_op != ANSOP)) {
169: rlsconn(conn);
170: u.u_error = ENXIO;
171: return;
172: }
173: }
174: conn->cn_sflags |= CHRAW;
175: conn->cn_mode = CHSTREAM;
176: }
177: }
178:
179: /* ARGSUSED */
180: chrclose(dev, flag, cp)
181: dev_t dev;
182: struct chan *cp;
183: {
184: register struct connection *conn = (struct connection *)cp;
185:
186: if (minor(dev) == CHURFCMIN) {
187: Chrfcrcv = 0;
188: freelist(Chrfclist);
189: Chrfclist = NOPKT;
190: return;
191: }
192: /*
193: * If this connection has been turned into a tty, then the
194: * tty owns it and we don't do anything.
195: */
196: if (conn->cn_mode != CHTTY)
197: chclose(conn, flag);
198: }
199: chclose(conn, flag)
200: register struct connection *conn;
201: {
202: register struct packet *pkt;
203:
204: switch (conn->cn_mode) {
205: case CHTTY:
206: panic("chclose on tty");
207: case CHSTREAM:
208: spl6();
209: if (setjmp(u.u_qsav)) {
210: pkt = pktstr(NOPKT, "User interrupted", 16);
211: if (pkt != NOPKT)
212: pkt->pk_op = CLSOP;
213: ch_close(conn, pkt, 0);
214: goto shut;
215: }
216: if (flag & FWRITE) {
217: /*
218: * If any input packets other than the RFC are around
219: * something is wrong and we just abort the connection
220: */
221: while ((pkt = conn->cn_rhead) != NOPKT) {
222: ch_read(conn);
223: if (pkt->pk_op != RFCOP)
224: goto recclose;
225: }
226: /*
227: * We set this flag telling the interrupt time
228: * receiver to abort the connection if any new packets
229: * arrive.
230: */
231: conn->cn_sflags |= CHCLOSING;
232: /*
233: * Closing a stream transmitter involves flushing
234: * the last packet, sending an EOF and waiting for
235: * it to be acknowledged. If the connection was
236: * bidirectional, the reader should have already
237: * read until EOF if everything is to be closed
238: * cleanly.
239: */
240: checkfull:
241: while (chtfull(conn)) {
242: conn->cn_sflags |= CHOWAIT;
243: sleep((caddr_t)&conn->cn_thead, CHIOPRIO);
244: }
245: if (conn->cn_state == CSOPEN ||
246: conn->cn_state == CSRFCRCVD) {
247: if (conn->cn_toutput) {
248: ch_sflush(conn);
249: goto checkfull;
250: }
251: if (conn->cn_state == CSOPEN)
252: (void)ch_eof(conn);
253: }
254: while (!chtempty(conn)) {
255: conn->cn_sflags |= CHOWAIT;
256: sleep((caddr_t)&conn->cn_thead, CHIOPRIO);
257: }
258: } else if (conn->cn_state == CSOPEN) {
259: /*
260: * If we are only reading then we should read the EOF
261: * before closing and wiat for the other end to close.
262: */
263: if (conn->cn_flags & CHEOFSEEN)
264: while (conn->cn_state == CSOPEN)
265: sleep((caddr_t)conn, CHIOPRIO);
266: }
267: recclose:
268: spl0();
269: /* Fall into... */
270: case CHRECORD: /* Record oriented close is just sending a CLOSE */
271: if (conn->cn_state == CSOPEN) {
272: pkt = pkalloc(0, 0);
273: if (pkt != NOPKT) {
274: pkt->pk_op = CLSOP;
275: pkt->pk_len = 0;
276: }
277: ch_close(conn, pkt, 0);
278: }
279: }
280: shut:
281: spl0();
282: ch_close(conn, NOPKT, 1);
283: ch_buffree();
284: }
285: /*
286: * Raw read routine.
287: */
288: chrread(dev)
289: dev_t dev;
290: {
291: register struct connection *conn;
292: register struct packet *pkt;
293: register int count, n;
294:
295: if(minor(dev) == CHURFCMIN) {
296: spl6();
297: while ((pkt = ch_rnext()) == NOPKT) {
298: Rfcwaiting++;
299: sleep((caddr_t)&Chrfclist, CHIOPRIO);
300: }
301: spl0();
302: if (u.u_count < pkt->pk_len)
303: u.u_error = EIO;
304: else
305: iomove((caddr_t)pkt->pk_cdata, pkt->pk_len, B_READ);
306: return;
307: }
308: conn = (struct connection *)CHFCONN(getf(u.u_arg[0]));
309:
310: switch (conn->cn_mode) {
311: case CHTTY:
312: panic("chread on tty");
313: break;
314: case CHSTREAM:
315: for (count = u.u_count; u.u_count != 0; )
316: switch (n = ch_sread(conn, (char*)0, u.u_count)) {
317: case 0: /* No data to read */
318: if (count != u.u_count)
319: return;
320: spl6();
321: while (chrempty(conn)) {
322: conn->cn_sflags |= CHIWAIT;
323: sleep((char *)&conn->cn_rhead,
324: CHIOPRIO);
325: }
326: spl0();
327: break;
328: case CHEOF:
329: return;
330: default:
331: if (n < 0) {
332: u.u_error = EIO;
333: return;
334: }
335: }
336: break;
337: /*
338: * Record oriented mode gives a one byte packet opcode
339: * followed by the data in the packet. The buffer must
340: * be large enough to fit the data and the opcode, otherwise an
341: * i/o error results.
342: */
343: case CHRECORD:
344: spl6();
345: while (chrempty(conn)) {
346: conn->cn_sflags |= CHIWAIT;
347: sleep((char *)&conn->cn_rhead,
348: CHIOPRIO);
349: }
350: spl0();
351: if ((pkt = conn->cn_rhead) == NOPKT ||
352: pkt->pk_len + 1 > u.u_count) /* + 1 for opcode */
353: u.u_error = EIO;
354: else {
355: iomove((caddr_t)&pkt->pk_op, 1, B_READ);
356: iomove((caddr_t)pkt->pk_cdata, pkt->pk_len, B_READ);
357: spl6();
358: ch_read(conn);
359: spl0();
360: }
361: }
362: }
363: /*
364: * Raw write routine
365: * Note that user programs can write to a connection
366: * that has been CHIOCANSWER"'d, implying transmission of an ANS packet
367: * rather than a normal packet. This is illegal for TTY mode connections,
368: * is handled in the system independent stream code for STREAM mode, and
369: * is handled here for RECORD mode.
370: */
371: chrwrite(dev)
372: dev_t dev;
373: {
374: register struct connection *conn;
375:
376: if(minor(dev) == CHURFCMIN) {
377: u.u_error = EIO;
378: return;
379: }
380: conn = (struct connection *)CHFCONN(getf(u.u_arg[0]));
381: chwrite(conn);
382: }
383: chwrite(conn)
384: register struct connection *conn;
385: {
386: register struct packet *pkt;
387: register int n;
388:
389: if (conn->cn_rhead != NOPKT && conn->cn_rhead->pk_op == RFCOP) {
390: spl6();
391: ch_read(conn);
392: spl0();
393: }
394: switch (conn->cn_mode) {
395: case CHTTY:
396: /* Fall into (on RAW mode only) */
397: case CHSTREAM:
398: while (u.u_count != 0)
399: switch (n = ch_swrite(conn, (char *)0, u.u_count)) {
400: case 0:
401: spl6();
402: while (chtfull(conn)) {
403: conn->cn_sflags |= CHOWAIT;
404: sleep((caddr_t)&conn->cn_thead,
405: CHIOPRIO);
406: }
407: spl0();
408: break;
409: case CHTEMP:
410: sleep((caddr_t)&lbolt, CHIOPRIO);
411: break;
412: default:
413: if (n < 0) {
414: u.u_error = EIO;
415: return;
416: }
417: }
418: break;
419: case CHRECORD: /* one write call -> one packet */
420: if (u.u_count < 1 || u.u_count - 1 > CHMAXDATA) {
421: u.u_error = EIO;
422: return;
423: }
424: loop:
425: spl6();
426: while (chtfull(conn)) {
427: conn->cn_sflags |= CHOWAIT;
428: sleep((caddr_t)&conn->cn_thead, CHIOPRIO);
429: }
430: spl0();
431: if ((pkt = pkalloc((int)(u.u_count - 1), 0)) == NOPKT) {
432: sleep((caddr_t)&lbolt, CHIOPRIO);
433: goto loop;
434: }
435: iomove(&pkt->pk_op, 1, B_WRITE);
436: pkt->pk_len = u.u_count;
437: if (u.u_count)
438: iomove(pkt->pk_cdata, u.u_count, B_WRITE);
439: if (u.u_error == 0) {
440: spl6();
441: if (ch_write(conn, pkt))
442: u.u_error = EIO;
443: spl0();
444: }
445: }
446: }
447:
448: /*
449: * This routine allocates a packet and fills it with data from pointer in
450: * user space until null or CHMAXDATA characters
451: */
452: static struct packet *
453: fillpacket(str, len)
454: register char *str;
455: int len; /* assumed <= CHMAXDATA */
456: {
457: register char *ptr;
458: register struct packet *pkt;
459: int c;
460: extern uchar();
461:
462: if ((pkt = pkalloc(CHMAXDATA, 0)) != NOPKT) {
463: ptr = pkt->pk_cdata;
464: for (pkt->pk_len = 0; *str != '\0' && pkt->pk_len < len; pkt->pk_len++)
465: *ptr++ = *str++;
466: while ((c = uchar()) > 0 && pkt->pk_len < CHMAXDATA) {
467: *ptr++ = c;
468: pkt->pk_len++;
469: }
470: if (c > 0) {
471: debug(DABNOR,
472: printf("Fillpacket too long: %s\n",
473: pkt->pk_cdata));
474: ch_free((char *)pkt);
475: } else
476: return(pkt);
477: }
478: u.u_error = ENXIO;
479: return(NOPKT);
480: }
481: /*
482: * This is atoi from users space terminates on / or null.
483: * If cpp is not NULL then get the number from *cpp (u.u_dbuf).
484: * *cpp is stuffed where the scan stopped, enabling further usage of the
485: * contents of u.u_dbuf.
486: */
487: static
488: uatoi(cpp)
489: char **cpp;
490: {
491: register char *p = cpp ? *cpp - 1 : (char *)0;
492: register int i = 0, chr;
493: extern uchar();
494:
495: for (;;) {
496: if (p)
497: if (++p >= &u.u_dbuf[DIRSIZ])
498: break;
499: else
500: chr = *p;
501: else if ((chr = uchar()) == '/')
502: break;
503: if ((chr -= '0') < 0 || chr > 9)
504: break;
505: i *= 10;
506: i += chr;
507: }
508: if (cpp)
509: *cpp = p;
510: return(i);
511: }
512:
513: /*
514: * Raw ioctl routine - perform non-connection functions, otherwise call down
515: */
516: chrioctl(dev, cmd, addr, flag)
517: register int cmd;
518: caddr_t addr;
519: {
520: register char *cp;
521: register int c;
522:
523: switch (cmd) {
524: /*
525: * Skip the first unmatched RFC at the head of the queue
526: * and mark it so that ch_rnext will never pick it up again.
527: */
528: case CHIOCRSKIP:
529: if (minor(dev) != CHURFCMIN)
530: break;
531: spl6();
532: ch_rskip();
533: spl0();
534: return;
535: /*
536: * Specify the chaosnet address of an interlan ethernet interface.
537: */
538: case CHIOCILADDR:
539: if (minor(dev) != CHURFCMIN)
540: break;
541: #if NCHIL > 0
542: {
543: struct chiladdr ca;
544:
545: if (addr == 0 || copyin(addr, (caddr_t)&ca, sizeof(ca)))
546: break;
547: if (chilseta(ca.cil_device, ca.cil_address))
548: break;
549: return;
550: }
551: #else
552: break;
553: #endif
554: case CHIOCNAME:
555: if (minor(dev) != CHURFCMIN)
556: break;
557: for (cp = Chmyname; c = fubyte(addr); *cp++ = c, addr++)
558: if (c < 0) {
559: cp = Chmyname;
560: u.u_error = EFAULT;
561: break;
562: } else if(cp >= &Chmyname[CHSTATNAME])
563: break;
564: while (cp < &Chmyname[CHSTATNAME])
565: *cp++ = '\0';
566: if (c >= 0)
567: return;
568: break;
569: /*
570: * Specify my own network number.
571: */
572: case CHIOCADDR:
573: if (minor(dev) != CHURFCMIN)
574: break;
575: Chmyaddr = (int)addr;
576: return;
577: default:
578: if (minor(dev) == CHURFCMIN)
579: break;
580: chioctl(CHFCONN(getf(u.u_arg[0])), dev, cmd, addr, flag);
581: return;
582: }
583: u.u_error = ENXIO;
584: }
585: /* ARGSUSED */
586: chioctl(conn, dev, cmd, addr, flag)
587: register struct connection *conn;
588: dev_t dev;
589: caddr_t addr;
590: {
591: register struct packet *pkt;
592: struct chstatus chst;
593:
594: switch(cmd) {
595: /*
596: * Read the first packet in the read queue for a connection.
597: * This call is primarily intended for those who want to read
598: * non-data packets (which are normally ignored) like RFC
599: * (for arguments in the contact string), CLS (for error string) etc.
600: * The reader's buffer is assumed to be CHMAXDATA long. When ioctl's
601: * change on the VAX to have data length arguments, this will be done
602: * right. An error results if there is no packet to read.
603: * No hanging is currently provided for.
604: * The normal mode of operation for reading such packets is to
605: * first do a CHIOCGSTAT call to find out whether there is a packet
606: * to read (and what kind) and then make this call - except for
607: * RFC's when you know it must be there.
608: */
609: case CHIOCPREAD:
610: if ((pkt = conn->cn_rhead) == NULL)
611: break;
612: if (copyout((caddr_t)pkt->pk_cdata, addr, pkt->pk_len))
613: break;
614: spl6();
615: ch_read(conn);
616: spl0();
617: return;
618: /*
619: * Change the mode of the connection.
620: * The default mode is CHSTREAM.
621: */
622: case CHIOCSMODE:
623: switch ((int)addr) {
624: case CHTTY:
625: #if NCHT > 0
626: if (conn->cn_state == CSOPEN &&
627: conn->cn_mode != CHTTY) {
628: register struct tty *tp;
629: extern struct tty cht_tty[];
630: extern int cht_cnt;
631: /*
632: * To turn a connection into a tty,
633: * we need to find a tty that is waiting to
634: * be opened and connect ourselves to it.
635: */
636: for (tp = cht_tty; tp < &cht_tty[cht_cnt]; tp++)
637: if (tp->t_addr == 0 &&
638: tp->t_state & WOPEN) {
639: tp->t_addr = (caddr_t)conn;
640: tp->t_state |= CARR_ON;
641: conn->cn_ttyp = tp;
642: conn->cn_mode = CHTTY;
643: wakeup((caddr_t)&tp->t_rawq);
644: return;
645: }
646:
647: }
648: #endif
649: break;
650: case CHSTREAM:
651: case CHRECORD:
652: if (conn->cn_mode == CHTTY)
653: break;
654: conn->cn_mode = (int)addr;
655: return;
656: }
657: break;
658: /*
659: * Flush the current output packet if there is one.
660: * This is only valid in stream mode.
661: * If the argument is non-zero an error is returned if the
662: * transmit window is full, otherwise we hang.
663: */
664: case CHIOCFLUSH:
665: if (conn->cn_mode == CHSTREAM) {
666: spl6();
667: while ((flag = ch_sflush(conn)) == CHTEMP)
668: if (addr)
669: break;
670: else {
671: conn->cn_sflags |= CHOWAIT;
672: sleep((caddr_t)&conn->cn_thead,
673: CHIOPRIO);
674: }
675: if (flag)
676: u.u_error = EIO;
677: spl0();
678: return;
679: }
680: break;
681: /*
682: * Wait for all output to be acknowledged. If addr is non-zero
683: * an EOF packet is also sent before waiting.
684: * If in stream mode, output is flushed first.
685: */
686: case CHIOCOWAIT:
687: if (conn->cn_mode == CHSTREAM) {
688: spl6();
689: while ((flag = ch_sflush(conn)) == CHTEMP) {
690: conn->cn_sflags |= CHOWAIT;
691: sleep((caddr_t)&conn->cn_thead, CHIOPRIO);
692: }
693: spl0();
694: if (flag) {
695: u.u_error = EIO;
696: return;
697: }
698: }
699: if (addr) {
700: spl6();
701: while (chtfull(conn)) {
702: conn->cn_sflags |= CHOWAIT;
703: sleep((caddr_t)&conn->cn_thead, CHIOPRIO);
704: }
705: flag = ch_eof(conn);
706: spl0();
707: if (flag) {
708: u.u_error = EIO;
709: return;
710: }
711: }
712: spl6();
713: while (!chtempty(conn)) {
714: conn->cn_sflags |= CHOWAIT;
715: sleep((caddr_t)&conn->cn_thead, CHIOPRIO);
716: }
717: spl0();
718: if (conn->cn_state != CSOPEN)
719: u.u_error = EIO;
720: return;
721: /*
722: * Return the status of the connection in a structure supplied
723: * by the user program.
724: */
725: case CHIOCGSTAT:
726: chst.st_fhost = conn->cn_faddr;
727: chst.st_cnum = conn->cn_ltidx;
728: chst.st_rwsize = conn->cn_rwsize;
729: chst.st_twsize = conn->cn_twsize;
730: chst.st_state = conn->cn_state;
731: chst.st_cmode = conn->cn_mode;
732: chst.st_oroom = conn->cn_twsize - (conn->cn_tlast - conn->cn_tacked);
733: if ((pkt = conn->cn_rhead) != NOPKT) {
734: chst.st_ptype = pkt->pk_op;
735: chst.st_plength = pkt->pk_len;
736: } else {
737: chst.st_ptype = 0;
738: chst.st_plength = 0;
739: }
740: if (copyout((caddr_t)&chst, addr, sizeof(chst)))
741: break;
742: return;
743: /*
744: * Wait for the state of the connection to be different from
745: * the given state.
746: */
747: case CHIOCSWAIT:
748: spl6();
749: while (conn->cn_state == (int)addr)
750: sleep((caddr_t)conn, CHIOPRIO);
751: spl0();
752: return;
753: /*
754: * Answer an RFC. Basically this call does nothing except
755: * setting a bit that says this connection should be of the
756: * datagram variety so that the connection automatically gets
757: * closed after the first write, whose data is immediately sent
758: * in an ANS packet.
759: */
760: case CHIOCANSWER:
761: spl6();
762: if (conn->cn_state == CSRFCRCVD && conn->cn_mode != CHTTY)
763: conn->cn_flags |= CHANSWER;
764: else
765: u.u_error = EIO;
766: spl0();
767: return;
768: /*
769: * Reject a RFC, giving a string (null terminated), to put in the
770: * close packet. This call can also be used to shut down a connection
771: * prematurely giving an ascii close reason.
772: */
773: case CHIOCREJECT:
774: spl6();
775: if (conn->cn_state == CSRFCRCVD || conn->cn_state == CSOPEN) {
776: u.u_dirp = addr; /* a kludge for fillpacket */
777: pkt = fillpacket("", 0);
778: pkt->pk_op = CLSOP;
779: ch_close(conn, pkt, 0);
780: } else
781: u.u_error = EIO;
782: spl0();
783: return;
784: /*
785: * Accept an RFC causing the OPEN packet to be sent
786: */
787: case CHIOCACCEPT:
788: spl6();
789: if (conn->cn_state == CSRFCRCVD)
790: ch_accept(conn);
791: else
792: u.u_error = EIO;
793: spl0();
794: return;
795: /*
796: * Count how many bytes can be immediately read.
797: */
798: case FIONREAD:
799: if (conn->cn_mode != CHTTY) {
800: off_t nread = 0;
801:
802: for (pkt = conn->cn_rhead; pkt != NOPKT; pkt = pkt->pk_next)
803: if (ISDATOP(pkt))
804: nread += pkt->pk_len;
805: if (conn->cn_rhead != NOPKT)
806: nread -= conn->cn_roffset;
807: if (copyout((caddr_t)&nread, addr, sizeof(off_t)))
808: u.u_error = EFAULT;
809: return;
810: }
811: default:
812: break;
813: }
814: u.u_error = ENXIO;
815: }
816: /*
817: * Timeout routine that implements the chaosnet clock process.
818: */
819: chtimeout()
820: {
821: register int s = spl6();
822: ch_clock();
823: timeout(chtimeout, 0, 1);
824: splx(s);
825: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.