![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chaosld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / chaosld|
Return to chaosld.c CVS log | Up to [Research Unix] / researchv8dc / sys / chaosld |
1.1 root 1: /*
2: * C H A O S L D
3: *
4: * Chaosnet line discipline, to be pushed on an ethernet controller.
5: * Handles xmit and rcv windows, packet numbering, and connection states.
6: *
7: *
8: * (c) Copyright 1985 Nirvonics, Inc.
9: *
10: * Written by Kurt Gollhardt
11: * Last update Tue Mar 12 04:18:58 1985
12: *
13: * This software is the property of Nirvonics, Inc.
14: * All rights reserved.
15: *
16: */
17:
18: #include "ch.h"
19: #if NCH
20: #include "../h/param.h"
21: #include "../h/systm.h"
22: #include "../h/stream.h"
23: #include "../h/ioctl.h"
24: #include "../h/ttyld.h"
25: #include "../h/map.h"
26: #include "../h/buf.h"
27: #include "../h/conf.h"
28: #include "../chaosld/types.h"
29: #define CHDEFINE
30: #include "../chaosld/globals.h"
31:
32:
33: extern int chrcv(), chb_put();
34: int chopen(), chclose(), chosrv(), chisrv();
35: static struct qinit chrinit = { chb_put, chisrv, chopen, chclose, 512, 64 };
36: static struct qinit chwinit = { putq, chosrv, chopen, chclose, 512, 64 };
37: struct streamtab chinfo = { &chrinit, &chwinit };
38:
39: chopen(q, dev)
40: register struct queue *q;
41: {
42: if (q->ptr)
43: return(1);
44: if (ChaosQ != (struct queue *)0) /* Already open */
45: return(0);
46: ChaosQ = q; /* that's the RD q */
47: q->flag |= QDELIM|QNOENB; /* chiput calls qenable() */
48: WR(q)->flag |= QDELIM;
49: return(1);
50: }
51:
52: chclose(q)
53: struct queue *q;
54: {
55: struct connection **connp;
56: int ps = spl6();
57:
58: for (connp = Chconn; connp < &Chconn[NCH]; ++connp)
59: if (*connp != NOCONN)
60: chld_close(*connp, NOPKT);
61:
62: freelist(Chlsnlist);
63: freelist(Chrfclist);
64: Chlsnlist = Chrfclist = Chrfctail = NOPKT;
65: Chmyaddr.ch_addr = 0;
66:
67: ChaosQ = (struct queue *)0;
68: splx(ps);
69: }
70:
71:
72: chisrv(q)
73: struct queue *q;
74: {
75: register struct block *bp;
76:
77: chrcv(q); /* Receive the packet */
78:
79: /* See if there's another packet on the queue */
80: for (bp = q->first; bp != NOBLOCK; bp = bp->next)
81: if (bp->type == M_DELIM) {
82: qenable(q); /* re-enable queue for the next packet */
83: break;
84: }
85: }
86:
87:
88: chosrv(q)
89: register struct queue *q;
90: {
91: register union stmsg *sp;
92: register struct block *bp;
93:
94: while(bp = getq(q)){
95: if(bp->type == M_IOCTL){
96: sp = (union stmsg *)bp->rptr;
97: switch(sp->ioc0.com){
98: case CHIOCNAME:
99: copyin(*(caddr_t *)sp->iocx.xxx, Chmyname, CHSTATNAME);
100: bp->rptr = bp->wptr;
101: bp->type = M_IOCACK;
102: qreply(q, bp);
103: break;
104: case CHIOCADDR:
105: Chmyaddr.ch_addr = *(int *)sp->iocx.xxx;
106: /* fall through */
107: default:
108: (*q->next->qinfo->putp)(q->next, bp);
109: break;
110: }
111: } else
112: (*q->next->qinfo->putp)(q->next, bp);
113: }
114: }
115:
116: chld_write(conn, pkt)
117: register struct connection *conn;
118: register struct packet *pkt;
119: {
120: setconn(conn, pkt);
121:
122: switch (pkt->pk_op) {
123: case ANSOP:
124: case FWDOP:
125: if (conn->cn_state != CSRFCRCVD ||
126: (conn->cn_flags & CHANSWER) == 0)
127: goto err;
128: chld_close(conn, pkt);
129: return 0;
130: case RFCOP:
131: case BRDOP:
132: if (conn->cn_state != CSRFCSENT)
133: goto err;
134: break;
135: case UNCOP:
136: pkt->pk_pkn = 0;
137: pkt->next = NOPKT;
138: senddata(pkt);
139: return 0;
140: default:
141: if (!ISDATA(pkt))
142: goto err;
143: case OPNOP:
144: case EOFOP:
145: if (conn->cn_state != CSOPEN)
146: goto err;
147: setack(conn, pkt);
148: break;
149: }
150:
151: pkt->pk_pkn = ++conn->cn_tlast;
152: senddata(pkt);
153: return 0;
154:
155: err:
156: free_packet(pkt);
157: return -1;
158: }
159:
160:
161: chld_eof(conn)
162: struct connection *conn;
163: {
164: register struct packet *pkt;
165:
166: if ((pkt = new_packet()) != NOPKT) {
167: setconn(conn, pkt);
168: pkt->pk_op = EOFOP;
169: return chld_write(conn, pkt);
170: }
171: return 0;
172: }
173:
174:
175: chld_accept(conn)
176: struct connection *conn;
177: {
178: conn->cn_state = CSOPEN;
179: sendopn(conn);
180: }
181:
182:
183: chld_open(conn, daddr, rwsize, pkt)
184: register struct connection *conn;
185: register struct packet *pkt;
186: {
187: conn->cn_faddr.ch_addr = daddr;
188: conn->cn_state = CSRFCSENT;
189: conn->cn_rwsize = rwsize;
190: conn->cn_rsts = rwsize / 2;
191: conn->cn_time = Chclock;
192: pkt->pk_op = RFCOP;
193: pkt->pk_fc = pkt->pk_ackn = 0;
194: debug(DCONN,printf("Conn #%x: RFCS state\n", conn->cn_lidx.ci_idx));
195: /*
196: * By writing the RFC packet like a data packet, it will be kept
197: * around for automatic retransmission until freed by the normal
198: * receipting mechanism; xmitdone() and chrcv() facilitate this.
199: * Since new_conn() clears the connection (including cn_tlast),
200: * the packet number of the RFC will be 1 (pkn = ++cn_tlast).
201: */
202: chld_write(conn, pkt);
203: }
204:
205:
206: chld_listen(conn, rwsize, pkt)
207: register struct connection *conn;
208: register struct packet *pkt;
209: {
210: register struct packet *opkt, *pktl;
211: int ps;
212:
213: conn->cn_state = CSLISTEN;
214: conn->cn_flags |= CHSERVER;
215: conn->cn_rwsize = rwsize;
216: pkt->pk_op = LSNOP;
217: setconn(conn, pkt);
218:
219: if (flatten(pkt)) {
220: free_packet(pkt);
221: return;
222: }
223:
224: ps = spl6();
225: opkt = NOPKT;
226: for (pktl = Chrfclist; pktl != NOPKT; pktl = (opkt = pktl)->next)
227: if (concmp(pktl, pkt->data->rptr, (int)pkt->pk_len)) {
228: if (opkt == NOPKT)
229: Chrfclist = pktl->next;
230: else
231: opkt->next = pktl->next;
232: if (pktl == Chrfctail)
233: Chrfctail = opkt;
234: free_packet(pkt);
235: lsnmatch(pktl, conn);
236: chd_newstate(conn);
237: splx(ps);
238: return;
239: }
240:
241: pkt->next = Chlsnlist;
242: Chlsnlist = pkt;
243: splx(ps);
244:
245: debug(DCONN,printf("Conn #%x: LISTEN state\n", conn->cn_lidx.ci_idx));
246: }
247:
248:
249: chld_close(conn, pkt)
250: register struct connection *conn;
251: register struct packet *pkt;
252: {
253: int ps = spl6();
254:
255: ch_busy++;
256: switch (conn->cn_state) {
257: case CSOPEN:
258: case CSRFCRCVD:
259: if (pkt != NOPKT) {
260: setconn(conn, pkt);
261: pkt->pk_ackn = pkt->pk_pkn = 0;
262: sendctl(pkt);
263: pkt = NOPKT;
264: }
265: /* Fall into ... */
266: case CSRFCSENT:
267: close_conn(conn, CSCLOSED, NOPKT);
268: break;
269: case CSLISTEN:
270: rmlisten(conn);
271: break;
272: }
273: --ch_busy;
274: splx(ps);
275:
276: if (pkt != NOPKT)
277: free_packet(pkt);
278: }
279:
280: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.