![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_lpb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso|
Return to if_lpb.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso |
1.1 root 1: /***********************************************************
2: Copyright IBM Corporation 1987
3:
4: All Rights Reserved
5:
6: Permission to use, copy, modify, and distribute this software and its
7: documentation for any purpose and without fee is hereby granted,
8: provided that the above copyright notice appear in all copies and that
9: both that copyright notice and this permission notice appear in
10: supporting documentation, and that the name of IBM not be
11: used in advertising or publicity pertaining to distribution of the
12: software without specific, written prior permission.
13:
14: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
15: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
16: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
17: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
18: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
19: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
20: SOFTWARE.
21:
22: ******************************************************************/
23:
24: /*
25: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
26: */
27: /*
28: * $Header: if_lpb.c,v 4.2 88/06/29 14:59:38 hagens Exp $
29: * $Source: /usr/argo/sys/netiso/RCS/if_lpb.c,v $
30: *
31: * LOOPBACK driver that mimics the
32: * Eicon x.25 board for use by CONS
33: */
34:
35: #ifndef lint
36: static char *rcsid = "$Header: if_lpb.c,v 4.2 88/06/29 14:59:38 hagens Exp $";
37: #endif lint
38:
39:
40: #include "param.h"
41: #include "systm.h"
42: #include "types.h"
43: #include "mbuf.h"
44: #include "buf.h"
45: #include "protosw.h"
46: #include "socket.h"
47: #include "ioctl.h"
48: #include "errno.h"
49:
50: #include "../net/if.h"
51: #include "../net/netisr.h"
52: #include "../net/route.h"
53: #include "machine/io.h"
54: #include "../machineio/ioccvar.h"
55:
56: #include "ecn.h"
57: #include "iso.h"
58: #include "argo_debug.h"
59: #include "../caif/eicon.h"
60: #include "iso_errno.h"
61:
62: #define LPB_DEBUG
63: #ifdef LPB_DEBUG
64: #define MT_LPB_OPEN 0x55
65: #define MT_LPB_ACK 0x56
66: #else LPB_DEBUG
67: #define MT_LPB_DATA MT_DATA
68: #define MT_LPB_ACK MT_DATA
69: #endif LPB_DEBUG
70:
71: extern struct ifqueue consintrq;
72: int lpboutput();
73:
74: /* These next 2 declarations are for Logical Unit Numbers - i.e. VC # -
75: * the 2I assigns and frees them; we have to fake it
76: */
77:
78: static u_char free_luns[32];
79: static u_char *next_lun = free_luns;
80:
81: /*
82: * Initialize all LUNs as available for use.
83: */
84: init_lpb()
85: {
86: register int i;
87:
88: for (i = 0; i < 32; i++) {
89: free_luns[i] = i+1;
90: }
91: next_lun = free_luns;
92: }
93:
94: /*
95: * Allocate new logical unit number.
96: * Allocating number n means that both n and -n are allocated & used.
97: * NOTE: next_lun always points to an UNALLOCATED lun, hence
98: * take a lun then increment, or decrement then stash the lun.
99: */
100:
101: u_char
102: getlun()
103: {
104: if( ((next_lun) - free_luns) > 32 ) {
105: printf("PANIC: if_lpb: too many channels! \n");
106: return 0;
107: }
108: IFDEBUG(D_CCONN)
109: printf("getlun: returns 0x%x\n", *next_lun);
110: ENDDEBUG
111: ASSERT( *next_lun != 0 );
112: if( *next_lun == 0 ) {
113: register int i;
114:
115: printf(
116: "PANIC IN lpb: free_luns 0x%x next_len 0x%x *next_lun 0x%x\n",
117: free_luns, next_lun, *next_lun);
118:
119: for(i=0; i<32; i++) {
120: printf("free_luns[ 0x%x ] = 0x%x\n", i, free_luns[i] );
121: }
122: }
123: return *(next_lun++);
124:
125: }
126:
127: /*
128: * When you free one you free its neg
129: */
130:
131: freelun(lun)
132: u_char lun;
133: {
134: IFDEBUG(D_CCONN)
135: printf("freelun(0x%x)\n", lun);
136: ENDDEBUG
137: if( lun > 32 )
138: return;
139:
140: ASSERT( (lun & 0xc0) == 0 );
141: ASSERT( lun <= 32 );
142:
143: /* check for lun already in the list */
144: {
145: register u_char *r = next_lun;
146:
147: while( (int)(r - free_luns) <= 32 ) {
148: if( *r == lun ) {
149: return;
150: }
151: r++;
152: }
153: }
154:
155: next_lun --;
156: *next_lun = lun;
157: }
158:
159:
160: /*
161: * FUNCTION: lpboutput
162: *
163: * PURPOSE: Process an eicon x.25 request from a higher layer
164: * protocol.
165: * ARGUMENTS: (ifp) is points to the ifnet structure for this unit/device
166: * (m) is an mbuf *, *m is an eicon request structure
167: *
168: * RETURNS: unix error code
169: *
170: * NOTES: Mimics the eicon driver.
171: *
172: */
173: lpboutput(ifp,m)
174: register struct ifnet *ifp;
175: register struct mbuf *m; /* request */
176: {
177: int s;
178: struct eicon_request *req;
179: int error = 0;
180:
181: /* Do this even if (ifp->if_flags & IFF_LOOPBACK) == 0
182: * because whether or not a vc is on loopback is determined
183: * at the time of connection establishement.
184: */
185: s = splnet();
186: req = mtod(m, struct eicon_request *);
187: IFDEBUG(D_CDUMP_REQ)
188: dump_buf(req, sizeof(struct eicon_request));
189: ENDDEBUG
190: switch (req->e_cmd) {
191: case ECN_CALL: {
192: /*
193: * ECN_CALL -> ECN_ACCEPT (for orig CONNECT)
194: * -> ECN_CONNECT (other side's connect indication)
195: */
196: struct mbuf *mdata;
197: struct mbuf *mopen;
198: struct eicon_request *open;
199:
200: MGET(mopen, M_DONTWAIT, MT_LPB_OPEN);
201: if (mopen == NULL) {
202: printf("No mbufs for copy\n");
203: error = ENOBUFS;
204: break;
205: }
206: mopen->m_len = sizeof(struct eicon_request);
207:
208: open = mtod(mopen, struct eicon_request *);
209: bcopy( req, open, sizeof(struct eicon_request) );
210:
211: /* get mbuf for the connect data */
212: MGET(mdata, M_DONTWAIT, MT_LPB_OPEN);
213: if (mdata == NULL) {
214: printf("No mbufs for copy\n");
215: error = ENOBUFS;
216: break;
217: }
218: mdata->m_len = (e_data(req))->m_len;
219: e_data(open) = mdata; /* e_data is really mtod(open)->m_next */
220: /* make a copy of the connect data */
221: IFDEBUG(D_CCONN)
222: printf("bcopy( 0x%x, 0x%x, 0x%x)\n", mtod(e_data(req), caddr_t),
223: mtod(mdata, caddr_t),
224: (e_data(req))->m_len);
225: ENDDEBUG
226: bcopy( mtod(e_data(req), caddr_t), mtod(mdata, caddr_t),
227: (e_data(req))->m_len);
228: /* setup call */
229: open->e_cmd = ECN_CONNECT;
230: open->e_vc = getlun();
231:
232: /* setup call confirm */
233: req->e_cmd = ECN_ACCEPT;
234: req->e_vc = -(open->e_vc);
235:
236: IFDEBUG(D_CDUMP_REQ)
237: printf("lpboutput CALL middle \n");
238: ENDDEBUG
239:
240: if (IF_QFULL(&consintrq)) {
241: IF_DROP(&consintrq);
242: m_freem(mopen);
243: printf("lpboutput: response dropped\n");
244: error = ENOBUFS;
245: break;
246: } else {
247: /* connect */
248: IFDEBUG(D_CCONS);
249: printf("CONNECT 0x%x --> X25INTRQ\n", mopen);
250: ENDDEBUG
251: IF_ENQUEUE(&consintrq, mopen);
252: IFDEBUG(D_CDUMP_REQ);
253: dump_buf(open, sizeof(struct eicon_request));
254: ENDDEBUG
255:
256: /* confirm */
257: IFDEBUG(D_CCONS);
258: printf("CONFIRM 0x%x (data 0x%x =?= 0x%x) --> X25INTRQ\n",
259: m, m->m_next, e_data(req));
260: ENDDEBUG
261: IF_ENQUEUE(&consintrq, m);
262: IFDEBUG(D_CDUMP_REQ);
263: dump_buf(req, sizeof(struct eicon_request));
264: ENDDEBUG
265: }
266: } break;
267:
268: case ECN_RESET:
269: case ECN_CLEAR: {
270: /*
271: * ECN_RESET -> ECN_RESET (other side's reset indication)
272: * ECN_CLEAR -> ECN_CLEAR (other side's close indication)
273: * TODO: MAY HAVE DATA PACKET!
274: * TODO: Have to be able to handle a 2nd CLEAR on on vc!
275: */
276: freelun(req->e_vc);
277: freelun((-req->e_vc)&0xff);
278: req->e_vc = -req->e_vc; /* other side */
279: req->e_reason = E_CO_PDNCLRESET;
280: if (IF_QFULL(&consintrq)) {
281: IF_DROP(&consintrq);
282: printf("lpboutput: respose dropped\n");
283: error = ENOBUFS;
284: } else {
285: IFDEBUG(D_CCONS);
286: printf("CLOSE 0x%x --> X25INTRQ\n", m);
287: ENDDEBUG
288: IF_ENQUEUE(&consintrq, m);
289: IFDEBUG(D_CDUMP_REQ);
290: dump_buf(req, sizeof(struct eicon_request));
291: ENDDEBUG
292: }
293: } break;
294:
295: case ECN_SEND: {
296: /*
297: * ECN_SEND -> ECN_RECEIVE (data send becomes data recvd)
298: */
299: struct mbuf *m0;
300: struct eicon_request *ack;
301:
302: MGET(m0, M_DONTWAIT, MT_LPB_ACK); /* sets type, next, off */
303: if (m0 == NULL) {
304: printf("PANIC No mbufs for copy\n");
305: error = ENOBUFS;
306: break;
307: }
308: m0->m_len = sizeof(struct eicon_request);
309:
310: ack = mtod(m0, struct eicon_request *);
311: /* setup ack */
312: ack->e_cmd = ECN_ACK;
313: ack->e_vc = req->e_vc;
314: req->e_vc = -req->e_vc;
315: req->e_cmd = ECN_RECEIVE;
316:
317: if (IF_QFULL(&consintrq)) {
318: IF_DROP(&consintrq);
319: printf("lpboutput: ADR_ACK DROPPED\n");
320: m_freem(m0);
321: error = ECONNABORTED;
322: } else {
323: IF_ENQUEUE(&consintrq, m);
324: IFDEBUG(D_CCONS);
325: printf("DATA 0x%x --> X25INTRQ\n", m);
326: ENDDEBUG
327: IFDEBUG(D_CDUMP_REQ);
328: dump_buf(req, sizeof(struct eicon_request));
329: ENDDEBUG
330: IFDEBUG(D_CCONS);
331: printf("ACK 0x%x --> X25INTRQ\n", m0);
332: ENDDEBUG
333: IF_ENQUEUE(&consintrq, m0);
334: IFDEBUG(D_CDUMP_REQ);
335: dump_buf(ack, sizeof(struct eicon_request));
336: ENDDEBUG
337: }
338: } break;
339:
340: default:
341: printf("Bad loopback request 0x%x\n", req->e_cmd);
342: error = EINVAL;
343: }
344:
345: if( error ) {
346: m_freem(m);
347: } else
348: schednetisr(NETISR_X25);
349:
350: splx(s);
351: return error;
352: }
353:
354: #if NECN>0
355: /* nothing */
356: #else
357:
358: /* KLUDGE: when no ecn board config-ed in, we need a routing
359: * ecnifp to return null. We want to be able to configure with
360: * sw loopback only.
361: */
362: struct ifnet *
363: ecnifp(unit)
364: int unit;
365: {
366: return (struct ifnet *)NULL;
367: }
368:
369: int
370: ecnoutput(ifp, m)
371: struct ifnet *ifp;
372: struct mbuf *m;
373: {
374: printf("ecnoutput: ecn not configured\n");
375: (void) m_freem(m);
376: return ENETDOWN;
377:
378: }
379:
380: ecnshutdown(ifp)
381: {
382: printf("ecnshutdown: ecn not configured\n");
383: }
384:
385: ecnrestart(ifp)
386: {
387: printf("ecnrestart: ecn not configured\n");
388: }
389: #endif NECN>0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.