![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_cons.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_cons.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_cons.c,v 4.7 88/08/11 15:52:55 nhall Exp $
29: * $Source: /usr/argo/sys/netiso/RCS/if_cons.c,v $
30: *
31: * cons.c - Connection Oriented Network Service:
32: * including support for a) user transport-level service,
33: * b) COSNS below CLNP, and c) CONS below TP.
34: */
35:
36: #ifndef lint
37: static char *rcsid = "$Header: if_cons.c,v 4.7 88/08/11 15:52:55 nhall Exp $";
38: #endif lint
39:
40: #ifdef ARGO_DEBUG
41: #define Static
42: unsigned LAST_CALL_PCB;
43: #else ARGO_DEBUG
44: #define Static static
45: #endif ARGO_DEBUG
46:
47: #include "ecn.h"
48: #include "argoxtwentyfive.h"
49:
50: #if NARGOXTWENTYFIVE > 0
51:
52: #ifdef KERNEL
53:
54: #include "param.h"
55: #include "systm.h"
56: #include "mbuf.h"
57: #include "protosw.h"
58: #include "socket.h"
59: #include "socketvar.h"
60: #include "errno.h"
61: #include "ioctl.h"
62: #include "tsleep.h"
63:
64: #include "../net/if.h"
65: #include "../net/netisr.h"
66: #include "../net/route.h"
67:
68: #include "../netiso/iso_errno.h"
69: #include "../netiso/argo_debug.h"
70: #include "../netiso/tp_trace.h"
71: #include "../netiso/iso.h"
72: #include "../netiso/cons.h"
73: #include "../netiso/iso_pcb.h"
74: #include "../netiso/cons_pcb.h"
75: #include "../caif/eicon.h"
76:
77: #ifdef ARGO_DEBUG
78: #define MT_XCONN 0x50
79: #define MT_XCLOSE 0x51
80: #define MT_XCONFIRM 0x52
81: #define MT_XDATA 0x53
82: #define MT_XHEADER 0x54
83: #else
84: #define MT_XCONN MT_DATA
85: #define MT_XCLOSE MT_DATA
86: #define MT_XCONFIRM MT_DATA
87: #define MT_XDATA MT_DATA
88: #define MT_XHEADER MT_HEADER
89: #endif ARGO_DEBUG
90:
91: #define DONTCLEAR -1
92:
93: /*********************************************************************
94: * cons.c - CONS interface to the eicon adapter
95: * Includes connection manager - for (TP, CLNP)/x.25
96: *
97: * TODO: figure out what resources we might run out of besides mbufs.
98: * If we run out of any of them (including mbufs) close and recycle
99: * lru x% of the connections, for some parameter x.
100: *
101: * There are 4 interfaces from above:
102: * 0) from CLNP:
103: * cons is an interface driver - CLNP calls
104: * cosns_output(ifp, m, dst), a device-type interface output routine
105: * that does some connection management stuff and queues a
106: * request on the eicon driver queue by calling ifp->if_output.
107: * The eicon's ifp structure contains cosns_output as its output routine
108: * rather than ifp_>if_output! Kludge, but we don't have much choice...
109: * X25 connections created in this manner may always be multiplexed
110: * but only with their own kind (not with connections servicing TP
111: * directly.)
112: * co_flags & CONSF_DGM
113: * 1) from TP0:
114: * cons CO network service
115: * TP associates a transport connection with a network connection.
116: * cons_output( isop, m, len, isdgm==0 )
117: * co_flags == 0
118: * 2) from TP 4:
119: * It's a datagram service, like clnp is. - even though it calls
120: * cons_output( isop, m, len, isdgm==1 )
121: * it eventually goes through
122: * cosns_output(ifp, m, dst).
123: * TP4 permits multiplexing (reuse, possibly simultaneously) of the
124: * network connections.
125: * This means that many sockets (many tpcbs) may be associated with
126: * this cons_pcb, hence cannot have a back ptr from cons_pcb to a tpcb.
127: * co_flags & CONSF_DGM
128: * co_socket is null since there may be many sockets that use this copcb.
129: * 3) from user: cons_usrreq(), cons_ctloutput()
130: * cons is a standard transport service interface.
131: * There is a 1-1 correspondence between net connections and sockets.
132: * co_socket points to a socket.
133: *
134: NOTE:
135: streams would really be nice. sigh.
136: NOTE:
137: eicon <--> cons interface: the first mbuf (the ecn_request structure)
138: had better NOT be a cluster.
139: NOTE:
140: PVCs could be handled by config-ing a cons with an address and with the
141: IFF_POINTTOPOINT flag on. This code would then have to skip the
142: connection setup stuff for pt-to-pt links.
143: NOTE:
144: We keep track of the ifp for each connection. Right now this is
145: unnecessary, but just in case someone comes up with some kind
146: of a kludge to allow > 1 eicon to be attached at a time,
147: (i.e., some meaningful netof( a type 37 address ) ),
148: we do keep track of this.
149:
150:
151: *********************************************************************/
152:
153: #define touch(copcb) copcb->co_ttl = copcb->co_init_ttl
154:
155: #define CONS_IFQMAXLEN 5
156:
157: #define SET_CHANMASK( isop, chan )\
158: if( (u_int)(chan) < 32 ) \
159: (isop)->isop_chanmask = (1<<((chan)-1));\
160: else \
161: (isop)->isop_negchanmask = (1<<((256-(chan))-1))
162:
163: #define ADD_CHANMASK( isop, chan )\
164: if( (u_int)(chan) < 32 ) \
165: (isop)->isop_chanmask |= (1<<((chan)-1));\
166: else \
167: (isop)->isop_negchanmask |= (1<<((256-(chan))-1))
168:
169: struct ifnet *consif; /* TO BE REMOVED */
170: Static int consinit(), consioctl(), consattach();
171:
172: /* protosw pointers for getting to higher layer */
173: Static struct protosw *CLNP_proto;
174: Static struct protosw *TP_proto;
175: Static struct protosw *X25_proto;
176: Static int issue_clear_req();
177:
178: #ifndef PHASEONE
179: extern struct ifaddr *ifa_ifwithnet();
180: #endif PHASEONE
181:
182: extern struct ifaddr *ifa_ifwithaddr();
183:
184: Static struct socket dummysocket; /* for use by cosns */
185:
186: extern struct isopcb tp_isopcb; /* chain of all TP pcbs */
187: struct isopcb cons_isopcb; /* chain of all cons pcbs */
188: struct isopcb tp_incoming_pending; /* incoming connections
189: for TP, pending */
190:
191: struct isopcb *Xpcblist[] = {
192: &cons_isopcb,
193: &tp_incoming_pending,
194: &tp_isopcb,
195: (struct isopcb *)0
196: };
197:
198: Static int parse_facil(), NSAPtoDTE(), make_partial_x25_packet();
199: Static int FACILtoNSAP(), DTEtoNSAP();
200: Static struct cons_pcb *cons_chan_to_pcb();
201:
202: #define HIGH_NIBBLE 1
203: #define LOW_NIBBLE 0
204:
205: /*
206: * NAME: nibble_copy()
207: * FUNCTION and ARGUMENTS:
208: * copies (len) nibbles from (src_octet), high or low nibble
209: * to (dst_octet), high or low nibble,
210: * src_nibble & dst_nibble should be:
211: * HIGH_NIBBLE (1) if leftmost 4 bits/ most significant nibble
212: * LOW_NIBBLE (0) if rightmost 4 bits/ least significant nibble
213: * RETURNS: VOID
214: */
215: void
216: nibble_copy( src_octet, src_nibble, dst_octet, dst_nibble, len)
217: register char *src_octet;
218: register char *dst_octet;
219: register unsigned src_nibble;
220: register unsigned dst_nibble;
221: int len;
222: {
223:
224: register i;
225: register unsigned dshift, sshift;
226:
227: IFDEBUG(D_CADDR)
228: printf("nibble_copy ( 0x%x, 0x%x, 0x%x, 0x%x 0x%x)\n",
229: src_octet, src_nibble, dst_octet, dst_nibble, len);
230: ENDDEBUG
231: #define SHIFT 0x4
232:
233: dshift = dst_nibble << 2;
234: sshift = src_nibble << 2;
235:
236: for (i=0; i<len; i++) {
237: /* clear dst_nibble */
238: *dst_octet &= ~(0xf<< dshift);
239:
240: /* set dst nibble */
241: *dst_octet |= ( 0xf & (*src_octet >> sshift))<< dshift;
242:
243: dshift ^= SHIFT;
244: sshift ^= SHIFT;
245: src_nibble = 1-src_nibble;
246: dst_nibble = 1-dst_nibble;
247: src_octet += src_nibble;
248: dst_octet += dst_nibble;
249: }
250: IFDEBUG(D_CADDR)
251: printf("nibble_copy DONE\n");
252: ENDDEBUG
253: }
254:
255: /*
256: * NAME: nibble_match()
257: * FUNCTION and ARGUMENTS:
258: * compares src_octet/src_nibble and dst_octet/dst_nibble for len nibbles.
259: * RETURNS: 0 if they differ, 1 if they are the same.
260: */
261: int
262: nibble_match( src_octet, src_nibble, dst_octet, dst_nibble, len)
263: register char *src_octet;
264: register char *dst_octet;
265: register unsigned src_nibble;
266: register unsigned dst_nibble;
267: int len;
268: {
269:
270: register i;
271: register unsigned dshift, sshift;
272: u_char nibble_a, nibble_b;
273:
274: IFDEBUG(D_CADDR)
275: printf("nibble_match ( 0x%x, 0x%x, 0x%x, 0x%x 0x%x)\n",
276: src_octet, src_nibble, dst_octet, dst_nibble, len);
277: ENDDEBUG
278: #define SHIFT 0x4
279:
280: dshift = dst_nibble << 2;
281: sshift = src_nibble << 2;
282:
283: for (i=0; i<len; i++) {
284: nibble_b = ((*dst_octet)>>dshift) & 0xf;
285: nibble_a = ( 0xf & (*src_octet >> sshift));
286: if( nibble_b != nibble_a )
287: return 0;
288:
289: dshift ^= SHIFT;
290: sshift ^= SHIFT;
291: src_nibble = 1-src_nibble;
292: dst_nibble = 1-dst_nibble;
293: src_octet += src_nibble;
294: dst_octet += dst_nibble;
295: }
296: IFDEBUG(D_CADDR)
297: printf("nibble_match DONE\n");
298: ENDDEBUG
299: return 1;
300: }
301:
302: #ifdef ARGO_DEBUG
303:
304: Static
305: dump_copcb(copcb, str)
306: char * str;
307: register struct cons_pcb *copcb;
308: {
309: printf("XPCB DUMP %s\n", str);
310: if (copcb) {
311: printf("\t copcb 0x%x next 0x%x head 0x%x socket 0x%x ifp 0x%x\n",
312: copcb, copcb->co_next, copcb->co_head, copcb->co_socket, copcb->co_ifp);
313: printf("\t channel 0x%x state 0x%x flags 0x%x proto 0x%x\n",
314: copcb->co_channel, copcb->co_state, copcb->co_flags, copcb->co_proto);
315: printf("\t laddr :\n");
316: dump_isoaddr(&copcb->co_laddr);
317: printf("\t faddr :\n");
318: dump_isoaddr(&copcb->co_faddr);
319: printf("\tttl 0x%x init_ttl 0x%x pending: %d\n",
320: copcb->co_ttl, copcb->co_init_ttl, copcb->co_pending.ifq_len);
321: }
322: printf("END DUMP\n");
323: }
324: #endif ARGO_DEBUG
325:
326: /*
327: * FUNCTION : choose_output - chooses between the eicon and loopback.
328: * This MUST be here because the ifp->if_output routine is cosns_output
329: * -- due to our need to look like a device driver for CLNP. sigh.
330: * ARGUMENTS & PURPOSE: (copcb) ptr to a protocol control block for
331: * x.25, (m) is an mbuf ptr. *m is a request destined either
332: * for the eicon driver or for the loopback driver.
333: * RETURNS : whatever error value the 2I or loopback returns.
334: */
335: Static int
336: choose_output( ifp, m, loop)
337: struct ifnet *ifp;
338: struct mbuf *m;
339: int loop;
340: {
341: int error;
342:
343: if( !m )
344: return 0;
345: ASSERT(m->m_len != 0);
346: if( loop != 0)
347: error = lpboutput( ifp, m );
348: else
349: error = ecnoutput( ifp, m );
350:
351: if (error == 0)
352: ifp->if_opackets ++;
353: else {
354: ifp->if_oerrors ++;
355: IFTRACE(D_CDATA)
356: tptrace( TPPTmisc,
357: "choose_output: ifp m error loop\n",
358: ifp, m, error, loop);
359: ENDTRACE
360: }
361: IFDEBUG(D_CCONS)
362: printf("choose_output returns 0x%x\n", error );
363: ENDDEBUG
364: return error;
365: }
366:
367: /*
368: **************************** NET PROTOCOL cons ***************************
369: */
370:
371: /*
372: * NAME: cons_init()
373: * CALLED FROM:
374: * autoconf
375: * FUNCTION:
376: * initialize the protocol
377: */
378: cons_init()
379: {
380: init_lpb();
381: consattach();
382:
383: /* protocol init stuff */
384:
385: consintrq.ifq_maxlen = IFQ_MAXLEN;
386: consintrq.ifq_head = consintrq.ifq_tail = (struct mbuf *)0;
387:
388: CLNP_proto = pffindproto(AF_ISO, ISOPROTO_CLNP, SOCK_DGRAM);
389: X25_proto = pffindproto(AF_ISO, ISOPROTO_X25, SOCK_STREAM);
390: TP_proto = pffindproto(AF_ISO, ISOPROTO_TP0, SOCK_SEQPACKET);
391: IFDEBUG(D_CCONS)
392: printf("cons_init end : cnlp_proto 0x%x cons proto 0x%x tp proto 0x%x\n",
393: CLNP_proto, X25_proto, TP_proto);
394: ENDDEBUG
395:
396: cons_isopcb.isop_next = cons_isopcb.isop_prev = &cons_isopcb;
397: tp_incoming_pending.isop_next = tp_incoming_pending.isop_prev =
398: &tp_incoming_pending;
399: }
400:
401: #ifdef notdef
402:
403: /*
404: * NAME: cons_free_lru()
405: * some day CALLED FROM:
406: * wherever we run out of mbufs (not used right yet)
407: * FUNCTION:
408: * get rid of the num least recently used connections and
409: * recycle their mbufs.
410: * NOTE: GROTESQUELY INEFFICIENT needs to be written nicely
411: */
412:
413: Static
414: cons_free_lru(qty)
415: int qty;
416: {
417: register struct cons_pcb **copcblist = (struct cons_pcb **)Xpcblist;
418: register struct cons_pcb *copcb;
419: struct cons_pcb Lru;
420: struct cons_pcb *lru;
421:
422: IFDEBUG(D_CCONS)
423: printf("cons_free_lru( 0x%x )\n", qty);
424: ENDDEBUG
425:
426: Lru.co_ttl = X25_TTL;
427: lru = &Lru;
428:
429: while (qty > 1) { /* GROT */
430: cons_free_lru( 1 );
431: qty -- ;
432: }
433:
434: for( copcb = *copcblist; copcb; copcb = *(++copcblist) ) {
435: copcb = (struct cons_pcb *)copcb->co_next;
436: while (copcb != *copcblist) {
437: if( copcb->co_ttl < lru->co_ttl )
438: lru = copcb;
439: copcb = (struct cons_pcb *)copcb->co_next;
440: }
441: }
442:
443: if(lru->co_socket) {
444: soisdisconnected(lru->co_socket);
445: sohasoutofband(lru->co_socket); /* signal */
446: }
447:
448: cons_clear_and_detach( lru, E_CO_HLI_RESYNC, PRC_TIMXCEED_REASS);
449: }
450: #endif notdef
451:
452: /*
453: * NAME: cons_slowtimo()
454: * CALLED FROM:
455: * the clock
456: * FUNCTION:
457: * get rid of any timed-out cons connections
458: * cons connections get "touched" with every use, meaning the
459: * time-to-live gets reset to its max value w/ every use.
460: * The slowtimo() rtn decrements the time-to-live for each
461: * cons connection. If one of them hits zero ---> zap the connection.
462: * This really only applies to those used for CLNP and TP4.
463: * TP4 keeps the connections open with keepalive.
464: * TODO:
465: * Have this happen ONLY for international connections since
466: * there's no connect time charge for domestic calls.
467: * Make default 5 min; make a user option to change it.
468: * TODO:
469: * Maybe if the ttl gets lower than a certain threshold, move this
470: * copcb to the END of its queue so it doesn't slow down the others.
471: */
472:
473: cons_slowtimo()
474: {
475: register struct cons_pcb **copcblist = (struct cons_pcb **)Xpcblist;
476: register struct cons_pcb *copcb;
477: int s = splnet();
478: int qlen = 0;
479: int qdrops = 0;
480: int nvisited = 0;
481:
482: #ifdef ARGO_DEBUG
483: Static int count;
484:
485: count = 0;
486: #endif ARGO_DEBUG
487:
488: IncStat(co_slowtimo);
489: for( copcb = *copcblist; copcb; copcb = *(++copcblist) ) {
490: #ifdef ARGO_DEBUG
491: if( copcb == (struct cons_pcb *)0 ) {
492: ASSERT( 0 );
493: panic("TURNING OFF cons_slowtimo()!!! \n");
494: }
495: #endif ARGO_DEBUG
496: copcb = (struct cons_pcb *)copcb->co_next;
497: while (copcb != *copcblist) {
498: #ifdef ARGO_DEBUG
499: if(++count >50 ) {
500: printf("cons PANIC: slowtimo LOOP\n");
501: splx(s);
502: return;
503: }
504: #endif ARGO_DEBUG
505: #ifdef notdef
506: if( copcb->co_init_ttl == 0 ) {
507: ASSERT( (struct isopcb *)(*copcblist)==(struct isopcb *)&tp_isopcb );
508: copcb = (struct cons_pcb *)copcb->co_next;
509: continue;
510: }
511: #endif notdef
512: nvisited ++;
513: ASSERT( copcb != (struct cons_pcb *)0 );
514: qlen += copcb->co_pending.ifq_len;
515: qdrops += copcb->co_pending.ifq_drops;
516:
517: if( copcb->co_socket) {
518: /* don't want XTS, TP0 connections to be subject to time out */
519: copcb = (struct cons_pcb *)copcb->co_next;
520: continue;
521: }
522:
523: if( -- (copcb->co_ttl) > 0 ) {
524: copcb = (struct cons_pcb *)copcb->co_next;
525: continue;
526: }
527:
528: IncStat(co_timedout);
529:
530: IFDEBUG(D_CCONN)
531: printf("TIMING OUT chan 0x%x copcb 0x%x flags 0x%x\n",
532: copcb->co_channel, copcb, copcb->co_flags );
533: ENDDEBUG
534:
535: {
536: register struct cons_pcb * next =
537: (struct cons_pcb *)copcb->co_next;
538: cons_clear_and_detach(copcb,
539: E_CO_HLI_RESYNC, PRC_TIMXCEED_REASS);
540: copcb = next;
541: }
542: }
543: }
544: if(nvisited) {
545: cons_stat.co_avg_qlen = qlen / nvisited;
546: cons_stat.co_avg_qdrop = qdrops / nvisited;
547: cons_stat.co_active = nvisited;
548: }
549: done:
550: splx(s);
551: }
552:
553: DUMP_PCBLIST()
554: {
555: register int i=0;
556: register struct cons_pcb *copcb;
557: register struct cons_pcb **copcblist = (struct cons_pcb **)Xpcblist;
558:
559: for( copcb = *copcblist; copcb; copcb = *(++copcblist) ) {
560: printf("FOR %d: 0x%x ", ++i, copcb);
561: copcb = (struct cons_pcb *)copcb->co_next;
562: printf(" next 0x%x, *copcblist 0x%x\n", copcb, *copcblist);
563: while (copcb != *copcblist) {
564: ASSERT( copcb != (struct cons_pcb *)0 );
565: printf("\tCOPCB 0x%x\n", copcb);
566: if( copcb )
567: dump_buf(copcb, sizeof( *copcb));
568: else
569: break;
570: copcb = (struct cons_pcb *)copcb->co_next;
571: }
572: }
573: }
574:
575: /*
576: * NAME: cons_pcballoc()
577: * CALLED FROM:
578: * cons_usrreq() when doing PRU_ATTACH,
579: * cons_incoming() when opening a new connection.
580: * FUNCTION and ARGUMENTS:
581: * Allocates a new pcb.
582: * The flags and proto arguments are stashed into the new pcb.
583: * RETURN VALUE:
584: * E* if error, 0 if ok
585: */
586: Static int
587: cons_pcballoc(so, head, flags, proto, dest)
588: struct socket *so;
589: struct isopcb *head;
590: u_short flags;
591: struct protosw *proto;
592: struct cons_pcb **dest;
593: {
594: int error;
595: register struct cons_pcb *copcb;
596:
597: IFDEBUG(D_CCONN)
598: printf("cons_pcballoc (0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
599: so, head, flags, proto, dest);
600: ENDDEBUG
601: if(proto == (struct protosw *)0)
602: return EPROTONOSUPPORT;
603:
604: if( ( error = iso_pcballoc(so, head) ) == EOK ) {
605: /* Have allocated a cleared mbuf */
606:
607: copcb = (struct cons_pcb *)so->so_pcb;
608: copcb->co_ttl = copcb->co_init_ttl = X25_TTL;
609: copcb->co_flags = flags;
610: copcb->co_proto = proto;
611: copcb->co_pending.ifq_maxlen = CONS_IFQMAXLEN;
612: copcb->co_myself = copcb;
613:
614: if (so == &dummysocket)
615: copcb->co_socket = (struct socket *)0;
616:
617: *dest = copcb;
618: }
619: done:
620: IFDEBUG(D_CCONN)
621: printf("cons_pcballoc returns 0x%x: DUMP\n", copcb);
622: dump_buf( copcb, sizeof(*copcb));
623: ENDDEBUG
624: if( (flags & CONSF_ICRE) == 0) {
625: struct dte_addr *dtea = &(*dest)->co_peer_dte;
626: int len;
627:
628: error = iso_8208snparesolve(&(*dest)->co_faddr, dtea, &len);
629: ASSERT(error == 0);
630: ASSERT(len == sizeof(struct dte_addr));
631: }
632:
633: return error;
634: }
635:
636: /*
637: * NAME: cons_connect()
638: * CALLED FROM:
639: * cons_usrreq() when opening a new connection.
640: * FUNCTION anD ARGUMENTS:
641: * Figures out which device to use, finding a route if one doesn't
642: * already exist.
643: * Builds an eicon connection request and gives it to the device.
644: * RETURN VALUE:
645: * returns E*
646: */
647: Static int
648: cons_connect( copcb )
649: register struct cons_pcb *copcb;
650: {
651: register struct eicon_request *ecnrq;
652: register struct mbuf *m;
653: int error = 0;
654: struct ifaddr *ifa;
655:
656: IFDEBUG(D_CCONN)
657: printf("cons_connect( 0x%x ) : ifp 0x%x\npeer: ", copcb, copcb->co_ifp);
658: dump_isoaddr(&copcb->co_faddr);
659: printf("\nmyaddr: ");
660: dump_isoaddr(&copcb->co_laddr);
661: printf("\n" );
662: ENDDEBUG
663:
664: /* PHASE 2: this call is OK */
665: if( ifa = ifa_ifwithaddr(&copcb->co_faddr ) ) {
666: /* foreign address is me */
667: copcb->co_ifp = ifa->ifa_ifp;
668: IFDEBUG(D_CCONN)
669: printf("cons_connect: after if_withaddr copcb->co_ifp 0x%x\n",
670: copcb->co_ifp);
671: ENDDEBUG
672:
673: if( (ifa->ifa_ifp->if_flags&(IFF_LOOPBACK|IFF_UP)) ==
674: (IFF_LOOPBACK|IFF_UP)) {
675: copcb->co_flags |= CONSF_LOOPBACK;
676: }
677: bcopy((caddr_t)&ifa->ifa_addr, (caddr_t)&copcb->co_laddr,
678: sizeof(struct sockaddr));
679: }
680: IFDEBUG(D_CCONN)
681: printf("cons_connect: co_flags 0x%x\n", copcb->co_flags);
682: if( ifa ) {
683: printf(" cons_connect withaddr returns %s\n",
684: copcb->co_ifp->if_name);
685: }
686: ENDDEBUG
687: else if ( copcb->co_ifp == (struct ifnet *)0 ) {
688: #ifdef PHASEONE
689: /*
690: * We need to get the local nsap address.
691: * First, route to the destination. This will provide us with
692: * an ifp. Second, determine which local address linked on
693: * that ifp is appropriate
694: */
695: struct sockaddr_iso *first_hop; /* filled by clnp_route */
696: struct iso_addr *localaddr, *clnp_srcaddr();
697:
698: if (error = clnp_route(&copcb->co_faddr,
699: &((struct isopcb *)copcb)->isop_route, /* flags */0,
700: &first_hop, &copcb->co_ifp))
701: goto bad;
702:
703: /* determine local address based upon ifp */
704: if ((localaddr = clnp_srcaddr(copcb->co_ifp,
705: &first_hop->siso_addr)) == NULL) {
706: error = ENETUNREACH;
707: goto bad;
708: }
709: copcb->co_laddr.siso_family = AF_ISO;
710: copcb->co_laddr.siso_addr = *localaddr;
711: #else
712: /* Foreign addr isn't me (lpb). If still don't have an ifp or have
713: * an ifp but don't know its address, look for a route
714: */
715: if( ifa = ifa_ifwithnet(&copcb->co_faddr) ) {
716: copcb->co_ifp = ifa->ifa_ifp;
717: IFDEBUG(D_CCONN)
718: printf(" cons_connect withnet returns %s\n",
719: copcb->co_ifp->if_name);
720: ENDDEBUG
721: } else {
722: printf("cons PANIC: connect: can't find SNPA \n");
723: error = ENETUNREACH;
724: goto bad;
725: }
726: #endif PHASEONE
727: }
728: #ifndef PHASEONE
729: if( ifa == (struct ifaddr *)0 ) {
730: struct ifaddr * iso_ifwithidi();
731:
732: if( ifa = iso_ifwithidi(&copcb->co_faddr) ) {
733: copcb->co_ifp = ifa->ifa_ifp;
734: IFDEBUG(D_CCONN)
735: printf(" cons_connect withnet returns %s\n",
736: copcb->co_ifp->if_name);
737: ENDDEBUG
738: } else {
739: printf("cons PANIC: connect: can't find SNPA \n");
740: error = ENETUNREACH;
741: goto bad;
742: }
743: }
744: bcopy((caddr_t)&ifa->ifa_addr, (caddr_t)&copcb->co_laddr,
745: sizeof(struct sockaddr));
746: #endif PHASEONE
747:
748: copcb->co_state = CONNECTING;
749:
750: ASSERT( copcb->co_ifp != (struct ifnet *) 0);
751: if ( copcb->co_ifp == (struct ifnet *)0 ) {
752: error = ENETUNREACH;
753: goto bad;
754: }
755:
756: m = m_getclr(M_DONTWAIT, MT_XCONN);
757: if( !m ) {
758: copcb->co_ifp->if_oerrors ++;
759: error = ENOBUFS;
760: goto bad;
761: }
762: m->m_len = sizeof(struct eicon_request);
763:
764: ecnrq = mtod(m, struct eicon_request *);
765:
766: copcb->co_myself = copcb;
767: ecnrq->e_pcb = (caddr_t)copcb;
768: #ifdef ARGO_DEBUG
769: LAST_CALL_PCB = (unsigned) ecnrq->e_pcb;
770: #endif ARGO_DEBUG
771: ecnrq->e_cmd = ECN_CALL;
772: ecnrq->e_vc = 0; /* mbz ? */
773: ecnrq->e_info = 0; /* mbz */
774:
775: /* get data buffer */
776: { struct mbuf *n;
777:
778: MGET(n, M_DONTWAIT, MT_XCONN);
779: if( n==MNULL ) {
780: copcb->co_ifp->if_oerrors ++;
781: error = ENOBUFS;
782: goto bad;
783: }
784: e_data(ecnrq) = n; /* e_data is really dtom(ecnrq)->m_next */
785: }
786:
787: IFDEBUG(D_CCONN)
788: printf(
789: "calling make_partial_x25_packet( 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
790: &copcb->co_laddr, &copcb->co_faddr,
791: copcb->co_proto->pr_protocol,
792: e_data(ecnrq),
793: copcb->co_flags & CONSF_XTS);
794: ENDDEBUG
795: if( error = make_partial_x25_packet( copcb, e_data(ecnrq)) ) {
796: copcb->co_ifp->if_oerrors ++;
797: m_freem(m);
798: goto bad;
799: }
800:
801: IncStat(co_call);
802:
803: IFDEBUG(D_CDUMP_REQ)
804: printf("cons_connect ecnrq:\n");
805: dump_buf(ecnrq, sizeof(*ecnrq));
806: ENDDEBUG
807:
808: ASSERT( copcb->co_channel == 0);
809: if( copcb->co_channel != 0) {
810: printf("cons_connect PANIC: channel is 0x%x\n", copcb->co_channel);
811: }
812:
813: error = choose_output(copcb->co_ifp, m, copcb->co_flags & CONSF_LOOPBACK);
814:
815: switch( error ) {
816: case 0: /* ok */
817: break;
818: default: /* problem */
819: printf("cons: PANIC: if_output returns 0x%x\n", error);
820: cons_clear_and_detach( copcb, DONTCLEAR, PRC_ROUTEDEAD);
821: }
822:
823: bad:
824: IFTRACE(D_CDATA)
825: tptrace( TPPTmisc,
826: "cons_connect: choose (copcb m) returned error\n",
827: copcb, m, error, 0);
828: ENDTRACE
829: return error;
830: }
831:
832: /*
833: * NAME: cons_find()
834: * CALLED FROM:
835: * cosns_output1() thus:
836: * cons_find( CONSF_DGM, dst, proto, 0, 0) where
837: * proto is one of { TP_proto, CLNP_proto }
838: * FUNCTION and ARGUMENTS:
839: * Looks through list of connections for the destination,
840: * for one marked for the use indicated by flags.
841: * If none found, opens up a new connection.
842: * These connections will be eliminated by :
843: * a) slowtimo timer, or
844: * b) the need for a new connection, when we've run out of resources.
845: * The argument flags describes the type of pcb we want - may
846: * specify multiplexing-ok, datagram use, etc.
847: * The argument proto points the the higher layer protocol that
848: * will be using this connection.
849: * RETURN VALUE:
850: * returns a ptr to a pcb whose characteristics match those
851: * described by (flags, proto)
852: */
853:
854: Static struct cons_pcb *
855: cons_find(flags, dst, proto, addl_criteria, mask)
856: u_int flags, mask;
857: struct sockaddr_iso *dst;
858: struct protosw *proto;
859: int (*addl_criteria)();
860: {
861: register struct cons_pcb *copcb;
862: register struct cons_pcb **copcblist = (struct cons_pcb **)Xpcblist;
863: int s = splnet(); /* or whatever, for the device! */
864: struct dte_addr dest_dte;
865: int dummy;
866:
867: struct copcb_descriptor {
868: int xd_qlen;
869: struct cons_pcb *xd_pcb;
870: } next_best = {
871: 0, (struct cons_pcb *)0
872: };
873:
874: IFDEBUG(D_CFIND)
875: printf("cons_find( flags 0x%x proto 0x%x) ", flags, proto);
876: ENDDEBUG
877:
878: if ( iso_8208snparesolve(dst, &dest_dte, &dummy)) {
879: ASSERT(0);
880: return (struct cons_pcb *)0; /* error */
881: }
882: ASSERT(dummy == sizeof(struct dte_addr));
883:
884: for( copcb = *copcblist; copcb; copcb = *(++copcblist) ) {
885: copcb = (struct cons_pcb *)copcb->co_next;
886: while (copcb != *copcblist) {
887: IFDEBUG(D_CFIND)
888: printf(
889: "cons_find: chan 0x%x flags 0x%x proto 0x%x state 0x%x \n",
890: copcb->co_channel, copcb->co_flags, copcb->co_proto,
891: copcb->co_state);
892: ENDDEBUG
893: /*
894: * if flags is a subset of the bits in co_flags, it will suffice
895: */
896: if( ((copcb->co_flags & flags) == flags ) &&
897: /* PHASE2: where do we get the mask if we use nsaps ????
898: * If dte addresses are used, then use
899: * nibble compare otherwise...???
900: */
901: #ifdef notdef
902: iso_addrmatch1(&(copcb->co_faddr.siso_addr), &(dst->siso_addr))
903: #else
904: dest_dte.dtea_niblen == copcb->co_peer_dte.dtea_niblen &&
905: nibble_match( (char *)&(copcb->co_peer_dte.dtea_addr),
906: HIGH_NIBBLE, (char *)dest_dte.dtea_addr,
907: HIGH_NIBBLE, dest_dte.dtea_niblen)
908: #endif notdef
909: &&
910: (copcb->co_proto == proto) &&
911: (copcb->co_state >= MIN_USABLE_STATE)) {
912: IFDEBUG(D_CFIND)
913: printf(
914: "cons_find: add'l criteria...\n" );
915: ENDDEBUG
916: if((copcb->co_state != OPEN) &&
917: (next_best.xd_qlen > copcb->co_pending.ifq_len)) {
918: next_best.xd_pcb = copcb;
919: next_best.xd_qlen = copcb->co_pending.ifq_len;
920: }
921: if( !addl_criteria || (*addl_criteria)(copcb, mask) ) {
922: goto found; /* have to break out of 2 loops */
923: }
924: }
925: copcb = (struct cons_pcb *)copcb->co_next ;
926: }
927: }
928: #ifdef notdef
929: /* TODO:
930: * have a limit of the number of calls per desitination.
931: * If we didn't find one already open AND our limit for this
932: * destination hasn't been reached, return 0 'cause
933: * then the caller will open a new one.
934: * Otherwise return next_best.
935: * To do this we need some sort of per-destination info.
936: * Could go into the directory service. Oh, grotesque.
937: */
938: #endif notdef
939: if( copcb == (struct cons_pcb *)0 ) {
940: copcb = next_best.xd_pcb; /* may be zero too */
941: IFDEBUG(D_CFIND)
942: printf("NEXT_BEST! \n");
943: dump_copcb(copcb, "find: next_best");
944: ENDDEBUG
945: }
946: found:
947:
948: splx(s);
949:
950: IFDEBUG(D_CFIND)
951: printf("returns 0x%x \n", copcb);
952: ENDDEBUG
953: return copcb;
954: }
955:
956:
957: /*
958: * NAME: issue_clear_req()
959: * CALLED FROM:
960: * cons_clear() and wherever we get an error from x.25 that makes us
961: * want to close the vc on which it came, but don't have
962: * a copcb assoc. with that vc.
963: * FUNCTION and ARGUMENTS:
964: * Creates an eicon_request for a clear request, returns it in an mbuf.
965: * (chan) is the channel on which to do the clear, (reason) is the
966: * clear reason(diagnostic).
967: * RETURN VALUE:
968: * returns E*
969: */
970: Static int
971: issue_clear_req(chan, reason, ifp, loop)
972: u_char chan, reason;
973: struct ifnet *ifp;
974: int loop;
975: {
976: register struct mbuf *m;
977: register struct mbuf *cdm;
978: register struct eicon_request *ecnrq;
979: struct e_clear_data *ecd;
980:
981: IFDEBUG(D_CCONN)
982: printf("issue_clear_req(0x%x, 0x%x, 0x%x, 0x%x)\n",
983: chan, reason, ifp, loop);
984: ENDDEBUG
985: m = m_getclr(M_DONTWAIT, MT_XCLOSE);
986: if( !m ) {
987: return ENOBUFS;
988: }
989: m->m_len = sizeof(struct eicon_request);
990: ecnrq = mtod(m, struct eicon_request *);
991: ecnrq->e_cmd = ECN_CLEAR;
992: ecnrq->e_vc = chan & 0xff;
993: /*
994: * see p. 149 of 8208 for reasons (diagnostic codes)
995: */
996: MGET(cdm, M_DONTWAIT, MT_XCLOSE);
997: if( !cdm ) {
998: m_freem(m);
999: return ENOBUFS;
1000: }
1001: cdm->m_len = sizeof(struct e_clear_data); /* cause, diagnostic */
1002: e_data(ecnrq) = cdm;
1003:
1004: ecd = mtod(cdm, struct e_clear_data *);
1005: ecd->ecd_cause = 0x0; /* DTE initiated, diagnostic tells more */
1006: ecd->ecd_diagnostic = (u_char)reason;
1007:
1008: IncStat(co_clear_out);
1009: return choose_output(ifp, m, loop);
1010: }
1011:
1012:
1013: /*
1014: * NAME: cons_clear()
1015: * CALLED FROM:
1016: * cons_usrreq(), PRU_DISCONNECT,
1017: * cons_slowtimo(), cons_free_lru()
1018: * FUNCTION and ARGUMENTS:
1019: * Builds a clear request for the connection represented by copcb,
1020: * gives it to the device.
1021: * ECN_CLEAR(request) takes e_vc only, returns adr_status.
1022: * RETURN VALUE:
1023: */
1024:
1025: Static int
1026: cons_clear( copcb, reason)
1027: register struct cons_pcb *copcb;
1028: u_char reason;
1029: {
1030: register struct mbuf *m;
1031: int error;
1032:
1033: IFDEBUG(D_CCONN)
1034: printf("cons_clear(0x%x, 0x%x)\n", copcb, reason);
1035: ENDDEBUG
1036: if( !copcb) {
1037: printf("cons PANIC: clear: No copcb\n");
1038: return 0;
1039: }
1040: while( copcb->co_pending.ifq_len > 0 ) {
1041: register int s = splimp();
1042:
1043: IF_DEQUEUE( &copcb->co_pending, m );
1044: splx(s);
1045: m_freem(m);
1046: }
1047: if( (copcb->co_state == CLOSED) || (copcb->co_state == CLOSING) )
1048: return 0;
1049:
1050: #ifdef ARGO_DEBUG
1051: if( copcb->co_state == CONNECTING) {
1052: IFDEBUG(D_CCONN)
1053: dump_copcb(copcb, "clear");
1054: ENDDEBUG
1055: } else if( (copcb->co_channel == 0) || (copcb->co_channel == X_NOCHANNEL) ) {
1056: IFDEBUG(D_CCONN)
1057: dump_copcb(copcb, "clear");
1058: ENDDEBUG
1059: }
1060: #endif ARGO_DEBUG
1061:
1062: copcb->co_state = CLOSING;
1063:
1064: IFDEBUG(D_CCONN)
1065: printf("cons_clear: channel 0x%x copcb 0x%x dst: ",
1066: copcb->co_channel, copcb);
1067: dump_isoaddr(&copcb->co_faddr);
1068: dump_copcb(copcb, "clear");
1069: ENDDEBUG
1070:
1071: error = issue_clear_req(copcb->co_channel, reason, copcb->co_ifp,
1072: copcb->co_flags & CONSF_LOOPBACK);
1073: copcb->co_channel = X_NOCHANNEL;
1074: copcb->co_state = CLOSED;
1075: return error;
1076: }
1077:
1078:
1079: /*
1080: * NAME: cons_senddata()
1081: * CALLED FROM:
1082: * cons_output(), consoutput(), consintr()
1083: * FUNCTION and ARGUMENTS:
1084: * issued a data (write) command - if the device isn't ready,
1085: * it enqueues the command on a per-connection queue.
1086: * RETURN VALUE:
1087: * ENOBUFS
1088: * Is responsible for freeing m0!
1089: *
1090: * ECN_SEND (write)
1091: */
1092:
1093: Static int
1094: cons_senddata(copcb, m0)
1095: register struct cons_pcb *copcb;
1096: struct mbuf *m0;
1097: {
1098: register struct mbuf *m;
1099: register struct eicon_request *ecnrq;
1100: int s;
1101:
1102: IFDEBUG(D_CDATA)
1103: printf("cons_senddata( 0x%x, m 0x%x ) chan 0x%x",
1104: copcb, m0, copcb->co_channel );
1105: printf(" co_lport 0x%x\n", copcb->co_lport);
1106: ENDDEBUG
1107: if( m0 == MNULL )
1108: return;
1109: ASSERT( m0->m_len > 0);
1110: if( m0->m_len <= 0) {
1111: printf("cons_senddata : BAD MLEN? 0x%x", m0->m_len);
1112: }
1113:
1114: touch(copcb);
1115:
1116: if( (copcb->co_state == CONNECTING) || (copcb->co_state == ACKWAIT) ) {
1117: IFDEBUG(D_CDATA)
1118: printf("senddata PUTTING ON PENDING Q copcb 0x%x state 0x%x\n",
1119: copcb, copcb->co_state);
1120: ENDDEBUG
1121: s = splimp();
1122: if (IF_QFULL(&copcb->co_pending)) {
1123: IFDEBUG(D_CDATA)
1124: printf("senddata DROPPING m0 0x%x\n", m0);
1125: ENDDEBUG
1126: IF_DROP(&copcb->co_pending);
1127: if(copcb->co_ifp) {
1128: copcb->co_ifp->if_snd.ifq_drops ++;
1129: }
1130: IncStat(co_Xdrops);
1131: copcb->co_ifp->if_oerrors ++;
1132: splx(s);
1133: m_freem (m0);
1134:
1135: if( copcb->co_proto && copcb->co_proto->pr_ctlinput ) {
1136: (*copcb->co_proto->pr_ctlinput)(PRC_QUENCH,
1137: (struct sockaddr_iso *)&copcb->co_faddr,
1138: (caddr_t)copcb);
1139:
1140: return 0;
1141: } else
1142: return E_CO_QFULL;
1143: }
1144: IFDEBUG(D_CDATA)
1145: printf("Putting 0x%x on 0x%x->pending Q\n", m0, copcb);
1146: ENDDEBUG
1147: IF_ENQUEUE( &copcb->co_pending, m0 );
1148: splx(s);
1149: return 0;
1150: }
1151: if(copcb->co_channel == 0 ) {
1152: return E_CO_CHAN;
1153: }
1154: ASSERT( copcb->co_state == OPEN);
1155:
1156: m = m_getclr(M_DONTWAIT, MT_XDATA);
1157: if( !m ) {
1158: copcb->co_ifp->if_oerrors ++;
1159: m_freem (m0);
1160: return ENOBUFS;
1161: }
1162: m->m_len = sizeof(struct eicon_request);
1163: ecnrq = mtod(m, struct eicon_request *);
1164: ecnrq->e_pcb = (caddr_t)copcb;
1165: if( copcb->co_myself != copcb ) {
1166: struct mbuf *mm;
1167: /* TODO: REMOVE THIS DEBUGGING HACK */
1168: ASSERT(0);
1169: printf("BAD e_pcb from HL (0x%x,0x%x)\n", copcb, copcb->co_myself);
1170: mm = dtom( copcb );
1171: if(mm->m_type == MT_FREE)
1172: printf("FREED MBUF!\n");
1173: return ENETDOWN;
1174: }
1175: ASSERT( copcb->co_channel != 0);
1176: ASSERT( copcb->co_channel != X_NOCHANNEL);
1177: ecnrq->e_vc = (copcb->co_channel & 0xff);
1178: ecnrq->e_cmd = ECN_SEND;
1179: e_data(ecnrq) = m0;
1180: {
1181: /* TODO: REMOVE THIS DEBUGGING HACK */
1182: struct mbuf *thedata = e_data(ecnrq);
1183: u_int *firstint = mtod( thedata, u_int *);
1184:
1185: if( (*firstint & 0xff000000) != 0x81000000 ) {
1186: /* not clnp */
1187: switch( ((*firstint) & 0x00ff0000) >> 20 ) {
1188: case 0x1:
1189: case 0x2:
1190: case 0x3:
1191: case 0x6:
1192: case 0x7:
1193: case 0x8:
1194: case 0xc:
1195: case 0xd:
1196: case 0xe:
1197: case 0xf:
1198: break;
1199: default:
1200: printf(" ECN_SEND! BAD DATA\n" );
1201: dump_buf( thedata, 20 + 12 );
1202: m_freem( m0 );
1203: return ENETDOWN;
1204: }
1205: }
1206: }
1207:
1208: ecnrq->e_info = 0;
1209:
1210: IFDEBUG(D_CDUMP_REQ)
1211: printf("senddata ecnrq\n");
1212: ENDDEBUG
1213: IncStat(co_send);
1214:
1215: ASSERT( copcb->co_state == OPEN );
1216: copcb->co_state = ACKWAIT;
1217:
1218: if( copcb->co_myself != copcb ) {
1219: struct mbuf *mm;
1220: /* TODO: REMOVE this and all mention of co_myself */
1221: ASSERT(0);
1222: printf("BAD e_pcb TO THE BOARD ecn (0x%x) cmd 0x%x\n",
1223: ecnrq->e_pcb, ecnrq->e_cmd);
1224: mm = dtom( copcb );
1225: if(mm->m_type == MT_FREE)
1226: printf("FREED MBUF!\n");
1227: dump_buf (ecnrq, sizeof (*ecnrq));
1228: return ENETDOWN;
1229: }
1230:
1231: return
1232: choose_output(copcb->co_ifp, dtom(ecnrq), copcb->co_flags&CONSF_LOOPBACK);
1233: }
1234:
1235: /*
1236: * NAME: cons_send_on_vc()
1237: * CALLED FROM:
1238: * tp_error_emit()
1239: * FUNCTION and ARGUMENTS:
1240: * Take a packet(m0), of length (datalen) from tp and
1241: * send it on the channel (chan).
1242: *
1243: * RETURN VALUE:
1244: * whatever (E*) is returned form the net layer output routine.
1245: */
1246: int
1247: cons_send_on_vc(chan, m, datalen)
1248: int chan;
1249: struct mbuf *m;
1250: int datalen;
1251: {
1252: struct cons_pcb *copcb = (struct cons_pcb *)0;
1253:
1254: if(m == MNULL)
1255: return;
1256:
1257: if((copcb =
1258: #ifdef ARGO_DEBUG
1259: cons_chan_to_pcb( chan, __LINE__ )
1260: #else ARGO_DEBUG
1261: cons_chan_to_pcb( chan )
1262: #endif ARGO_DEBUG
1263: ) == (struct cons_pcb *)0 )
1264: return E_CO_CHAN;
1265: IFDEBUG(D_CCONS)
1266: printf("cons_send_on_vc m 0x%x m_len 0x%x\n", m, m->m_len);
1267: ENDDEBUG
1268: return cons_senddata( copcb, m);
1269: }
1270:
1271: /*
1272: * NAME: cons_output()
1273: * CALLED FROM:
1274: * tpiso_output(), can have whatever interface we want it to...
1275: * tpiso_output() decides whether to give a packet to CLNP or to
1276: * cons; if the latter, it calls this routine.
1277: * FUNCTION and ARGUMENTS:
1278: * tp has alloc-ed a pcb - but it may not be open.
1279: * some classes of tp may allow multiplexing, in which
1280: * case, you may choose to send the data on ANOTHER cons connection.
1281: * This decides which net connection to use, opens one if necessary.
1282: * Then it sends the data.
1283: */
1284:
1285: cons_output(isop, m, len, isdgm)
1286: struct isopcb *isop;
1287: struct mbuf *m;
1288: int len;
1289: int isdgm;
1290: {
1291: struct cons_pcb *copcb = (struct cons_pcb *)0;
1292: int error;
1293: int s = splnet();
1294:
1295: IFDEBUG(D_CCONS)
1296: printf("cons_output( isop 0x%x, m 0x%x, len 0x%x, dgm 0x%x )\n",
1297: isop,m,len, isdgm);
1298: ENDDEBUG
1299:
1300: if( m == MNULL )
1301: return 0;
1302: ASSERT(m->m_len > 0);
1303: if( isdgm ) {
1304: error = cosns_output1(0, m, &isop->isop_faddr, TP_proto, isop);
1305: IFDEBUG(D_CDATA)
1306: if(error)
1307: printf("cosns_output1 RETURNS ERROR 0x%x\n", error);
1308: ENDDEBUG
1309: return error;
1310: }
1311:
1312: if( isop->isop_chanmask || isop->isop_negchanmask) {
1313: register int mask = isop->isop_chanmask;
1314: register int chan = 1;
1315:
1316: if( mask == 0)
1317: mask = isop->isop_negchanmask;
1318:
1319: for ( chan=1; (mask & 1)==0; chan++,mask>>=1 ) ;
1320:
1321: if( isop->isop_chanmask == 0 )
1322: chan = -chan;
1323:
1324: IFDEBUG(D_CCONS)
1325: printf(
1326: "cons_output: isop 0x%x cmask 0x%x negmask 0x%x, chan 0x%x\n",
1327: isop, isop->isop_chanmask, isop->isop_negchanmask, chan);
1328: ENDDEBUG
1329: ASSERT( chan != 0);
1330: #ifdef ARGO_DEBUG
1331: copcb = cons_chan_to_pcb( chan, __LINE__ );
1332: #else ARGO_DEBUG
1333: copcb = cons_chan_to_pcb( chan );
1334: #endif ARGO_DEBUG
1335: }
1336: if( copcb == (struct cons_pcb *)0 ) {
1337: /* get a new one */
1338:
1339: if(( error = cons_pcballoc(&dummysocket, &cons_isopcb, CONSF_OCRE,
1340: TP_proto, &copcb)) != EOK ) {
1341: IFDEBUG(D_CCONS)
1342: printf("cosns_output: no copcb; returns 0x%x\n", error);
1343: ENDDEBUG
1344: (void) m_freem (m);
1345: splx(s);
1346: return error ;
1347: }
1348:
1349: /* abbreviated form of iso_pcbconnect(): */
1350: bcopy((caddr_t)&isop->isop_faddr, (caddr_t)&copcb->co_faddr,
1351: sizeof(struct sockaddr_iso));
1352:
1353: if ( error = cons_connect( copcb ) ) { /* if it doesn't work */
1354: /* oh, dear, throw packet away */
1355: remque((struct isopcb *)copcb);
1356: (void) m_free(dtom(copcb));
1357: (void) m_freem( m );
1358: splx(s);
1359: return error;
1360: }
1361:
1362: if( copcb->co_socket ) {
1363: while( (copcb->co_state != OPEN) &&
1364: !(error = copcb->co_socket->so_error) ) {
1365: IFDEBUG(D_CCONS)
1366: printf(
1367: "SLEEP1 copcb 0x%x isop 0x%x state 0x%x chan 0x%x mask 0x%x neg 0x%x\n",
1368: copcb, isop, copcb->co_state, copcb->co_channel,
1369: ((struct isopcb *)isop)->isop_chanmask,
1370: ((struct isopcb *)isop)->isop_negchanmask
1371: );
1372: ENDDEBUG
1373: tsleep( (caddr_t)&copcb->co_state, PZERO+1,
1374: SLP_ISO_CONSOUT, 0);
1375: IFDEBUG(D_CCONS)
1376: printf("AFTER SLEEP 1 chan 0x%x chanmask 0x%x negchanmask 0x%x\n",
1377: copcb->co_channel, isop->isop_chanmask,
1378: isop->isop_negchanmask);
1379: ENDDEBUG
1380: }
1381: if( !error )
1382: SET_CHANMASK( isop, copcb->co_channel);
1383: }
1384:
1385: }
1386:
1387: IFDEBUG(D_CDATA)
1388: printf("cons_output calling senddata(0x%x 0x%x)\n", copcb, m);
1389: ASSERT(m != MNULL);
1390: ASSERT(m->m_len != 0);
1391: ENDDEBUG
1392:
1393: if( !error )
1394: error = cons_senddata( copcb, m);
1395: splx(s);
1396: return error;
1397: }
1398:
1399: /*
1400: * NAME: cons_openvc()
1401: * CALLED FROM:
1402: * TP when it decides to open a VC for TP 0
1403: * FUNCTION:
1404: * opens a connection and stashes the pcb info in the socket
1405: * substitute for iso_pcbconnect/ in_pcbconnect for the class 0 case
1406: * only.
1407: */
1408: int
1409: cons_openvc(copcb, faddr, so)
1410: struct cons_pcb *copcb;
1411: struct sockaddr_iso *faddr;
1412: struct socket *so;
1413: {
1414: int error = 0;
1415: int s = splnet();
1416: struct cons_pcb *cons_chan_to_pcb();
1417:
1418:
1419: ASSERT( copcb->co_socket == so );
1420: IFTRACE(D_CCONN)
1421: tptrace(TPPTmisc, "cons_openvc( copcb so )\n", copcb, so, 0, 0);
1422: ENDTRACE
1423: IFDEBUG(D_CCONN)
1424: printf("cons_openvc( copcb 0x%x, so 0x%x )\n", copcb,so);
1425: ENDDEBUG
1426: /*
1427: * initialize the copcb part of the isopcb
1428: */
1429: copcb->co_ttl = copcb->co_init_ttl = X25_TTL;
1430: copcb->co_flags = CONSF_OCRE;
1431: copcb->co_proto = TP_proto;
1432: copcb->co_pending.ifq_maxlen = CONS_IFQMAXLEN;
1433:
1434: /* abbreviated form of iso_pcbconnect(): */
1435: bcopy((caddr_t)faddr, (caddr_t)&copcb->co_faddr,
1436: sizeof(struct sockaddr_iso));
1437:
1438: ASSERT( copcb->co_socket == so );
1439: if( error = cons_connect( copcb ) )
1440: goto done;
1441: while( (copcb->co_state != OPEN) && !(error = so->so_error) ) {
1442: IFDEBUG(D_CCONS)
1443: printf(
1444: "SLEEP2 copcb 0x%x state 0x%x chan 0x%x mask 0x%x neg 0x%x\n",
1445: copcb, copcb->co_state, copcb->co_channel,
1446: copcb->co_chanmask,
1447: copcb->co_negchanmask
1448: );
1449: ENDDEBUG
1450: tsleep((caddr_t)&copcb->co_state, PZERO+2, SLP_ISO_CONSCONN, 0);
1451: IFDEBUG(D_CCONS)
1452: printf("AFTER SLEEP2 chan 0x%x chanmask 0x%x negchanmask 0x%x\n",
1453: copcb->co_channel, copcb->co_chanmask,
1454: copcb->co_negchanmask);
1455: ENDDEBUG
1456: }
1457: if( !error )
1458: SET_CHANMASK( (struct isopcb *)copcb, copcb->co_channel);
1459: done:
1460: ASSERT( copcb->co_socket == so );
1461: splx(s);
1462:
1463: IFDEBUG(D_CCONN)
1464: printf("cons_openvc: copcb 0x%x error 0x%x\n", copcb, error );
1465: ENDDEBUG
1466: return error;
1467: }
1468:
1469: /*
1470: * NAME: cons_netcmd()
1471: * CALLED FROM:
1472: * tp_route_to() when it decides to accept or reject an incoming
1473: * connection it calls this.
1474: * FUNCTION:
1475: * either closes the cons connection named by (channel)
1476: * or associates the copcb with the channel #.
1477: * and removes the old copcb from the tp_incoming_pending list.
1478: */
1479: int
1480: cons_netcmd(cmd, isop, channel, isdgm)
1481: int cmd;
1482: struct isopcb *isop;
1483: int channel;
1484: {
1485: int s = splnet();
1486: int error = 0;
1487: struct cons_pcb *copcb = (struct cons_pcb *)0;
1488: struct cons_pcb *cons_chan_to_pcb();
1489:
1490: IFTRACE(D_CCONN)
1491: tptrace(TPPTmisc, "cons_netcmd( cmd isopcb channel isdgm)\n",
1492: cmd,isop,channel, isdgm);
1493: ENDTRACE
1494: IFDEBUG(D_CCONN)
1495: printf("cons_netcmd( cmd 0x%x, isop 0x%x, channel 0x%x, isdgm 0x%x)\n",
1496: cmd,isop,channel, isdgm);
1497: if( isop )
1498: printf("cons_netcmd: isop->socket 0x%x\n",
1499: isop->isop_socket);
1500: ENDDEBUG
1501: ASSERT(cmd != CONN_OPEN);
1502:
1503: /* Can we find a cons-level pcb based on channel? */
1504: if(channel) {
1505: if((copcb =
1506: #ifdef ARGO_DEBUG
1507: cons_chan_to_pcb( channel, __LINE__ )
1508: #else ARGO_DEBUG
1509: cons_chan_to_pcb( channel)
1510: #endif ARGO_DEBUG
1511: ) == (struct cons_pcb *)0) {
1512: error = ECONNABORTED;
1513: splx(s);
1514: return error;
1515: }
1516: if( copcb == (struct cons_pcb *) isop ) {
1517: copcb = (struct cons_pcb *)0;
1518: /* avoid operating on a pcb twice */
1519: } else {
1520: /* if isop is null (close/refuse):
1521: * this would remove from the TP list, which is NOT what we want
1522: * so only remove if there is an isop (gag)
1523: */
1524: if( isop ) {
1525: remque((struct cons_pcb *)copcb); /* take it off pending list */
1526: } else {
1527: ASSERT( (cmd == CONN_CLOSE) || (cmd == CONN_REFUSE) );
1528: }
1529: }
1530: }
1531: /* now we have one of these cases:
1532: * 1) isop is non-null and copcb is null
1533: * 2) isop is non-null and copcb is non-null and they are different
1534: * 3) isop is null and copcb is non-null
1535: */
1536: ASSERT( (isop != (struct isopcb *)0) || (copcb != (struct cons_pcb *)0));
1537:
1538: switch(cmd) {
1539:
1540: case CONN_CONFIRM:
1541: if( isdgm ) {
1542: /* we want two separate pcbs */
1543: /* if we don't have a copcb, get one */
1544:
1545: if( copcb == (struct cons_pcb *)0 ) {
1546: if(( error = cons_pcballoc(&dummysocket, &cons_isopcb,
1547: ((struct cons_pcb *)isop)->co_flags,
1548: TP_proto, &copcb)) != EOK )
1549: return error;
1550: /* copy missing info from isop */
1551: copcb->co_laddr = isop->isop_laddr;
1552: copcb->co_faddr = isop->isop_faddr;
1553: /* don't care about tsuffices */
1554: ((struct cons_pcb *)isop)->co_channel = 0;
1555: /* no longer used */
1556:
1557: copcb->co_ifp = ((struct cons_pcb *)isop)->co_ifp ;
1558: ASSERT( copcb->co_pending.ifq_len == 0 );
1559:
1560: } else {
1561: insque((struct isopcb *)copcb,
1562: (struct isopcb *)&cons_isopcb);
1563: }
1564: copcb->co_state = OPEN;
1565: copcb->co_flags |= CONSF_DGM;
1566: copcb->co_channel = channel;
1567: ASSERT(copcb->co_channel != 0);
1568:
1569: IFDEBUG(D_CCONN)
1570: printf("cons_netcmd: put 0x%x on regular list \n", copcb);
1571: ENDDEBUG
1572: } else {
1573: /* must be TP 0, since this is never called from XTS code */
1574: /* we want ONE pcb, namely isop.
1575: * If this TPE were the active side,
1576: * there ought not to be a copcb, since TP should
1577: * know that you can't send a CR with dgm and negot down
1578: * to non-dgm.
1579: * If this TPE were the passive side, we want to copy from
1580: * the copcb that was on the pending list, and delete the
1581: * pending copcb.
1582: */
1583: if( copcb ) {
1584: IFDEBUG(D_CCONN)
1585: printf("cons_netcmd: copied info from 0x%x to 0x%x\n",
1586: copcb, isop);
1587: ENDDEBUG
1588: isop->isop_laddr = copcb->co_laddr;
1589: isop->isop_faddr = copcb->co_faddr;
1590: /* tsuffices, socket should be there already */
1591: ((struct cons_pcb *)isop)->co_flags =
1592: copcb->co_flags & ~CONSF_DGM;
1593: ((struct cons_pcb *)isop)->co_init_ttl = copcb->co_init_ttl;
1594: touch(((struct cons_pcb *)isop));
1595: ((struct cons_pcb *)isop)->co_channel = channel;
1596: ((struct cons_pcb *)isop)->co_ifp = copcb->co_ifp;
1597: ((struct cons_pcb *)isop)->co_proto = copcb->co_proto;
1598: ((struct cons_pcb *)isop)->co_myself =
1599: (struct cons_pcb *)isop;
1600: SET_CHANMASK( isop, ((struct cons_pcb *)isop)->co_channel );
1601: ASSERT( copcb->co_pending.ifq_len == 0 );
1602:
1603: /* get rid of the copcb that was on the pending list */
1604: (void) m_free(dtom(copcb));
1605: }
1606: ((struct cons_pcb *)isop)->co_state = OPEN;
1607: }
1608: break;
1609:
1610: case CONN_CLOSE:
1611: case CONN_REFUSE:
1612: /* if dgm then ignore; the connections will
1613: * be re-used or will time out
1614: */
1615: if( isdgm )
1616: break;
1617:
1618: /* we should never come in here with both isop and copcb
1619: * unless is dgm, hence the following assertion:
1620: */
1621: ASSERT( (copcb == (struct cons_pcb *)0) ||
1622: (isop == (struct isopcb *)0) );
1623:
1624: /* close whichever pcb we have */
1625: if( copcb )
1626: error = cons_clear(copcb, (cmd == CONN_CLOSE)?
1627: E_CO_HLI_DISCN:E_CO_HLI_REJT);
1628: if( isop )
1629: error = cons_clear((struct cons_pcb *)isop, (cmd == CONN_CLOSE)?
1630: E_CO_HLI_DISCN:E_CO_HLI_REJT);
1631:
1632: if(copcb && (copcb->co_socket == (struct socket *)0) ) {
1633: ASSERT( copcb->co_flags & (CONSF_DGM | CONSF_ICRE) );
1634: (void) m_free(dtom(copcb)); /* detached */
1635: }
1636: /* isop will always be detached by the higher layer */
1637: break;
1638: default:
1639: error = EOPNOTSUPP;
1640: break;
1641: }
1642: splx(s);
1643:
1644: IFDEBUG(D_CCONN)
1645: printf("cons_netcmd returns 0x%x: isop 0x%x\n", isop, error );
1646: ENDDEBUG
1647: return error;
1648: }
1649:
1650:
1651: /*
1652: * NAME: addr_proto_consistency_check()
1653: * CALLED FROM: cons_incoming()
1654: * FUNCTION and ARGUMENTS:
1655: * Enforces a set of rules regarding what addresses will serve
1656: * what protocol stack. This is a kludge forced upon us by the
1657: * fact that there's no way to tell which NET layer you want to
1658: * run when opening a socket. Besides, no doubt, OSI directory
1659: * services won't advertise any kind of a protocol stack with the
1660: * NSAPs. sigh.
1661: * RETURNS
1662: * EAFNOSUPPORT or EOK.
1663: */
1664: Static int
1665: addr_proto_consistency_check(proto, addr)
1666: int proto;
1667: struct sockaddr_iso *addr;
1668: {
1669: switch( proto ) {
1670: case ISOPROTO_CLNP:
1671: break;
1672:
1673: case ISOPROTO_INACT_NL:
1674: case ISOPROTO_CLTP:
1675: return E_CO_HLI_PROTOID;
1676:
1677: case ISOPROTO_TP:
1678: case ISOPROTO_X25:
1679: /* hl is TP or X.25 */
1680: if (addr->siso_addr.isoa_afi != AFI_37)
1681: return E_CO_AIWP;
1682: /* kludge - necessary because this is the only type of
1683: * NSAP we build for an incoming NC
1684: */
1685: break;
1686: default: /* unsupported */
1687: return E_CO_HLI_PROTOID;
1688: }
1689: return EOK;
1690: }
1691: /*
1692: * NAME: cons_incoming()
1693: * CALLED FROM:
1694: * consintr() for incoming OPEN
1695: * FUNCTION and ARGUMENTS:
1696: * Determines which higher layer gets this call, and
1697: * thus whether to immediately accept, reject, or to let the
1698: * higher layer determine this question.
1699: */
1700: Static
1701: cons_incoming(ifp, ecnrq)
1702: struct ifnet *ifp;
1703: register struct eicon_request *ecnrq;
1704: {
1705: struct sockaddr_iso me;
1706: struct sockaddr_iso peer;
1707: struct cons_pcb *copcb;
1708: int loop = 0;
1709: int proto =0;
1710: int error = 0;
1711: struct dte_addr peer_dte;
1712:
1713: IFDEBUG(D_INCOMING)
1714: printf("consincoming enter: ifp 0x%x ecnrq 0x%x\n", ifp, ecnrq);
1715: ENDDEBUG
1716: bzero( &me, sizeof(me));
1717: error = parse_facil( mtod(e_data(ecnrq), caddr_t),
1718: (e_data(ecnrq))->m_len, &me, &peer, &proto,
1719: &peer_dte);
1720: loop = is_me( &peer ); /* <-- THIS may be a problem :
1721: * peer may be nonsense.
1722: * We can only expect that WE will do it right
1723: * and never will we get an error return from
1724: * parse_facil on a facil that WE generated,
1725: * so if garbage comes in, peer will be garbage,
1726: * and loop will be false.
1727: */
1728: if( error != EOK ) {
1729: (void) issue_clear_req(ecnrq->e_vc, error, ifp, loop);
1730: IncStat(co_parse_facil_err);
1731: IncStat(co_Rdrops);
1732: return;
1733: }
1734:
1735: if( (error = addr_proto_consistency_check(proto, &me)) != EOK ) {
1736: /* problem with consistency */
1737: (void) issue_clear_req(ecnrq->e_vc, error, ifp, loop);
1738: IncStat(co_addr_proto_consist_err);
1739: IncStat(co_Rdrops);
1740: return;
1741: } else {
1742: switch( proto ) {
1743: case ISOPROTO_X25:
1744: copcb = (struct cons_pcb *)
1745: ((struct cons_pcb *)(&cons_isopcb))->co_next;
1746:
1747: while (copcb != (struct cons_pcb *)&cons_isopcb) {
1748: if( copcb->co_lport == me.siso_tsuffix ) {
1749: /* for cons "transport service",
1750: * multiplexing is not allowed
1751: */
1752: if( !copcb->co_socket ) {
1753: printf(
1754: "PANIC cons_incoming NOT TP but no sock\n");
1755: copcb = (struct cons_pcb *)0;
1756: break;
1757: }
1758: if( copcb->co_socket->so_options & SO_ACCEPTCONN ) {
1759: struct cons_pcb *newx;
1760:
1761: newx = (struct cons_pcb *)
1762: sonewconn(copcb->co_socket)->so_pcb;
1763: newx->co_laddr = copcb->co_laddr;
1764: newx->co_peer_dte = peer_dte;
1765: newx->co_proto = copcb->co_proto;
1766: newx->co_myself = newx;
1767: touch(copcb);
1768: copcb = newx;
1769: soisconnected(copcb->co_socket);
1770: break;
1771: } /* else keep looking */
1772: }
1773: copcb = (struct cons_pcb *)copcb->co_next;
1774: }
1775: if (copcb == (struct cons_pcb *)&cons_isopcb)
1776: copcb = (struct cons_pcb *) 0;
1777: break;
1778:
1779: case ISOPROTO_TP:
1780: ASSERT( me.siso_tsuffix == 0 );
1781: /*
1782: * We treat this rather like we do for CLNP.
1783: * TP can't tell which socket
1784: * wants this until the TP header comes in, so there's no way
1785: * to associate this channel with a tpcb/isopcb.
1786: * We assume data will arrive (a CR TPDU) and be given to TP along with
1787: * the channel number. We can then expect TP to call us with
1788: * the channel number and pcb ptr, telling us to keep this connection
1789: * or clear it.
1790: * Now, tp will have created an isopcb in the tp_isopcb list.
1791: * We will have to keep another copcb though, because there is no
1792: * 1-1 correspondence between socket and copcb when multiplexing
1793: * is allowed.
1794: * But we want to save the peer address, ifp, and state, proto.
1795: * If the channel should clear before TP responds, we need
1796: * to know that also, so we create a tp-pending list...
1797: */
1798: if( cons_pcballoc(&dummysocket, &tp_incoming_pending,
1799: CONSF_ICRE, TP_proto, &copcb) != EOK ) {
1800: copcb = (struct cons_pcb *)0;
1801: } else {
1802: copcb->co_peer_dte = peer_dte;
1803: }
1804: break;
1805:
1806:
1807: case ISOPROTO_CLNP:
1808: if( cons_pcballoc(&dummysocket, &cons_isopcb,
1809: CONSF_ICRE | CONSF_DGM, CLNP_proto, &copcb ) != EOK ) {
1810: /* choke */
1811: copcb = (struct cons_pcb *)0;
1812: } else {
1813: copcb->co_peer_dte = peer_dte;
1814: }
1815: break;
1816:
1817: default:
1818: panic("cons_incoming");
1819: } /* end switch */
1820:
1821: if(copcb) {
1822: touch(copcb);
1823: copcb->co_channel = (int)ecnrq->e_vc;
1824: ASSERT( copcb->co_channel != 0);
1825: copcb->co_state = OPEN;
1826: copcb->co_ifp = ifp;
1827: copcb->co_laddr = me;
1828: copcb->co_faddr = peer;
1829: if(loop)
1830: copcb->co_flags |= CONSF_LOOPBACK;
1831: IFDEBUG(D_CADDR)
1832: printf("cons_incoming found XPCB 0x%x, loop 0x%x\n",
1833: copcb, loop);
1834: printf("\nco_laddr: ");
1835: dump_buf(&copcb->co_laddr, sizeof(copcb->co_laddr));
1836: printf("\nco_faddr: ");
1837: dump_buf(&copcb->co_faddr, sizeof(copcb->co_faddr));
1838: printf("\n");
1839: ENDDEBUG
1840: } else {
1841: ifp->if_ierrors ++;
1842: (void) issue_clear_req(ecnrq->e_vc, E_CO_OSI_UNSAP, ifp, loop);
1843: IncStat(co_no_copcb);
1844: IncStat(co_Rdrops);
1845: }
1846: }
1847: /* caller frees the mbuf so we don't have to do any such thing */
1848: }
1849:
1850: /*
1851: **************************** DEVICE cons ***************************
1852: */
1853:
1854: /*
1855: * NAME: cosns_output()
1856: * CALLED FROM:
1857: * clnp - this routine is given as the device-output routine
1858: * for the adcom driver.
1859: * FUNCTION and ARGUMENTS:
1860: * (ifp) is the cons/adcom, found by routing function.
1861: * (m0) is the clnp datagram.
1862: * (dst) is the destination address
1863: * This routine finds an x.25 connection for datagram use and
1864: * sends the packet.
1865: */
1866: int
1867: cosns_output(ifp, m0, dst)
1868: {
1869: return cosns_output1(ifp, m0, dst, CLNP_proto, NULL);
1870: }
1871:
1872: /* DEBUGGING ONLY? */
1873: int total_cosns_len = 0;
1874: int total_cosns_cnt = 0;
1875: int total_pkts_to_clnp = 0;
1876:
1877: /*
1878: * The isop is passed here so that if we have set x25crud in the
1879: * pcb, it can be passed down to cons_connect. It could be null
1880: * however, in the case of tp4/x25/clnp
1881: */
1882: Static int
1883: cosns_output1(ifp, m0, dst, proto, isop)
1884: struct ifnet *ifp;
1885: register struct mbuf *m0;
1886: struct sockaddr_iso *dst;
1887: struct protosw *proto;
1888: struct isopcb *isop; /* NULL if coming from clnp */
1889: {
1890: register struct cons_pcb *copcb;
1891: int s = splnet();
1892: int error = 0;
1893:
1894: { register struct mbuf *n=m0;
1895: register int len = 0;
1896:
1897: for(;;) {
1898: len += n->m_len;
1899: if (n->m_next == MNULL ) {
1900: break;
1901: }
1902: n = n->m_next;
1903: }
1904: total_cosns_len += len;
1905: total_cosns_cnt ++;
1906:
1907: }
1908:
1909: IFDEBUG(D_CCONS)
1910: printf("cosns_output1( ifp 0x%x, m 0x%x, dst 0x%x )\n", ifp, m0, dst );
1911: ENDDEBUG
1912: if ( ! (copcb = cons_find( CONSF_DGM, dst, proto, 0, 0) )) {
1913: struct cons_pcb *newcopcb; /* so we can pass addr of this to pcballoc */
1914:
1915: if( (error = cons_pcballoc(&dummysocket, &cons_isopcb,
1916: CONSF_DGM | CONSF_OCRE, proto, &newcopcb) ) != EOK ) {
1917: IFDEBUG(D_CCONS)
1918: printf("cosns_output: no copcb; returns \n");
1919: ENDDEBUG
1920: (void) m_freem(m0);
1921: goto done;
1922: }
1923: copcb = newcopcb;
1924:
1925: /* abbreviated form of iso_pcbconnect(): */
1926: bcopy((caddr_t)dst, (caddr_t)&copcb->co_faddr,
1927: sizeof(struct sockaddr_iso));
1928:
1929: /* copy x25crud into copcb if necessary */
1930: if ((isop != NULL) && (isop->isop_x25crud_len > 0)) {
1931: bcopy(isop->isop_x25crud, copcb->co_x25crud,
1932: isop->isop_x25crud_len);
1933: copcb->co_x25crud_len = isop->isop_x25crud_len;
1934: }
1935:
1936: copcb->co_ifp = ifp; /* NULL IF COMING FROM TP4! */
1937:
1938: if ( error = cons_connect( copcb ) ) { /* if it doesn't work */
1939: /* oh, dear, throw packet away */
1940: remque((struct isopcb *)copcb);
1941: (void) m_free(dtom(copcb));
1942: (void) m_freem(m0);
1943: goto done;
1944: }
1945: }
1946: IFDEBUG(D_CDATA)
1947: printf("cosns_output1 @ senddata: state 0x%x flags 0x%x channel 0x%x\n",
1948: copcb->co_state, copcb->co_flags, copcb->co_channel);
1949: ENDDEBUG
1950: ASSERT(copcb->co_channel != X_NOCHANNEL);
1951: error = cons_senddata(copcb, m0);
1952: done:
1953: splx(s);
1954: return error;
1955: }
1956:
1957:
1958: /*
1959: **************************** TRANSPORT cons ***************************
1960: */
1961:
1962:
1963: /*
1964: * NAME: cons_detach()
1965: * CALLED FROM:
1966: * cons_usrreq() on PRU_DETACH
1967: * cons_netcmd() when TP releases a net connection
1968: * cons_slowtimo() when timeout releases a net connection
1969: * FUNCTION and ARGUMENT:
1970: * removes the copcb from the list of copcbs in use, and frees the mbufs.
1971: * detaches the pcb from the socket, where a socket exists.
1972: * RETURN VALUE:
1973: * ENOTCONN if it couldn't find the copcb in the list of connections.
1974: */
1975:
1976: Static int
1977: cons_detach( copcb )
1978: register struct cons_pcb *copcb;
1979: {
1980: struct socket *so = copcb->co_socket;
1981:
1982: IFDEBUG(D_CCONN)
1983: printf("cons_detach( copcb 0x%x )\n", copcb);
1984: ENDDEBUG
1985: if(so) {
1986: if (so->so_head) {
1987: if (!soqremque(so, 0) && !soqremque(so, 1))
1988: panic("sofree dq");
1989: so->so_head = 0;
1990: }
1991: ((struct isopcb *)copcb)->isop_options = 0; /* kludge */
1992: iso_pcbdetach(copcb); /* detaches from so */
1993: } else {
1994: remque((struct isopcb *)copcb);
1995: (void) m_free(dtom(copcb));
1996: }
1997: }
1998:
1999: Static int
2000: cons_clear_and_detach(copcb, clearreason, ctlcmd)
2001: register struct cons_pcb *copcb;
2002: int clearreason;
2003: int ctlcmd;
2004: {
2005: IFDEBUG(D_CCONN)
2006: printf("Clear and Detach (0x%x, 0x%x, 0x%x)\n",
2007: copcb, clearreason, ctlcmd);
2008: ENDDEBUG
2009: if( clearreason != DONTCLEAR ) {
2010: (void) cons_clear( copcb , clearreason );
2011: }
2012: if( copcb->co_proto && copcb->co_proto->pr_ctlinput )
2013: (*copcb->co_proto->pr_ctlinput)(ctlcmd,
2014: (struct sockaddr_iso *)&copcb->co_faddr, (caddr_t)copcb);
2015:
2016: if( copcb->co_socket == (struct socket *)0 ) {
2017: /* tp4, clnp users only */
2018: (void) cons_detach( copcb );
2019: } /* else detach will be called by the socket's closing */
2020: else {
2021: ASSERT( copcb->co_socket != &dummysocket );
2022: ASSERT( (copcb->co_flags & CONSF_DGM) == 0 );
2023: }
2024: IFDEBUG(D_CCONN)
2025: printf("END OF Clear and Detach (0x%x, 0x%x, 0x%x)\n",
2026: copcb, clearreason, ctlcmd);
2027: ENDDEBUG
2028: }
2029:
2030: Static int
2031: cons_pcbbind( copcb, nam )
2032: register struct cons_pcb *copcb;
2033: struct mbuf *nam;
2034: {
2035: int error;
2036:
2037: if( error = iso_pcbbind( copcb, nam) )
2038: return error;
2039:
2040: /* iso_pcbbind already ensured that if port < 1024 it's superuser */
2041: /* Now we check: must be in range 0 .. 23 or in range 1024 .. 99 */
2042:
2043: if( (copcb->co_lport < X25_PORT_RESERVED) ||
2044: ((copcb->co_lport >= ISO_PORT_RESERVED) &&
2045: (copcb->co_lport <= X25_PORT_USERMAX))) {
2046: munge( copcb->co_lport, (&copcb->co_laddr)->siso_addr.t37_idi +
2047: ADDR37_IDI_LEN, 1 /* nibble */);
2048: munge( copcb->co_fport, (&copcb->co_faddr)->siso_addr.t37_idi +
2049: ADDR37_IDI_LEN, 1 /* nibble */);
2050: return 0;
2051: } else
2052: return EADDRNOTAVAIL;
2053: }
2054: /*
2055: * NAME: cons_usrreq()
2056: * CALLED FROM:
2057: * user level via proto switch
2058: * FUNCTION and ARGUMENTS:
2059: * so : socket
2060: * req: which PRU* request
2061: * m : data or mbuf ptr into which to stash data
2062: * nam: mbuf ptr which is really a sockaddr_iso
2063: * ifq: in PRU_CONTROL case, an ifnet structure
2064: * RETURN VALUE:
2065: * ENOTCONN if trying to do something which requires a connection
2066: * and it's not yet connected
2067: * EISCONN if trying to do something which cannot be done to a connection
2068: * but it's connected
2069: * ENOBUFS if ran out of mbufs
2070: * EWOULDBLOCK if in nonblocking mode & can't send right away
2071: * EOPNOSUPP if req isn't supported
2072: * E* other passed up from lower layers or from other routines
2073: */
2074:
2075: cons_usrreq(so, req, m, nam, ifp)
2076: struct socket *so;
2077: u_int req;
2078: struct mbuf *m, *nam;
2079: int *ifp;
2080: {
2081: struct cons_pcb *copcb = (struct cons_pcb *)so->so_pcb;
2082: int s = splnet();
2083: int error = 0;
2084:
2085: IFDEBUG(D_CCONS)
2086: printf("cons_usrreq 0x%x so 0x%x copcb 0x%x\n", req, so, copcb);
2087: ENDDEBUG
2088: if (req == PRU_CONTROL) {
2089: error = iso_control(so, (int)m, (caddr_t)nam, (struct ifnet *)ifp);
2090: splx(s);
2091: return error;
2092: }
2093: if (copcb == (struct cons_pcb *)0 && req != PRU_ATTACH) {
2094: splx(s);
2095: return ENOTCONN;
2096: }
2097:
2098: switch (req) {
2099:
2100: case PRU_ATTACH:
2101: if (copcb) {
2102: error = EISCONN;
2103: break;
2104: }
2105: soreserve(so, X25_SBSIZE, X25_SBSIZE); /* CONS size */
2106: error = cons_pcballoc(so, &cons_isopcb, CONSF_XTS, X25_proto, &copcb );
2107: break;
2108:
2109: case PRU_ABORT: /* called from close() */
2110: /* called for each incoming connect queued on the parent (accepting)
2111: * socket (SO_ACCEPTCONN);
2112: */
2113: error = cons_detach ( copcb );
2114: break;
2115:
2116: case PRU_DETACH: /* called from close() */
2117: /* called after disconnect was called iff was connected at the time
2118: * of the close, or directly if socket never got connected */
2119: error = cons_detach ( copcb );
2120: break;
2121:
2122: case PRU_SHUTDOWN:
2123: /* recv end may have been released; local credit might be zero */
2124: case PRU_DISCONNECT:
2125: soisdisconnected(so);
2126: error = cons_clear(copcb, E_CO_HLI_DISCN);
2127: break;
2128:
2129: case PRU_BIND:
2130: error = cons_pcbbind( copcb, nam);
2131: break;
2132:
2133: case PRU_LISTEN:
2134: if (copcb->co_lport == 0)
2135: error = cons_pcbbind( copcb, 0 );
2136: break;
2137:
2138:
2139: case PRU_SOCKADDR: {
2140: struct sockaddr_iso *siso = mtod(nam, struct sockaddr_iso *);
2141:
2142: nam->m_len = sizeof (struct sockaddr_iso);
2143: if(copcb->co_ifp)
2144: bcopy( (caddr_t)&copcb->co_laddr,
2145: (caddr_t)siso, sizeof(struct sockaddr_iso) );
2146:
2147: ((struct sockaddr_iso *)siso)->siso_tsuffix = copcb->co_lport;
2148: }
2149: break;
2150:
2151: case PRU_PEERADDR:
2152: if( (so->so_state & SS_ISCONNECTED) &&
2153: (so->so_state & SS_ISDISCONNECTING) == 0) {
2154: struct sockaddr_iso *siso = mtod(nam, struct sockaddr_iso *);
2155:
2156: nam->m_len = sizeof (struct sockaddr_iso);
2157: bcopy( (caddr_t)&copcb->co_faddr, (caddr_t)siso,
2158: sizeof(struct sockaddr_iso) );
2159: } else
2160: error = ENOTCONN;
2161: break;
2162:
2163: case PRU_CONNECT:
2164: /* TODO: We need to bind to the RIGHT interface.
2165: * The only way to have the right interface is to have
2166: * the right route.
2167: */
2168: IFDEBUG(D_CCONN)
2169: printf("PRU_CONNECT 1: local tsuffix 0x%x so->so_head 0x%x nam:\n",
2170: copcb->co_lport, so->so_head);
2171: dump_isoaddr( mtod(nam, struct sockaddr_iso *) );
2172: ENDDEBUG
2173: if (copcb->co_lport == 0) {
2174: if( error = cons_pcbbind( copcb, 0 ))
2175: break;
2176: }
2177: IFDEBUG(D_CCONN)
2178: printf("PRU_CONNECT 2: local tsuffix 0x%x so->so_head 0x%x nam:\n",
2179: copcb->co_lport, so->so_head);
2180: dump_isoaddr( mtod(nam, struct sockaddr_iso *) );
2181: ENDDEBUG
2182:
2183: { /* change the destination address so the last 2 digits
2184: * are the port/suffix/selector (whatever you want to call it)
2185: */
2186: register struct sockaddr_iso *siso =
2187: mtod(nam, struct sockaddr_iso *);
2188: if( (siso->siso_tsuffix < X25_PORT_RESERVED) ||
2189: ((siso->siso_tsuffix >= ISO_PORT_RESERVED) &&
2190: (siso->siso_tsuffix <= X25_PORT_USERMAX)))
2191: munge( siso->siso_tsuffix,
2192: siso->siso_addr.t37_idi + ADDR37_IDI_LEN,
2193: 1 /* nibble */);
2194: }
2195:
2196: soisconnecting(so);
2197: if (error = iso_pcbconnect(copcb, nam))
2198: break;
2199: error = cons_connect( copcb );
2200: if ( error ) {
2201: /*
2202: remque((struct isopcb *)copcb);
2203: (void) m_free(dtom(copcb));
2204: */
2205: break;
2206: }
2207: while( (copcb->co_state != OPEN)&&(copcb->co_socket->so_error == 0) ) {
2208: IFDEBUG(D_CCONN)
2209: printf("PRU_CONNECT: error 0x%x sleeping on 0x%x\n",
2210: copcb->co_socket->so_error,
2211: (caddr_t)&copcb->co_state );
2212: ENDDEBUG
2213: sleep((caddr_t)&copcb->co_state, PZERO+3, SLP_ISO_CONS, 0 );
2214: }
2215:
2216: ASSERT( copcb->co_channel != 0);
2217:
2218: SET_CHANMASK ( (struct isopcb *)copcb, copcb->co_channel);
2219: break;
2220:
2221: case PRU_ACCEPT:
2222: /* so here is the NEW socket */
2223: so->so_error = 0;
2224: if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTED)== 0) {
2225: error = EWOULDBLOCK;
2226: break;
2227: }
2228: {
2229: struct sockaddr_iso *siso = mtod(nam, struct sockaddr_iso *);
2230:
2231: /* copy the peer's address into the return argument */
2232: nam->m_len = sizeof (struct sockaddr_iso);
2233: bcopy( (caddr_t)&copcb->co_faddr, (caddr_t)siso,
2234: sizeof(struct sockaddr_iso));
2235: }
2236: break;
2237:
2238: case PRU_SEND:
2239: case PRU_SENDEOT:
2240: /*
2241: * sosend calls this until sbspace goes negative.
2242: * Sbspace may be made negative by appending this mbuf chain,
2243: * possibly by a whole cluster.
2244: */
2245: {
2246: /* no need to actually queue this stuff and dequeue it,
2247: * just bump the pointers in so_snd so that higher
2248: * layer of socket code will cause it to sleep when
2249: * we've run out of socket space
2250: * TODO:
2251: * Unfortunately that makes sbflush vomit so we have
2252: * to allocate a single real mbuf (say size 240)
2253: * and sballoc it and sbfree it upon CONS_SEND_DONE.
2254: * Oh, my, is this sickening or what?
2255: */
2256: {
2257: struct mbuf *mx;
2258:
2259: MGET(mx, M_DONTWAIT, MT_DATA);
2260: mx->m_len = MLEN;
2261: sbappend((caddr_t)&copcb->co_socket->so_snd, mx);
2262: }
2263: if( m ) {
2264: IFDEBUG(D_CDATA)
2265: printf("X.25 Usrreq calling cons_senddata(0x%x, 0x%x)\n",
2266: copcb, m);
2267: ENDDEBUG
2268: error = cons_senddata(copcb, m);
2269: }
2270: IFDEBUG(D_CCONS)
2271: printf("PRU_SEND sent tsuffix 0x%x, m 0x%x error 0x%x\n",
2272: copcb->co_lport, m, error);
2273: ENDDEBUG
2274:
2275: if( req == PRU_SENDEOT ) {
2276: while(copcb->co_socket->so_snd.sb_cc > 0)
2277: sbwait(&copcb->co_socket->so_snd);
2278: }
2279: }
2280: break;
2281:
2282: case PRU_CONTROL:
2283: error = cons_ioctl(so, m, (caddr_t)nam);
2284: break;
2285:
2286:
2287: case PRU_RCVD:
2288: case PRU_RCVOOB:
2289: case PRU_SENDOOB:
2290: /* COULD support INTERRUPT packets as oob */
2291: case PRU_PROTOSEND:
2292: case PRU_PROTORCV:
2293: case PRU_SENSE:
2294: case PRU_SLOWTIMO:
2295: case PRU_CONNECT2:
2296: case PRU_FASTTIMO:
2297: default:
2298: error = EOPNOTSUPP;
2299: }
2300:
2301: IFDEBUG(D_CCONS)
2302: printf("cons_usrreq cmd 0x%x copcb 0x%x returned error 0x%x\n",
2303: req, copcb, error);
2304: ENDDEBUG
2305: splx(s);
2306: return error;
2307: }
2308:
2309: /*
2310: * NAME: cons_input()
2311: * CALLED FROM:
2312: * consintr() through the isosw protosw for "transport" version of X25
2313: * FUNCTION & ARGUMENTS:
2314: * process incoming data
2315: */
2316: cons_input(m, faddr, laddr, so)
2317: register struct mbuf *m;
2318: struct sockaddr_iso *faddr, *laddr; /* not used */
2319: register struct socket *so;
2320: {
2321: IFDEBUG(D_CCONS)
2322: printf("cons_input( m 0x%x, so 0x%x)\n", m,so);
2323: ENDDEBUG
2324: sbappend(&so->so_rcv, m);
2325: sbwakeup(&so->so_rcv);
2326: }
2327:
2328: #ifdef notdef
2329: /*
2330: * NAME: cons_ctloutput()
2331: * CALLED FROM:
2332: * set/get sockopts()
2333: * Presently the protosw has 0 in the ctloutput spot
2334: * because we haven't inplemented anything yet.
2335: * If there's reason to put some options in here,
2336: * be sure to stick this routine name in the protosw in iso_proto.c
2337: */
2338: cons_ctloutput(cmd, so, level, optname, mp)
2339: int cmd, level, optname;
2340: struct socket *so;
2341: struct mbuf **mp;
2342: {
2343: int s = splnet();
2344:
2345: splx(s);
2346: return EOPNOTSUPP;
2347: }
2348: #endif notdef
2349:
2350:
2351: /*
2352: * NAME: cons_ctlinput()
2353: * CALLED FROM:
2354: * lower layer when ECN_CLEAR occurs : this routine is here
2355: * for consistency - cons subnet service calls its higher layer
2356: * through the protosw entry.
2357: * FUNCTION & ARGUMENTS:
2358: * cmd is a PRC_* command, list found in ../sys/protosw.h
2359: * copcb is the obvious.
2360: * This serves the higher-layer cons service.
2361: * NOTE: this takes 3rd arg. because cons uses it to inform itself
2362: * of things (timeouts, etc) but has a pcb instead of an address.
2363: */
2364: cons_ctlinput(cmd, sa, copcb)
2365: int cmd;
2366: struct sockaddr *sa;
2367: register struct cons_pcb *copcb;
2368: {
2369: int error = 0;
2370: int s = splnet();
2371: extern u_char inetctlerrmap[];
2372: extern int iso_rtchange();
2373:
2374: IFDEBUG(D_CCONS)
2375: printf("cons_ctlinput( cmd 0x%x, copcb 0x%x)\n", cmd, copcb);
2376: ENDDEBUG
2377: /* co_socket had better exist */
2378: switch (cmd) {
2379: case PRC_CONS_SEND_DONE:
2380: ASSERT( copcb->co_socket );
2381: ASSERT( copcb->co_flags & CONSF_XTS );
2382: sbdrop((caddr_t)&copcb->co_socket->so_snd, MLEN);
2383: sbwakeup((caddr_t)&copcb->co_socket->so_snd);
2384: break;
2385:
2386: case PRC_ROUTEDEAD:
2387: error = ENETUNREACH;
2388: break;
2389:
2390: case PRC_TIMXCEED_REASS:
2391: error = ETIMEDOUT;
2392: break;
2393:
2394: /*
2395: case PRC_QUENCH:
2396: iso_pcbnotify(&cons_pcb, sa,
2397: (int)inetctlerrmap[cmd], iso_rtchange);
2398: iso_pcbnotify(&tp_incoming_pending, sa,
2399: (int)inetctlerrmap[cmd], tpiso_quench);
2400: iso_pcbnotify(&tp_isopcb, sa,
2401: (int)inetctlerrmap[cmd], tpiso_quench);
2402: */
2403:
2404: case PRC_IFDOWN:
2405: iso_pcbnotify(&cons_isopcb, sa,
2406: (int)inetctlerrmap[cmd], iso_rtchange);
2407: iso_pcbnotify(&tp_incoming_pending, sa,
2408: (int)inetctlerrmap[cmd], iso_rtchange);
2409: iso_pcbnotify(&tp_isopcb, sa,
2410: (int)inetctlerrmap[cmd], iso_rtchange);
2411: break;
2412:
2413:
2414: default:
2415: printf("cons_ctlinput: unknown cmd 0x%x\n", cmd);
2416: }
2417: if(error) {
2418: soisdisconnected(copcb->co_socket);
2419: sohasoutofband(copcb->co_socket);
2420: }
2421: splx(s);
2422: }
2423:
2424: /*
2425: *********************** SERVES ALL cons embodiments *******************
2426: */
2427:
2428: /*
2429: * NAME: cons_chan_to_pcb()
2430: * CALLED FROM:
2431: * cons_chan_to_tpcb() in tp_cons.c
2432: * and in this file: incoming requests that give only a channel number, i.e.,
2433: * ECN_ACCEPT, ECN_RECEIVE, ECN_CLEAR
2434: * FUNCTION:
2435: * identify the pcb assoc with that channel
2436: * RETURN:
2437: * ptr to the pcb
2438: */
2439: struct cons_pcb *
2440: #ifdef ARGO_DEBUG
2441: cons_chan_to_pcb( channel, linenumber )
2442: int linenumber;
2443: #else ARGO_DEBUG
2444: cons_chan_to_pcb( channel)
2445: #endif ARGO_DEBUG
2446: register int channel;
2447: {
2448: register struct cons_pcb **copcblist = (struct cons_pcb **)Xpcblist;
2449: register struct cons_pcb *copcb;
2450:
2451: /* just to be sure */
2452: channel = channel & 0xff;
2453:
2454: for( copcb = *copcblist; copcb; copcb = *(++copcblist) ) {
2455: copcb = (struct cons_pcb *)copcb->co_next;
2456: while (copcb != *copcblist) {
2457: if ( copcb->co_channel == channel )
2458: goto found; /* want to break out of both loops */
2459:
2460: copcb = (struct cons_pcb *)copcb->co_next;
2461: }
2462: }
2463: found: /* or maybe not... */
2464: IFDEBUG(D_CCONS)
2465: printf("cons_chan_to_pcb( 0x%x, %d ) %s 0x%x\n", channel, linenumber,
2466: copcb?"FOUND":"FAILED", copcb);
2467: ENDDEBUG
2468:
2469: return copcb;
2470: }
2471:
2472:
2473: /*
2474: * NAME: is_me()
2475: * CALLED FROM:
2476: * cons_incoming(). Perhaps could just expand in line.
2477: * FUNCTION and ARGUMENTS:
2478: * for the given remote address (remadr) if it exactly matches
2479: * one of the addresses of ME, and I am up as loopback,
2480: * return TRUE, else return FALSE.
2481: * RETURNS:
2482: * Boolean
2483: */
2484: Static int
2485: is_me(remaddr)
2486: struct sockaddr_iso *remaddr;
2487: {
2488: struct ifnet *ifp = consif;
2489: /* PHASE2: this is ok */
2490: struct ifaddr *ifa = ifa_ifwithaddr(remaddr);
2491:
2492: IFDEBUG(D_CADDR)
2493: printf("is_me: withaddr returns %s\n",
2494: ifa?ifa->ifa_ifp->if_name:"NONE");
2495: ENDDEBUG
2496: if( ifa ) {
2497: /* remaddr matches one of my interfaces exactly */
2498: if( ifa->ifa_ifp->if_flags & IFF_LOOPBACK ) {
2499: ASSERT( ifp == ifa->ifa_ifp );
2500: return 1;
2501: }
2502: }
2503: return 0;
2504: }
2505:
2506: find_error_reason( ecnrq )
2507: register struct eicon_request *ecnrq;
2508: {
2509: extern u_char x25_error_stats[];
2510: int error;
2511: struct mbuf *cdm;
2512: struct e_clear_data *ecd;
2513:
2514: cdm = e_data(ecnrq);
2515: if( cdm && cdm->m_len > 0 ) {
2516: ecd = mtod(cdm, struct e_clear_data *);
2517: switch( ecd->ecd_cause ) {
2518: case 0x00:
2519: case 0x80:
2520: /* DTE originated; look at the diagnostic */
2521: error = (CONL_ERROR_MASK | ecd->ecd_diagnostic);
2522: goto done;
2523:
2524: case 0x01: /* number busy */
2525: case 0x81:
2526: case 0x09: /* Out of order */
2527: case 0x89:
2528: case 0x11: /* Remot Procedure Error */
2529: case 0x91:
2530: case 0x19: /* reverse charging accept not subscribed */
2531: case 0x99:
2532: case 0x21: /* Incampat destination */
2533: case 0xa1:
2534: case 0x29: /* fast select accept not subscribed */
2535: case 0xa9:
2536: case 0x39: /* ship absent */
2537: case 0xb9:
2538: case 0x03: /* invalid facil request */
2539: case 0x83:
2540: case 0x0b: /* access barred */
2541: case 0x8b:
2542: case 0x13: /* local procedure error */
2543: case 0x93:
2544: case 0x05: /* network congestion */
2545: case 0x85:
2546: case 0x8d: /* not obtainable */
2547: case 0x0d:
2548: case 0x95: /* RPOA out of order */
2549: case 0x15:
2550: /* take out bit 8
2551: * so we don't have to have so many perror entries
2552: */
2553: error = (CONL_ERROR_MASK | 0x100 | (ecd->ecd_cause & ~0x80));
2554: goto done;
2555:
2556: case 0xc1: /* gateway-detected proc error */
2557: case 0xc3: /* gateway congestion */
2558:
2559: error = (CONL_ERROR_MASK | 0x100 | ecd->ecd_cause);
2560: goto done;
2561: }
2562: }
2563: /* otherwise, a *hopefully* valid perror exists in the e_reason field */
2564: error = ecnrq->e_reason;
2565: if (error = 0) {
2566: printf("Incoming PKT TYPE 0x%x with reason 0x%x\n",
2567: ecnrq->e_cmd,
2568: ecnrq->e_reason);
2569: error = E_CO_HLI_DISCA;
2570: }
2571:
2572: done:
2573: if(error & 0x1ff == 0) {
2574: error = 0;
2575: } else if( error & 0x1ff > sizeof(x25_error_stats)) {
2576: ASSERT(0);
2577: } else {
2578: x25_error_stats[error& 0x1ff] ++;
2579: }
2580: return error;
2581: }
2582:
2583: /*
2584: * NAME: consintr()
2585: * CALLED FROM:
2586: * the eicon driver via software interrupt
2587: * FUNCTION and ARGUMENTS:
2588: * processes incoming indications, passing them
2589: * along to clnp, tp, or x.25-transport as appropriate.
2590: */
2591: consintr()
2592: {
2593: struct ifnet *ifp = consif;
2594: register struct eicon_request *ecnrq;
2595: register struct cons_pcb *copcb = (struct cons_pcb *)0;
2596: register struct mbuf *m;
2597: int s, s0 = splnet();
2598:
2599: IncStat(co_intr);
2600: ifp->if_ipackets ++;
2601:
2602: for(;;) {
2603: /*
2604: * Get next request off input queue
2605: */
2606: s = splimp();
2607: IF_DEQUEUE(&consintrq, m);
2608: splx(s);
2609: IFDEBUG(D_INCOMING)
2610: printf("cons intr() 0x%x m_off 0x%x m_len 0x%x dequeued\n",
2611: m, m?m->m_off:0, m?m->m_len:0);
2612: ENDDEBUG
2613:
2614: if (m == 0) {
2615: splx(s0);
2616: return;
2617: }
2618:
2619: if((m->m_off != MMINOFF)||(m->m_len != sizeof (struct eicon_request))){
2620: ifp->if_ierrors ++;
2621: IncStat(co_Rdrops);
2622: printf("Cons R DROP! BAD MBUF FROM LL 0x%x sizeof(...) 0x%x\n",
2623: m, sizeof(struct eicon_request));
2624: continue;
2625: }
2626:
2627: ecnrq = mtod(m, struct eicon_request *);
2628:
2629:
2630: IFDEBUG(D_INCOMING)
2631: printf("INTR: e_cmd 0x%x, e_data 0x%x\n", ecnrq->e_cmd,
2632: e_data(ecnrq));
2633: if( e_data(ecnrq) != 0 ) {
2634: /* let's just look at the first few bytes */
2635: /*
2636: dump_buf( e_data(ecnrq), (e_data(ecnrq))->m_len + 12);
2637: */
2638: dump_buf( e_data(ecnrq), 20 + 12);
2639: }
2640: ENDDEBUG
2641: IFTRACE(D_CDATA)
2642: tptrace( TPPTmisc, "INTR: req_type m lun\n",
2643: ecnrq->e_cmd, m, ecnrq->e_vc, 0);
2644: ENDTRACE
2645:
2646: switch( ecnrq->e_cmd ) {
2647:
2648: case ECN_ACK: /* data put on the board */
2649: IncStat(co_ack);
2650: ASSERT( ecnrq->e_vc != 0);
2651: /* from ACKWAIT to OPEN */
2652: if ( (copcb =
2653: #ifdef ARGO_DEBUG
2654: cons_chan_to_pcb( (int)ecnrq->e_vc, __LINE__ )
2655: #else ARGO_DEBUG
2656: cons_chan_to_pcb( (int)ecnrq->e_vc )
2657: #endif ARGO_DEBUG
2658: ) == (struct cons_pcb *)0 )
2659: break;
2660: copcb->co_state = OPEN;
2661: /*
2662: * Anything on the pending queue for this connection?
2663: */
2664: if( copcb->co_pending.ifq_len == 0 ) {
2665: if( copcb->co_proto->pr_ctlinput )
2666: /* for the sake of higher layer protocol (tp) */
2667: (*copcb->co_proto->pr_ctlinput)
2668: (PRC_CONS_SEND_DONE,
2669: (struct sockaddr_iso *)&copcb->co_faddr,
2670: (caddr_t)copcb);
2671: } else {
2672: register struct mbuf *m0;
2673:
2674: s = splimp();
2675: IF_DEQUEUE( &copcb->co_pending, m0 );
2676: splx(s);
2677: /* CAN ONLY DO 1 item here
2678: * if you change this if to while, HA HA
2679: * it'll go right back onto
2680: * the pending queue (which means things will
2681: * be reordered on the queue!)
2682: */
2683: if( m0 ) {
2684: IFDEBUG(D_CDATA)
2685: printf("ACK sending pending queue 0x%x len 0x%x\n",
2686: m0, m0->m_len);
2687: ENDDEBUG
2688: ASSERT( m0->m_len != 0);
2689: (void) cons_senddata(copcb, m0);
2690: }
2691: }
2692:
2693: /* send more? */
2694: break;
2695:
2696: case ECN_ACCEPT: /* call accepted at other end */
2697: /* adr_src, adr_dst are as given in the ECN_CALL
2698: * pcb field is copied from our ECN_CALL
2699: * request, confirm gives me a channel number
2700: */
2701: ASSERT( ecnrq->e_vc != 0);
2702:
2703: IncStat(co_accept);
2704: if(copcb =
2705: #ifdef ARGO_DEBUG
2706: cons_chan_to_pcb((int)ecnrq->e_vc, __LINE__ )
2707: #else ARGO_DEBUG
2708: cons_chan_to_pcb((int)ecnrq->e_vc)
2709: #endif ARGO_DEBUG
2710: ) {
2711: /* error: already exists */
2712: printf("cons PANIC: dbl confirm for channel 0x%x\n",
2713: ecnrq->e_vc);
2714: break;
2715: }
2716: copcb = (struct cons_pcb *)ecnrq->e_pcb;
2717: if( copcb->co_myself != copcb ) {
2718: struct mbuf *mm;
2719: /* TODO: REMOVE */
2720: ASSERT(0);
2721: printf("BAD e_pcb from ecn (0x%x) cmd 0x%x\n",
2722: ecnrq->e_pcb, ecnrq->e_cmd);
2723: mm = dtom( copcb );
2724: if(mm->m_type == MT_FREE)
2725: printf("FREED MBUF!\n");
2726: dump_buf (ecnrq, sizeof (*ecnrq));
2727: panic("BAD ecnrq");
2728: break;
2729: }
2730: touch(copcb);
2731: copcb->co_state = OPEN;
2732: copcb->co_channel = (int)ecnrq->e_vc;
2733: if(copcb->co_socket) {
2734: /* tp0 will take care of itself */
2735: if( copcb->co_flags & CONSF_XTS)
2736: soisconnected(copcb->co_socket); /* wake 'em up */
2737: }
2738: wakeup( (caddr_t)&copcb->co_state );
2739:
2740: /*
2741: * Anything on the pending queue for this connection?
2742: */
2743: if( copcb->co_pending.ifq_len > 0 ) {
2744: register struct mbuf *m0;
2745:
2746: s = splimp();
2747: IF_DEQUEUE( &copcb->co_pending, m0 );
2748: splx(s);
2749: /* CAN ONLY DO 1 item here
2750: * if you change this if to while, HA HA
2751: * it'll go right back onto
2752: * the pending queue (which means things will
2753: * be reordered on the queue!)
2754: */
2755: if( m0 ) {
2756: IFDEBUG(D_CDATA)
2757: printf("ACPT sending pending queue 0x%x len 0x%x\n",
2758: m0, m0->m_len);
2759: ENDDEBUG
2760: ASSERT( m0->m_len != 0);
2761: (void) cons_senddata(copcb, m0);
2762: }
2763: }
2764: break;
2765:
2766: case ECN_REFUSE:
2767: /* other end refused our connect request */
2768: /* src, dst are as given in the ECN_CALL */
2769:
2770: IncStat(co_refuse);
2771: copcb = (struct cons_pcb *)ecnrq->e_pcb;
2772: if( copcb->co_myself != copcb ) {
2773: struct mbuf *mm;
2774: /* TODO: REMOVE */
2775: ASSERT(0);
2776: printf("BAD e_pcb from ecn (0x%x) cmd 0x%x\n",
2777: ecnrq->e_pcb, ecnrq->e_cmd);
2778: mm = dtom( copcb );
2779: if(mm->m_type == MT_FREE)
2780: printf("FREED MBUF!\n");
2781: dump_buf (ecnrq, sizeof (*ecnrq));
2782: dump_buf (copcb, sizeof (*copcb));
2783: panic("BAD ecnrq");
2784: break;
2785: }
2786: touch(copcb);
2787: copcb->co_state = CLOSED; /* do we have to do a clear?? */
2788: copcb->co_channel = X_NOCHANNEL;
2789: if(copcb->co_socket) {
2790: copcb->co_socket->so_error = ECONNREFUSED;
2791: /* TODO: if there's diagnostic info in the
2792: * packet, and it's more useful than this E*,
2793: * get it
2794: */
2795: soisdisconnected(copcb->co_socket); /* wake 'em up */
2796: IFDEBUG(D_INCOMING)
2797: printf("ECN_REFUSE: waking up 0x%x\n",
2798: (caddr_t)&copcb->co_state );
2799: ENDDEBUG
2800: wakeup( (caddr_t)&copcb->co_state );
2801: }
2802: /*
2803: * Anything on the pending queue for this connection?
2804: */
2805: while( copcb->co_pending.ifq_len > 0 ) {
2806: register struct mbuf *m0;
2807:
2808: s = splimp();
2809: IF_DEQUEUE( &copcb->co_pending, m0 );
2810: splx(s);
2811: m_freem(m0);
2812: }
2813: if ( ecnrq->e_reason == E_CO_NORESOURCES ) {
2814: IncStat(co_noresources);
2815: cons_clear_and_detach( copcb, DONTCLEAR, PRC_QUENCH );
2816: } else if(copcb->co_socket ) {
2817: copcb->co_socket->so_error = find_error_reason( ecnrq );
2818: }
2819: break;
2820:
2821: case ECN_CONNECT: /* incoming call */
2822: /*
2823: * ECN_CONNECT indication gives adc_src, adc_dst and channel
2824: */
2825: ASSERT( ecnrq->e_vc != 0);
2826:
2827: IncStat(co_connect);
2828: cons_incoming(ifp, ecnrq);
2829: break;
2830:
2831: case ECN_RESET:
2832: case ECN_CLEAR:
2833: /*
2834: * ECN_CLEAR(indication) (if we can construct such a beast)
2835: * gives e_vc,
2836: * Throw away anything queued pending on this connection
2837: * give a reset indication to the upper layer if TP
2838: * free the mbufs
2839: */
2840: ASSERT( ecnrq->e_vc != 0);
2841: if( ecnrq->e_cmd == ECN_CLEAR )
2842: IncStat(co_clear_in);
2843: else
2844: IncStat(co_reset_in);
2845: #ifdef ARGO_DEBUG
2846: if( ! (copcb=cons_chan_to_pcb((int)ecnrq->e_vc, __LINE__)) )
2847: #else ARGO_DEBUG
2848: if( ! (copcb=cons_chan_to_pcb((int)ecnrq->e_vc)) )
2849: #endif ARGO_DEBUG
2850:
2851: break;
2852: while( copcb->co_pending.ifq_len ) {
2853: register struct mbuf *m0;
2854:
2855: s = splimp();
2856: IF_DEQUEUE( &copcb->co_pending, m0 );
2857: splx(s);
2858: m_freem(m0);
2859: }
2860: copcb->co_state = CLOSED; /* do we have to do a clear? */
2861: copcb->co_channel = X_NOCHANNEL;
2862:
2863: cons_clear_and_detach( copcb, DONTCLEAR, PRC_ROUTEDEAD );
2864: if (copcb->co_socket ) {
2865: copcb->co_socket->so_error = find_error_reason( ecnrq );
2866: }
2867: break;
2868:
2869: case ECN_RECEIVE:
2870: /*
2871: * ECN_RECEIVE (read)
2872: */
2873: ASSERT( ecnrq->e_vc != 0);
2874: IncStat(co_receive);
2875: {
2876: /* TODO: REMOVE */
2877: struct mbuf *thedata = e_data(ecnrq);
2878: u_int *firstint = mtod( thedata, u_int *);
2879:
2880: if( (*firstint & 0xff000000) != 0x81000000 ) {
2881: /* not clnp */
2882: switch( ((*firstint) & 0x00ff0000) >> 20 ) {
2883: case 0x1:
2884: case 0x2:
2885: case 0x3:
2886: case 0x6:
2887: case 0x7:
2888: case 0x8:
2889: case 0xc:
2890: case 0xd:
2891: case 0xe:
2892: case 0xf:
2893: break;
2894: default:
2895: printf(" ECN_RECEIVE! BAD DATA\n" );
2896: dump_buf( thedata, 20 + 12 );
2897: m_freem( m );
2898: splx(s0);
2899: }
2900: }
2901: }
2902: if ( (copcb =
2903: #ifdef ARGO_DEBUG
2904: cons_chan_to_pcb( (int)ecnrq->e_vc, __LINE__ )
2905: #else ARGO_DEBUG
2906: cons_chan_to_pcb( (int)ecnrq->e_vc )
2907: #endif ARGO_DEBUG
2908: ) == (struct cons_pcb *)0 ) {
2909: ifp->if_ierrors ++;
2910: IFTRACE(D_CDATA)
2911: tptrace(TPPTmisc, "ECN_RECEIVE DROPPED chan \n",
2912: ecnrq->e_vc, 0, 0, 0);
2913: ENDTRACE
2914: break;
2915: }
2916:
2917: touch(copcb);
2918: if( ecnrq->e_info & ECN_INFO_RCVD_INT ) {
2919: /* interrupt packet */
2920: printf("consintr: interrupt pkttype : DROPPED\n");
2921: IncStat(co_intrpt_pkts_in);
2922: IncStat(co_Rdrops);
2923: break;
2924: }
2925: /* new way */
2926: if( copcb->co_proto == CLNP_proto )
2927: {
2928: /* IP: put it on the queue and set soft interrupt */
2929: struct ifqueue *ifq;
2930: extern struct ifqueue clnlintrq;
2931: register struct mbuf *ifpp; /* for ptr to ifp */
2932: register struct mbuf *data = e_data(ecnrq);
2933:
2934: total_pkts_to_clnp ++;
2935:
2936: /* when acting as a subnet service, have to prepend a
2937: * pointer to the ifnet before handing this to clnp
2938: * GAG
2939: */
2940: if( ( data->m_off > MMINOFF + sizeof(struct snpa_hdr)) &&
2941: ( data->m_off <= MMAXOFF )) {
2942: data->m_off -= sizeof(struct snpa_hdr);
2943: data->m_len += sizeof(struct snpa_hdr);
2944: } else {
2945: MGET(ifpp, M_DONTWAIT, MT_XHEADER);
2946: if( !ifpp ) {
2947: ifp->if_ierrors ++;
2948: splx(s0);
2949: m_freem(m); /* frees everything */
2950: return;
2951: }
2952: ifpp->m_len = sizeof(struct snpa_hdr);
2953: ifpp->m_act = 0;
2954: ifpp->m_next = data;
2955: data = ifpp;
2956: }
2957: IFTRACE(D_CDATA)
2958: tptrace(TPPTmisc, "-->CLNP copcb\n", copcb, 0, 0, 0);
2959: ENDTRACE
2960: {
2961: /*
2962: * TODO: if we ever use esis/cons we have to
2963: * think of something reasonable to stick in the
2964: * snh_shost,snh_dhost fields. I guess
2965: * the x.121 address is what we want.
2966: *
2967: * That would also require length fields in the
2968: * snpa_hdr structure.
2969: */
2970: struct snpa_hdr *snh =
2971: mtod(data, struct snpa_hdr *);
2972: bzero((caddr_t)&snh, sizeof(struct snpa_hdr));
2973: bcopy((caddr_t)&ifp, (caddr_t)&snh->snh_ifp,
2974: sizeof(struct ifnet *));
2975: }
2976: *( mtod(data, struct ifnet **) ) = ifp; /* KLUDGE */
2977:
2978: ifq = &clnlintrq;
2979: splimp();
2980: if (IF_QFULL(ifq)) {
2981: IF_DROP(ifq);
2982: m_freem(m);
2983: IFDEBUG(D_INCOMING)
2984: printf("DROPPED! ecnrq 0x%x, data 0x%x\n", m,data);
2985: ENDDEBUG
2986: splx(s0);
2987: ifp->if_ierrors ++;
2988: return;
2989: }
2990: IF_ENQUEUE(ifq, data);
2991: IFDEBUG(D_INCOMING)
2992: printf(
2993: "0x%x enqueued on ip Q: m_len 0x%x m_type 0x%x m_off 0x%x\n",
2994: data, data->m_len, data->m_type, data->m_off);
2995: dump_buf(mtod(data, caddr_t), data->m_len);
2996: ENDDEBUG
2997: e_data(ecnrq) = (struct mbuf *)0;
2998: schednetisr(NETISR_CLNP);
2999: } else {
3000: /* HL is NOT clnp */
3001: IFTRACE(D_CDATA)
3002: tptrace(TPPTmisc,
3003: "-->HL pr_input so copcb channel\n",
3004: copcb->co_proto->pr_input,
3005: copcb->co_socket, copcb,
3006: copcb->co_channel);
3007: ENDTRACE
3008: IFDEBUG(D_INCOMING)
3009: printf( "0x%x --> HL proto 0x%x chan 0x%x\n",
3010: e_data(ecnrq), copcb->co_proto, copcb->co_channel );
3011: ENDDEBUG
3012:
3013: (*copcb->co_proto->pr_input)(e_data(ecnrq),
3014: &copcb->co_faddr,
3015: &copcb->co_laddr,
3016: copcb->co_socket, /* used by cons-transport interface */
3017: (copcb->co_flags & CONSF_DGM)?0:
3018: copcb->co_channel);/* used by tp-cons interface */
3019:
3020: /*
3021: * the pr_input will free the data chain, so we must
3022: * zero the ptr to is so that m_free doesn't panic
3023: */
3024: e_data(ecnrq) = (struct mbuf *)0;
3025: }
3026: break;
3027:
3028: default:
3029: /* error */
3030: ifp->if_ierrors ++;
3031: printf("consintr: unknown request\n");
3032: }
3033: IFDEBUG(D_INCOMING)
3034: printf("consintr: m_freem( 0x%x )\n", m);
3035: ENDDEBUG
3036: m_freem( m );
3037: }
3038: splx(s0);
3039: }
3040:
3041: /*
3042: * Process an ioctl request.
3043: * also set-time-limit, extend-time-limit
3044: * for ALL channels, the time-limit ioctls will be done by open-a-dummy-socket,
3045: * do ioctl with the channel number, close the socket (dumb!).
3046: */
3047: /* ARGSUSED */
3048: cons_ioctl(so, cmd, data)
3049: struct socket *so;
3050: int cmd;
3051: caddr_t data;
3052: {
3053: int s = splnet();
3054: int error = 0;
3055:
3056: IFDEBUG(D_CCONS)
3057: printf("cons_ioctl( cmd 0x%x )\n", cmd);
3058: ENDDEBUG
3059:
3060: #ifdef notdef
3061: switch (cmd) {
3062:
3063: default:
3064: #endif notdef
3065: error = EOPNOTSUPP;
3066: #ifdef notdef
3067: }
3068: #endif notdef
3069:
3070: splx(s);
3071: return (error);
3072: }
3073:
3074:
3075: /*
3076: *************************************************************
3077: * *
3078: * *
3079: * Interface to CO Subnetwork service from CLNP *
3080: * Must be a device interface. *****
3081: * ***
3082: * *
3083: * Poof!
3084: */
3085:
3086: /*
3087: * NAME: consioctl()
3088: * CALLED FROM:
3089: * called through the ifnet structure.
3090: * FUNCTION and ARGUMENTS:
3091: * the usual ioctl stuff
3092: * RETURNS:
3093: * E*
3094: * SIDE EFFECTS:
3095: * NOTES:
3096: */
3097: consioctl(ifp, cmd, data)
3098: register struct ifnet *ifp;
3099: register int cmd;
3100: register caddr_t data;
3101: {
3102: register struct ifaddr *ifa = (struct ifaddr *)data;
3103: register int s = splimp();
3104: register struct ifreq *ifr = (struct ifreq *)data;
3105: register int error = 0;
3106: void consshutdown();
3107:
3108: switch (cmd) {
3109: case SIOCSIFADDR:
3110: switch (ifa->ifa_addr.sa_family) {
3111: case AF_ISO:
3112: if( (ifp->if_flags & IFF_UP ) == 0)
3113: consinit(ifp->if_unit);
3114: break;
3115: default:
3116: printf("CANNOT config cons with address family %d\n",
3117: ifa->ifa_addr.sa_family);
3118: break;
3119: }
3120: break;
3121: case SIOCSIFFLAGS:
3122: IFDEBUG(D_CCONS)
3123: printf("consioctl: set flags to x%x\n", ifr->ifr_flags);
3124: printf("consioctl: ifp flags are x%x\n", ifp->if_flags);
3125: ENDDEBUG
3126: if( ifr->ifr_flags & IFF_LOOPBACK )
3127: ifp->if_flags |= IFF_LOOPBACK;
3128: else
3129: ifp->if_flags &= ~IFF_LOOPBACK;
3130:
3131: /* if board is down but request takes it up, init the board */
3132: if (ifr->ifr_flags & IFF_UP && (ifp->if_flags & IFF_UP) == 0)
3133: consinit(ifp->if_unit);
3134:
3135: /* if board is up but request takes it down, shut the board down */
3136: if (((ifr->ifr_flags & IFF_UP) == 0) && (ifp->if_flags & IFF_UP)) {
3137: consshutdown(ifp->if_unit);
3138: }
3139: IFDEBUG(D_CCONS)
3140: printf("consioctl: flags are x%x\n", ifp->if_flags);
3141: ENDDEBUG
3142: break;
3143: case SIOCGSTATUS:
3144: /* warning: must coerse ifp to (struct ifstatus *) in order to use */
3145: IFDEBUG(D_CCONS)
3146: printf("consioctl: EICON status request\n");
3147: ENDDEBUG
3148: #if NECN>0
3149: ecnioctl(ifp, cmd, data);
3150: #else
3151: error = ENODEV;
3152: #endif NECN>0
3153: break;
3154: default:
3155: error = EINVAL;
3156: }
3157: splx(s);
3158: return error;
3159: }
3160:
3161: /*
3162: * NAME: consattach()
3163: * CALLED FROM:
3164: * cons_init() (which comes from autoconf)
3165: * FUNCTION and ARGUMENTS:
3166: * creates an ifp and fills it in; calls ifattach() on it.
3167: * RETURNS:
3168: * no return value
3169: * SIDE EFFECTS:
3170: * NOTES:
3171: */
3172: consattach()
3173: {
3174: register struct ifnet *ifp;
3175: register struct mbuf *m;
3176:
3177: if(sizeof(struct ifnet) > MLEN) {
3178: printf("Can't attach cons! sizeof(struct ifnet) > MLEN\n");
3179: return;
3180: }
3181: MGET(m, M_DONTWAIT, MT_IFADDR);
3182: if( !m ) {
3183: printf("Can't attach cons! NO MBUFS!\n");
3184: return;
3185: }
3186: m->m_len = sizeof(struct ifnet);
3187: ifp = consif = mtod(m, struct ifnet *);
3188: ifp->if_unit = 0;
3189: ifp->if_name = "cons";
3190: ifp->if_mtu = ECN_MTU;
3191: ifp->if_init = consinit;
3192: ifp->if_ioctl = consioctl;
3193: ifp->if_output = cosns_output; /* called by clnp */
3194: ifp->if_flags = IFF_LOOPBACK; /* default */
3195: if_attach(ifp);
3196: printf("cons%d: pseudo device attached \n", ifp->if_unit);
3197: }
3198:
3199: /*
3200: * NAME: consinit()
3201: * CALLED FROM:
3202: * consioctl()
3203: * FUNCTION and ARGUMENTS:
3204: * Initializes apropos data structures, etc.
3205: * Marks the device as up.
3206: * Zaps the address list.
3207: * Calls device layer restart on the device if necessary.
3208: */
3209: Static
3210: consinit(_unit)
3211: register int _unit; /* unit to initialize */
3212: {
3213: struct ifnet *ecnifp();
3214: struct ifnet *ifp;
3215: int s;
3216:
3217: if ((ifp = ecnifp(_unit)) != (struct ifnet *)0 ) {
3218: ecnrestart(ifp);
3219: IncStat(co_restart);
3220: }
3221: if (consif->if_addrlist == (struct ifaddr *)0)
3222: return;
3223: if ((consif->if_flags & IFF_UP) == 0) {
3224: s = splimp();
3225: consif->if_flags |= IFF_UP;
3226: splx(s);
3227: }
3228:
3229: }
3230:
3231: /*
3232: * NAME: consshutdown()
3233: * CALLED FROM:
3234: * cons_ioctl() when user takes down an interface w/ SIOCSIFFLAGS
3235: * FUNCTION and ARGUMENTS:
3236: * calls lower layer shutdown routine on the device.
3237: * and marks the if as down if the if is the sw loopback pseudodevice.
3238: * RETURNS:
3239: * no return value
3240: */
3241: void
3242: consshutdown(_unit)
3243: register int _unit; /* unit to shutdown */
3244: {
3245: extern struct ifnet *ecnifp();
3246: struct ifnet *ifp;
3247: int s;
3248:
3249: if ((ifp = ecnifp(_unit)) != (struct ifnet *)0 ) {
3250: ecnshutdown(ifp);
3251: }
3252: if ((consif->if_flags & IFF_UP) ) {
3253: s = splimp();
3254: consif->if_flags &= ~IFF_UP;
3255: splx(s);
3256: }
3257: }
3258: #endif KERNEL
3259:
3260: /*
3261: * NAME: munge()
3262: * CALLED FROM:
3263: * cons_pcbbind(), cons_usrreq()
3264: * FUNCTION and ARGUMENTS:
3265: * Takes the argument (value) and stashes it into the last two
3266: * nibbles of an X.121 address. Does this in the two nibbles beginning
3267: * at the location defined by the character pointer (dst_octet) and the
3268: * integer (dst_nibble). Nibble 0 is the lower nibble (high
3269: * order 4 bits); nibble 1 is the low order 4 bits of *(dst_octet).
3270: *
3271: * RETURNS:
3272: * no return value
3273: */
3274: Static
3275: munge( value, dst_octet, dst_nibble)
3276: int value;
3277: caddr_t dst_octet;
3278: int dst_nibble;
3279: {
3280: IFDEBUG(D_CCONN)
3281: printf("MUNGE: value 0x%x dst_octet 0x%x, nibble 0x%x)\n",
3282: value, dst_octet, dst_nibble);
3283: ENDDEBUG
3284: if (value >= ISO_PORT_RESERVED)
3285: value -= 1000;
3286:
3287: {
3288: /* convert so it looks like a decimal number */
3289: register int tens, ones;
3290:
3291: tens = value/10;
3292: ASSERT( tens <= 9 );
3293: ones = value - (tens * 10);
3294:
3295: value = tens * 16 + ones;
3296: }
3297:
3298: dst_octet --;
3299: /* leave nibble same 'cause it's one after the last set nibble */
3300:
3301: *dst_octet &= ~(0xff<<(dst_nibble << 2)); /* zero it */
3302: *dst_octet |= ((value>>4) << (dst_nibble<<2));
3303: dst_nibble = 1-dst_nibble;
3304: dst_octet += dst_nibble;
3305:
3306: *dst_octet &= ~(0xff<<(dst_nibble << 2)); /* zero it */
3307: *dst_octet |= ((value&0xff) << (dst_nibble<<2));
3308: }
3309:
3310: /*
3311: * NAME: unmunge()
3312: * CALLED FROM:
3313: * DTEtoNSAP(), FACILtoNSAP()
3314: * FUNCTION and ARGUMENTS:
3315: * return the port/tsuffix represented by the two digits found in a
3316: * bcd string beginning at the (dst_nibble)th nibble of the
3317: * octet BEFORE (dst_octet).
3318: *
3319: * dst_octet,dst_nibble is the nibble after the one we'll look at
3320: * RETURNS:
3321: * an integer, the port/tsuffix
3322: * Note- converts to a port > 1000 if necessary.
3323: */
3324: Static int
3325: unmunge( dst_octet, dst_nibble )
3326: caddr_t dst_octet;
3327: int dst_nibble;
3328: {
3329: register u_short last = 0;
3330:
3331: dst_octet --;
3332: /* leave nibble same 'cause it's one after the last set nibble */
3333: IFDEBUG(D_CADDR)
3334: printf("unmunge: *octet 0x%x, nibble 0x%x\n", *dst_octet,
3335: dst_nibble);
3336: ENDDEBUG
3337:
3338: last = ((*dst_octet) & (0xff<<(dst_nibble<<2)));
3339: dst_nibble = 1-dst_nibble;
3340: dst_octet += dst_nibble;
3341:
3342: last |= ((*dst_octet) & (0xff<<(dst_nibble << 2)));
3343: {
3344: /* convert to a decimal number */
3345: register int tens, ones;
3346:
3347: tens = (last&0xf0)>>4;
3348: ones = last&0xf;
3349:
3350: last = tens * 10 + ones;
3351: }
3352:
3353: IFDEBUG(D_CADDR)
3354: printf("unmunge computes 0x%x\n", last);
3355: ENDDEBUG
3356: if((int)last+1000 >= ISO_PORT_RESERVED)
3357: last += 1000;
3358: IFDEBUG(D_CADDR)
3359: printf("unmunge returns 0x%x\n", last);
3360: ENDDEBUG
3361: return last;
3362: }
3363:
3364: /*
3365: * NAME: make_partial_x25_packet()
3366: *
3367: * FUNCTION and ARGUMENTS:
3368: * Makes part of an X.25 call packet, for use by the eicon board.
3369: * (src) and (dst) are the NSAP-addresses of source and destination.
3370: * (proto) is the higher-layer protocol number (in iso.h)
3371: * (buf) is a ptr to a buffer into which to write this partial header.
3372: *
3373: * The partial header looks like (choke):
3374: * octet meaning
3375: * 1 calling DTE len | called DTE len (lengths in nibbles)
3376: * 2..n-1 called DTE addr | (<-- boundary may be middle of an octet)
3377: * calling DTE addr | zero nibble to round to octet boundary.
3378: * n Facility length (in octets)
3379: * n+1 Facility field, which is a set of:
3380: * m facil code
3381: * m+1 facil param len (for >2-byte facilities) in octets
3382: * m+2..p facil param field
3383: * q user data (protocol identification octet)
3384: *
3385: *
3386: * RETURNS:
3387: * 0 if OK
3388: * E* if failed.
3389: */
3390:
3391: #ifdef X25_1984
3392: int cons_use_facils = 1;
3393: #else X25_1984
3394: int cons_use_facils = 0;
3395: #endif X25_1984
3396:
3397: int cons_use_udata = 1; /* KLUDGE FOR DEBUGGING */
3398:
3399: Static int
3400: make_partial_x25_packet(copcb, m)
3401: struct cons_pcb *copcb;
3402: struct mbuf *m;
3403: {
3404: struct sockaddr_iso *src, *dst;
3405: u_int proto;
3406: int flag;
3407: caddr_t buf = mtod(m, caddr_t);
3408: register caddr_t ptr = buf + 1; /* make room for 2 length nibbles */
3409: register int len = 0;
3410: int buflen =0;
3411: caddr_t facil_len;
3412: int oddness = 0;
3413:
3414: src = &copcb->co_laddr;
3415: dst = &copcb->co_faddr;
3416: proto = copcb->co_proto->pr_protocol,
3417: flag = copcb->co_flags & CONSF_XTS;
3418:
3419:
3420: IFDEBUG(D_CCONN)
3421: printf("make_partial_x25_packet(0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
3422: src, dst, proto, m, flag);
3423: ENDDEBUG
3424:
3425: /*
3426: * Note - order of addrs in x25 pkt hdr is wierd:
3427: * calling len/called len/called addr/calling addr (p.40 ISO 8202)
3428: */
3429: if( (len = copcb->co_peer_dte.dtea_niblen) > 0 ) {
3430: nibble_copy( (char *)(copcb->co_peer_dte.dtea_addr), HIGH_NIBBLE,
3431: ptr, HIGH_NIBBLE, len);
3432: } else {
3433: if ((len = NSAPtoDTE( ptr, HIGH_NIBBLE, dst)) <=0 ) {
3434: return E_CO_OSI_UNSAP;
3435: }
3436: }
3437: *buf = len; /* fill in called dte addr length */
3438: ptr += len>>1; /* len is in nibbles */
3439: oddness += len&0x1;
3440:
3441: if ((len = NSAPtoDTE( ptr, 1-(len&0x1), src)) <=0 ) {
3442: return E_CO_OSI_UNSAP;
3443: }
3444: ptr += len>>1; /* len is in nibbles */
3445: *buf |= len << 4; /* fill in calling dte addr length */
3446: oddness += len&0x1;
3447:
3448: IFDEBUG(D_CADDR)
3449: printf("make_partial 2: ptr 0x%x, len 0x%x oddness 0x%x\n",
3450: ptr, len, oddness );
3451: ENDDEBUG
3452: /* if either of the addresses were an odd length, the count is off by 1 */
3453: if( oddness ) {
3454: ptr ++;
3455: }
3456:
3457: /* ptr now points to facil length (len of whole facil field in OCTETS */
3458: facil_len = ptr ++;
3459:
3460: IFDEBUG(D_CADDR)
3461: printf("make_partial calling: ptr 0x%x, len 0x%x\n", ptr,
3462: src->siso_addr.isoa_len);
3463: ENDDEBUG
3464: if( cons_use_facils ) {
3465: *ptr = 0xcb; /* calling facility code */
3466: ptr ++;
3467: ptr ++; /* leave room for facil param len (in OCTETS + 1) */
3468: ptr ++; /* leave room for the facil param len (in nibbles),
3469: * high two bits of which indicate full/partial NSAP
3470: */
3471: len = src->siso_addr.isoa_len;
3472: bcopy( &src->siso_addr.isoa_afi, ptr, len);
3473: *(ptr-2) = len+2; /* facil param len in octets */
3474: *(ptr-1) = len<<1; /* facil param len in nibbles */
3475: ptr += len;
3476:
3477: IFDEBUG(D_CADDR)
3478: printf("make_partial called: ptr 0x%x, len 0x%x\n", ptr,
3479: dst->siso_addr.isoa_len);
3480: ENDDEBUG
3481: *ptr = 0xc9; /* called facility code */
3482: ptr ++;
3483: ptr ++; /* leave room for facil param len (in OCTETS + 1) */
3484: ptr ++; /* leave room for the facil param len (in nibbles),
3485: * high two bits of which indicate full/partial NSAP
3486: */
3487: len = dst->siso_addr.isoa_len;
3488: bcopy( &dst->siso_addr.isoa_afi, ptr, len);
3489: *(ptr-2) = len+2; /* facil param len = addr len + 1 for each of these
3490: * two length fields, in octets */
3491: *(ptr-1) = len<<1; /* facil param len in nibbles */
3492: ptr += len;
3493:
3494: }
3495: *facil_len = ptr - facil_len - 1;
3496: if(*facil_len > X25_FACIL_LEN_MAX )
3497: return E_CO_PNA_LONG;
3498:
3499: if( cons_use_udata ) {
3500: if (copcb->co_x25crud_len > 0) {
3501: /*
3502: * The user specified something. Stick it in
3503: */
3504: bcopy(copcb->co_x25crud, ptr, copcb->co_x25crud_len);
3505: ptr += copcb->co_x25crud_len;
3506: } else {
3507: /* protocol identifier */
3508: switch (proto) {
3509: /* unfortunately all are considered 1 protocol */
3510: case ISOPROTO_TP0:
3511: case ISOPROTO_TP1:
3512: case ISOPROTO_TP2:
3513: case ISOPROTO_TP3:
3514: case ISOPROTO_TP4:
3515: case ISOPROTO_CLTP:
3516: /* no user data for TP */
3517: break;
3518:
3519: case ISOPROTO_CLNP:
3520: *ptr = 0x81;
3521: ptr++; /* count the proto id byte! */
3522: break;
3523: case ISOPROTO_INACT_NL:
3524: *ptr = 0x0;
3525: ptr++; /* count the proto id byte! */
3526: break;
3527: case ISOPROTO_X25:
3528: *ptr = 0xff; /* reserved for future extensions */
3529: /* we're stealing this value for local use */
3530: ptr++; /* count the proto id byte! */
3531: break;
3532: default:
3533: return EPROTONOSUPPORT;
3534: }
3535: }
3536: }
3537:
3538: buflen = (int)(ptr - buf);
3539:
3540: IFDEBUG(D_CDUMP_REQ)
3541: register int i;
3542:
3543: printf("ECN_CONNECT DATA buf 0x%x len %d (0x%x)\n",
3544: buf, buflen, buflen);
3545: for( i=0; i < buflen; ) {
3546: printf("+%d: %x %x %x %x %x %x %x %x\n",
3547: i,
3548: *(buf+i), *(buf+i+1), *(buf+i+2), *(buf+i+3),
3549: *(buf+i+4), *(buf+i+5), *(buf+i+6), *(buf+i+7));
3550: i+=8;
3551: }
3552: ENDDEBUG
3553: IFDEBUG(D_CADDR)
3554: printf("make_partial returns buf 0x%x size 0x%x bytes\n",
3555: mtod(m, caddr_t), buflen);
3556: ENDDEBUG
3557:
3558: ASSERT( X25_PARTIAL_PKT_LEN_MAX < MLEN );
3559:
3560: if(buflen > X25_PARTIAL_PKT_LEN_MAX)
3561: return E_CO_PNA_LONG;
3562:
3563: m->m_len = buflen;
3564: return 0;
3565: }
3566:
3567: /*
3568: * NAME: NSAPtoDTE()
3569: * CALLED FROM:
3570: * make_partial_x25_packet()
3571: * FUNCTION and ARGUMENTS:
3572: * get a DTE address from an NSAP-address (struct sockaddr_iso)
3573: * (dst_octet) is the octet into which to begin stashing the DTE addr
3574: * (dst_nibble) takes 0 or 1. 1 means begin filling in the DTE addr
3575: * in the high-order nibble of dst_octet. 0 means low-order nibble.
3576: * (addr) is the NSAP-address
3577: * (flag) is true if the transport suffix is to become the
3578: * last two digits of the DTE address
3579: * A DTE address is a series of BCD digits
3580: *
3581: * A DTE address may have leading zeros. The are significant.
3582: * 1 digit per nibble, may be an odd number of nibbles.
3583: *
3584: * An NSAP-address has the DTE address in the IDI. Leading zeros are
3585: * significant. Trailing hex f indicates the end of the DTE address.
3586: * Also is a series of BCD digits, one per nibble.
3587: *
3588: * RETURNS
3589: * # significant digits in the DTE address, -1 if error.
3590: */
3591:
3592: Static int
3593: NSAPtoDTE( dst_octet, dst_nibble, addr)
3594: caddr_t dst_octet;
3595: int dst_nibble;
3596: register struct sockaddr_iso *addr;
3597: {
3598: int error;
3599: u_char x121string[7]; /* maximum is 14 digits */
3600: int x121strlen;
3601: struct dte_addr *dtea;
3602:
3603: IFDEBUG(D_CADDR)
3604: printf("NSAPtoDTE: nsap: %s\n", clnp_iso_addrp(&addr->siso_addr));
3605: ENDDEBUG
3606:
3607: error = iso_8208snparesolve(addr, x121string, &x121strlen);
3608: ASSERT(error == 0);
3609: if( error != 0 ) {
3610: /* no snpa - cannot send */
3611: IFDEBUG(D_CADDR)
3612: printf("NSAPtoDTE: 8208resolve: %d\n", error );
3613: ENDDEBUG
3614: return 0;
3615: }
3616: ASSERT(x121strlen == sizeof(struct dte_addr));
3617: dtea = (struct dte_addr *)x121string;
3618: x121strlen = dtea->dtea_niblen;
3619:
3620: nibble_copy((char *)x121string, HIGH_NIBBLE,
3621: dst_octet, dst_nibble, x121strlen);
3622: return x121strlen;
3623: }
3624:
3625: /*
3626: * NAME: FACILtoNSAP()
3627: * CALLED FROM:
3628: * parse_facil()
3629: * FUNCTION and ARGUMENTS:
3630: * Creates and NSAP in the sockaddr_iso (addr) from the
3631: * x.25 facility found at (buf), of length (buf_len).
3632: * RETURNS:
3633: * 0 if ok, non-zero if error;
3634: */
3635:
3636: Static int
3637: FACILtoNSAP( buf, buf_len, addr)
3638: caddr_t buf;
3639: u_char buf_len; /* in bytes */
3640: register struct sockaddr_iso *addr;
3641: {
3642: int len_in_nibbles;
3643:
3644: IFDEBUG(D_CADDR)
3645: printf("FACILtoNSAP( 0x%x, 0x%x, 0x%x )\n",
3646: buf, buf_len, addr );
3647: ENDDEBUG
3648:
3649: len_in_nibbles = *buf;
3650: /* despite the fact that X.25 makes us put a length in nibbles
3651: * here, the NSAP-addrs are always in full octets
3652: */
3653: buf ++;
3654:
3655: bzero( addr, sizeof (struct sockaddr_iso) );
3656:
3657: ASSERT(buf_len <= 1+sizeof (struct iso_addr));
3658: if(buf_len > 1+sizeof (struct iso_addr)) {
3659: return -1; /* error */
3660: }
3661: ASSERT(len_in_nibbles == (buf_len - 1)<<1);
3662: if(len_in_nibbles != (buf_len - 1)<<1) {
3663: return -2; /* error */
3664: }
3665: bcopy(buf, &addr->siso_addr.isoa_afi, buf_len-1);
3666: addr->siso_addr.isoa_len = buf_len-1;
3667: IFDEBUG(D_CADDR)
3668: printf("FACILtoNSAP: isoa_len 0x%x\n",
3669: addr->siso_addr.isoa_len);
3670: ENDDEBUG
3671: addr->siso_family = AF_ISO;
3672:
3673: addr->siso_tsuffix =
3674: unmunge( ((caddr_t)&addr->siso_addr.t37_idi) + ADDR37_IDI_LEN , 1 );
3675: return 0;
3676: }
3677:
3678: /*
3679: * NAME: DTEtoNSAP()
3680: * CALLED FROM:
3681: * parse_facil()
3682: * FUNCTION and ARGUMENTS:
3683: * Creates a type 37 NSAP in the sockaddr_iso (addr)
3684: * from a DTE address found at the (src_nibble)th nibble of
3685: * the octet (src_octet), of length (src_nib_len).
3686: *
3687: * RETURNS:
3688: * 0 if ok; E* otherwise.
3689: */
3690:
3691: Static int
3692: DTEtoNSAP(addr, src_octet, src_nibble, src_nib_len)
3693: struct sockaddr_iso *addr;
3694: caddr_t src_octet;
3695: int src_nibble, src_nib_len;
3696: {
3697: caddr_t dst_octet;
3698: int pad_len;
3699: int dst_nibble;
3700: char first_nib;
3701: static char *z_pad = "\0\0\0\0\0\0\0";
3702: static char *f_pad = "\021\021\021\021\021\021\021";
3703:
3704: IFDEBUG(D_CADDR)
3705: printf("DTEtoNSAP( 0x%x, 0x%x, 0x%x, 0x%x )\n",
3706: src_octet, src_nibble, src_nib_len, addr );
3707: ENDDEBUG
3708:
3709: bzero( addr, sizeof(*addr));
3710: addr->siso_family = AF_ISO;
3711: /*
3712: * Coming from a DTE addr it's always type 37.
3713: * src_octet <-- starting place in the NSAP-address of
3714: * the embedded SNPA-address (x.121 addr or DTE addr).
3715: */
3716: addr->siso_addr.isoa_afi = 0x37;
3717:
3718: /* first, figure out what pad to use and pad */
3719:
3720: first_nib = (*src_octet) >> (SHIFT*(1-src_nibble));
3721: pad_len = (ADDR37_IDI_LEN<<1 - src_nib_len);
3722: nibble_copy(first_nib? z_pad : f_pad, HIGH_NIBBLE,
3723: (caddr_t) addr->siso_addr.t37_idi, HIGH_NIBBLE, pad_len);
3724:
3725: dst_octet += (pad_len>>1);
3726: dst_nibble = 1-(pad_len & 0x1);
3727: IFDEBUG(D_CADDR)
3728: printf("DTEtoNSAP 2( 0x%x, 0x%x, 0x%x, 0x%x )\n",
3729: dst_octet, dst_nibble, pad_len, src_nib_len );
3730: ENDDEBUG
3731:
3732: /* now copy the dte address */
3733: nibble_copy( src_octet, src_nibble, dst_octet, dst_nibble, src_nib_len);
3734:
3735: addr->siso_addr.isoa_len = ADDR37_IDI_LEN + ADDR37_DSP_LEN +1 /* for afi */;
3736: /* kludge */
3737:
3738: addr->siso_tsuffix = unmunge(
3739: (caddr_t) &(addr->siso_addr.t37_idi[ADDR37_IDI_LEN]), HIGH_NIBBLE);
3740:
3741: IFDEBUG(D_CADDR)
3742: printf("DTEtoNSAP 3 returning 0 tsuffix 0x%x\n", addr->siso_tsuffix);
3743: ENDDEBUG
3744:
3745: return 0; /* ok */
3746: }
3747:
3748: /*
3749: * FUNCTION and ARGUMENTS:
3750: * parses (buf_len) bytes beginning at (buf) and finds
3751: * a called nsap, a calling nsap, and protocol identifier.
3752: * RETURNS:
3753: * 0 if ok, E* otherwise.
3754: */
3755:
3756: Static int
3757: parse_facil( buf, buf_len, called, calling, proto, peer_dte)
3758: caddr_t buf;
3759: u_char buf_len; /* in bytes */
3760: register struct sockaddr_iso *called, *calling;
3761: int *proto;
3762: struct dte_addr *peer_dte;
3763: {
3764: register int i;
3765: caddr_t ptr;
3766: caddr_t facil_len;
3767: int facil_param_len;
3768: struct sockaddr_iso *addr;
3769: int addrs_not_parsed = (int)0xcb + (int)0xc9;
3770:
3771: IFDEBUG(D_CADDR)
3772: printf("parse_facil( 0x%x, 0x%x, 0x%x, 0x%x, 0x%x )\n",
3773: buf, buf_len, called, calling, *proto);
3774: dump_buf(buf, buf_len);
3775: ENDDEBUG
3776:
3777: /* find the beginnings of the facility fields in buf
3778: * by skipping over the called & calling DTE addresses
3779: * i <- # nibbles in called + # nibbles in calling
3780: * i += 1 so that an odd nibble gets rounded up to even
3781: * before dividing by 2, then divide by two to get # octets
3782: */
3783: i = (int)(*buf >> 4) + (int)(*buf&0xf);
3784: i++;
3785: ptr = (caddr_t) (buf + (i>>1));
3786: /* now i is number of octets */
3787:
3788: ptr ++; /* plus one for the DTE lengths byte */
3789:
3790: /* ptr now is at facil_length field */
3791: facil_len = ptr++;
3792: IFDEBUG(D_CADDR)
3793: printf("parse_facils: facil length is 0x%x\n", (int) *facil_len);
3794: ENDDEBUG
3795:
3796: while( ptr <= (caddr_t)(facil_len + (int)*facil_len) ) {
3797: /* get NSAP addresses from facilities */
3798: switch (*ptr) {
3799: case 0xcb:
3800: facil_param_len = 0;
3801: addr = calling;
3802: addrs_not_parsed -= 0xcb;
3803: break;
3804: case 0xc9:
3805: facil_param_len = 0;
3806: addr = called;
3807: addrs_not_parsed -= 0xc9;
3808: break;
3809:
3810: /* from here to default are legit cases that I ignore */
3811:
3812: /* variable length */
3813: case 0xca: /* end-to-end transit delay negot */
3814: case 0xc6: /* network user id */
3815: case 0xc5: /* charging info : indicating monetary unit */
3816: case 0xc2: /* charging info : indicating segment count */
3817: case 0xc1: /* charging info : indicating call duration */
3818: case 0xc4: /* RPOA extended format */
3819: case 0xc3: /* call redirection notification */
3820: facil_param_len = 0;
3821: addr = (struct sockaddr_iso *)0;
3822: break;
3823:
3824: /* 1 octet */
3825: case 0x0a: /* min. throughput class negot */
3826: case 0x02: /* throughput class */
3827: case 0x03: case 0x47: /* CUG shit */
3828: case 0x0b: /* expedited data negot */
3829: case 0x01: /* Fast select or reverse charging
3830: (example of intelligent protocol design) */
3831: case 0x04: /* charging info : requesting service */
3832: case 0x08: /* called line addr modified notification */
3833: facil_param_len = 1;
3834: addr = (struct sockaddr_iso *)0;
3835: break;
3836:
3837: /* any 2 octets */
3838: case 0x42: /* pkt size */
3839: case 0x43: /* win size */
3840: case 0x44: /* RPOA basic format */
3841: case 0x41: /* bilateral CUG shit */
3842: case 0x49: /* transit delay selection and indication */
3843: facil_param_len = 2;
3844: addr = (struct sockaddr_iso *)0;
3845: break;
3846:
3847: /* don't have any 3 octets */
3848: /*
3849: facil_param_len = 3;
3850: */
3851: default:
3852: ASSERT(0);
3853: printf(
3854: "BOGUS FACILITY CODE facil_len 0x%x *facil_len 0x%x, ptr 0x%x *ptr 0x%x\n",
3855: facil_len, *facil_len,
3856: ptr, *ptr);
3857: addr = (struct sockaddr_iso *)0;
3858: /* facil that we don't handle */
3859: return E_CO_HLI_REJI;
3860: }
3861: ptr++; /* one for facil code */
3862: if(facil_param_len == 0) /* variable length */
3863: facil_param_len = (int)*ptr; /* 1 + the real facil param */
3864: if( addr && FACILtoNSAP(ptr+1, facil_param_len-1, addr) ) {
3865: return E_CO_OSI_UNSAP;
3866: }
3867: ptr += facil_param_len;
3868: }
3869: if( addrs_not_parsed ) {
3870: /* no facilities, get NSAP addresses from DTE addresses */
3871: register int ed, ing;
3872:
3873: ed = (int)(*buf&0xf);
3874: if( ed == 0 ) {
3875: panic("Called DTE address absent");
3876: }
3877: DTEtoNSAP(called, (buf + 1)/*octet*/,
3878: 1/*nibble*/, ed);
3879:
3880: ing = (int)(*buf >> 4);
3881: if( ing == 0 ) {
3882: printf("cons: panic: Calling DTE address absent");
3883: return E_CO_HLI_REJI;
3884: }
3885: nibble_copy((buf + (ed>>1)+1)/*octet*/, 1-(ed&0x1)/*nibble*/,
3886: peer_dte->dtea_addr, HIGH_NIBBLE, ing);
3887: DTEtoNSAP(calling, (buf + (ed>>1)+1)/*octet*/,
3888: 1-(ed&0x1)/*nibble*/, ing);
3889:
3890: }
3891:
3892: ASSERT( ptr == (caddr_t)(facil_len + 1 + (int)*facil_len) );
3893:
3894: /*
3895: * now look for user data to find protocol identifier
3896: */
3897: if( ptr == buf + buf_len ) {
3898: /* no user data */
3899: *proto = ISOPROTO_TP; /* to proto id --> use TP */
3900: IFDEBUG(D_CADDR)
3901: printf("NO USER DATA: use TP\n");
3902: ENDDEBUG
3903: } else {
3904: ASSERT ( ptr < buf + buf_len );
3905: if ( ptr >= buf + buf_len ) {
3906: printf("ptr 0x%x buf 0x%x buf_len 0x%x buf+buf_len 0x%x\n",
3907: ptr, buf, buf_len, buf+buf_len);
3908: }
3909: IFDEBUG(D_CADDR)
3910: printf("proto byte 0x%x, value 0x%x\n", ptr, *ptr);
3911: ENDDEBUG
3912: switch(*ptr) {
3913: case 0x81:
3914: *proto = ISOPROTO_CLNP;
3915: break;
3916: case 0x0:
3917: *proto = ISOPROTO_INACT_NL;
3918: break;
3919: case 'e': /* for EAN */
3920: *proto = ISOPROTO_TP;
3921: /* can check for "an2" or can ignore the rest of the u data */
3922: break;
3923: case 0xff: /* reserved for future extensions */
3924: *proto = ISOPROTO_X25;
3925: break;
3926: case 0x82: /* 9542 not implemented */
3927: case 0x84: /* 8878/A SNDCP not implemented */
3928: default:
3929: *proto = -1;
3930: return E_CO_HLI_PROTOID;
3931: }
3932: }
3933: return 0;
3934: }
3935:
3936: #endif NARGOXTWENTYFIVE > 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.