![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pk_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netccitt|
Return to pk_subr.c CVS log | Up to [Apple XNU] / XNU / bsd / netccitt |
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) University of British Columbia, 1984
24: * Copyright (C) Computer Science Department IV,
25: * University of Erlangen-Nuremberg, Germany, 1992
26: * Copyright (c) 1991, 1992, 1993
27: * The Regents of the University of California. All rights reserved.
28: *
29: * This code is derived from software contributed to Berkeley by the
30: * Laboratory for Computation Vision and the Computer Science Department
31: * of the the University of British Columbia and the Computer Science
32: * Department (IV) of the University of Erlangen-Nuremberg, Germany.
33: *
34: * Redistribution and use in source and binary forms, with or without
35: * modification, are permitted provided that the following conditions
36: * are met:
37: * 1. Redistributions of source code must retain the above copyright
38: * notice, this list of conditions and the following disclaimer.
39: * 2. Redistributions in binary form must reproduce the above copyright
40: * notice, this list of conditions and the following disclaimer in the
41: * documentation and/or other materials provided with the distribution.
42: * 3. All advertising materials mentioning features or use of this software
43: * must display the following acknowledgement:
44: * This product includes software developed by the University of
45: * California, Berkeley and its contributors.
46: * 4. Neither the name of the University nor the names of its contributors
47: * may be used to endorse or promote products derived from this software
48: * without specific prior written permission.
49: *
50: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60: * SUCH DAMAGE.
61: *
62: * @(#)pk_subr.c 8.1 (Berkeley) 6/10/93
63: */
64:
65: #include <sys/param.h>
66: #include <sys/systm.h>
67: #include <sys/mbuf.h>
68: #include <sys/socket.h>
69: #include <sys/protosw.h>
70: #include <sys/socketvar.h>
71: #include <sys/errno.h>
72: #include <sys/time.h>
73: #include <sys/kernel.h>
74: #include <sys/malloc.h>
75:
76: #include <net/if.h>
77: #include <net/route.h>
78:
79: #include <netccitt/dll.h>
80: #include <netccitt/x25.h>
81: #include <netccitt/x25err.h>
82: #include <netccitt/pk.h>
83: #include <netccitt/pk_var.h>
84:
85: int pk_sendspace = 1024 * 2 + 8;
86: int pk_recvspace = 1024 * 2 + 8;
87:
88: struct pklcd_q pklcd_q = {&pklcd_q, &pklcd_q};
89:
90: struct x25bitslice x25_bitslice[] = {
91: /* mask, shift value */
92: { 0xf0, 0x4 },
93: { 0xf, 0x0 },
94: { 0x80, 0x7 },
95: { 0x40, 0x6 },
96: { 0x30, 0x4 },
97: { 0xe0, 0x5 },
98: { 0x10, 0x4 },
99: { 0xe, 0x1 },
100: { 0x1, 0x0 }
101: };
102:
103:
104: /*
105: * Attach X.25 protocol to socket, allocate logical channel descripter
106: * and buffer space, and enter LISTEN state if we are to accept
107: * IN-COMMING CALL packets.
108: *
109: */
110:
111: struct pklcd *
112: pk_attach (so)
113: struct socket *so;
114: {
115: register struct pklcd *lcp;
116: register int error = ENOBUFS;
117: int pk_output ();
118:
119: MALLOC(lcp, struct pklcd *, sizeof (*lcp), M_PCB, M_NOWAIT);
120: if (lcp) {
121: bzero ((caddr_t)lcp, sizeof (*lcp));
122: insque (&lcp -> lcd_q, &pklcd_q);
123: lcp -> lcd_state = READY;
124: lcp -> lcd_send = pk_output;
125: if (so) {
126: error = soreserve (so, pk_sendspace, pk_recvspace);
127: lcp -> lcd_so = so;
128: if (so -> so_options & SO_ACCEPTCONN)
129: lcp -> lcd_state = LISTEN;
130: } else
131: sbreserve (&lcp -> lcd_sb, pk_sendspace);
132: }
133: if (so) {
134: so -> so_pcb = (caddr_t) lcp;
135: so -> so_error = error;
136: }
137: return (lcp);
138: }
139:
140: /*
141: * Disconnect X.25 protocol from socket.
142: */
143:
144: pk_disconnect (lcp)
145: register struct pklcd *lcp;
146: {
147: register struct socket *so = lcp -> lcd_so;
148: register struct pklcd *l, *p;
149:
150: switch (lcp -> lcd_state) {
151: case LISTEN:
152: for (p = 0, l = pk_listenhead; l && l != lcp; p = l, l = l -> lcd_listen);
153: if (p == 0) {
154: if (l != 0)
155: pk_listenhead = l -> lcd_listen;
156: }
157: else
158: if (l != 0)
159: p -> lcd_listen = l -> lcd_listen;
160: pk_close (lcp);
161: break;
162:
163: case READY:
164: pk_acct (lcp);
165: pk_close (lcp);
166: break;
167:
168: case SENT_CLEAR:
169: case RECEIVED_CLEAR:
170: break;
171:
172: default:
173: pk_acct (lcp);
174: if (so) {
175: soisdisconnecting (so);
176: sbflush (&so -> so_rcv);
177: }
178: pk_clear (lcp, 241, 0); /* Normal Disconnect */
179:
180: }
181: }
182:
183: /*
184: * Close an X.25 Logical Channel. Discard all space held by the
185: * connection and internal descriptors. Wake up any sleepers.
186: */
187:
188: pk_close (lcp)
189: struct pklcd *lcp;
190: {
191: register struct socket *so = lcp -> lcd_so;
192:
193: /*
194: * If the X.25 connection is torn down due to link
195: * level failure (e.g. LLC2 FRMR) and at the same the user
196: * level is still filling up the socket send buffer that
197: * send buffer is locked. An attempt to sbflush () that send
198: * buffer will lead us into - no, not temptation but - panic!
199: * So - we'll just check wether the send buffer is locked
200: * and if that's the case we'll mark the lcp as zombie and
201: * have the pk_timer () do the cleaning ...
202: */
203:
204: if (so && so -> so_snd.sb_flags & SB_LOCK)
205: lcp -> lcd_state = LCN_ZOMBIE;
206: else
207: pk_freelcd (lcp);
208:
209: if (so == NULL)
210: return;
211:
212: so -> so_pcb = 0;
213: soisdisconnected (so);
214: /* sofree (so); /* gak!!! you can't do that here */
215: }
216:
217: /*
218: * Create a template to be used to send X.25 packets on a logical
219: * channel. It allocates an mbuf and fills in a skeletal packet
220: * depending on its type. This packet is passed to pk_output where
221: * the remainer of the packet is filled in.
222: */
223:
224: struct mbuf *
225: pk_template (lcn, type)
226: int lcn, type;
227: {
228: register struct mbuf *m;
229: register struct x25_packet *xp;
230:
231: MGETHDR (m, M_DONTWAIT, MT_HEADER);
232: if (m == 0)
233: panic ("pk_template");
234: m -> m_act = 0;
235:
236: /*
237: * Efficiency hack: leave a four byte gap at the beginning
238: * of the packet level header with the hope that this will
239: * be enough room for the link level to insert its header.
240: */
241: m -> m_data += max_linkhdr;
242: m -> m_pkthdr.len = m -> m_len = PKHEADERLN;
243:
244: xp = mtod (m, struct x25_packet *);
245: *(long *)xp = 0; /* ugly, but fast */
246: /* xp -> q_bit = 0;*/
247: X25SBITS(xp -> bits, fmt_identifier, 1);
248: /* xp -> lc_group_number = 0;*/
249:
250: SET_LCN(xp, lcn);
251: xp -> packet_type = type;
252:
253: return (m);
254: }
255:
256: /*
257: * This routine restarts all the virtual circuits. Actually,
258: * the virtual circuits are not "restarted" as such. Instead,
259: * any active switched circuit is simply returned to READY
260: * state.
261: */
262:
263: pk_restart (pkp, restart_cause)
264: register struct pkcb *pkp;
265: int restart_cause;
266: {
267: register struct mbuf *m;
268: register struct pklcd *lcp;
269: register int i;
270:
271: /* Restart all logical channels. */
272: if (pkp -> pk_chan == 0)
273: return;
274:
275: /*
276: * Don't do this if we're doing a restart issued from
277: * inside pk_connect () --- which is only done if and
278: * only if the X.25 link is down, i.e. a RESTART needs
279: * to be done to get it up.
280: */
281: if (!(pkp -> pk_dxerole & DTE_CONNECTPENDING)) {
282: for (i = 1; i <= pkp -> pk_maxlcn; ++i)
283: if ((lcp = pkp -> pk_chan[i]) != NULL) {
284: if (lcp -> lcd_so) {
285: lcp -> lcd_so -> so_error = ENETRESET;
286: pk_close (lcp);
287: } else {
288: pk_flush (lcp);
289: lcp -> lcd_state = READY;
290: if (lcp -> lcd_upper)
291: lcp -> lcd_upper (lcp, 0);
292: }
293: }
294: }
295:
296: if (restart_cause < 0)
297: return;
298:
299: pkp -> pk_state = DTE_SENT_RESTART;
300: pkp -> pk_dxerole &= ~(DTE_PLAYDCE | DTE_PLAYDTE);
301: lcp = pkp -> pk_chan[0];
302: m = lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESTART);
303: m -> m_pkthdr.len = m -> m_len += 2;
304: mtod (m, struct x25_packet *) -> packet_data = 0; /* DTE only */
305: mtod (m, octet *)[4] = restart_cause;
306: pk_output (lcp);
307: }
308:
309:
310: /*
311: * This procedure frees up the Logical Channel Descripter.
312: */
313:
314: pk_freelcd (lcp)
315: register struct pklcd *lcp;
316: {
317: if (lcp == NULL)
318: return;
319:
320: if (lcp -> lcd_lcn > 0)
321: lcp -> lcd_pkp -> pk_chan[lcp -> lcd_lcn] = NULL;
322:
323: pk_flush (lcp);
324: remque (&lcp -> lcd_q);
325: FREE((caddr_t)lcp, M_PCB);
326: }
327:
328: static struct x25_ifaddr *
329: pk_ifwithaddr (sx)
330: struct sockaddr_x25 *sx;
331: {
332: struct ifnet *ifp;
333: struct ifaddr *ifa;
334: register struct x25_ifaddr *ia;
335: char *addr = sx -> x25_addr;
336:
337: for (ifp = ifnet; ifp; ifp = ifp -> if_next)
338: for (ifa = ifp -> if_addrlist; ifa; ifa = ifa -> ifa_next)
339: if (ifa -> ifa_addr -> sa_family == AF_CCITT) {
340: ia = (struct x25_ifaddr *)ifa;
341: if (bcmp (addr, ia -> ia_xc.xc_addr.x25_addr,
342: 16) == 0)
343: return (ia);
344:
345: }
346: return ((struct x25_ifaddr *)0);
347: }
348:
349:
350: /*
351: * Bind a address and protocol value to a socket. The important
352: * part is the protocol value - the first four characters of the
353: * Call User Data field.
354: */
355:
356: #define XTRACTPKP(rt) ((rt) -> rt_flags & RTF_GATEWAY ? \
357: ((rt) -> rt_llinfo ? \
358: (struct pkcb *) ((struct rtentry *)((rt) -> rt_llinfo)) -> rt_llinfo : \
359: (struct pkcb *) NULL) : \
360: (struct pkcb *)((rt) -> rt_llinfo))
361:
362: pk_bind (lcp, nam)
363: struct pklcd *lcp;
364: struct mbuf *nam;
365: {
366: register struct pklcd *pp;
367: register struct sockaddr_x25 *sa;
368:
369: if (nam == NULL)
370: return (EADDRNOTAVAIL);
371: if (lcp -> lcd_ceaddr) /* XXX */
372: return (EADDRINUSE);
373: if (pk_checksockaddr (nam))
374: return (EINVAL);
375: sa = mtod (nam, struct sockaddr_x25 *);
376:
377: /*
378: * If the user wishes to accept calls only from a particular
379: * net (net != 0), make sure the net is known
380: */
381:
382: if (sa -> x25_addr[0]) {
383: if (!pk_ifwithaddr (sa))
384: return (ENETUNREACH);
385: } else if (sa -> x25_net) {
386: if (!ifa_ifwithnet ((struct sockaddr *)sa))
387: return (ENETUNREACH);
388: }
389:
390: /*
391: * For ISO's sake permit default listeners, but only one such . . .
392: */
393: for (pp = pk_listenhead; pp; pp = pp -> lcd_listen) {
394: register struct sockaddr_x25 *sa2 = pp -> lcd_ceaddr;
395: if ((sa2 -> x25_udlen == sa -> x25_udlen) &&
396: (sa2 -> x25_udlen == 0 ||
397: (bcmp (sa2 -> x25_udata, sa -> x25_udata,
398: min (sa2 -> x25_udlen, sa -> x25_udlen)) == 0)))
399: return (EADDRINUSE);
400: }
401: lcp -> lcd_laddr = *sa;
402: lcp -> lcd_ceaddr = &lcp -> lcd_laddr;
403: return (0);
404: }
405:
406: /*
407: * Include a bound control block in the list of listeners.
408: */
409: pk_listen (lcp)
410: register struct pklcd *lcp;
411: {
412: register struct pklcd **pp;
413:
414: if (lcp -> lcd_ceaddr == 0)
415: return (EDESTADDRREQ);
416:
417: lcp -> lcd_state = LISTEN;
418: /*
419: * Add default listener at end, any others at start.
420: */
421: if (lcp -> lcd_ceaddr -> x25_udlen == 0) {
422: for (pp = &pk_listenhead; *pp; )
423: pp = &((*pp) -> lcd_listen);
424: *pp = lcp;
425: } else {
426: lcp -> lcd_listen = pk_listenhead;
427: pk_listenhead = lcp;
428: }
429: return (0);
430: }
431: /*
432: * Include a listening control block for the benefit of other protocols.
433: */
434: pk_protolisten (spi, spilen, callee)
435: int (*callee) ();
436: {
437: register struct pklcd *lcp = pk_attach ((struct socket *)0);
438: register struct mbuf *nam;
439: register struct sockaddr_x25 *sa;
440: int error = ENOBUFS;
441:
442: if (lcp) {
443: if (nam = m_getclr (MT_SONAME, M_DONTWAIT)) {
444: sa = mtod (nam, struct sockaddr_x25 *);
445: sa -> x25_family = AF_CCITT;
446: sa -> x25_len = nam -> m_len = sizeof (*sa);
447: sa -> x25_udlen = spilen;
448: sa -> x25_udata[0] = spi;
449: lcp -> lcd_upper = callee;
450: lcp -> lcd_flags = X25_MBS_HOLD;
451: if ((error = pk_bind (lcp, nam)) == 0)
452: error = pk_listen (lcp);
453: (void) m_free (nam);
454: }
455: if (error)
456: pk_freelcd (lcp);
457: }
458: return error; /* Hopefully Zero !*/
459: }
460:
461: /*
462: * Associate a logical channel descriptor with a network.
463: * Fill in the default network specific parameters and then
464: * set any parameters explicitly specified by the user or
465: * by the remote DTE.
466: */
467:
468: pk_assoc (pkp, lcp, sa)
469: register struct pkcb *pkp;
470: register struct pklcd *lcp;
471: register struct sockaddr_x25 *sa;
472: {
473:
474: lcp -> lcd_pkp = pkp;
475: lcp -> lcd_packetsize = pkp -> pk_xcp -> xc_psize;
476: lcp -> lcd_windowsize = pkp -> pk_xcp -> xc_pwsize;
477: lcp -> lcd_rsn = MODULUS - 1;
478: pkp -> pk_chan[lcp -> lcd_lcn] = lcp;
479:
480: if (sa -> x25_opts.op_psize)
481: lcp -> lcd_packetsize = sa -> x25_opts.op_psize;
482: else
483: sa -> x25_opts.op_psize = lcp -> lcd_packetsize;
484: if (sa -> x25_opts.op_wsize)
485: lcp -> lcd_windowsize = sa -> x25_opts.op_wsize;
486: else
487: sa -> x25_opts.op_wsize = lcp -> lcd_windowsize;
488: sa -> x25_net = pkp -> pk_xcp -> xc_addr.x25_net;
489: lcp -> lcd_flags |= sa -> x25_opts.op_flags;
490: lcp -> lcd_stime = time.tv_sec;
491: }
492:
493: pk_connect (lcp, sa)
494: register struct pklcd *lcp;
495: register struct sockaddr_x25 *sa;
496: {
497: register struct pkcb *pkp;
498: register struct rtentry *rt;
499: register struct rtentry *nrt;
500:
501: struct rtentry *npaidb_enter ();
502: struct pkcb *pk_newlink ();
503:
504: if (sa -> x25_addr[0] == '\0')
505: return (EDESTADDRREQ);
506:
507: /*
508: * Is the destination address known?
509: */
510: if (!(rt = rtalloc1 ((struct sockaddr *)sa, 1)))
511: return (ENETUNREACH);
512:
513: if (!(pkp = XTRACTPKP(rt)))
514: pkp = pk_newlink ((struct x25_ifaddr *) (rt -> rt_ifa),
515: (caddr_t) 0);
516:
517: /*
518: * Have we entered the LLC address?
519: */
520: if (nrt = npaidb_enter (rt -> rt_gateway, rt_key (rt), rt, 0))
521: pkp -> pk_llrt = nrt;
522:
523: /*
524: * Have we allocated an LLC2 link yet?
525: */
526: if (pkp -> pk_llnext == (caddr_t)0 && pkp -> pk_llctlinput) {
527: struct dll_ctlinfo ctlinfo;
528:
529: ctlinfo.dlcti_rt = rt;
530: ctlinfo.dlcti_pcb = (caddr_t) pkp;
531: ctlinfo.dlcti_conf =
532: (struct dllconfig *) (&((struct x25_ifaddr *)(rt -> rt_ifa)) -> ia_xc);
533: pkp -> pk_llnext =
534: (pkp -> pk_llctlinput) (PRC_CONNECT_REQUEST, 0, &ctlinfo);
535: }
536:
537: if (pkp -> pk_state != DTE_READY && pkp -> pk_state != DTE_WAITING)
538: return (ENETDOWN);
539: if ((lcp -> lcd_lcn = pk_getlcn (pkp)) == 0)
540: return (EMFILE);
541:
542: lcp -> lcd_faddr = *sa;
543: lcp -> lcd_ceaddr = & lcp -> lcd_faddr;
544: pk_assoc (pkp, lcp, lcp -> lcd_ceaddr);
545:
546: /*
547: * If the link is not up yet, initiate an X.25 RESTART
548: */
549: if (pkp -> pk_state == DTE_WAITING) {
550: pkp -> pk_dxerole |= DTE_CONNECTPENDING;
551: pk_ctlinput (PRC_LINKUP, (struct sockaddr *)0, pkp);
552: if (lcp -> lcd_so)
553: soisconnecting (lcp -> lcd_so);
554: return 0;
555: }
556:
557: if (lcp -> lcd_so)
558: soisconnecting (lcp -> lcd_so);
559: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL);
560: pk_callrequest (lcp, lcp -> lcd_ceaddr, pkp -> pk_xcp);
561: return (*pkp -> pk_ia -> ia_start) (lcp);
562: }
563:
564: /*
565: * Complete all pending X.25 call requests --- this gets called after
566: * the X.25 link has been restarted.
567: */
568: #define RESHUFFLELCN(maxlcn, lcn) ((maxlcn) - (lcn) + 1)
569:
570: pk_callcomplete (pkp)
571: register struct pkcb *pkp;
572: {
573: register struct pklcd *lcp;
574: register int i;
575: register int ni;
576:
577:
578: if (pkp -> pk_dxerole & DTE_CONNECTPENDING)
579: pkp -> pk_dxerole &= ~DTE_CONNECTPENDING;
580: else return;
581:
582: if (pkp -> pk_chan == 0)
583: return;
584:
585: /*
586: * We pretended to be a DTE for allocating lcns, if
587: * it turns out that we are in reality performing as a
588: * DCE we need to reshuffle the lcps.
589: *
590: * /+---------------+-------- -
591: * / | a (maxlcn-1) | \
592: * / +---------------+ \
593: * +--- * | b (maxlcn-2) | \
594: * | \ +---------------+ \
595: * r | \ | c (maxlcn-3) | \
596: * e | \+---------------+ |
597: * s | | . |
598: * h | | . | m
599: * u | | . | a
600: * f | | . | x
601: * f | | . | l
602: * l | /+---------------+ | c
603: * e | / | c' ( 3 ) | | n
604: * | / +---------------+ |
605: * +--> * | b' ( 2 ) | /
606: * \ +---------------+ /
607: * \ | a' ( 1 ) | /
608: * \+---------------+ /
609: * | 0 | /
610: * +---------------+-------- -
611: *
612: */
613: if (pkp -> pk_dxerole & DTE_PLAYDCE) {
614: /* Sigh, reshuffle it */
615: for (i = pkp -> pk_maxlcn; i > 0; --i)
616: if (pkp -> pk_chan[i]) {
617: ni = RESHUFFLELCN(pkp -> pk_maxlcn, i);
618: pkp -> pk_chan[ni] = pkp -> pk_chan[i];
619: pkp -> pk_chan[i] = NULL;
620: pkp -> pk_chan[ni] -> lcd_lcn = ni;
621: }
622: }
623:
624: for (i = 1; i <= pkp -> pk_maxlcn; ++i)
625: if ((lcp = pkp -> pk_chan[i]) != NULL) {
626: /* if (lcp -> lcd_so)
627: soisconnecting (lcp -> lcd_so); */
628: lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_CALL);
629: pk_callrequest (lcp, lcp -> lcd_ceaddr, pkp -> pk_xcp);
630: (*pkp -> pk_ia -> ia_start) (lcp);
631: }
632: }
633:
634: struct bcdinfo {
635: octet *cp;
636: unsigned posn;
637: };
638: /*
639: * Build the rest of the CALL REQUEST packet. Fill in calling
640: * address, facilities fields and the user data field.
641: */
642:
643: pk_callrequest (lcp, sa, xcp)
644: struct pklcd *lcp;
645: register struct sockaddr_x25 *sa;
646: register struct x25config *xcp;
647: {
648: register struct x25_calladdr *a;
649: register struct mbuf *m = lcp -> lcd_template;
650: register struct x25_packet *xp = mtod (m, struct x25_packet *);
651: struct bcdinfo b;
652:
653: if (lcp -> lcd_flags & X25_DBIT)
654: X25SBITS(xp -> bits, d_bit, 1);
655: a = (struct x25_calladdr *) &xp -> packet_data;
656: b.cp = (octet *) a -> address_field;
657: b.posn = 0;
658: X25SBITS(a -> addrlens, called_addrlen, to_bcd (&b, sa, xcp));
659: X25SBITS(a -> addrlens, calling_addrlen, to_bcd (&b, &xcp -> xc_addr, xcp));
660: if (b.posn & 0x01)
661: *b.cp++ &= 0xf0;
662: m -> m_pkthdr.len = m -> m_len += b.cp - (octet *) a;
663:
664: if (lcp -> lcd_facilities) {
665: m -> m_pkthdr.len +=
666: (m -> m_next = lcp -> lcd_facilities) -> m_pkthdr.len;
667: lcp -> lcd_facilities = 0;
668: } else
669: pk_build_facilities (m, sa, (int)xcp -> xc_type);
670:
671: m_copyback (m, m -> m_pkthdr.len, sa -> x25_udlen, sa -> x25_udata);
672: }
673:
674: pk_build_facilities (m, sa, type)
675: register struct mbuf *m;
676: struct sockaddr_x25 *sa;
677: {
678: register octet *cp;
679: register octet *fcp;
680: register int revcharge;
681:
682: cp = mtod (m, octet *) + m -> m_len;
683: fcp = cp + 1;
684: revcharge = sa -> x25_opts.op_flags & X25_REVERSE_CHARGE ? 1 : 0;
685: /*
686: * This is specific to Datapac X.25(1976) DTEs. International
687: * calls must have the "hi priority" bit on.
688: */
689: if (type == X25_1976 && sa -> x25_opts.op_psize == X25_PS128)
690: revcharge |= 02;
691: if (revcharge) {
692: *fcp++ = FACILITIES_REVERSE_CHARGE;
693: *fcp++ = revcharge;
694: }
695: switch (type) {
696: case X25_1980:
697: case X25_1984:
698: *fcp++ = FACILITIES_PACKETSIZE;
699: *fcp++ = sa -> x25_opts.op_psize;
700: *fcp++ = sa -> x25_opts.op_psize;
701:
702: *fcp++ = FACILITIES_WINDOWSIZE;
703: *fcp++ = sa -> x25_opts.op_wsize;
704: *fcp++ = sa -> x25_opts.op_wsize;
705: }
706: *cp = fcp - cp - 1;
707: m -> m_pkthdr.len = (m -> m_len += *cp + 1);
708: }
709:
710: to_bcd (b, sa, xcp)
711: register struct bcdinfo *b;
712: struct sockaddr_x25 *sa;
713: register struct x25config *xcp;
714: {
715: register char *x = sa -> x25_addr;
716: unsigned start = b -> posn;
717: /*
718: * The nodnic and prepnd0 stuff looks tedious,
719: * but it does allow full X.121 addresses to be used,
720: * which is handy for routing info (& OSI type 37 addresses).
721: */
722: if (xcp -> xc_addr.x25_net && (xcp -> xc_nodnic || xcp -> xc_prepnd0)) {
723: char dnicname[sizeof (long) * NBBY/3 + 2];
724: register char *p = dnicname;
725:
726: sprintf (p, "%d", xcp -> xc_addr.x25_net & 0x7fff);
727: for (; *p; p++) /* *p == 0 means dnic matched */
728: if ((*p ^ *x++) & 0x0f)
729: break;
730: if (*p || xcp -> xc_nodnic == 0)
731: x = sa -> x25_addr;
732: if (*p && xcp -> xc_prepnd0) {
733: if ((b -> posn)++ & 0x01)
734: *(b -> cp)++;
735: else
736: *(b -> cp) = 0;
737: }
738: }
739: while (*x)
740: if ((b -> posn)++ & 0x01)
741: *(b -> cp)++ |= *x++ & 0x0F;
742: else
743: *(b -> cp) = *x++ << 4;
744: return ((b -> posn) - start);
745: }
746:
747: /*
748: * This routine gets the first available logical channel number. The
749: * search is
750: * - from the highest number to lowest number if playing DTE, and
751: * - from lowest to highest number if playing DCE.
752: */
753:
754: pk_getlcn (pkp)
755: register struct pkcb *pkp;
756: {
757: register int i;
758:
759: if (pkp -> pk_chan == 0)
760: return (0);
761: if ( pkp -> pk_dxerole & DTE_PLAYDCE ) {
762: for (i = 1; i <= pkp -> pk_maxlcn; ++i)
763: if (pkp -> pk_chan[i] == NULL)
764: break;
765: } else {
766: for (i = pkp -> pk_maxlcn; i > 0; --i)
767: if (pkp -> pk_chan[i] == NULL)
768: break;
769: }
770: i = ( i > pkp -> pk_maxlcn ? 0 : i );
771: return (i);
772: }
773:
774: /*
775: * This procedure sends a CLEAR request packet. The lc state is
776: * set to "SENT_CLEAR".
777: */
778:
779: pk_clear (lcp, diagnostic, abortive)
780: register struct pklcd *lcp;
781: {
782: register struct mbuf *m = pk_template (lcp -> lcd_lcn, X25_CLEAR);
783:
784: m -> m_len += 2;
785: m -> m_pkthdr.len += 2;
786: mtod (m, struct x25_packet *) -> packet_data = 0;
787: mtod (m, octet *)[4] = diagnostic;
788: if (lcp -> lcd_facilities) {
789: m -> m_next = lcp -> lcd_facilities;
790: m -> m_pkthdr.len += m -> m_next -> m_len;
791: lcp -> lcd_facilities = 0;
792: }
793: if (abortive)
794: lcp -> lcd_template = m;
795: else {
796: struct socket *so = lcp -> lcd_so;
797: struct sockbuf *sb = so ? & so -> so_snd : & lcp -> lcd_sb;
798: sbappendrecord (sb, m);
799: }
800: pk_output (lcp);
801:
802: }
803:
804: /*
805: * This procedure generates RNR's or RR's to inhibit or enable
806: * inward data flow, if the current state changes (blocked ==> open or
807: * vice versa), or if forced to generate one. One forces RNR's to ack data.
808: */
809: pk_flowcontrol (lcp, inhibit, forced)
810: register struct pklcd *lcp;
811: {
812: inhibit = (inhibit != 0);
813: if (lcp == 0 || lcp -> lcd_state != DATA_TRANSFER ||
814: (forced == 0 && lcp -> lcd_rxrnr_condition == inhibit))
815: return;
816: lcp -> lcd_rxrnr_condition = inhibit;
817: lcp -> lcd_template =
818: pk_template (lcp -> lcd_lcn, inhibit ? X25_RNR : X25_RR);
819: pk_output (lcp);
820: }
821:
822: /*
823: * This procedure sends a RESET request packet. It re-intializes
824: * virtual circuit.
825: */
826:
827: static
828: pk_reset (lcp, diagnostic)
829: register struct pklcd *lcp;
830: {
831: register struct mbuf *m;
832: register struct socket *so = lcp -> lcd_so;
833:
834: if (lcp -> lcd_state != DATA_TRANSFER)
835: return;
836:
837: if (so)
838: so -> so_error = ECONNRESET;
839: lcp -> lcd_reset_condition = TRUE;
840:
841: /* Reset all the control variables for the channel. */
842: pk_flush (lcp);
843: lcp -> lcd_window_condition = lcp -> lcd_rnr_condition =
844: lcp -> lcd_intrconf_pending = FALSE;
845: lcp -> lcd_rsn = MODULUS - 1;
846: lcp -> lcd_ssn = 0;
847: lcp -> lcd_output_window = lcp -> lcd_input_window =
848: lcp -> lcd_last_transmitted_pr = 0;
849: m = lcp -> lcd_template = pk_template (lcp -> lcd_lcn, X25_RESET);
850: m -> m_pkthdr.len = m -> m_len += 2;
851: mtod (m, struct x25_packet *) -> packet_data = 0;
852: mtod (m, octet *)[4] = diagnostic;
853: pk_output (lcp);
854:
855: }
856:
857: /*
858: * This procedure frees all data queued for output or delivery on a
859: * virtual circuit.
860: */
861:
862: pk_flush (lcp)
863: register struct pklcd *lcp;
864: {
865: register struct socket *so;
866:
867: if (lcp -> lcd_template)
868: m_freem (lcp -> lcd_template);
869:
870: if (lcp -> lcd_cps) {
871: m_freem (lcp -> lcd_cps);
872: lcp -> lcd_cps = 0;
873: }
874: if (lcp -> lcd_facilities) {
875: m_freem (lcp -> lcd_facilities);
876: lcp -> lcd_facilities = 0;
877: }
878: if (so = lcp -> lcd_so)
879: sbflush (&so -> so_snd);
880: else
881: sbflush (&lcp -> lcd_sb);
882: }
883:
884: /*
885: * This procedure handles all local protocol procedure errors.
886: */
887:
888: pk_procerror (error, lcp, errstr, diagnostic)
889: register struct pklcd *lcp;
890: char *errstr;
891: {
892:
893: pk_message (lcp -> lcd_lcn, lcp -> lcd_pkp -> pk_xcp, errstr);
894:
895: switch (error) {
896: case CLEAR:
897: if (lcp -> lcd_so) {
898: lcp -> lcd_so -> so_error = ECONNABORTED;
899: soisdisconnecting (lcp -> lcd_so);
900: }
901: pk_clear (lcp, diagnostic, 1);
902: break;
903:
904: case RESET:
905: pk_reset (lcp, diagnostic);
906: }
907: }
908:
909: /*
910: * This procedure is called during the DATA TRANSFER state to check
911: * and process the P(R) values received in the DATA, RR OR RNR
912: * packets.
913: */
914:
915: pk_ack (lcp, pr)
916: struct pklcd *lcp;
917: unsigned pr;
918: {
919: register struct socket *so = lcp -> lcd_so;
920:
921: if (lcp -> lcd_output_window == pr)
922: return (PACKET_OK);
923: if (lcp -> lcd_output_window < lcp -> lcd_ssn) {
924: if (pr < lcp -> lcd_output_window || pr > lcp -> lcd_ssn) {
925: pk_procerror (RESET, lcp,
926: "p(r) flow control error", 2);
927: return (ERROR_PACKET);
928: }
929: }
930: else {
931: if (pr < lcp -> lcd_output_window && pr > lcp -> lcd_ssn) {
932: pk_procerror (RESET, lcp,
933: "p(r) flow control error #2", 2);
934: return (ERROR_PACKET);
935: }
936: }
937:
938: lcp -> lcd_output_window = pr; /* Rotate window. */
939: if (lcp -> lcd_window_condition == TRUE)
940: lcp -> lcd_window_condition = FALSE;
941:
942: if (so && ((so -> so_snd.sb_flags & SB_WAIT) ||
943: (so -> so_snd.sb_flags & SB_NOTIFY)))
944: sowwakeup (so);
945:
946: return (PACKET_OK);
947: }
948:
949: /*
950: * This procedure decodes the X.25 level 3 packet returning a
951: * code to be used in switchs or arrays.
952: */
953:
954: pk_decode (xp)
955: register struct x25_packet *xp;
956: {
957: register int type;
958:
959: if (X25GBITS(xp -> bits, fmt_identifier) != 1)
960: return (INVALID_PACKET);
961: #ifdef ancient_history
962: /*
963: * Make sure that the logical channel group number is 0.
964: * This restriction may be removed at some later date.
965: */
966: if (xp -> lc_group_number != 0)
967: return (INVALID_PACKET);
968: #endif
969: /*
970: * Test for data packet first.
971: */
972: if (!(xp -> packet_type & DATA_PACKET_DESIGNATOR))
973: return (DATA);
974:
975: /*
976: * Test if flow control packet (RR or RNR).
977: */
978: if (!(xp -> packet_type & RR_OR_RNR_PACKET_DESIGNATOR))
979: switch (xp -> packet_type & 0x1f) {
980: case X25_RR:
981: return (RR);
982: case X25_RNR:
983: return (RNR);
984: case X25_REJECT:
985: return (REJECT);
986: }
987:
988: /*
989: * Determine the rest of the packet types.
990: */
991: switch (xp -> packet_type) {
992: case X25_CALL:
993: type = CALL;
994: break;
995:
996: case X25_CALL_ACCEPTED:
997: type = CALL_ACCEPTED;
998: break;
999:
1000: case X25_CLEAR:
1001: type = CLEAR;
1002: break;
1003:
1004: case X25_CLEAR_CONFIRM:
1005: type = CLEAR_CONF;
1006: break;
1007:
1008: case X25_INTERRUPT:
1009: type = INTERRUPT;
1010: break;
1011:
1012: case X25_INTERRUPT_CONFIRM:
1013: type = INTERRUPT_CONF;
1014: break;
1015:
1016: case X25_RESET:
1017: type = RESET;
1018: break;
1019:
1020: case X25_RESET_CONFIRM:
1021: type = RESET_CONF;
1022: break;
1023:
1024: case X25_RESTART:
1025: type = RESTART;
1026: break;
1027:
1028: case X25_RESTART_CONFIRM:
1029: type = RESTART_CONF;
1030: break;
1031:
1032: case X25_DIAGNOSTIC:
1033: type = DIAG_TYPE;
1034: break;
1035:
1036: default:
1037: type = INVALID_PACKET;
1038: }
1039: return (type);
1040: }
1041:
1042: /*
1043: * A restart packet has been received. Print out the reason
1044: * for the restart.
1045: */
1046:
1047: pk_restartcause (pkp, xp)
1048: struct pkcb *pkp;
1049: register struct x25_packet *xp;
1050: {
1051: register struct x25config *xcp = pkp -> pk_xcp;
1052: register int lcn = LCN(xp);
1053:
1054: switch (xp -> packet_data) {
1055: case X25_RESTART_LOCAL_PROCEDURE_ERROR:
1056: pk_message (lcn, xcp, "restart: local procedure error");
1057: break;
1058:
1059: case X25_RESTART_NETWORK_CONGESTION:
1060: pk_message (lcn, xcp, "restart: network congestion");
1061: break;
1062:
1063: case X25_RESTART_NETWORK_OPERATIONAL:
1064: pk_message (lcn, xcp, "restart: network operational");
1065: break;
1066:
1067: default:
1068: pk_message (lcn, xcp, "restart: unknown cause");
1069: }
1070: }
1071:
1072: #define MAXRESETCAUSE 7
1073:
1074: int Reset_cause[] = {
1075: EXRESET, EXROUT, 0, EXRRPE, 0, EXRLPE, 0, EXRNCG
1076: };
1077:
1078: /*
1079: * A reset packet has arrived. Return the cause to the user.
1080: */
1081:
1082: pk_resetcause (pkp, xp)
1083: struct pkcb *pkp;
1084: register struct x25_packet *xp;
1085: {
1086: register struct pklcd *lcp =
1087: pkp -> pk_chan[LCN(xp)];
1088: register int code = xp -> packet_data;
1089:
1090: if (code > MAXRESETCAUSE)
1091: code = 7; /* EXRNCG */
1092:
1093: pk_message (LCN(xp), lcp -> lcd_pkp, "reset code 0x%x, diagnostic 0x%x",
1094: xp -> packet_data, 4[(u_char *)xp]);
1095:
1096: if (lcp -> lcd_so)
1097: lcp -> lcd_so -> so_error = Reset_cause[code];
1098: }
1099:
1100: #define MAXCLEARCAUSE 25
1101:
1102: int Clear_cause[] = {
1103: EXCLEAR, EXCBUSY, 0, EXCINV, 0, EXCNCG, 0,
1104: 0, 0, EXCOUT, 0, EXCAB, 0, EXCNOB, 0, 0, 0, EXCRPE,
1105: 0, EXCLPE, 0, 0, 0, 0, 0, EXCRRC
1106: };
1107:
1108: /*
1109: * A clear packet has arrived. Return the cause to the user.
1110: */
1111:
1112: pk_clearcause (pkp, xp)
1113: struct pkcb *pkp;
1114: register struct x25_packet *xp;
1115: {
1116: register struct pklcd *lcp =
1117: pkp -> pk_chan[LCN(xp)];
1118: register int code = xp -> packet_data;
1119:
1120: if (code > MAXCLEARCAUSE)
1121: code = 5; /* EXRNCG */
1122: if (lcp -> lcd_so)
1123: lcp -> lcd_so -> so_error = Clear_cause[code];
1124: }
1125:
1126: char *
1127: format_ntn (xcp)
1128: register struct x25config *xcp;
1129: {
1130:
1131: return (xcp -> xc_addr.x25_addr);
1132: }
1133:
1134: /* VARARGS1 */
1135: pk_message (lcn, xcp, fmt, a1, a2, a3, a4, a5, a6)
1136: struct x25config *xcp;
1137: char *fmt;
1138: {
1139:
1140: if (lcn)
1141: if (!PQEMPTY)
1142: printf ("X.25(%s): lcn %d: ", format_ntn (xcp), lcn);
1143: else
1144: printf ("X.25: lcn %d: ", lcn);
1145: else
1146: if (!PQEMPTY)
1147: printf ("X.25(%s): ", format_ntn (xcp));
1148: else
1149: printf ("X.25: ");
1150:
1151: printf (fmt, a1, a2, a3, a4, a5, a6);
1152: printf ("\n");
1153: }
1154:
1155: pk_fragment (lcp, m0, qbit, mbit, wait)
1156: struct mbuf *m0;
1157: register struct pklcd *lcp;
1158: {
1159: register struct mbuf *m = m0;
1160: register struct x25_packet *xp;
1161: register struct sockbuf *sb;
1162: struct mbuf *head = 0, *next, **mp = &head, *m_split ();
1163: int totlen, psize = 1 << (lcp -> lcd_packetsize);
1164:
1165: if (m == 0)
1166: return 0;
1167: if (m -> m_flags & M_PKTHDR == 0)
1168: panic ("pk_fragment");
1169: totlen = m -> m_pkthdr.len;
1170: m -> m_act = 0;
1171: sb = lcp -> lcd_so ? &lcp -> lcd_so -> so_snd : & lcp -> lcd_sb;
1172: do {
1173: if (totlen > psize) {
1174: if ((next = m_split (m, psize, wait)) == 0)
1175: goto abort;
1176: totlen -= psize;
1177: } else
1178: next = 0;
1179: M_PREPEND(m, PKHEADERLN, wait);
1180: if (m == 0)
1181: goto abort;
1182: *mp = m;
1183: mp = & m -> m_act;
1184: *mp = 0;
1185: xp = mtod (m, struct x25_packet *);
1186: 0[(char *)xp] = 0;
1187: if (qbit)
1188: X25SBITS(xp -> bits, q_bit, 1);
1189: if (lcp -> lcd_flags & X25_DBIT)
1190: X25SBITS(xp -> bits, d_bit, 1);
1191: X25SBITS(xp -> bits, fmt_identifier, 1);
1192: xp -> packet_type = X25_DATA;
1193: SET_LCN(xp, lcp -> lcd_lcn);
1194: if (next || (mbit && (totlen == psize ||
1195: (lcp -> lcd_flags & X25_DBIT))))
1196: SMBIT(xp, 1);
1197: } while (m = next);
1198: for (m = head; m; m = next) {
1199: next = m -> m_act;
1200: m -> m_act = 0;
1201: sbappendrecord (sb, m);
1202: }
1203: return 0;
1204: abort:
1205: if (wait)
1206: panic ("pk_fragment null mbuf after wait");
1207: if (next)
1208: m_freem (next);
1209: for (m = head; m; m = next) {
1210: next = m -> m_act;
1211: m_freem (m);
1212: }
1213: return ENOBUFS;
1214: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.