![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_x25subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netccitt|
Return to if_x25subr.c CVS log | Up to [Net/2] / Net2 / netccitt |
1.1 root 1: /*
2: * Copyright (c) 1990 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)if_x25subr.c 7.14 (Berkeley) 6/26/91
34: */
35:
36: #include "param.h"
37: #include "systm.h"
38: #include "malloc.h"
39: #include "mbuf.h"
40: #include "protosw.h"
41: #include "socket.h"
42: #include "socketvar.h"
43: #include "ioctl.h"
44: #include "errno.h"
45: #include "syslog.h"
46:
47: #include "../net/if.h"
48: #include "../net/if_types.h"
49: #include "../net/netisr.h"
50: #include "../net/route.h"
51:
52: #include "x25.h"
53: #include "x25err.h"
54: #include "pk.h"
55: #include "pk_var.h"
56:
57: #include "machine/mtpr.h"
58:
59: #ifdef INET
60: #include "../netinet/in.h"
61: #include "../netinet/in_var.h"
62: #endif
63:
64: #ifdef NS
65: #include "../netns/ns.h"
66: #include "../netns/ns_if.h"
67: #endif
68:
69: #ifdef ISO
70: int tp_incoming();
71: #include "../netiso/argo_debug.h"
72: #include "../netiso/iso.h"
73: #include "../netiso/iso_var.h"
74: #endif
75:
76: extern struct ifnet loif;
77: struct llinfo_x25 llinfo_x25 = {&llinfo_x25, &llinfo_x25};
78: struct sockaddr *x25_dgram_sockmask;
79:
80: struct if_x25stats {
81: int ifx_wrongplen;
82: int ifx_nophdr;
83: } if_x25stats;
84: int x25_autoconnect = 0;
85:
86: #define senderr(x) {error = x; goto bad;}
87: /*
88: * Ancillary routines
89: */
90: static struct llinfo_x25 *
91: x25_lxalloc(rt)
92: register struct rtentry *rt;
93: {
94: register struct llinfo_x25 *lx;
95: register struct sockaddr *dst = rt_key(rt);
96: register struct ifaddr *ifa;
97:
98: MALLOC(lx, struct llinfo_x25 *, sizeof (*lx), M_PCB, M_NOWAIT);
99: if (lx == 0)
100: return lx;
101: Bzero(lx, sizeof(*lx));
102: lx->lx_rt = rt;
103: lx->lx_family = dst->sa_family;
104: rt->rt_refcnt++;
105: if (rt->rt_llinfo)
106: insque(lx, (struct llinfo_x25 *)rt->rt_llinfo);
107: else {
108: rt->rt_llinfo = (caddr_t)lx;
109: insque(lx, &llinfo_x25);
110: }
111: for (ifa = rt->rt_ifp->if_addrlist; ifa; ifa = ifa->ifa_next) {
112: if (ifa->ifa_addr->sa_family == AF_CCITT)
113: lx->lx_ia = (struct x25_ifaddr *)ifa;
114: }
115: return lx;
116: }
117: x25_lxfree(lx)
118: register struct llinfo_x25 *lx;
119: {
120: register struct rtentry *rt = lx->lx_rt;
121: register struct pklcd *lcp = lx->lx_lcd;
122:
123: if (lcp) {
124: lcp->lcd_upper = 0;
125: pk_disconnect(lcp);
126: }
127: if ((rt->rt_llinfo == (caddr_t)lx) && (lx->lx_next->lx_rt == rt))
128: rt->rt_llinfo = (caddr_t)lx->lx_next;
129: else
130: rt->rt_llinfo = 0;
131: RTFREE(rt);
132: remque(lx);
133: FREE(lx, M_PCB);
134: }
135: /*
136: * Process a x25 packet as datagram;
137: */
138: x25_ifinput(lcp, m)
139: struct pklcd *lcp;
140: register struct mbuf *m;
141: {
142: struct llinfo_x25 *lx = (struct llinfo_x25 *)lcp->lcd_upnext;
143: register struct ifnet *ifp;
144: struct ifqueue *inq;
145: extern struct timeval time;
146: int s, len, isr;
147:
148: if (m == 0 || lcp->lcd_state != DATA_TRANSFER) {
149: x25_connect_callback(lcp, 0);
150: return;
151: }
152: pk_flowcontrol(lcp, 0, 1); /* Generate RR */
153: ifp = m->m_pkthdr.rcvif;
154: ifp->if_lastchange = time;
155: switch (m->m_type) {
156: case MT_OOBDATA:
157: if (m)
158: m_freem(m);
159: default:
160: return;
161:
162: case MT_DATA:
163: /* FALLTHROUGH */;
164: }
165: switch (lx->lx_family) {
166: #ifdef INET
167: case AF_INET:
168: isr = NETISR_IP;
169: inq = &ipintrq;
170: break;
171:
172: #endif
173: #ifdef NS
174: case AF_NS:
175: isr = NETISR_NS;
176: inq = &nsintrq;
177: break;
178:
179: #endif
180: #ifdef ISO
181: case AF_ISO:
182: isr = NETISR_ISO;
183: inq = &clnlintrq;
184: break;
185: #endif
186: default:
187: m_freem(m);
188: ifp->if_noproto++;
189: return;
190: }
191: s = splimp();
192: schednetisr(isr);
193: if (IF_QFULL(inq)) {
194: IF_DROP(inq);
195: m_freem(m);
196: } else {
197: IF_ENQUEUE(inq, m);
198: ifp->if_ibytes += m->m_pkthdr.len;
199: }
200: splx(s);
201: }
202: x25_connect_callback(lcp, m)
203: register struct pklcd *lcp;
204: register struct mbuf *m;
205: {
206: register struct llinfo_x25 *lx = (struct llinfo_x25 *)lcp->lcd_upnext;
207: if (m == 0)
208: goto refused;
209: if (m->m_type != MT_CONTROL) {
210: printf("x25_connect_callback: should panic\n");
211: goto refused;
212: }
213: switch (pk_decode(mtod(m, struct x25_packet *))) {
214: case CALL_ACCEPTED:
215: lcp->lcd_upper = x25_ifinput;
216: if (lcp->lcd_sb.sb_mb)
217: lcp->lcd_send(lcp); /* XXX start queued packets */
218: return;
219: default:
220: refused:
221: lcp->lcd_upper = 0;
222: lx->lx_lcd = 0;
223: pk_disconnect(lcp);
224: return;
225: }
226: }
227: #define SA(p) ((struct sockaddr *)(p))
228: #define RT(p) ((struct rtentry *)(p))
229:
230: x25_dgram_incoming(lcp, m0)
231: register struct pklcd *lcp;
232: struct mbuf *m0;
233: {
234: register struct rtentry *rt, *nrt;
235: register struct mbuf *m = m0->m_next; /* m0 has calling sockaddr_x25 */
236: int x25_rtrequest();
237:
238: rt = rtalloc1(SA(&lcp->lcd_faddr), 0);
239: if (rt == 0) {
240: refuse: lcp->lcd_upper = 0;
241: pk_close(lcp);
242: return;
243: }
244: rt->rt_refcnt--;
245: if ((nrt = RT(rt->rt_llinfo)) == 0 || rt_mask(rt) != x25_dgram_sockmask)
246: goto refuse;
247: if ((nrt->rt_flags & RTF_UP) == 0) {
248: rt->rt_llinfo = (caddr_t)rtalloc1(rt->rt_gateway, 0);
249: rtfree(nrt);
250: if ((nrt = RT(rt->rt_llinfo)) == 0)
251: goto refuse;
252: nrt->rt_refcnt--;
253: }
254: if (nrt->rt_ifa == 0 || nrt->rt_ifa->ifa_rtrequest != x25_rtrequest)
255: goto refuse;
256: lcp->lcd_send(lcp); /* confirm call */
257: x25_rtattach(lcp, nrt);
258: m_freem(m);
259: }
260:
261: /*
262: * X.25 output routine.
263: */
264: x25_ifoutput(ifp, m0, dst, rt)
265: struct ifnet *ifp;
266: struct mbuf *m0;
267: struct sockaddr *dst;
268: register struct rtentry *rt;
269: {
270: register struct mbuf *m = m0;
271: register struct llinfo_x25 *lx;
272: struct pklcd *lcp;
273: int s, error = 0;
274:
275: int plen;
276: for (plen = 0; m; m = m->m_next)
277: plen += m->m_len;
278: m = m0;
279:
280: if ((ifp->if_flags & IFF_UP) == 0)
281: senderr(ENETDOWN);
282: while (rt == 0 || (rt->rt_flags & RTF_GATEWAY)) {
283: if (rt) {
284: if (rt->rt_llinfo) {
285: rt = (struct rtentry *)rt->rt_llinfo;
286: continue;
287: }
288: dst = rt->rt_gateway;
289: }
290: if ((rt = rtalloc1(dst, 1)) == 0)
291: senderr(EHOSTUNREACH);
292: rt->rt_refcnt--;
293: }
294: /*
295: * Sanity checks.
296: */
297: if ((rt->rt_ifp != ifp) ||
298: (rt->rt_flags & (RTF_CLONING | RTF_GATEWAY)) ||
299: ((lx = (struct llinfo_x25 *)rt->rt_llinfo) == 0)) {
300: senderr(ENETUNREACH);
301: }
302: if ((m->m_flags & M_PKTHDR) == 0) {
303: if_x25stats.ifx_nophdr++;
304: m = m_gethdr(M_NOWAIT, MT_HEADER);
305: if (m == 0)
306: senderr(ENOBUFS);
307: m->m_pkthdr.len = plen;
308: m->m_next = m0;
309: }
310: if (plen != m->m_pkthdr.len) {
311: if_x25stats.ifx_wrongplen++;
312: m->m_pkthdr.len = plen;
313: }
314: next_circuit:
315: lcp = lx->lx_lcd;
316: if (lcp == 0) {
317: lx->lx_lcd = lcp = pk_attach((struct socket *)0);
318: if (lcp == 0)
319: senderr(ENOBUFS);
320: lcp->lcd_upper = x25_connect_callback;
321: lcp->lcd_upnext = (caddr_t)lx;
322: lcp->lcd_packetsize = lx->lx_ia->ia_xc.xc_psize;
323: lcp->lcd_flags = X25_MBS_HOLD;
324: }
325: switch (lcp->lcd_state) {
326: case READY:
327: if (dst->sa_family == AF_INET &&
328: ifp->if_type == IFT_X25DDN &&
329: rt->rt_gateway->sa_family != AF_CCITT)
330: x25_ddnip_to_ccitt(dst, rt);
331: if (rt->rt_gateway->sa_family != AF_CCITT) {
332: if ((rt->rt_flags & RTF_XRESOLVE) == 0)
333: senderr(EHOSTUNREACH);
334: } else if (x25_autoconnect)
335: error = pk_connect(lcp,
336: (struct sockaddr_x25 *)rt->rt_gateway);
337: if (error)
338: senderr(error);
339: /* FALLTHROUGH */
340: case SENT_CALL:
341: case DATA_TRANSFER:
342: if (sbspace(&lcp->lcd_sb) < 0) {
343: lx = lx->lx_next;
344: if (lx->lx_rt != rt)
345: senderr(ENOSPC);
346: goto next_circuit;
347: }
348: if (lx->lx_ia)
349: lcp->lcd_dg_timer =
350: lx->lx_ia->ia_xc.xc_dg_idletimo;
351: pk_send(lcp, m);
352: break;
353: default:
354: /*
355: * We count on the timer routine to close idle
356: * connections, if there are not enough circuits to go
357: * around.
358: *
359: * So throw away data for now.
360: * After we get it all working, we'll rewrite to handle
361: * actively closing connections (other than by timers),
362: * when circuits get tight.
363: *
364: * In the DDN case, the imp itself closes connections
365: * under heavy load.
366: */
367: error = ENOBUFS;
368: bad:
369: if (m)
370: m_freem(m);
371: }
372: return (error);
373: }
374:
375: /*
376: * Simpleminded timer routine.
377: */
378: x25_iftimeout(ifp)
379: struct ifnet *ifp;
380: {
381: register struct pkcb *pkcb = 0;
382: register struct pklcd **lcpp, *lcp;
383: int s = splimp();
384:
385: for (pkcb = pkcbhead; pkcb; pkcb = pkcb->pk_next)
386: if (pkcb->pk_ia->ia_ifp == ifp)
387: for (lcpp = pkcb->pk_chan + pkcb->pk_maxlcn;
388: --lcpp > pkcb->pk_chan;)
389: if ((lcp = *lcpp) &&
390: lcp->lcd_state == DATA_TRANSFER &&
391: (lcp->lcd_flags & X25_DG_CIRCUIT) &&
392: (lcp->lcd_dg_timer && --lcp->lcd_dg_timer == 0)) {
393: lcp->lcd_upper(lcp, 0);
394: }
395: splx(s);
396: }
397: /*
398: * This routine gets called when validating additions of new routes
399: * or deletions of old ones.
400: */
401: x25_rtrequest(cmd, rt, dst)
402: register struct rtentry *rt;
403: struct sockaddr *dst;
404: {
405: register struct llinfo_x25 *lx = (struct llinfo_x25 *)rt->rt_llinfo;
406: register struct sockaddr_x25 *sa =(struct sockaddr_x25 *)rt->rt_gateway;
407: register struct pklcd *lcp;
408:
409: if (rt->rt_flags & RTF_GATEWAY) {
410: if (rt->rt_llinfo)
411: RTFREE((struct rtentry *)rt->rt_llinfo);
412: rt->rt_llinfo = (cmd == RTM_ADD) ?
413: (caddr_t)rtalloc1(rt->rt_gateway, 1) : 0;
414: return;
415: }
416: if ((rt->rt_flags & RTF_HOST) == 0)
417: return;
418: if (cmd == RTM_DELETE) {
419: while (rt->rt_llinfo)
420: x25_lxfree((struct llinfo *)rt->rt_llinfo);
421: x25_rtinvert(RTM_DELETE, rt->rt_gateway, rt);
422: return;
423: }
424: if (lx == 0 && (lx = x25_lxalloc(rt)) == 0)
425: return;
426: if ((lcp = lx->lx_lcd) && lcp->lcd_state != READY) {
427: /*
428: * This can only happen on a RTM_CHANGE operation
429: * though cmd will be RTM_ADD.
430: */
431: if (lcp->lcd_ceaddr &&
432: Bcmp(rt->rt_gateway, lcp->lcd_ceaddr,
433: lcp->lcd_ceaddr->x25_len) != 0) {
434: x25_rtinvert(RTM_DELETE, lcp->lcd_ceaddr, rt);
435: lcp->lcd_upper = 0;
436: pk_disconnect(lcp);
437: }
438: lcp = 0;
439: }
440: x25_rtinvert(RTM_ADD, rt->rt_gateway, rt);
441: }
442:
443: int x25_dont_rtinvert = 0;
444:
445: x25_rtinvert(cmd, sa, rt)
446: register struct sockaddr *sa;
447: register struct rtentry *rt;
448: {
449: struct rtentry *rt2 = 0;
450: /*
451: * rt_gateway contains PID indicating which proto
452: * family on the other end, so will be different
453: * from general host route via X.25.
454: */
455: if (rt->rt_ifp->if_type == IFT_X25DDN || x25_dont_rtinvert)
456: return;
457: if (sa->sa_family != AF_CCITT)
458: return;
459: if (cmd != RTM_DELETE) {
460: rtrequest(RTM_ADD, sa, rt_key(rt), x25_dgram_sockmask,
461: RTF_PROTO2, &rt2);
462: if (rt2) {
463: rt2->rt_llinfo = (caddr_t) rt;
464: rt->rt_refcnt++;
465: }
466: return;
467: }
468: rt2 = rt;
469: if ((rt = rtalloc1(sa, 0)) == 0 ||
470: (rt->rt_flags & RTF_PROTO2) == 0 ||
471: rt->rt_llinfo != (caddr_t)rt2) {
472: printf("x25_rtchange: inverse route screwup\n");
473: return;
474: } else
475: rt2->rt_refcnt--;
476: rtrequest(RTM_DELETE, sa, rt_key(rt2), x25_dgram_sockmask,
477: 0, (struct rtentry **) 0);
478: }
479:
480: static struct sockaddr_x25 blank_x25 = {sizeof blank_x25, AF_CCITT};
481: /*
482: * IP to X25 address routine copyright ACC, used by permission.
483: */
484: union imp_addr {
485: struct in_addr ip;
486: struct imp {
487: u_char s_net;
488: u_char s_host;
489: u_char s_lh;
490: u_char s_impno;
491: } imp;
492: };
493:
494: /*
495: * The following is totally bogus and here only to preserve
496: * the IP to X.25 translation.
497: */
498: x25_ddnip_to_ccitt(src, rt)
499: struct sockaddr_in *src;
500: register struct rtentry *rt;
501: {
502: register struct sockaddr_x25 *dst = (struct sockaddr_x25 *)rt->rt_gateway;
503: union imp_addr imp_addr;
504: int imp_no, imp_port, temp;
505: char *x25addr = dst->x25_addr;
506:
507:
508: imp_addr.ip = src->sin_addr;
509: *dst = blank_x25;
510: if ((imp_addr.imp.s_net & 0x80) == 0x00) { /* class A */
511: imp_no = imp_addr.imp.s_impno;
512: imp_port = imp_addr.imp.s_host;
513: } else if ((imp_addr.imp.s_net & 0xc0) == 0x80) { /* class B */
514: imp_no = imp_addr.imp.s_impno;
515: imp_port = imp_addr.imp.s_lh;
516: } else { /* class C */
517: imp_no = imp_addr.imp.s_impno / 32;
518: imp_port = imp_addr.imp.s_impno % 32;
519: }
520:
521: x25addr[0] = 12; /* length */
522: /* DNIC is cleared by struct copy above */
523:
524: if (imp_port < 64) { /* Physical: 0000 0 IIIHH00 [SS] *//* s_impno
525: * -> III, s_host -> HH */
526: x25addr[5] = 0; /* set flag bit */
527: x25addr[6] = imp_no / 100;
528: x25addr[7] = (imp_no % 100) / 10;
529: x25addr[8] = imp_no % 10;
530: x25addr[9] = imp_port / 10;
531: x25addr[10] = imp_port % 10;
532: } else { /* Logical: 0000 1 RRRRR00 [SS] *//* s
533: * _host * 256 + s_impno -> RRRRR */
534: temp = (imp_port << 8) + imp_no;
535: x25addr[5] = 1;
536: x25addr[6] = temp / 10000;
537: x25addr[7] = (temp % 10000) / 1000;
538: x25addr[8] = (temp % 1000) / 100;
539: x25addr[9] = (temp % 100) / 10;
540: x25addr[10] = temp % 10;
541: }
542: }
543:
544: /*
545: * This routine is a sketch and is not to be believed!!!!!
546: *
547: * This is a utility routine to be called by x25 devices when a
548: * call request is honored with the intent of starting datagram forwarding.
549: */
550: x25_dg_rtinit(dst, ia, af)
551: struct sockaddr_x25 *dst;
552: register struct x25_ifaddr *ia;
553: {
554: struct sockaddr *sa = 0;
555: struct rtentry *rt;
556: struct in_addr my_addr;
557: static struct sockaddr_in sin = {sizeof(sin), AF_INET};
558:
559: if (ia->ia_ifp->if_type == IFT_X25DDN && af == AF_INET) {
560: /*
561: * Inverse X25 to IP mapping copyright and courtesy ACC.
562: */
563: int imp_no, imp_port, temp;
564: union imp_addr imp_addr;
565: {
566: /*
567: * First determine our IP addr for network
568: */
569: register struct in_ifaddr *ina;
570: extern struct in_ifaddr *in_ifaddr;
571:
572: for (ina = in_ifaddr; ina; ina = ina->ia_next)
573: if (ina->ia_ifp == ia->ia_ifp) {
574: my_addr = ina->ia_addr.sin_addr;
575: break;
576: }
577: }
578: {
579:
580: register char *x25addr = dst->x25_addr;
581:
582: switch (x25addr[5] & 0x0f) {
583: case 0: /* Physical: 0000 0 IIIHH00 [SS] */
584: imp_no =
585: ((int) (x25addr[6] & 0x0f) * 100) +
586: ((int) (x25addr[7] & 0x0f) * 10) +
587: ((int) (x25addr[8] & 0x0f));
588:
589:
590: imp_port =
591: ((int) (x25addr[9] & 0x0f) * 10) +
592: ((int) (x25addr[10] & 0x0f));
593: break;
594: case 1: /* Logical: 0000 1 RRRRR00 [SS] */
595: temp = ((int) (x25addr[6] & 0x0f) * 10000)
596: + ((int) (x25addr[7] & 0x0f) * 1000)
597: + ((int) (x25addr[8] & 0x0f) * 100)
598: + ((int) (x25addr[9] & 0x0f) * 10)
599: + ((int) (x25addr[10] & 0x0f));
600:
601: imp_port = temp >> 8;
602: imp_no = temp & 0xff;
603: break;
604: default:
605: return (0L);
606: }
607: imp_addr.ip = my_addr;
608: if ((imp_addr.imp.s_net & 0x80) == 0x00) {
609: /* class A */
610: imp_addr.imp.s_host = imp_port;
611: imp_addr.imp.s_impno = imp_no;
612: imp_addr.imp.s_lh = 0;
613: } else if ((imp_addr.imp.s_net & 0xc0) == 0x80) {
614: /* class B */
615: imp_addr.imp.s_lh = imp_port;
616: imp_addr.imp.s_impno = imp_no;
617: } else {
618: /* class C */
619: imp_addr.imp.s_impno = (imp_no << 5) + imp_port;
620: }
621: }
622: sin.sin_addr = imp_addr.ip;
623: sa = (struct sockaddr *)&sin;
624: } else {
625: /*
626: * This uses the X25 routing table to do inverse
627: * lookup of x25 address to sockaddr.
628: */
629: if (rt = rtalloc1(dst, 0)) {
630: sa = rt->rt_gateway;
631: rt->rt_refcnt--;
632: }
633: }
634: /*
635: * Call to rtalloc1 will create rtentry for reverse path
636: * to callee by virtue of cloning magic and will allocate
637: * space for local control block.
638: */
639: if (sa && (rt = rtalloc1(sa, 1)))
640: rt->rt_refcnt--;
641: }
642: #ifndef _offsetof
643: #define _offsetof(t, m) ((int)((caddr_t)&((t *)0)->m))
644: #endif
645: struct sockaddr_x25 x25_dgmask = {
646: _offsetof(struct sockaddr_x25, x25_udata[1]), /* _len */
647: 0, /* _family */
648: 0, /* _net */
649: { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, /* _addr */
650: {0}, /* opts */
651: -1, /* _udlen */
652: {-1} /* _udata */
653: };
654: int x25_startproto = 1;
655: struct radix_tree_head *x25_rnhead;
656:
657: pk_init()
658: {
659: /*
660: * warning, sizeof (struct sockaddr_x25) > 32,
661: * but contains no data of interest beyond 32
662: */
663: struct radix_node *rn_addmask();
664: rn_inithead(&x25_rnhead, 32, AF_CCITT);
665: x25_dgram_sockmask =
666: SA(rn_addmask((caddr_t)&x25_dgmask, 0, 4)->rn_key);
667: if (x25_startproto) {
668: pk_protolisten(0xcc, 1, x25_dgram_incoming);
669: pk_protolisten(0x81, 1, x25_dgram_incoming);
670: }
671: }
672:
673: struct x25_dgproto {
674: u_char spi;
675: u_char spilen;
676: int (*f)();
677: } x25_dgprototab[] = {
678: #if defined(ISO) && defined(TPCONS)
679: { 0x0, 0, tp_incoming},
680: #endif
681: { 0xcc, 1, x25_dgram_incoming},
682: { 0xcd, 1, x25_dgram_incoming},
683: { 0x81, 1, x25_dgram_incoming},
684: };
685:
686: pk_user_protolisten(info)
687: register u_char *info;
688: {
689: register struct x25_dgproto *dp = x25_dgprototab
690: + ((sizeof x25_dgprototab) / (sizeof *dp));
691: register struct pklcd *lcp;
692:
693: while (dp > x25_dgprototab)
694: if ((--dp)->spi == info[0])
695: goto gotspi;
696: return ESRCH;
697:
698: gotspi: if (info[1])
699: return pk_protolisten(dp->spi, dp->spilen, dp->f);
700: for (lcp = pk_listenhead; lcp; lcp = lcp->lcd_listen)
701: if (lcp->lcd_laddr.x25_udlen == dp->spilen &&
702: Bcmp(&dp->spi, lcp->lcd_laddr.x25_udata, dp->spilen) == 0) {
703: pk_disconnect(lcp);
704: return 0;
705: }
706: return ESRCH;
707: }
708:
709: /*
710: * This routine transfers an X.25 circuit to or from a routing entry.
711: * If the supplied circuit is * in DATA_TRANSFER state, it is added to the
712: * routing entry. If freshly allocated, it glues back the vc from
713: * the rtentry to the socket.
714: */
715: pk_rtattach(so, m0)
716: register struct socket *so;
717: struct mbuf *m0;
718: {
719: register struct pklcd *lcp = (struct pklcd *)so->so_pcb;
720: register struct mbuf *m = m0;
721: struct sockaddr *dst = mtod(m, struct sockaddr *);
722: register struct rtentry *rt = rtalloc1(dst, 0);
723: register struct llinfo_x25 *lx;
724: caddr_t cp;
725: #define ROUNDUP(a) \
726: ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
727: #define transfer_sockbuf(s, f, l) \
728: while (m = (s)->sb_mb)\
729: {(s)->sb_mb = m->m_act; m->m_act = 0; sbfree((s), m); f(l, m);}
730:
731: if (rt)
732: rt->rt_refcnt--;
733: cp = (dst->sa_len < m->m_len) ? ROUNDUP(dst->sa_len) + (caddr_t)dst : 0;
734: while (rt &&
735: ((cp == 0 && rt_mask(rt) != 0) ||
736: (cp != 0 && (rt_mask(rt) == 0 ||
737: Bcmp(cp, rt_mask(rt), rt_mask(rt)->sa_len)) != 0)))
738: rt = (struct rtentry *)rt->rt_nodes->rn_dupedkey;
739: if (rt == 0 || (rt->rt_flags & RTF_GATEWAY) ||
740: (lx = (struct llinfo_x25 *)rt->rt_llinfo) == 0)
741: return ESRCH;
742: if (lcp == 0)
743: return ENOTCONN;
744: switch (lcp->lcd_state) {
745: default:
746: return ENOTCONN;
747:
748: case READY:
749: /* Detach VC from rtentry */
750: if (lx->lx_lcd == 0)
751: return ENOTCONN;
752: lcp->lcd_so = 0;
753: pk_close(lcp);
754: lcp = lx->lx_lcd;
755: if (lx->lx_next->lx_rt == rt)
756: x25_lxfree(lx);
757: lcp->lcd_so = so;
758: lcp->lcd_upper = 0;
759: lcp->lcd_upnext = 0;
760: transfer_sockbuf(&lcp->lcd_sb, sbappendrecord, &so->so_snd);
761: soisconnected(so);
762: return 0;
763:
764: case DATA_TRANSFER:
765: /* Add VC to rtentry */
766: lcp->lcd_so = 0;
767: lcp->lcd_sb = so->so_snd; /* structure copy */
768: bzero((caddr_t)&so->so_snd, sizeof(so->so_snd)); /* XXXXXX */
769: so->so_pcb = 0;
770: x25_rtattach(lcp, rt);
771: transfer_sockbuf(&so->so_rcv, x25_ifinput, lcp);
772: soisdisconnected(so);
773: }
774: return 0;
775: }
776: x25_rtattach(lcp0, rt)
777: register struct pklcd *lcp0;
778: struct rtentry *rt;
779: {
780: register struct llinfo_x25 *lx = (struct llinfo_x25 *)rt->rt_llinfo;
781: register struct pklcd *lcp;
782: register struct mbuf *m;
783: if (lcp = lx->lx_lcd) { /* adding an additional VC */
784: if (lcp->lcd_state == READY) {
785: transfer_sockbuf(&lcp->lcd_sb, pk_output, lcp0);
786: lcp->lcd_upper = 0;
787: pk_close(lcp);
788: } else {
789: lx = x25_lxalloc(rt);
790: if (lx == 0)
791: return ENOBUFS;
792: }
793: }
794: lx->lx_lcd = lcp = lcp0;
795: lcp->lcd_upper = x25_ifinput;
796: lcp->lcd_upnext = (caddr_t)lx;
797: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.