![[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 [Apple Darwin 0.x] / kernel / bsd / netiso|
Return to if_cons.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netiso |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*-
26: * Copyright (c) 1991, 1993
27: * The Regents of the University of California. All rights reserved.
28: *
29: * Redistribution and use in source and binary forms, with or without
30: * modification, are permitted provided that the following conditions
31: * are met:
32: * 1. Redistributions of source code must retain the above copyright
33: * notice, this list of conditions and the following disclaimer.
34: * 2. Redistributions in binary form must reproduce the above copyright
35: * notice, this list of conditions and the following disclaimer in the
36: * documentation and/or other materials provided with the distribution.
37: * 3. All advertising materials mentioning features or use of this software
38: * must display the following acknowledgement:
39: * This product includes software developed by the University of
40: * California, Berkeley and its contributors.
41: * 4. Neither the name of the University nor the names of its contributors
42: * may be used to endorse or promote products derived from this software
43: * without specific prior written permission.
44: *
45: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
46: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
49: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55: * SUCH DAMAGE.
56: *
57: * @(#)if_cons.c 8.1 (Berkeley) 6/10/93
58: */
59:
60: /***********************************************************
61: Copyright IBM Corporation 1987
62:
63: All Rights Reserved
64:
65: Permission to use, copy, modify, and distribute this software and its
66: documentation for any purpose and without fee is hereby granted,
67: provided that the above copyright notice appear in all copies and that
68: both that copyright notice and this permission notice appear in
69: supporting documentation, and that the name of IBM not be
70: used in advertising or publicity pertaining to distribution of the
71: software without specific, written prior permission.
72:
73: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
74: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
75: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
76: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
77: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
78: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
79: SOFTWARE.
80:
81: ******************************************************************/
82:
83: /*
84: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
85: */
86: /*
87: * cons.c - Connection Oriented Network Service:
88: * including support for a) user transport-level service,
89: * b) COSNS below CLNP, and c) CONS below TP.
90: */
91:
92: #if TPCONS
93: #ifdef _KERNEL
94: #ifdef ARGO_DEBUG
95: #define Static
96: unsigned LAST_CALL_PCB;
97: #else /* ARGO_DEBUG */
98: #define Static static
99: #endif /* ARGO_DEBUG */
100:
101: #ifndef SOCK_STREAM
102: #include <sys/param.h>
103: #include <sys/systm.h>
104: #include <sys/mbuf.h>
105: #include <sys/protosw.h>
106: #include <sys/socket.h>
107: #include <sys/socketvar.h>
108: #include <sys/errno.h>
109: #include <sys/ioctl.h>
110: #include <sys/tsleep.h>
111:
112: #include <net/if.h>
113: #include <net/netisr.h>
114: #include <net/route.h>
115:
116: #include <netiso/iso_errno.h>
117: #include <netiso/argo_debug.h>
118: #include <netiso/tp_trace.h>
119: #include <netiso/iso.h>
120: #include <netiso/cons.h>
121: #include <netiso/iso_pcb.h>
122:
123: #include <netccitt/x25.h>
124: #include <netccitt/pk.h>
125: #include <netccitt/pk_var.h>
126: #endif
127:
128: #ifdef ARGO_DEBUG
129: #define MT_XCONN 0x50
130: #define MT_XCLOSE 0x51
131: #define MT_XCONFIRM 0x52
132: #define MT_XDATA 0x53
133: #define MT_XHEADER 0x54
134: #else
135: #define MT_XCONN MT_DATA
136: #define MT_XCLOSE MT_DATA
137: #define MT_XCONFIRM MT_DATA
138: #define MT_XDATA MT_DATA
139: #define MT_XHEADER MT_HEADER
140: #endif /* ARGO_DEBUG */
141:
142: #define DONTCLEAR -1
143:
144: /*********************************************************************
145: * cons.c - CONS interface to the x.25 layer
146: *
147: * TODO: figure out what resources we might run out of besides mbufs.
148: * If we run out of any of them (including mbufs) close and recycle
149: * lru x% of the connections, for some parameter x.
150: *
151: * There are 2 interfaces from above:
152: * 1) from TP0:
153: * cons CO network service
154: * TP associates a transport connection with a network connection.
155: * cons_output( isop, m, len, isdgm==0 )
156: * co_flags == 0
157: * 2) from TP4:
158: * It's a datagram service, like clnp is. - even though it calls
159: * cons_output( isop, m, len, isdgm==1 )
160: * it eventually goes through
161: * cosns_output(ifp, m, dst).
162: * TP4 permits multiplexing (reuse, possibly simultaneously) of the
163: * network connections.
164: * This means that many sockets (many tpcbs) may be associated with
165: * this pklcd, hence cannot have a back ptr from pklcd to a tpcb.
166: * co_flags & CONSF_DGM
167: * co_socket is null since there may be many sockets that use this pklcd.
168: *
169: NOTE:
170: streams would really be nice. sigh.
171: NOTE:
172: PVCs could be handled by config-ing a cons with an address and with the
173: IFF_POINTTOPOINT flag on. This code would then have to skip the
174: connection setup stuff for pt-to-pt links.
175:
176:
177: *********************************************************************/
178:
179:
180: #define CONS_IFQMAXLEN 5
181:
182:
183: /* protosw pointers for getting to higher layer */
184: Static struct protosw *CLNP_proto;
185: Static struct protosw *TP_proto;
186: Static struct protosw *X25_proto;
187: Static int issue_clear_req();
188:
189: #ifndef PHASEONE
190: extern struct ifaddr *ifa_ifwithnet();
191: #endif /* PHASEONE */
192:
193: extern struct ifaddr *ifa_ifwithaddr();
194:
195: extern struct isopcb tp_isopcb; /* chain of all TP pcbs */
196:
197:
198: Static int parse_facil(), NSAPtoDTE(), make_partial_x25_packet();
199: Static int FACILtoNSAP(), DTEtoNSAP();
200: Static struct pklcd *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: /*
303: **************************** NET PROTOCOL cons ***************************
304: */
305: /*
306: * NAME: cons_init()
307: * CALLED FROM:
308: * autoconf
309: * FUNCTION:
310: * initialize the protocol
311: */
312: cons_init()
313: {
314: int tp_incoming(), clnp_incoming();
315:
316:
317: CLNP_proto = pffindproto(AF_ISO, ISOPROTO_CLNP, SOCK_DGRAM);
318: X25_proto = pffindproto(AF_ISO, ISOPROTO_X25, SOCK_STREAM);
319: TP_proto = pffindproto(AF_ISO, ISOPROTO_TP0, SOCK_SEQPACKET);
320: IFDEBUG(D_CCONS)
321: printf("cons_init end : cnlp_proto 0x%x cons proto 0x%x tp proto 0x%x\n",
322: CLNP_proto, X25_proto, TP_proto);
323: ENDDEBUG
324: #ifdef notdef
325: pk_protolisten(0x81, 0, clnp_incoming);
326: pk_protolisten(0x82, 0, esis_incoming);
327: pk_protolisten(0x84, 0, tp8878_A_incoming);
328: pk_protolisten(0, 0, tp_incoming);
329: #endif
330: }
331:
332: tp_incoming(lcp, m)
333: struct pklcd *lcp;
334: register struct mbuf *m;
335: {
336: register struct isopcb *isop;
337: int cons_tpinput();
338:
339: if (iso_pcballoc((struct socket *)0, &tp_isopcb)) {
340: pk_close(lcp);
341: return;
342: }
343: isop = tp_isopcb.isop_next;
344: lcp->lcd_upper = cons_tpinput;
345: lcp->lcd_upnext = (caddr_t)isop;
346: lcp->lcd_send(lcp); /* Confirms call */
347: isop->isop_chan = (caddr_t)lcp;
348: isop->isop_laddr = &isop->isop_sladdr;
349: isop->isop_faddr = &isop->isop_sfaddr;
350: DTEtoNSAP(isop->isop_laddr, &lcp->lcd_laddr);
351: DTEtoNSAP(isop->isop_faddr, &lcp->lcd_faddr);
352: parse_facil(lcp, isop, &(mtod(m, struct x25_packet *)->packet_data),
353: m->m_pkthdr.len - PKHEADERLN);
354: }
355:
356: cons_tpinput(lcp, m0)
357: struct mbuf *m0;
358: struct pklcd *lcp;
359: {
360: register struct isopcb *isop = (struct isopcb *)lcp->lcd_upnext;
361: register struct x25_packet *xp;
362: int cmd, ptype = CLEAR;
363:
364: if (isop == 0)
365: return;
366: if (m0 == 0)
367: goto dead;
368: switch(m0->m_type) {
369: case MT_DATA:
370: case MT_OOBDATA:
371: tpcons_input(m0, isop->isop_faddr, isop->isop_laddr, (caddr_t)lcp);
372: return;
373:
374: case MT_CONTROL:
375: switch (ptype = pk_decode(mtod(m0, struct x25_packet *))) {
376:
377: case RR:
378: cmd = PRC_CONS_SEND_DONE;
379: break;
380:
381: case CALL_ACCEPTED:
382: if (lcp->lcd_sb.sb_mb)
383: lcp->lcd_send(lcp); /* XXX - fix this */
384: /*FALLTHROUGH*/
385: default:
386: return;
387:
388: dead:
389: case CLEAR:
390: case CLEAR_CONF:
391: lcp->lcd_upper = 0;
392: lcp->lcd_upnext = 0;
393: isop->isop_chan = 0;
394: case RESET:
395: cmd = PRC_ROUTEDEAD;
396: }
397: tpcons_ctlinput(cmd, isop->isop_faddr, isop);
398: if (cmd = PRC_ROUTEDEAD && isop->isop_refcnt == 0)
399: iso_pcbdetach(isop);
400: }
401: }
402:
403: /*
404: * NAME: cons_connect()
405: * CALLED FROM:
406: * tpcons_pcbconnect() when opening a new connection.
407: * FUNCTION anD ARGUMENTS:
408: * Figures out which device to use, finding a route if one doesn't
409: * already exist.
410: * RETURN VALUE:
411: * returns E*
412: */
413: cons_connect(isop)
414: register struct isopcb *isop;
415: {
416: register struct pklcd *lcp = (struct pklcd *)isop->isop_chan;
417: register struct mbuf *m;
418: struct ifaddr *ifa;
419: int error;
420:
421: IFDEBUG(D_CCONN)
422: printf("cons_connect(0x%x): ", isop);
423: dump_isoaddr(isop->isop_faddr);
424: printf("myaddr: ");
425: dump_isoaddr(isop->isop_laddr);
426: printf("\n" );
427: ENDDEBUG
428: NSAPtoDTE(isop->isop_faddr, &lcp->lcd_faddr);
429: lcp->lcd_upper = cons_tpinput;
430: lcp->lcd_upnext = (caddr_t)isop;
431: IFDEBUG(D_CCONN)
432: printf(
433: "calling make_partial_x25_packet( 0x%x, 0x%x, 0x%x)\n",
434: &lcp->lcd_faddr, &lcp->lcd_laddr,
435: isop->isop_socket->so_proto->pr_protocol);
436: ENDDEBUG
437: if ((error = make_partial_x25_packet(isop, lcp, m)) == 0)
438: error = pk_connect(lcp, &lcp->lcd_faddr);
439: return error;
440: }
441:
442: /*
443: **************************** DEVICE cons ***************************
444: */
445:
446:
447: /*
448: * NAME: cons_ctlinput()
449: * CALLED FROM:
450: * lower layer when ECN_CLEAR occurs : this routine is here
451: * for consistency - cons subnet service calls its higher layer
452: * through the protosw entry.
453: * FUNCTION & ARGUMENTS:
454: * cmd is a PRC_* command, list found in ../sys/protosw.h
455: * copcb is the obvious.
456: * This serves the higher-layer cons service.
457: * NOTE: this takes 3rd arg. because cons uses it to inform itself
458: * of things (timeouts, etc) but has a pcb instead of an address.
459: */
460: cons_ctlinput(cmd, sa, copcb)
461: int cmd;
462: struct sockaddr *sa;
463: register struct pklcd *copcb;
464: {
465: }
466:
467:
468: find_error_reason( xp )
469: register struct x25_packet *xp;
470: {
471: extern u_char x25_error_stats[];
472: int error, cause;
473:
474: if (xp) {
475: cause = 4[(char *)xp];
476: switch (cause) {
477: case 0x00:
478: case 0x80:
479: /* DTE originated; look at the diagnostic */
480: error = (CONL_ERROR_MASK | cause);
481: goto done;
482:
483: case 0x01: /* number busy */
484: case 0x81:
485: case 0x09: /* Out of order */
486: case 0x89:
487: case 0x11: /* Remot Procedure Error */
488: case 0x91:
489: case 0x19: /* reverse charging accept not subscribed */
490: case 0x99:
491: case 0x21: /* Incampat destination */
492: case 0xa1:
493: case 0x29: /* fast select accept not subscribed */
494: case 0xa9:
495: case 0x39: /* ship absent */
496: case 0xb9:
497: case 0x03: /* invalid facil request */
498: case 0x83:
499: case 0x0b: /* access barred */
500: case 0x8b:
501: case 0x13: /* local procedure error */
502: case 0x93:
503: case 0x05: /* network congestion */
504: case 0x85:
505: case 0x8d: /* not obtainable */
506: case 0x0d:
507: case 0x95: /* RPOA out of order */
508: case 0x15:
509: /* take out bit 8
510: * so we don't have to have so many perror entries
511: */
512: error = (CONL_ERROR_MASK | 0x100 | (cause & ~0x80));
513: goto done;
514:
515: case 0xc1: /* gateway-detected proc error */
516: case 0xc3: /* gateway congestion */
517:
518: error = (CONL_ERROR_MASK | 0x100 | cause);
519: goto done;
520: }
521: }
522: /* otherwise, a *hopefully* valid perror exists in the e_reason field */
523: error = xp->packet_data;
524: if (error = 0) {
525: printf("Incoming PKT TYPE 0x%x with reason 0x%x\n",
526: pk_decode(xp),
527: cause);
528: error = E_CO_HLI_DISCA;
529: }
530:
531: done:
532: return error;
533: }
534:
535:
536:
537: #endif /* KERNEL */
538:
539: /*
540: * NAME: make_partial_x25_packet()
541: *
542: * FUNCTION and ARGUMENTS:
543: * Makes part of an X.25 call packet, for use by x25.
544: * (src) and (dst) are the NSAP-addresses of source and destination.
545: * (buf) is a ptr to a buffer into which to write this partial header.
546: *
547: * 0 Facility length (in octets)
548: * 1 Facility field, which is a set of:
549: * m facil code
550: * m+1 facil param len (for >2-byte facilities) in octets
551: * m+2..p facil param field
552: * q user data (protocol identification octet)
553: *
554: *
555: * RETURNS:
556: * 0 if OK
557: * E* if failed.
558: *
559: * SIDE EFFECTS:
560: * Stores facilites mbuf in X.25 control block, where the connect
561: * routine knows where to look for it.
562: */
563:
564: #ifdef X25_1984
565: int cons_use_facils = 1;
566: #else /* X25_1984 */
567: int cons_use_facils = 0;
568: #endif /* X25_1984 */
569:
570: int cons_use_udata = 1; /* KLUDGE FOR DEBUGGING */
571:
572: Static int
573: make_partial_x25_packet(isop, lcp)
574: struct isopcb *isop;
575: struct pklcd *lcp;
576: {
577: u_int proto;
578: int flag;
579: caddr_t buf;
580: register caddr_t ptr;
581: register int len = 0;
582: int buflen =0;
583: caddr_t facil_len;
584: int oddness = 0;
585: struct mbuf *m;
586:
587:
588: IFDEBUG(D_CCONN)
589: printf("make_partial_x25_packet(0x%x, 0x%x, 0x%x, 0x%x, 0x%x)\n",
590: isop->isop_laddr, isop->isop_faddr, proto, m, flag);
591: ENDDEBUG
592: if (cons_use_udata) {
593: if (isop->isop_x25crud_len > 0) {
594: /*
595: * The user specified something. Stick it in
596: */
597: bcopy(isop->isop_x25crud, lcp->lcd_faddr.x25_udata,
598: isop->isop_x25crud_len);
599: lcp->lcd_faddr.x25_udlen = isop->isop_x25crud_len;
600: }
601: }
602:
603: if (cons_use_facils == 0) {
604: lcp->lcd_facilities = 0;
605: return 0;
606: }
607: MGETHDR(m, MT_DATA, M_WAITOK);
608: if (m == 0)
609: return ENOBUFS;
610: buf = mtod(m, caddr_t);
611: ptr = buf;
612:
613: /* ptr now points to facil length (len of whole facil field in OCTETS */
614: facil_len = ptr ++;
615: m->m_len = 0;
616: pk_build_facilities(m, &lcp->lcd_faddr, 0);
617:
618: IFDEBUG(D_CADDR)
619: printf("make_partial calling: ptr 0x%x, len 0x%x\n", ptr,
620: isop->isop_laddr->siso_addr.isoa_len);
621: ENDDEBUG
622: if (cons_use_facils) {
623: *ptr++ = 0; /* Marker to separate X.25 facitilies from CCITT ones */
624: *ptr++ = 0x0f;
625: *ptr = 0xcb; /* calling facility code */
626: ptr ++;
627: ptr ++; /* leave room for facil param len (in OCTETS + 1) */
628: ptr ++; /* leave room for the facil param len (in nibbles),
629: * high two bits of which indicate full/partial NSAP
630: */
631: len = isop->isop_laddr->siso_addr.isoa_len;
632: bcopy( isop->isop_laddr->siso_data, ptr, len);
633: *(ptr-2) = len+1; /* facil param len in octets */
634: *(ptr-1) = len<<1; /* facil param len in nibbles */
635: ptr += len;
636:
637: IFDEBUG(D_CADDR)
638: printf("make_partial called: ptr 0x%x, len 0x%x\n", ptr,
639: isop->isop_faddr->siso_addr.isoa_len);
640: ENDDEBUG
641: *ptr = 0xc9; /* called facility code */
642: ptr ++;
643: ptr ++; /* leave room for facil param len (in OCTETS + 1) */
644: ptr ++; /* leave room for the facil param len (in nibbles),
645: * high two bits of which indicate full/partial NSAP
646: */
647: len = isop->isop_faddr->siso_nlen;
648: bcopy(isop->isop_faddr->siso_data, ptr, len);
649: *(ptr-2) = len+1; /* facil param len = addr len + 1 for each of these
650: * two length fields, in octets */
651: *(ptr-1) = len<<1; /* facil param len in nibbles */
652: ptr += len;
653:
654: }
655: *facil_len = ptr - facil_len - 1;
656: if (*facil_len > MAX_FACILITIES)
657: return E_CO_PNA_LONG;
658:
659: buflen = (int)(ptr - buf);
660:
661: IFDEBUG(D_CDUMP_REQ)
662: register int i;
663:
664: printf("ECN_CONNECT DATA buf 0x%x len %d (0x%x)\n",
665: buf, buflen, buflen);
666: for( i=0; i < buflen; ) {
667: printf("+%d: %x %x %x %x %x %x %x %x\n",
668: i,
669: *(buf+i), *(buf+i+1), *(buf+i+2), *(buf+i+3),
670: *(buf+i+4), *(buf+i+5), *(buf+i+6), *(buf+i+7));
671: i+=8;
672: }
673: ENDDEBUG
674: IFDEBUG(D_CADDR)
675: printf("make_partial returns buf 0x%x size 0x%x bytes\n",
676: mtod(m, caddr_t), buflen);
677: ENDDEBUG
678:
679: if (buflen > MHLEN)
680: return E_CO_PNA_LONG;
681:
682: m->m_pkthdr.len = m->m_len = buflen;
683: lcp->lcd_facilities = m;
684: return 0;
685: }
686:
687: /*
688: * NAME: NSAPtoDTE()
689: * CALLED FROM:
690: * make_partial_x25_packet()
691: * FUNCTION and ARGUMENTS:
692: * get a DTE address from an NSAP-address (struct sockaddr_iso)
693: * (dst_octet) is the octet into which to begin stashing the DTE addr
694: * (dst_nibble) takes 0 or 1. 1 means begin filling in the DTE addr
695: * in the high-order nibble of dst_octet. 0 means low-order nibble.
696: * (addr) is the NSAP-address
697: * (flag) is true if the transport suffix is to become the
698: * last two digits of the DTE address
699: * A DTE address is a series of ASCII digits
700: *
701: * A DTE address may have leading zeros. The are significant.
702: * 1 digit per nibble, may be an odd number of nibbles.
703: *
704: * An NSAP-address has the DTE address in the IDI. Leading zeros are
705: * significant. Trailing hex f indicates the end of the DTE address.
706: * The IDI is a series of BCD digits, one per nibble.
707: *
708: * RETURNS
709: * # significant digits in the DTE address, -1 if error.
710: */
711:
712: Static int
713: NSAPtoDTE(siso, sx25)
714: register struct sockaddr_iso *siso;
715: register struct sockaddr_x25 *sx25;
716: {
717: int dtelen = -1;
718:
719: IFDEBUG(D_CADDR)
720: printf("NSAPtoDTE: nsap: %s\n", clnp_iso_addrp(&siso->siso_addr));
721: ENDDEBUG
722:
723: if (siso->siso_data[0] == AFI_37) {
724: register char *out = sx25->x25_addr;
725: register char *in = siso->siso_data + 1;
726: register int nibble;
727: char *lim = siso->siso_data + siso->siso_nlen;
728: char *olim = out+15;
729: int lowNibble = 0;
730:
731: while (in < lim) {
732: nibble = ((lowNibble ? *in++ : (*in >> 4)) & 0xf) | 0x30;
733: lowNibble ^= 1;
734: if (nibble != 0x3f && out < olim)
735: *out++ = nibble;
736: }
737: dtelen = out - sx25->x25_addr;
738: *out++ = 0;
739: } else {
740: /* error = iso_8208snparesolve(addr, x121string, &x121strlen);*/
741: register struct rtentry *rt;
742: extern struct sockaddr_iso blank_siso;
743: struct sockaddr_iso nsiso;
744:
745: nsiso = blank_siso;
746: bcopy(nsiso.siso_data, siso->siso_data,
747: nsiso.siso_nlen = siso->siso_nlen);
748: if (rt = rtalloc1(&nsiso, 1)) {
749: register struct sockaddr_x25 *sxx =
750: (struct sockaddr_x25 *)rt->rt_gateway;
751: register char *in = sxx->x25_addr;
752:
753: rt->rt_use--;
754: if (sxx && sxx->x25_family == AF_CCITT) {
755: bcopy(sx25->x25_addr, sxx->x25_addr, sizeof(sx25->x25_addr));
756: while (*in++) {}
757: dtelen = in - sxx->x25_addr;
758: }
759: }
760: }
761: return dtelen;
762: }
763:
764: /*
765: * NAME: FACILtoNSAP()
766: * CALLED FROM:
767: * parse_facil()
768: * FUNCTION and ARGUMENTS:
769: * Creates and NSAP in the sockaddr_iso (addr) from the
770: * x.25 facility found at buf - 1.
771: * RETURNS:
772: * 0 if ok, -1 if error.
773: */
774:
775: Static int
776: FACILtoNSAP(addr, buf)
777: register u_char *buf;
778: register struct sockaddr_iso *addr;
779: {
780: int len_in_nibbles = *++buf & 0x3f;
781: u_char buf_len = (len_in_nibbles + 1) >> 1;; /* in bytes */
782:
783: IFDEBUG(D_CADDR)
784: printf("FACILtoNSAP( 0x%x, 0x%x, 0x%x )\n",
785: buf, buf_len, addr );
786: ENDDEBUG
787:
788: len_in_nibbles = *buf & 0x3f;
789: /* despite the fact that X.25 makes us put a length in nibbles
790: * here, the NSAP-addrs are always in full octets
791: */
792: switch (*buf++ & 0xc0) {
793: case 0:
794: /* Entire OSI NSAP address */
795: bcopy((caddr_t)buf, addr->siso_data, addr->siso_nlen = buf_len);
796: break;
797:
798: case 40:
799: /* Partial OSI NSAP address, assume trailing */
800: if (buf_len + addr->siso_nlen > sizeof(addr->siso_addr))
801: return -1;
802: bcopy((caddr_t)buf, TSEL(addr), buf_len);
803: addr->siso_nlen += buf_len;
804: break;
805:
806: default:
807: /* Rather than blow away the connection, just ignore and use
808: NSAP from DTE */;
809: }
810: return 0;
811: }
812:
813: Static
814: init_siso(siso)
815: register struct sockaddr_iso *siso;
816: {
817: siso->siso_len = sizeof (*siso);
818: siso->siso_family = AF_ISO;
819: siso->siso_data[0] = AFI_37;
820: siso->siso_nlen = 8;
821: }
822:
823: /*
824: * NAME: DTEtoNSAP()
825: * CALLED FROM:
826: * parse_facil()
827: * FUNCTION and ARGUMENTS:
828: * Creates a type 37 NSAP in the sockaddr_iso (addr)
829: * from a DTE address found in a sockaddr_x25.
830: *
831: * RETURNS:
832: * 0 if ok; E* otherwise.
833: */
834:
835: Static int
836: DTEtoNSAP(addr, sx)
837: struct sockaddr_iso *addr;
838: struct sockaddr_x25 *sx;
839: {
840: register char *in, *out;
841: register int first;
842: int pad_tail = 0;
843: int src_len;
844:
845:
846: init_siso(addr);
847: in = sx->x25_addr;
848: src_len = strlen(in);
849: addr->siso_nlen = (src_len + 3) / 2;
850: out = addr->siso_data;
851: *out++ = 0x37;
852: if (src_len & 1) {
853: pad_tail = 0xf;
854: src_len++;
855: }
856: for (first = 0; src_len > 0; src_len--) {
857: first |= 0xf & *in++;
858: if (src_len & 1) {
859: *out++ = first;
860: first = 0;
861: }
862: else first <<= 4;
863: }
864: if (pad_tail)
865: out[-1] |= 0xf;
866: return 0; /* ok */
867: }
868:
869: /*
870: * FUNCTION and ARGUMENTS:
871: * parses (buf_len) bytes beginning at (buf) and finds
872: * a called nsap, a calling nsap, and protocol identifier.
873: * RETURNS:
874: * 0 if ok, E* otherwise.
875: */
876:
877: Static int
878: parse_facil(lcp, isop, buf, buf_len)
879: caddr_t buf;
880: u_char buf_len; /* in bytes */
881: struct isopcb *isop;
882: struct pklcd *lcp;
883: {
884: register int i;
885: register u_char *ptr = (u_char *)buf;
886: u_char *ptr_lim, *facil_lim;
887: int facil_param_len, facil_len;
888:
889: IFDEBUG(D_CADDR)
890: printf("parse_facil(0x%x, 0x%x, 0x%x, 0x%x)\n",
891: lcp, isop, buf, buf_len);
892: dump_buf(buf, buf_len);
893: ENDDEBUG
894:
895: /* find the beginnings of the facility fields in buf
896: * by skipping over the called & calling DTE addresses
897: * i <- # nibbles in called + # nibbles in calling
898: * i += 1 so that an odd nibble gets rounded up to even
899: * before dividing by 2, then divide by two to get # octets
900: */
901: i = (int)(*ptr >> 4) + (int)(*ptr&0xf);
902: i++;
903: ptr += i >> 1;
904: ptr ++; /* plus one for the DTE lengths byte */
905:
906: /* ptr now is at facil_length field */
907: facil_len = *ptr++;
908: facil_lim = ptr + facil_len;
909: IFDEBUG(D_CADDR)
910: printf("parse_facils: facil length is 0x%x\n", (int) facil_len);
911: ENDDEBUG
912:
913: while (ptr < facil_lim) {
914: /* get NSAP addresses from facilities */
915: switch (*ptr++) {
916: case 0xcb:
917: /* calling NSAP */
918: facil_param_len = FACILtoNSAP(isop->isop_faddr, ptr);
919: break;
920: case 0xc9:
921: /* called NSAP */
922: facil_param_len = FACILtoNSAP(isop->isop_laddr, ptr);
923: break;
924:
925: /* from here to default are legit cases that I ignore */
926: /* variable length */
927: case 0xca: /* end-to-end transit delay negot */
928: case 0xc6: /* network user id */
929: case 0xc5: /* charging info : indicating monetary unit */
930: case 0xc2: /* charging info : indicating segment count */
931: case 0xc1: /* charging info : indicating call duration */
932: case 0xc4: /* RPOA extended format */
933: case 0xc3: /* call redirection notification */
934: facil_param_len = 0;
935: break;
936:
937: /* 1 octet */
938: case 0x0a: /* min. throughput class negot */
939: case 0x02: /* throughput class */
940: case 0x03: case 0x47: /* CUG xxxx */
941: case 0x0b: /* expedited data negot */
942: case 0x01: /* Fast select or reverse charging
943: (example of intelligent protocol design) */
944: case 0x04: /* charging info : requesting service */
945: case 0x08: /* called line addr modified notification */
946: case 0x00: /* marker to indicate beginning of CCITT facils */
947: facil_param_len = 1;
948: break;
949:
950: /* any 2 octets */
951: case 0x42: /* pkt size */
952: case 0x43: /* win size */
953: case 0x44: /* RPOA basic format */
954: case 0x41: /* bilateral CUG xxxx */
955: case 0x49: /* transit delay selection and indication */
956: facil_param_len = 2;
957: break;
958:
959: default:
960: printf(
961: "BOGUS FACILITY CODE facil_lim 0x%x facil_len %d, ptr 0x%x *ptr 0x%x\n",
962: facil_lim, facil_len, ptr - 1, ptr[-1]);
963: /* facil that we don't handle
964: return E_CO_HLI_REJI; */
965: switch (ptr[-1] & 0xc0) {
966: case 0x00: facil_param_len = 1; break;
967: case 0x40: facil_param_len = 2; break;
968: case 0x80: facil_param_len = 3; break;
969: case 0xc0: facil_param_len = 0; break;
970: }
971: }
972: if (facil_param_len == -1)
973: return E_CO_REG_ICDA;
974: if (facil_param_len == 0) /* variable length */
975: facil_param_len = (int)*ptr++; /* 1 + the real facil param */
976: ptr += facil_param_len;
977: }
978: return 0;
979: }
980:
981: #endif /* TPCONS */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.