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